Date: Tue, 07 Apr 2026 11:00:12 +0000 From: Mikael Urankar <mikael@FreeBSD.org> To: ports-committers@FreeBSD.org, dev-commits-ports-all@FreeBSD.org, dev-commits-ports-main@FreeBSD.org Subject: git: e330aefa2382 - main - www/deno: Fix build when llvm22 is installed Message-ID: <69d4e3bc.1f886.d7500f1@gitrepo.freebsd.org>
index | next in thread | raw e-mail
The branch main has been updated by mikael: URL: https://cgit.FreeBSD.org/ports/commit/?id=e330aefa238248ff5ab18671061c4f8221f9f188 commit e330aefa238248ff5ab18671061c4f8221f9f188 Author: Mikael Urankar <mikael@FreeBSD.org> AuthorDate: 2026-04-06 15:36:07 +0000 Commit: Mikael Urankar <mikael@FreeBSD.org> CommitDate: 2026-04-07 10:59:18 +0000 www/deno: Fix build when llvm22 is installed For whatever reason the build fails if llvm22 is installed / used, the generated bindings.rs file doesn't have all the needed definitions. Fix this by providing libuv bindgen likes it's done for others OS [3] (it was generated with llvm21). error be like: libuv-sys-lite-1.48.2/src/functions.rs | 785 | addr: *mut sockaddr_in, | ^^^^^^^^^^^ help: a struct with a similar name exists: `sockaddr` For reference: deno issue [1], libuv-sys-lite issue [2] and fix [3] [1] https://github.com/denoland/deno/issues/32351 [2] https://github.com/nathanwhit/libuv-sys-lite/issues/1 [3] https://github.com/nathanwhit/libuv-sys-lite/commit/37c1821e8e94f70dc0c768092d8a44920609d045 PR: 293587 Tested by: gja822@narod.ru --- www/deno/files/patch-cargo-crates_libuv-sys-lite | 7400 ++++++++++++++++++++++ 1 file changed, 7400 insertions(+) diff --git a/www/deno/files/patch-cargo-crates_libuv-sys-lite b/www/deno/files/patch-cargo-crates_libuv-sys-lite new file mode 100644 index 000000000000..831f3a80453a --- /dev/null +++ b/www/deno/files/patch-cargo-crates_libuv-sys-lite @@ -0,0 +1,7400 @@ +--- cargo-crates/libuv-sys-lite-1.48.3/build.rs.orig 2026-04-06 17:29:47 UTC ++++ cargo-crates/libuv-sys-lite-1.48.3/build.rs +@@ -40,7 +40,7 @@ fn main() { + let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default(); + let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default(); + match (&*target_os, &*target_arch) { +- ("windows", "x86_64") | ("linux" | "macos", "x86_64" | "aarch64") => { ++ ("windows", "x86_64") | ("linux" | "macos" | "freebsd", "x86_64" | "aarch64") => { + let path = PathBuf::from("src").join(format!("bindings_{}_{}.rs", target_os, target_arch)); + let dest = PathBuf::from(std::env::var("OUT_DIR").unwrap()).join("bindings.rs"); + std::fs::copy(&path, &dest).unwrap(); + +--- cargo-crates/libuv-sys-lite-1.48.3/src/bindings_freebsd_x86_64.rs.orig 2026-04-06 17:27:53 UTC ++++ cargo-crates/libuv-sys-lite-1.48.3/src/bindings_freebsd_x86_64.rs +@@ -0,0 +1,3875 @@ ++/* automatically generated by rust-bindgen 0.70.1 */ ++ ++pub const UV__EOF: i32 = -4095; ++pub const UV__UNKNOWN: i32 = -4094; ++pub const UV__EAI_ADDRFAMILY: i32 = -3000; ++pub const UV__EAI_AGAIN: i32 = -3001; ++pub const UV__EAI_BADFLAGS: i32 = -3002; ++pub const UV__EAI_CANCELED: i32 = -3003; ++pub const UV__EAI_FAIL: i32 = -3004; ++pub const UV__EAI_FAMILY: i32 = -3005; ++pub const UV__EAI_MEMORY: i32 = -3006; ++pub const UV__EAI_NODATA: i32 = -3007; ++pub const UV__EAI_NONAME: i32 = -3008; ++pub const UV__EAI_OVERFLOW: i32 = -3009; ++pub const UV__EAI_SERVICE: i32 = -3010; ++pub const UV__EAI_SOCKTYPE: i32 = -3011; ++pub const UV__EAI_BADHINTS: i32 = -3013; ++pub const UV__EAI_PROTOCOL: i32 = -3014; ++pub const UV__ECHARSET: i32 = -4080; ++pub const UV__ENONET: i32 = -4056; ++pub const UV__EREMOTEIO: i32 = -4030; ++pub const UV__ENODATA: i32 = -9919; ++pub const UV__EUNATCH: i32 = -4023; ++pub const UV_VERSION_MAJOR: u32 = 1; ++pub const UV_VERSION_MINOR: u32 = 48; ++pub const UV_VERSION_PATCH: u32 = 0; ++pub const UV_VERSION_IS_RELEASE: u32 = 1; ++pub const UV_VERSION_SUFFIX: &[u8; 1] = b"\0"; ++pub const UV_VERSION_HEX: u32 = 77824; ++pub const UV_HAVE_KQUEUE: u32 = 1; ++pub const UV__DT_FILE: u32 = 8; ++pub const UV__DT_DIR: u32 = 4; ++pub const UV__DT_LINK: u32 = 10; ++pub const UV__DT_FIFO: u32 = 1; ++pub const UV__DT_SOCKET: u32 = 12; ++pub const UV__DT_CHAR: u32 = 2; ++pub const UV__DT_BLOCK: u32 = 6; ++pub const UV_FS_O_APPEND: u32 = 8; ++pub const UV_FS_O_CREAT: u32 = 512; ++pub const UV_FS_O_DIRECT: u32 = 65536; ++pub const UV_FS_O_DIRECTORY: u32 = 131072; ++pub const UV_FS_O_DSYNC: u32 = 16777216; ++pub const UV_FS_O_EXCL: u32 = 2048; ++pub const UV_FS_O_EXLOCK: u32 = 32; ++pub const UV_FS_O_NOATIME: u32 = 0; ++pub const UV_FS_O_NOCTTY: u32 = 32768; ++pub const UV_FS_O_NOFOLLOW: u32 = 256; ++pub const UV_FS_O_NONBLOCK: u32 = 4; ++pub const UV_FS_O_RDONLY: u32 = 0; ++pub const UV_FS_O_RDWR: u32 = 2; ++pub const UV_FS_O_SYMLINK: u32 = 0; ++pub const UV_FS_O_SYNC: u32 = 128; ++pub const UV_FS_O_TRUNC: u32 = 1024; ++pub const UV_FS_O_WRONLY: u32 = 1; ++pub const UV_FS_O_FILEMAP: u32 = 0; ++pub const UV_FS_O_RANDOM: u32 = 0; ++pub const UV_FS_O_SHORT_LIVED: u32 = 0; ++pub const UV_FS_O_SEQUENTIAL: u32 = 0; ++pub const UV_FS_O_TEMPORARY: u32 = 0; ++pub const UV_PRIORITY_LOW: u32 = 19; ++pub const UV_PRIORITY_BELOW_NORMAL: u32 = 10; ++pub const UV_PRIORITY_NORMAL: u32 = 0; ++pub const UV_PRIORITY_ABOVE_NORMAL: i32 = -7; ++pub const UV_PRIORITY_HIGH: i32 = -14; ++pub const UV_PRIORITY_HIGHEST: i32 = -20; ++pub const UV_MAXHOSTNAMESIZE: u32 = 257; ++pub const UV_FS_COPYFILE_EXCL: u32 = 1; ++pub const UV_FS_COPYFILE_FICLONE: u32 = 2; ++pub const UV_FS_COPYFILE_FICLONE_FORCE: u32 = 4; ++pub const UV_FS_SYMLINK_DIR: u32 = 1; ++pub const UV_FS_SYMLINK_JUNCTION: u32 = 2; ++pub const UV_IF_NAMESIZE: u32 = 17; ++pub type __uint8_t = ::std::os::raw::c_uchar; ++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 __gid_t = __uint32_t; ++pub type __ino_t = __uint64_t; ++pub type __mode_t = __uint16_t; ++pub type __off_t = __int64_t; ++pub type __pid_t = __int32_t; ++pub type __sa_family_t = __uint8_t; ++pub type __socklen_t = __uint32_t; ++pub type __uid_t = __uint32_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union __mbstate_t { ++ pub __mbstate8: [::std::os::raw::c_char; 128usize], ++ pub _mbstateL: __int64_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __mbstate_t"][::std::mem::size_of::<__mbstate_t>() - 128usize]; ++ ["Alignment of __mbstate_t"][::std::mem::align_of::<__mbstate_t>() - 8usize]; ++ ["Offset of field: __mbstate_t::__mbstate8"] ++ [::std::mem::offset_of!(__mbstate_t, __mbstate8) - 0usize]; ++ ["Offset of field: __mbstate_t::_mbstateL"] ++ [::std::mem::offset_of!(__mbstate_t, _mbstateL) - 0usize]; ++}; ++pub type fpos_t = __off_t; ++pub type off_t = __off_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __sbuf { ++ pub _base: *mut ::std::os::raw::c_uchar, ++ pub _size: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sbuf"][::std::mem::size_of::<__sbuf>() - 16usize]; ++ ["Alignment of __sbuf"][::std::mem::align_of::<__sbuf>() - 8usize]; ++ ["Offset of field: __sbuf::_base"] ++ [::std::mem::offset_of!(__sbuf, _base) - 0usize]; ++ ["Offset of field: __sbuf::_size"] ++ [::std::mem::offset_of!(__sbuf, _size) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct __sFILE { ++ pub _p: *mut ::std::os::raw::c_uchar, ++ pub _r: ::std::os::raw::c_int, ++ pub _w: ::std::os::raw::c_int, ++ pub _flags: ::std::os::raw::c_short, ++ pub _file: ::std::os::raw::c_short, ++ pub _bf: __sbuf, ++ pub _lbfsize: ::std::os::raw::c_int, ++ pub _cookie: *mut ::std::os::raw::c_void, ++ pub _close: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _read: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: *mut ::std::os::raw::c_char, ++ arg3: ::std::os::raw::c_int, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _seek: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: fpos_t, ++ arg3: ::std::os::raw::c_int, ++ ) -> fpos_t, ++ >, ++ pub _write: ::std::option::Option< ++ unsafe extern "C" fn( ++ arg1: *mut ::std::os::raw::c_void, ++ arg2: *const ::std::os::raw::c_char, ++ arg3: ::std::os::raw::c_int, ++ ) -> ::std::os::raw::c_int, ++ >, ++ pub _ub: __sbuf, ++ pub _up: *mut ::std::os::raw::c_uchar, ++ pub _ur: ::std::os::raw::c_int, ++ pub _ubuf: [::std::os::raw::c_uchar; 3usize], ++ pub _nbuf: [::std::os::raw::c_uchar; 1usize], ++ pub _lb: __sbuf, ++ pub _blksize: ::std::os::raw::c_int, ++ pub _offset: fpos_t, ++ pub _fl_mutex: *mut pthread_mutex, ++ pub _fl_owner: *mut pthread, ++ pub _fl_count: ::std::os::raw::c_int, ++ pub _orientation: ::std::os::raw::c_int, ++ pub _mbstate: __mbstate_t, ++ pub _flags2: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sFILE"][::std::mem::size_of::<__sFILE>() - 312usize]; ++ ["Alignment of __sFILE"][::std::mem::align_of::<__sFILE>() - 8usize]; ++ ["Offset of field: __sFILE::_p"] ++ [::std::mem::offset_of!(__sFILE, _p) - 0usize]; ++ ["Offset of field: __sFILE::_r"] ++ [::std::mem::offset_of!(__sFILE, _r) - 8usize]; ++ ["Offset of field: __sFILE::_w"] ++ [::std::mem::offset_of!(__sFILE, _w) - 12usize]; ++ ["Offset of field: __sFILE::_flags"] ++ [::std::mem::offset_of!(__sFILE, _flags) - 16usize]; ++ ["Offset of field: __sFILE::_file"] ++ [::std::mem::offset_of!(__sFILE, _file) - 18usize]; ++ ["Offset of field: __sFILE::_bf"] ++ [::std::mem::offset_of!(__sFILE, _bf) - 24usize]; ++ ["Offset of field: __sFILE::_lbfsize"] ++ [::std::mem::offset_of!(__sFILE, _lbfsize) - 40usize]; ++ ["Offset of field: __sFILE::_cookie"] ++ [::std::mem::offset_of!(__sFILE, _cookie) - 48usize]; ++ ["Offset of field: __sFILE::_close"] ++ [::std::mem::offset_of!(__sFILE, _close) - 56usize]; ++ ["Offset of field: __sFILE::_read"] ++ [::std::mem::offset_of!(__sFILE, _read) - 64usize]; ++ ["Offset of field: __sFILE::_seek"] ++ [::std::mem::offset_of!(__sFILE, _seek) - 72usize]; ++ ["Offset of field: __sFILE::_write"] ++ [::std::mem::offset_of!(__sFILE, _write) - 80usize]; ++ ["Offset of field: __sFILE::_ub"] ++ [::std::mem::offset_of!(__sFILE, _ub) - 88usize]; ++ ["Offset of field: __sFILE::_up"] ++ [::std::mem::offset_of!(__sFILE, _up) - 104usize]; ++ ["Offset of field: __sFILE::_ur"] ++ [::std::mem::offset_of!(__sFILE, _ur) - 112usize]; ++ ["Offset of field: __sFILE::_ubuf"] ++ [::std::mem::offset_of!(__sFILE, _ubuf) - 116usize]; ++ ["Offset of field: __sFILE::_nbuf"] ++ [::std::mem::offset_of!(__sFILE, _nbuf) - 119usize]; ++ ["Offset of field: __sFILE::_lb"] ++ [::std::mem::offset_of!(__sFILE, _lb) - 120usize]; ++ ["Offset of field: __sFILE::_blksize"] ++ [::std::mem::offset_of!(__sFILE, _blksize) - 136usize]; ++ ["Offset of field: __sFILE::_offset"] ++ [::std::mem::offset_of!(__sFILE, _offset) - 144usize]; ++ ["Offset of field: __sFILE::_fl_mutex"] ++ [::std::mem::offset_of!(__sFILE, _fl_mutex) - 152usize]; ++ ["Offset of field: __sFILE::_fl_owner"] ++ [::std::mem::offset_of!(__sFILE, _fl_owner) - 160usize]; ++ ["Offset of field: __sFILE::_fl_count"] ++ [::std::mem::offset_of!(__sFILE, _fl_count) - 168usize]; ++ ["Offset of field: __sFILE::_orientation"] ++ [::std::mem::offset_of!(__sFILE, _orientation) - 172usize]; ++ ["Offset of field: __sFILE::_mbstate"] ++ [::std::mem::offset_of!(__sFILE, _mbstate) - 176usize]; ++ ["Offset of field: __sFILE::_flags2"] ++ [::std::mem::offset_of!(__sFILE, _flags2) - 304usize]; ++}; ++pub type FILE = __sFILE; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__queue { ++ pub next: *mut uv__queue, ++ pub prev: *mut uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__queue"][::std::mem::size_of::<uv__queue>() - 16usize]; ++ ["Alignment of uv__queue"][::std::mem::align_of::<uv__queue>() - 8usize]; ++ ["Offset of field: uv__queue::next"] ++ [::std::mem::offset_of!(uv__queue, next) - 0usize]; ++ ["Offset of field: uv__queue::prev"] ++ [::std::mem::offset_of!(uv__queue, prev) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_cond { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_mutex { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_rwlock { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_barrier { ++ _unused: [u8; 0], ++} ++pub type pthread_t = *mut pthread; ++pub type pthread_mutex_t = *mut pthread_mutex; ++pub type pthread_cond_t = *mut pthread_cond; ++pub type pthread_key_t = ::std::os::raw::c_int; ++pub type pthread_once_t = pthread_once; ++pub type pthread_rwlock_t = *mut pthread_rwlock; ++pub type pthread_barrier_t = *mut pthread_barrier; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_once { ++ pub state: ::std::os::raw::c_int, ++ pub mutex: pthread_mutex_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_once"][::std::mem::size_of::<pthread_once>() - 16usize]; ++ ["Alignment of pthread_once"] ++ [::std::mem::align_of::<pthread_once>() - 8usize]; ++ ["Offset of field: pthread_once::state"] ++ [::std::mem::offset_of!(pthread_once, state) - 0usize]; ++ ["Offset of field: pthread_once::mutex"] ++ [::std::mem::offset_of!(pthread_once, mutex) - 8usize]; ++}; ++pub type gid_t = __gid_t; ++pub type in_addr_t = __uint32_t; ++pub type in_port_t = __uint16_t; ++pub type ino_t = __ino_t; ++pub type mode_t = __mode_t; ++pub type pid_t = __pid_t; ++pub type uid_t = __uid_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct dirent { ++ pub d_fileno: ino_t, ++ pub d_off: off_t, ++ pub d_reclen: __uint16_t, ++ pub d_type: __uint8_t, ++ pub d_pad0: __uint8_t, ++ pub d_namlen: __uint16_t, ++ pub d_pad1: __uint16_t, ++ pub d_name: [::std::os::raw::c_char; 256usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of dirent"][::std::mem::size_of::<dirent>() - 280usize]; ++ ["Alignment of dirent"][::std::mem::align_of::<dirent>() - 8usize]; ++ ["Offset of field: dirent::d_fileno"] ++ [::std::mem::offset_of!(dirent, d_fileno) - 0usize]; ++ ["Offset of field: dirent::d_off"] ++ [::std::mem::offset_of!(dirent, d_off) - 8usize]; ++ ["Offset of field: dirent::d_reclen"] ++ [::std::mem::offset_of!(dirent, d_reclen) - 16usize]; ++ ["Offset of field: dirent::d_type"] ++ [::std::mem::offset_of!(dirent, d_type) - 18usize]; ++ ["Offset of field: dirent::d_pad0"] ++ [::std::mem::offset_of!(dirent, d_pad0) - 19usize]; ++ ["Offset of field: dirent::d_namlen"] ++ [::std::mem::offset_of!(dirent, d_namlen) - 20usize]; ++ ["Offset of field: dirent::d_pad1"] ++ [::std::mem::offset_of!(dirent, d_pad1) - 22usize]; ++ ["Offset of field: dirent::d_name"] ++ [::std::mem::offset_of!(dirent, d_name) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _dirdesc { ++ _unused: [u8; 0], ++} ++pub type DIR = _dirdesc; ++pub type sa_family_t = __sa_family_t; ++pub type socklen_t = __socklen_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr { ++ pub sa_len: ::std::os::raw::c_uchar, ++ pub sa_family: sa_family_t, ++ pub sa_data: [::std::os::raw::c_char; 14usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr"][::std::mem::size_of::<sockaddr>() - 16usize]; ++ ["Alignment of sockaddr"][::std::mem::align_of::<sockaddr>() - 1usize]; ++ ["Offset of field: sockaddr::sa_len"] ++ [::std::mem::offset_of!(sockaddr, sa_len) - 0usize]; ++ ["Offset of field: sockaddr::sa_family"] ++ [::std::mem::offset_of!(sockaddr, sa_family) - 1usize]; ++ ["Offset of field: sockaddr::sa_data"] ++ [::std::mem::offset_of!(sockaddr, sa_data) - 2usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sockaddr_storage { ++ pub ss_len: ::std::os::raw::c_uchar, ++ pub ss_family: sa_family_t, ++ pub __ss_pad1: [::std::os::raw::c_char; 6usize], ++ pub __ss_align: __int64_t, ++ pub __ss_pad2: [::std::os::raw::c_char; 112usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_storage"] ++ [::std::mem::size_of::<sockaddr_storage>() - 128usize]; ++ ["Alignment of sockaddr_storage"] ++ [::std::mem::align_of::<sockaddr_storage>() - 8usize]; ++ ["Offset of field: sockaddr_storage::ss_len"] ++ [::std::mem::offset_of!(sockaddr_storage, ss_len) - 0usize]; ++ ["Offset of field: sockaddr_storage::ss_family"] ++ [::std::mem::offset_of!(sockaddr_storage, ss_family) - 1usize]; ++ ["Offset of field: sockaddr_storage::__ss_pad1"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_pad1) - 2usize]; ++ ["Offset of field: sockaddr_storage::__ss_align"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_align) - 8usize]; ++ ["Offset of field: sockaddr_storage::__ss_pad2"] ++ [::std::mem::offset_of!(sockaddr_storage, __ss_pad2) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct in_addr { ++ pub s_addr: in_addr_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in_addr"][::std::mem::size_of::<in_addr>() - 4usize]; ++ ["Alignment of in_addr"][::std::mem::align_of::<in_addr>() - 4usize]; ++ ["Offset of field: in_addr::s_addr"] ++ [::std::mem::offset_of!(in_addr, s_addr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++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: [::std::os::raw::c_char; 8usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_in"][::std::mem::size_of::<sockaddr_in>() - 16usize]; ++ ["Alignment of sockaddr_in"][::std::mem::align_of::<sockaddr_in>() - 4usize]; ++ ["Offset of field: sockaddr_in::sin_len"] ++ [::std::mem::offset_of!(sockaddr_in, sin_len) - 0usize]; ++ ["Offset of field: sockaddr_in::sin_family"] ++ [::std::mem::offset_of!(sockaddr_in, sin_family) - 1usize]; ++ ["Offset of field: sockaddr_in::sin_port"] ++ [::std::mem::offset_of!(sockaddr_in, sin_port) - 2usize]; ++ ["Offset of field: sockaddr_in::sin_addr"] ++ [::std::mem::offset_of!(sockaddr_in, sin_addr) - 4usize]; ++ ["Offset of field: sockaddr_in::sin_zero"] ++ [::std::mem::offset_of!(sockaddr_in, sin_zero) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct in6_addr { ++ pub __u6_addr: in6_addr__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union in6_addr__bindgen_ty_1 { ++ pub __u6_addr8: [u8; 16usize], ++ pub __u6_addr16: [u16; 8usize], ++ pub __u6_addr32: [u32; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in6_addr__bindgen_ty_1"] ++ [::std::mem::size_of::<in6_addr__bindgen_ty_1>() - 16usize]; ++ ["Alignment of in6_addr__bindgen_ty_1"] ++ [::std::mem::align_of::<in6_addr__bindgen_ty_1>() - 4usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr8"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr8) - 0usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr16"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr16) - 0usize]; ++ ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr32"] ++ [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr32) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of in6_addr"][::std::mem::size_of::<in6_addr>() - 16usize]; ++ ["Alignment of in6_addr"][::std::mem::align_of::<in6_addr>() - 4usize]; ++ ["Offset of field: in6_addr::__u6_addr"] ++ [::std::mem::offset_of!(in6_addr, __u6_addr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++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, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sockaddr_in6"][::std::mem::size_of::<sockaddr_in6>() - 28usize]; ++ ["Alignment of sockaddr_in6"] ++ [::std::mem::align_of::<sockaddr_in6>() - 4usize]; ++ ["Offset of field: sockaddr_in6::sin6_len"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_len) - 0usize]; ++ ["Offset of field: sockaddr_in6::sin6_family"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_family) - 1usize]; ++ ["Offset of field: sockaddr_in6::sin6_port"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_port) - 2usize]; ++ ["Offset of field: sockaddr_in6::sin6_flowinfo"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_flowinfo) - 4usize]; ++ ["Offset of field: sockaddr_in6::sin6_addr"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_addr) - 8usize]; ++ ["Offset of field: sockaddr_in6::sin6_scope_id"] ++ [::std::mem::offset_of!(sockaddr_in6, sin6_scope_id) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct addrinfo { ++ pub ai_flags: ::std::os::raw::c_int, ++ pub ai_family: ::std::os::raw::c_int, ++ pub ai_socktype: ::std::os::raw::c_int, ++ pub ai_protocol: ::std::os::raw::c_int, ++ pub ai_addrlen: socklen_t, ++ pub ai_canonname: *mut ::std::os::raw::c_char, ++ pub ai_addr: *mut sockaddr, ++ pub ai_next: *mut addrinfo, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of addrinfo"][::std::mem::size_of::<addrinfo>() - 48usize]; ++ ["Alignment of addrinfo"][::std::mem::align_of::<addrinfo>() - 8usize]; ++ ["Offset of field: addrinfo::ai_flags"] ++ [::std::mem::offset_of!(addrinfo, ai_flags) - 0usize]; ++ ["Offset of field: addrinfo::ai_family"] ++ [::std::mem::offset_of!(addrinfo, ai_family) - 4usize]; ++ ["Offset of field: addrinfo::ai_socktype"] ++ [::std::mem::offset_of!(addrinfo, ai_socktype) - 8usize]; ++ ["Offset of field: addrinfo::ai_protocol"] ++ [::std::mem::offset_of!(addrinfo, ai_protocol) - 12usize]; ++ ["Offset of field: addrinfo::ai_addrlen"] ++ [::std::mem::offset_of!(addrinfo, ai_addrlen) - 16usize]; ++ ["Offset of field: addrinfo::ai_canonname"] ++ [::std::mem::offset_of!(addrinfo, ai_canonname) - 24usize]; ++ ["Offset of field: addrinfo::ai_addr"] ++ [::std::mem::offset_of!(addrinfo, ai_addr) - 32usize]; ++ ["Offset of field: addrinfo::ai_next"] ++ [::std::mem::offset_of!(addrinfo, ai_next) - 40usize]; ++}; ++pub type tcflag_t = ::std::os::raw::c_uint; ++pub type cc_t = ::std::os::raw::c_uchar; ++pub type speed_t = ::std::os::raw::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++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; 20usize], ++ pub c_ispeed: speed_t, ++ pub c_ospeed: speed_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of termios"][::std::mem::size_of::<termios>() - 44usize]; ++ ["Alignment of termios"][::std::mem::align_of::<termios>() - 4usize]; ++ ["Offset of field: termios::c_iflag"] ++ [::std::mem::offset_of!(termios, c_iflag) - 0usize]; ++ ["Offset of field: termios::c_oflag"] ++ [::std::mem::offset_of!(termios, c_oflag) - 4usize]; ++ ["Offset of field: termios::c_cflag"] ++ [::std::mem::offset_of!(termios, c_cflag) - 8usize]; ++ ["Offset of field: termios::c_lflag"] ++ [::std::mem::offset_of!(termios, c_lflag) - 12usize]; ++ ["Offset of field: termios::c_cc"] ++ [::std::mem::offset_of!(termios, c_cc) - 16usize]; ++ ["Offset of field: termios::c_ispeed"] ++ [::std::mem::offset_of!(termios, c_ispeed) - 36usize]; ++ ["Offset of field: termios::c_ospeed"] ++ [::std::mem::offset_of!(termios, c_ospeed) - 40usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _usem2 { ++ pub _count: __uint32_t, ++ pub _flags: __uint32_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _usem2"][::std::mem::size_of::<_usem2>() - 8usize]; ++ ["Alignment of _usem2"][::std::mem::align_of::<_usem2>() - 4usize]; ++ ["Offset of field: _usem2::_count"] ++ [::std::mem::offset_of!(_usem2, _count) - 0usize]; ++ ["Offset of field: _usem2::_flags"] ++ [::std::mem::offset_of!(_usem2, _flags) - 4usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _sem { ++ pub _magic: __uint32_t, ++ pub _kern: _usem2, ++ pub _padding: __uint32_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _sem"][::std::mem::size_of::<_sem>() - 16usize]; ++ ["Alignment of _sem"][::std::mem::align_of::<_sem>() - 4usize]; ++ ["Offset of field: _sem::_magic"] ++ [::std::mem::offset_of!(_sem, _magic) - 0usize]; ++ ["Offset of field: _sem::_kern"] ++ [::std::mem::offset_of!(_sem, _kern) - 4usize]; ++ ["Offset of field: _sem::_padding"] ++ [::std::mem::offset_of!(_sem, _padding) - 12usize]; ++}; ++pub type sem_t = _sem; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__work { ++ pub work: ::std::option::Option<unsafe extern "C" fn(w: *mut uv__work)>, ++ pub done: ::std::option::Option< ++ unsafe extern "C" fn(w: *mut uv__work, status: ::std::os::raw::c_int), ++ >, ++ pub loop_: *mut uv_loop_s, ++ pub wq: uv__queue, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__work"][::std::mem::size_of::<uv__work>() - 40usize]; ++ ["Alignment of uv__work"][::std::mem::align_of::<uv__work>() - 8usize]; ++ ["Offset of field: uv__work::work"] ++ [::std::mem::offset_of!(uv__work, work) - 0usize]; ++ ["Offset of field: uv__work::done"] ++ [::std::mem::offset_of!(uv__work, done) - 8usize]; ++ ["Offset of field: uv__work::loop_"] ++ [::std::mem::offset_of!(uv__work, loop_) - 16usize]; ++ ["Offset of field: uv__work::wq"] ++ [::std::mem::offset_of!(uv__work, wq) - 24usize]; ++}; ++pub type uv__io_cb = ::std::option::Option< ++ unsafe extern "C" fn( ++ loop_: *mut uv_loop_s, ++ w: *mut uv__io_s, ++ events: ::std::os::raw::c_uint, ++ ), ++>; ++pub type uv__io_t = uv__io_s; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv__io_s { ++ pub cb: uv__io_cb, ++ pub pending_queue: uv__queue, ++ pub watcher_queue: uv__queue, ++ pub pevents: ::std::os::raw::c_uint, ++ pub events: ::std::os::raw::c_uint, ++ pub fd: ::std::os::raw::c_int, ++ pub rcount: ::std::os::raw::c_int, ++ pub wcount: ::std::os::raw::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv__io_s"][::std::mem::size_of::<uv__io_s>() - 64usize]; ++ ["Alignment of uv__io_s"][::std::mem::align_of::<uv__io_s>() - 8usize]; ++ ["Offset of field: uv__io_s::cb"] ++ [::std::mem::offset_of!(uv__io_s, cb) - 0usize]; ++ ["Offset of field: uv__io_s::pending_queue"] ++ [::std::mem::offset_of!(uv__io_s, pending_queue) - 8usize]; ++ ["Offset of field: uv__io_s::watcher_queue"] ++ [::std::mem::offset_of!(uv__io_s, watcher_queue) - 24usize]; ++ ["Offset of field: uv__io_s::pevents"] ++ [::std::mem::offset_of!(uv__io_s, pevents) - 40usize]; ++ ["Offset of field: uv__io_s::events"] ++ [::std::mem::offset_of!(uv__io_s, events) - 44usize]; ++ ["Offset of field: uv__io_s::fd"] ++ [::std::mem::offset_of!(uv__io_s, fd) - 48usize]; ++ ["Offset of field: uv__io_s::rcount"] ++ [::std::mem::offset_of!(uv__io_s, rcount) - 52usize]; ++ ["Offset of field: uv__io_s::wcount"] ++ [::std::mem::offset_of!(uv__io_s, wcount) - 56usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_buf_t { ++ pub base: *mut ::std::os::raw::c_char, ++ pub len: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_buf_t"][::std::mem::size_of::<uv_buf_t>() - 16usize]; ++ ["Alignment of uv_buf_t"][::std::mem::align_of::<uv_buf_t>() - 8usize]; ++ ["Offset of field: uv_buf_t::base"] ++ [::std::mem::offset_of!(uv_buf_t, base) - 0usize]; ++ ["Offset of field: uv_buf_t::len"] ++ [::std::mem::offset_of!(uv_buf_t, len) - 8usize]; ++}; ++pub type uv_file = ::std::os::raw::c_int; ++pub type uv_os_sock_t = ::std::os::raw::c_int; ++pub type uv_os_fd_t = ::std::os::raw::c_int; ++pub type uv_pid_t = pid_t; ++pub type uv_once_t = pthread_once_t; ++pub type uv_thread_t = pthread_t; ++pub type uv_mutex_t = pthread_mutex_t; ++pub type uv_rwlock_t = pthread_rwlock_t; ++pub type uv_sem_t = sem_t; ++pub type uv_cond_t = pthread_cond_t; ++pub type uv_key_t = pthread_key_t; ++pub type uv_barrier_t = pthread_barrier_t; ++pub type uv_gid_t = gid_t; ++pub type uv_uid_t = uid_t; ++pub type uv__dirent_t = dirent; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct uv_lib_t { ++ pub handle: *mut ::std::os::raw::c_void, ++ pub errmsg: *mut ::std::os::raw::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of uv_lib_t"][::std::mem::size_of::<uv_lib_t>() - 16usize]; ++ ["Alignment of uv_lib_t"][::std::mem::align_of::<uv_lib_t>() - 8usize]; ++ ["Offset of field: uv_lib_t::handle"] ++ [::std::mem::offset_of!(uv_lib_t, handle) - 0usize]; ++ ["Offset of field: uv_lib_t::errmsg"] ++ [::std::mem::offset_of!(uv_lib_t, errmsg) - 8usize]; ++}; ++impl uv_errno_t { ++ pub const UV_E2BIG: uv_errno_t = uv_errno_t(-7); ++} ++impl uv_errno_t { ++ pub const UV_EACCES: uv_errno_t = uv_errno_t(-13); ++} ++impl uv_errno_t { ++ pub const UV_EADDRINUSE: uv_errno_t = uv_errno_t(-48); ++} ++impl uv_errno_t { ++ pub const UV_EADDRNOTAVAIL: uv_errno_t = uv_errno_t(-49); ++} ++impl uv_errno_t { ++ pub const UV_EAFNOSUPPORT: uv_errno_t = uv_errno_t(-47); ++} ++impl uv_errno_t { ++ pub const UV_EAGAIN: uv_errno_t = uv_errno_t(-35); ++} ++impl uv_errno_t { ++ pub const UV_EAI_ADDRFAMILY: uv_errno_t = uv_errno_t(-3000); ++} ++impl uv_errno_t { ++ pub const UV_EAI_AGAIN: uv_errno_t = uv_errno_t(-3001); ++} ++impl uv_errno_t { ++ pub const UV_EAI_BADFLAGS: uv_errno_t = uv_errno_t(-3002); ++} ++impl uv_errno_t { ++ pub const UV_EAI_BADHINTS: uv_errno_t = uv_errno_t(-3013); ++} ++impl uv_errno_t { ++ pub const UV_EAI_CANCELED: uv_errno_t = uv_errno_t(-3003); ++} ++impl uv_errno_t { ++ pub const UV_EAI_FAIL: uv_errno_t = uv_errno_t(-3004); ++} ++impl uv_errno_t { ++ pub const UV_EAI_FAMILY: uv_errno_t = uv_errno_t(-3005); ++} ++impl uv_errno_t { ++ pub const UV_EAI_MEMORY: uv_errno_t = uv_errno_t(-3006); ++} ++impl uv_errno_t { ++ pub const UV_EAI_NODATA: uv_errno_t = uv_errno_t(-3007); ++} ++impl uv_errno_t { ++ pub const UV_EAI_NONAME: uv_errno_t = uv_errno_t(-3008); ++} ++impl uv_errno_t { ++ pub const UV_EAI_OVERFLOW: uv_errno_t = uv_errno_t(-3009); ++} ++impl uv_errno_t { ++ pub const UV_EAI_PROTOCOL: uv_errno_t = uv_errno_t(-3014); ++} ++impl uv_errno_t { ++ pub const UV_EAI_SERVICE: uv_errno_t = uv_errno_t(-3010); ++} ++impl uv_errno_t { ++ pub const UV_EAI_SOCKTYPE: uv_errno_t = uv_errno_t(-3011); ++} ++impl uv_errno_t { ++ pub const UV_EALREADY: uv_errno_t = uv_errno_t(-37); ++} ++impl uv_errno_t { ++ pub const UV_EBADF: uv_errno_t = uv_errno_t(-9); ++} ++impl uv_errno_t { ++ pub const UV_EBUSY: uv_errno_t = uv_errno_t(-16); ++} ++impl uv_errno_t { ++ pub const UV_ECANCELED: uv_errno_t = uv_errno_t(-85); ++} ++impl uv_errno_t { ++ pub const UV_ECHARSET: uv_errno_t = uv_errno_t(-4080); ++} ++impl uv_errno_t { ++ pub const UV_ECONNABORTED: uv_errno_t = uv_errno_t(-53); ++} ++impl uv_errno_t { ++ pub const UV_ECONNREFUSED: uv_errno_t = uv_errno_t(-61); ++} ++impl uv_errno_t { ++ pub const UV_ECONNRESET: uv_errno_t = uv_errno_t(-54); ++} ++impl uv_errno_t { ++ pub const UV_EDESTADDRREQ: uv_errno_t = uv_errno_t(-39); ++} ++impl uv_errno_t { ++ pub const UV_EEXIST: uv_errno_t = uv_errno_t(-17); ++} ++impl uv_errno_t { ++ pub const UV_EFAULT: uv_errno_t = uv_errno_t(-14); ++} ++impl uv_errno_t { ++ pub const UV_EFBIG: uv_errno_t = uv_errno_t(-27); ++} ++impl uv_errno_t { ++ pub const UV_EHOSTUNREACH: uv_errno_t = uv_errno_t(-65); ++} ++impl uv_errno_t { ++ pub const UV_EINTR: uv_errno_t = uv_errno_t(-4); ++} ++impl uv_errno_t { ++ pub const UV_EINVAL: uv_errno_t = uv_errno_t(-22); ++} ++impl uv_errno_t { ++ pub const UV_EIO: uv_errno_t = uv_errno_t(-5); ++} ++impl uv_errno_t { ++ pub const UV_EISCONN: uv_errno_t = uv_errno_t(-56); ++} ++impl uv_errno_t { ++ pub const UV_EISDIR: uv_errno_t = uv_errno_t(-21); ++} ++impl uv_errno_t { ++ pub const UV_ELOOP: uv_errno_t = uv_errno_t(-62); ++} ++impl uv_errno_t { ++ pub const UV_EMFILE: uv_errno_t = uv_errno_t(-24); ++} ++impl uv_errno_t { ++ pub const UV_EMSGSIZE: uv_errno_t = uv_errno_t(-40); ++} ++impl uv_errno_t { ++ pub const UV_ENAMETOOLONG: uv_errno_t = uv_errno_t(-63); ++} ++impl uv_errno_t { ++ pub const UV_ENETDOWN: uv_errno_t = uv_errno_t(-50); ++} ++impl uv_errno_t { ++ pub const UV_ENETUNREACH: uv_errno_t = uv_errno_t(-51); ++} ++impl uv_errno_t { ++ pub const UV_ENFILE: uv_errno_t = uv_errno_t(-23); ++} ++impl uv_errno_t { ++ pub const UV_ENOBUFS: uv_errno_t = uv_errno_t(-55); ++} ++impl uv_errno_t { ++ pub const UV_ENODEV: uv_errno_t = uv_errno_t(-19); ++} ++impl uv_errno_t { ++ pub const UV_ENOENT: uv_errno_t = uv_errno_t(-2); ++} ++impl uv_errno_t { ++ pub const UV_ENOMEM: uv_errno_t = uv_errno_t(-12); ++} ++impl uv_errno_t { ++ pub const UV_ENONET: uv_errno_t = uv_errno_t(-4056); ++} ++impl uv_errno_t { ++ pub const UV_ENOPROTOOPT: uv_errno_t = uv_errno_t(-42); ++} ++impl uv_errno_t { ++ pub const UV_ENOSPC: uv_errno_t = uv_errno_t(-28); ++} ++impl uv_errno_t { ++ pub const UV_ENOSYS: uv_errno_t = uv_errno_t(-78); ++} ++impl uv_errno_t { ++ pub const UV_ENOTCONN: uv_errno_t = uv_errno_t(-57); ++} ++impl uv_errno_t { ++ pub const UV_ENOTDIR: uv_errno_t = uv_errno_t(-20); ++} ++impl uv_errno_t { ++ pub const UV_ENOTEMPTY: uv_errno_t = uv_errno_t(-66); ++} ++impl uv_errno_t { ++ pub const UV_ENOTSOCK: uv_errno_t = uv_errno_t(-38); ++} ++impl uv_errno_t { ++ pub const UV_ENOTSUP: uv_errno_t = uv_errno_t(-45); ++} ++impl uv_errno_t { ++ pub const UV_EOVERFLOW: uv_errno_t = uv_errno_t(-84); ++} ++impl uv_errno_t { ++ pub const UV_EPERM: uv_errno_t = uv_errno_t(-1); ++} ++impl uv_errno_t { ++ pub const UV_EPIPE: uv_errno_t = uv_errno_t(-32); ++} ++impl uv_errno_t { ++ pub const UV_EPROTO: uv_errno_t = uv_errno_t(-92); ++} ++impl uv_errno_t { ++ pub const UV_EPROTONOSUPPORT: uv_errno_t = uv_errno_t(-43); ++} ++impl uv_errno_t { ++ pub const UV_EPROTOTYPE: uv_errno_t = uv_errno_t(-41); ++} ++impl uv_errno_t { ++ pub const UV_ERANGE: uv_errno_t = uv_errno_t(-34); ++} ++impl uv_errno_t { ++ pub const UV_EROFS: uv_errno_t = uv_errno_t(-30); ++} ++impl uv_errno_t { ++ pub const UV_ESHUTDOWN: uv_errno_t = uv_errno_t(-58); ++} ++impl uv_errno_t { ++ pub const UV_ESPIPE: uv_errno_t = uv_errno_t(-29); ++} ++impl uv_errno_t { ++ pub const UV_ESRCH: uv_errno_t = uv_errno_t(-3); ++} ++impl uv_errno_t { ++ pub const UV_ETIMEDOUT: uv_errno_t = uv_errno_t(-60); ++} ++impl uv_errno_t { ++ pub const UV_ETXTBSY: uv_errno_t = uv_errno_t(-26); ++} ++impl uv_errno_t { ++ pub const UV_EXDEV: uv_errno_t = uv_errno_t(-18); ++} ++impl uv_errno_t { ++ pub const UV_UNKNOWN: uv_errno_t = uv_errno_t(-4094); ++} ++impl uv_errno_t { ++ pub const UV_EOF: uv_errno_t = uv_errno_t(-4095); ++} ++impl uv_errno_t { ++ pub const UV_ENXIO: uv_errno_t = uv_errno_t(-6); ++} ++impl uv_errno_t { ++ pub const UV_EMLINK: uv_errno_t = uv_errno_t(-31); ++} ++impl uv_errno_t { ++ pub const UV_EHOSTDOWN: uv_errno_t = uv_errno_t(-64); ++} ++impl uv_errno_t { ++ pub const UV_EREMOTEIO: uv_errno_t = uv_errno_t(-4030); ++} ++impl uv_errno_t { ++ pub const UV_ENOTTY: uv_errno_t = uv_errno_t(-25); ++} ++impl uv_errno_t { ++ pub const UV_EFTYPE: uv_errno_t = uv_errno_t(-79); ++} ++impl uv_errno_t { ++ pub const UV_EILSEQ: uv_errno_t = uv_errno_t(-86); ++} *** 6454 LINES SKIPPED ***home | help
Want to link to this message? Use this
URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?69d4e3bc.1f886.d7500f1>