From 88f5213106a291a20b81af1c74a1303d3123f8b8 Mon Sep 17 00:00:00 2001 From: BotoX Date: Thu, 3 Jun 2021 19:51:32 +0200 Subject: [PATCH] add precompiled libuv v1.41.0 --- .gitignore | 3 +- AMBuildScript | 1 + extension/libuv/.gitignore | 2 - extension/libuv/include/uv.h | 1833 ++++++++++++++++++ extension/libuv/include/uv/aix.h | 32 + extension/libuv/include/uv/android-ifaddrs.h | 54 + extension/libuv/include/uv/bsd.h | 34 + extension/libuv/include/uv/darwin.h | 61 + extension/libuv/include/uv/errno.h | 448 +++++ extension/libuv/include/uv/linux.h | 34 + extension/libuv/include/uv/os390.h | 33 + extension/libuv/include/uv/posix.h | 31 + extension/libuv/include/uv/stdint-msvc2008.h | 247 +++ extension/libuv/include/uv/sunos.h | 44 + extension/libuv/include/uv/threadpool.h | 37 + extension/libuv/include/uv/tree.h | 768 ++++++++ extension/libuv/include/uv/unix.h | 507 +++++ extension/libuv/include/uv/version.h | 43 + extension/libuv/include/uv/win.h | 691 +++++++ extension/libuv/libuv.a | Bin 0 -> 1039316 bytes 20 files changed, 4899 insertions(+), 4 deletions(-) delete mode 100644 extension/libuv/.gitignore create mode 100644 extension/libuv/include/uv.h create mode 100644 extension/libuv/include/uv/aix.h create mode 100644 extension/libuv/include/uv/android-ifaddrs.h create mode 100644 extension/libuv/include/uv/bsd.h create mode 100644 extension/libuv/include/uv/darwin.h create mode 100644 extension/libuv/include/uv/errno.h create mode 100644 extension/libuv/include/uv/linux.h create mode 100644 extension/libuv/include/uv/os390.h create mode 100644 extension/libuv/include/uv/posix.h create mode 100644 extension/libuv/include/uv/stdint-msvc2008.h create mode 100644 extension/libuv/include/uv/sunos.h create mode 100644 extension/libuv/include/uv/threadpool.h create mode 100644 extension/libuv/include/uv/tree.h create mode 100644 extension/libuv/include/uv/unix.h create mode 100644 extension/libuv/include/uv/version.h create mode 100644 extension/libuv/include/uv/win.h create mode 100644 extension/libuv/libuv.a diff --git a/.gitignore b/.gitignore index 98c6eb2..31dc0db 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,2 @@ extension/msvc*/* -extension/libs/* -build/* \ No newline at end of file +build/* diff --git a/AMBuildScript b/AMBuildScript index 076fd34..5541550 100644 --- a/AMBuildScript +++ b/AMBuildScript @@ -189,6 +189,7 @@ class AsyncSocketConfig(object): cxx.linkflags += ['-static-libgcc'] elif cxx.vendor == 'clang': cxx.linkflags += ['-lgcc_eh'] + cxx.linkflags += ['-static-libstdc++'] def configure_mac(self, cxx): cxx.defines += ['OSX', '_OSX', 'POSIX'] diff --git a/extension/libuv/.gitignore b/extension/libuv/.gitignore deleted file mode 100644 index d6b7ef3..0000000 --- a/extension/libuv/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -* -!.gitignore diff --git a/extension/libuv/include/uv.h b/extension/libuv/include/uv.h new file mode 100644 index 0000000..1e1fc94 --- /dev/null +++ b/extension/libuv/include/uv.h @@ -0,0 +1,1833 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +/* See https://github.com/libuv/libuv#documentation for documentation. */ + +#ifndef UV_H +#define UV_H +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(BUILDING_UV_SHARED) && defined(USING_UV_SHARED) +#error "Define either BUILDING_UV_SHARED or USING_UV_SHARED, not both." +#endif + +#ifdef _WIN32 + /* Windows - set up dll import/export decorators. */ +# if defined(BUILDING_UV_SHARED) + /* Building shared library. */ +# define UV_EXTERN __declspec(dllexport) +# elif defined(USING_UV_SHARED) + /* Using shared library. */ +# define UV_EXTERN __declspec(dllimport) +# else + /* Building static library. */ +# define UV_EXTERN /* nothing */ +# endif +#elif __GNUC__ >= 4 +# define UV_EXTERN __attribute__((visibility("default"))) +#else +# define UV_EXTERN /* nothing */ +#endif + +#include "uv/errno.h" +#include "uv/version.h" +#include +#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif + +#if defined(_WIN32) +# include "uv/win.h" +#else +# include "uv/unix.h" +#endif + +/* Expand this list if necessary. */ +#define UV_ERRNO_MAP(XX) \ + XX(E2BIG, "argument list too long") \ + XX(EACCES, "permission denied") \ + XX(EADDRINUSE, "address already in use") \ + XX(EADDRNOTAVAIL, "address not available") \ + XX(EAFNOSUPPORT, "address family not supported") \ + XX(EAGAIN, "resource temporarily unavailable") \ + XX(EAI_ADDRFAMILY, "address family not supported") \ + XX(EAI_AGAIN, "temporary failure") \ + XX(EAI_BADFLAGS, "bad ai_flags value") \ + XX(EAI_BADHINTS, "invalid value for hints") \ + XX(EAI_CANCELED, "request canceled") \ + XX(EAI_FAIL, "permanent failure") \ + XX(EAI_FAMILY, "ai_family not supported") \ + XX(EAI_MEMORY, "out of memory") \ + XX(EAI_NODATA, "no address") \ + XX(EAI_NONAME, "unknown node or service") \ + XX(EAI_OVERFLOW, "argument buffer overflow") \ + XX(EAI_PROTOCOL, "resolved protocol is unknown") \ + XX(EAI_SERVICE, "service not available for socket type") \ + XX(EAI_SOCKTYPE, "socket type not supported") \ + XX(EALREADY, "connection already in progress") \ + XX(EBADF, "bad file descriptor") \ + XX(EBUSY, "resource busy or locked") \ + XX(ECANCELED, "operation canceled") \ + XX(ECHARSET, "invalid Unicode character") \ + XX(ECONNABORTED, "software caused connection abort") \ + XX(ECONNREFUSED, "connection refused") \ + XX(ECONNRESET, "connection reset by peer") \ + XX(EDESTADDRREQ, "destination address required") \ + XX(EEXIST, "file already exists") \ + XX(EFAULT, "bad address in system call argument") \ + XX(EFBIG, "file too large") \ + XX(EHOSTUNREACH, "host is unreachable") \ + XX(EINTR, "interrupted system call") \ + XX(EINVAL, "invalid argument") \ + XX(EIO, "i/o error") \ + XX(EISCONN, "socket is already connected") \ + XX(EISDIR, "illegal operation on a directory") \ + XX(ELOOP, "too many symbolic links encountered") \ + XX(EMFILE, "too many open files") \ + XX(EMSGSIZE, "message too long") \ + XX(ENAMETOOLONG, "name too long") \ + XX(ENETDOWN, "network is down") \ + XX(ENETUNREACH, "network is unreachable") \ + XX(ENFILE, "file table overflow") \ + XX(ENOBUFS, "no buffer space available") \ + XX(ENODEV, "no such device") \ + XX(ENOENT, "no such file or directory") \ + XX(ENOMEM, "not enough memory") \ + XX(ENONET, "machine is not on the network") \ + XX(ENOPROTOOPT, "protocol not available") \ + XX(ENOSPC, "no space left on device") \ + XX(ENOSYS, "function not implemented") \ + XX(ENOTCONN, "socket is not connected") \ + XX(ENOTDIR, "not a directory") \ + XX(ENOTEMPTY, "directory not empty") \ + XX(ENOTSOCK, "socket operation on non-socket") \ + XX(ENOTSUP, "operation not supported on socket") \ + XX(EPERM, "operation not permitted") \ + XX(EPIPE, "broken pipe") \ + XX(EPROTO, "protocol error") \ + XX(EPROTONOSUPPORT, "protocol not supported") \ + XX(EPROTOTYPE, "protocol wrong type for socket") \ + XX(ERANGE, "result too large") \ + XX(EROFS, "read-only file system") \ + XX(ESHUTDOWN, "cannot send after transport endpoint shutdown") \ + XX(ESPIPE, "invalid seek") \ + XX(ESRCH, "no such process") \ + XX(ETIMEDOUT, "connection timed out") \ + XX(ETXTBSY, "text file is busy") \ + XX(EXDEV, "cross-device link not permitted") \ + XX(UNKNOWN, "unknown error") \ + XX(EOF, "end of file") \ + XX(ENXIO, "no such device or address") \ + XX(EMLINK, "too many links") \ + XX(EHOSTDOWN, "host is down") \ + XX(EREMOTEIO, "remote I/O error") \ + XX(ENOTTY, "inappropriate ioctl for device") \ + XX(EFTYPE, "inappropriate file type or format") \ + XX(EILSEQ, "illegal byte sequence") \ + +#define UV_HANDLE_TYPE_MAP(XX) \ + XX(ASYNC, async) \ + XX(CHECK, check) \ + XX(FS_EVENT, fs_event) \ + XX(FS_POLL, fs_poll) \ + XX(HANDLE, handle) \ + XX(IDLE, idle) \ + XX(NAMED_PIPE, pipe) \ + XX(POLL, poll) \ + XX(PREPARE, prepare) \ + XX(PROCESS, process) \ + XX(STREAM, stream) \ + XX(TCP, tcp) \ + XX(TIMER, timer) \ + XX(TTY, tty) \ + XX(UDP, udp) \ + XX(SIGNAL, signal) \ + +#define UV_REQ_TYPE_MAP(XX) \ + XX(REQ, req) \ + XX(CONNECT, connect) \ + XX(WRITE, write) \ + XX(SHUTDOWN, shutdown) \ + XX(UDP_SEND, udp_send) \ + XX(FS, fs) \ + XX(WORK, work) \ + XX(GETADDRINFO, getaddrinfo) \ + XX(GETNAMEINFO, getnameinfo) \ + XX(RANDOM, random) \ + +typedef enum { +#define XX(code, _) UV_ ## code = UV__ ## code, + UV_ERRNO_MAP(XX) +#undef XX + UV_ERRNO_MAX = UV__EOF - 1 +} uv_errno_t; + +typedef enum { + UV_UNKNOWN_HANDLE = 0, +#define XX(uc, lc) UV_##uc, + UV_HANDLE_TYPE_MAP(XX) +#undef XX + UV_FILE, + UV_HANDLE_TYPE_MAX +} uv_handle_type; + +typedef enum { + UV_UNKNOWN_REQ = 0, +#define XX(uc, lc) UV_##uc, + UV_REQ_TYPE_MAP(XX) +#undef XX + UV_REQ_TYPE_PRIVATE + UV_REQ_TYPE_MAX +} uv_req_type; + + +/* Handle types. */ +typedef struct uv_loop_s uv_loop_t; +typedef struct uv_handle_s uv_handle_t; +typedef struct uv_dir_s uv_dir_t; +typedef struct uv_stream_s uv_stream_t; +typedef struct uv_tcp_s uv_tcp_t; +typedef struct uv_udp_s uv_udp_t; +typedef struct uv_pipe_s uv_pipe_t; +typedef struct uv_tty_s uv_tty_t; +typedef struct uv_poll_s uv_poll_t; +typedef struct uv_timer_s uv_timer_t; +typedef struct uv_prepare_s uv_prepare_t; +typedef struct uv_check_s uv_check_t; +typedef struct uv_idle_s uv_idle_t; +typedef struct uv_async_s uv_async_t; +typedef struct uv_process_s uv_process_t; +typedef struct uv_fs_event_s uv_fs_event_t; +typedef struct uv_fs_poll_s uv_fs_poll_t; +typedef struct uv_signal_s uv_signal_t; + +/* Request types. */ +typedef struct uv_req_s uv_req_t; +typedef struct uv_getaddrinfo_s uv_getaddrinfo_t; +typedef struct uv_getnameinfo_s uv_getnameinfo_t; +typedef struct uv_shutdown_s uv_shutdown_t; +typedef struct uv_write_s uv_write_t; +typedef struct uv_connect_s uv_connect_t; +typedef struct uv_udp_send_s uv_udp_send_t; +typedef struct uv_fs_s uv_fs_t; +typedef struct uv_work_s uv_work_t; +typedef struct uv_random_s uv_random_t; + +/* None of the above. */ +typedef struct uv_env_item_s uv_env_item_t; +typedef struct uv_cpu_info_s uv_cpu_info_t; +typedef struct uv_interface_address_s uv_interface_address_t; +typedef struct uv_dirent_s uv_dirent_t; +typedef struct uv_passwd_s uv_passwd_t; +typedef struct uv_utsname_s uv_utsname_t; +typedef struct uv_statfs_s uv_statfs_t; + +typedef enum { + UV_LOOP_BLOCK_SIGNAL = 0, + UV_METRICS_IDLE_TIME +} uv_loop_option; + +typedef enum { + UV_RUN_DEFAULT = 0, + UV_RUN_ONCE, + UV_RUN_NOWAIT +} uv_run_mode; + + +UV_EXTERN unsigned int uv_version(void); +UV_EXTERN const char* uv_version_string(void); + +typedef void* (*uv_malloc_func)(size_t size); +typedef void* (*uv_realloc_func)(void* ptr, size_t size); +typedef void* (*uv_calloc_func)(size_t count, size_t size); +typedef void (*uv_free_func)(void* ptr); + +UV_EXTERN void uv_library_shutdown(void); + +UV_EXTERN int uv_replace_allocator(uv_malloc_func malloc_func, + uv_realloc_func realloc_func, + uv_calloc_func calloc_func, + uv_free_func free_func); + +UV_EXTERN uv_loop_t* uv_default_loop(void); +UV_EXTERN int uv_loop_init(uv_loop_t* loop); +UV_EXTERN int uv_loop_close(uv_loop_t* loop); +/* + * NOTE: + * This function is DEPRECATED (to be removed after 0.12), users should + * allocate the loop manually and use uv_loop_init instead. + */ +UV_EXTERN uv_loop_t* uv_loop_new(void); +/* + * NOTE: + * This function is DEPRECATED (to be removed after 0.12). Users should use + * uv_loop_close and free the memory manually instead. + */ +UV_EXTERN void uv_loop_delete(uv_loop_t*); +UV_EXTERN size_t uv_loop_size(void); +UV_EXTERN int uv_loop_alive(const uv_loop_t* loop); +UV_EXTERN int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...); +UV_EXTERN int uv_loop_fork(uv_loop_t* loop); + +UV_EXTERN int uv_run(uv_loop_t*, uv_run_mode mode); +UV_EXTERN void uv_stop(uv_loop_t*); + +UV_EXTERN void uv_ref(uv_handle_t*); +UV_EXTERN void uv_unref(uv_handle_t*); +UV_EXTERN int uv_has_ref(const uv_handle_t*); + +UV_EXTERN void uv_update_time(uv_loop_t*); +UV_EXTERN uint64_t uv_now(const uv_loop_t*); + +UV_EXTERN int uv_backend_fd(const uv_loop_t*); +UV_EXTERN int uv_backend_timeout(const uv_loop_t*); + +typedef void (*uv_alloc_cb)(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf); +typedef void (*uv_read_cb)(uv_stream_t* stream, + ssize_t nread, + const uv_buf_t* buf); +typedef void (*uv_write_cb)(uv_write_t* req, int status); +typedef void (*uv_connect_cb)(uv_connect_t* req, int status); +typedef void (*uv_shutdown_cb)(uv_shutdown_t* req, int status); +typedef void (*uv_connection_cb)(uv_stream_t* server, int status); +typedef void (*uv_close_cb)(uv_handle_t* handle); +typedef void (*uv_poll_cb)(uv_poll_t* handle, int status, int events); +typedef void (*uv_timer_cb)(uv_timer_t* handle); +typedef void (*uv_async_cb)(uv_async_t* handle); +typedef void (*uv_prepare_cb)(uv_prepare_t* handle); +typedef void (*uv_check_cb)(uv_check_t* handle); +typedef void (*uv_idle_cb)(uv_idle_t* handle); +typedef void (*uv_exit_cb)(uv_process_t*, int64_t exit_status, int term_signal); +typedef void (*uv_walk_cb)(uv_handle_t* handle, void* arg); +typedef void (*uv_fs_cb)(uv_fs_t* req); +typedef void (*uv_work_cb)(uv_work_t* req); +typedef void (*uv_after_work_cb)(uv_work_t* req, int status); +typedef void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* req, + int status, + struct addrinfo* res); +typedef void (*uv_getnameinfo_cb)(uv_getnameinfo_t* req, + int status, + const char* hostname, + const char* service); +typedef void (*uv_random_cb)(uv_random_t* req, + int status, + void* buf, + size_t buflen); + +typedef struct { + long tv_sec; + long tv_nsec; +} uv_timespec_t; + + +typedef struct { + uint64_t st_dev; + uint64_t st_mode; + uint64_t st_nlink; + uint64_t st_uid; + uint64_t st_gid; + uint64_t st_rdev; + uint64_t st_ino; + uint64_t st_size; + uint64_t st_blksize; + uint64_t st_blocks; + uint64_t st_flags; + uint64_t st_gen; + uv_timespec_t st_atim; + uv_timespec_t st_mtim; + uv_timespec_t st_ctim; + uv_timespec_t st_birthtim; +} uv_stat_t; + + +typedef void (*uv_fs_event_cb)(uv_fs_event_t* handle, + const char* filename, + int events, + int status); + +typedef void (*uv_fs_poll_cb)(uv_fs_poll_t* handle, + int status, + const uv_stat_t* prev, + const uv_stat_t* curr); + +typedef void (*uv_signal_cb)(uv_signal_t* handle, int signum); + + +typedef enum { + UV_LEAVE_GROUP = 0, + UV_JOIN_GROUP +} uv_membership; + + +UV_EXTERN int uv_translate_sys_error(int sys_errno); + +UV_EXTERN const char* uv_strerror(int err); +UV_EXTERN char* uv_strerror_r(int err, char* buf, size_t buflen); + +UV_EXTERN const char* uv_err_name(int err); +UV_EXTERN char* uv_err_name_r(int err, char* buf, size_t buflen); + + +#define UV_REQ_FIELDS \ + /* public */ \ + void* data; \ + /* read-only */ \ + uv_req_type type; \ + /* private */ \ + void* reserved[6]; \ + UV_REQ_PRIVATE_FIELDS \ + +/* Abstract base class of all requests. */ +struct uv_req_s { + UV_REQ_FIELDS +}; + + +/* Platform-specific request types. */ +UV_PRIVATE_REQ_TYPES + + +UV_EXTERN int uv_shutdown(uv_shutdown_t* req, + uv_stream_t* handle, + uv_shutdown_cb cb); + +struct uv_shutdown_s { + UV_REQ_FIELDS + uv_stream_t* handle; + uv_shutdown_cb cb; + UV_SHUTDOWN_PRIVATE_FIELDS +}; + + +#define UV_HANDLE_FIELDS \ + /* public */ \ + void* data; \ + /* read-only */ \ + uv_loop_t* loop; \ + uv_handle_type type; \ + /* private */ \ + uv_close_cb close_cb; \ + void* handle_queue[2]; \ + union { \ + int fd; \ + void* reserved[4]; \ + } u; \ + UV_HANDLE_PRIVATE_FIELDS \ + +/* The abstract base class of all handles. */ +struct uv_handle_s { + UV_HANDLE_FIELDS +}; + +UV_EXTERN size_t uv_handle_size(uv_handle_type type); +UV_EXTERN uv_handle_type uv_handle_get_type(const uv_handle_t* handle); +UV_EXTERN const char* uv_handle_type_name(uv_handle_type type); +UV_EXTERN void* uv_handle_get_data(const uv_handle_t* handle); +UV_EXTERN uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle); +UV_EXTERN void uv_handle_set_data(uv_handle_t* handle, void* data); + +UV_EXTERN size_t uv_req_size(uv_req_type type); +UV_EXTERN void* uv_req_get_data(const uv_req_t* req); +UV_EXTERN void uv_req_set_data(uv_req_t* req, void* data); +UV_EXTERN uv_req_type uv_req_get_type(const uv_req_t* req); +UV_EXTERN const char* uv_req_type_name(uv_req_type type); + +UV_EXTERN int uv_is_active(const uv_handle_t* handle); + +UV_EXTERN void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg); + +/* Helpers for ad hoc debugging, no API/ABI stability guaranteed. */ +UV_EXTERN void uv_print_all_handles(uv_loop_t* loop, FILE* stream); +UV_EXTERN void uv_print_active_handles(uv_loop_t* loop, FILE* stream); + +UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb); + +UV_EXTERN int uv_send_buffer_size(uv_handle_t* handle, int* value); +UV_EXTERN int uv_recv_buffer_size(uv_handle_t* handle, int* value); + +UV_EXTERN int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd); + +UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len); + +UV_EXTERN int uv_pipe(uv_file fds[2], int read_flags, int write_flags); +UV_EXTERN int uv_socketpair(int type, + int protocol, + uv_os_sock_t socket_vector[2], + int flags0, + int flags1); + +#define UV_STREAM_FIELDS \ + /* number of bytes queued for writing */ \ + size_t write_queue_size; \ + uv_alloc_cb alloc_cb; \ + uv_read_cb read_cb; \ + /* private */ \ + UV_STREAM_PRIVATE_FIELDS + +/* + * uv_stream_t is a subclass of uv_handle_t. + * + * uv_stream is an abstract class. + * + * uv_stream_t is the parent class of uv_tcp_t, uv_pipe_t and uv_tty_t. + */ +struct uv_stream_s { + UV_HANDLE_FIELDS + UV_STREAM_FIELDS +}; + +UV_EXTERN size_t uv_stream_get_write_queue_size(const uv_stream_t* stream); + +UV_EXTERN int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb); +UV_EXTERN int uv_accept(uv_stream_t* server, uv_stream_t* client); + +UV_EXTERN int uv_read_start(uv_stream_t*, + uv_alloc_cb alloc_cb, + uv_read_cb read_cb); +UV_EXTERN int uv_read_stop(uv_stream_t*); + +UV_EXTERN int uv_write(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb); +UV_EXTERN int uv_write2(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle, + uv_write_cb cb); +UV_EXTERN int uv_try_write(uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs); + +/* uv_write_t is a subclass of uv_req_t. */ +struct uv_write_s { + UV_REQ_FIELDS + uv_write_cb cb; + uv_stream_t* send_handle; /* TODO: make private and unix-only in v2.x. */ + uv_stream_t* handle; + UV_WRITE_PRIVATE_FIELDS +}; + + +UV_EXTERN int uv_is_readable(const uv_stream_t* handle); +UV_EXTERN int uv_is_writable(const uv_stream_t* handle); + +UV_EXTERN int uv_stream_set_blocking(uv_stream_t* handle, int blocking); + +UV_EXTERN int uv_is_closing(const uv_handle_t* handle); + + +/* + * uv_tcp_t is a subclass of uv_stream_t. + * + * Represents a TCP stream or TCP server. + */ +struct uv_tcp_s { + UV_HANDLE_FIELDS + UV_STREAM_FIELDS + UV_TCP_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_tcp_init(uv_loop_t*, uv_tcp_t* handle); +UV_EXTERN int uv_tcp_init_ex(uv_loop_t*, uv_tcp_t* handle, unsigned int flags); +UV_EXTERN int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock); +UV_EXTERN int uv_tcp_nodelay(uv_tcp_t* handle, int enable); +UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle, + int enable, + unsigned int delay); +UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable); + +enum uv_tcp_flags { + /* Used with uv_tcp_bind, when an IPv6 address is used. */ + UV_TCP_IPV6ONLY = 1 +}; + +UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int flags); +UV_EXTERN int uv_tcp_getsockname(const uv_tcp_t* handle, + struct sockaddr* name, + int* namelen); +UV_EXTERN int uv_tcp_getpeername(const uv_tcp_t* handle, + struct sockaddr* name, + int* namelen); +UV_EXTERN int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb); +UV_EXTERN int uv_tcp_connect(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr* addr, + uv_connect_cb cb); + +/* uv_connect_t is a subclass of uv_req_t. */ +struct uv_connect_s { + UV_REQ_FIELDS + uv_connect_cb cb; + uv_stream_t* handle; + UV_CONNECT_PRIVATE_FIELDS +}; + + +/* + * UDP support. + */ + +enum uv_udp_flags { + /* Disables dual stack mode. */ + UV_UDP_IPV6ONLY = 1, + /* + * Indicates message was truncated because read buffer was too small. The + * remainder was discarded by the OS. Used in uv_udp_recv_cb. + */ + UV_UDP_PARTIAL = 2, + /* + * Indicates if SO_REUSEADDR will be set when binding the handle. + * This sets the SO_REUSEPORT socket flag on the BSDs and OS X. On other + * Unix platforms, it sets the SO_REUSEADDR flag. What that means is that + * multiple threads or processes can bind to the same address without error + * (provided they all set the flag) but only the last one to bind will receive + * any traffic, in effect "stealing" the port from the previous listener. + */ + UV_UDP_REUSEADDR = 4, + /* + * Indicates that the message was received by recvmmsg, so the buffer provided + * must not be freed by the recv_cb callback. + */ + UV_UDP_MMSG_CHUNK = 8, + /* + * Indicates that the buffer provided has been fully utilized by recvmmsg and + * that it should now be freed by the recv_cb callback. When this flag is set + * in uv_udp_recv_cb, nread will always be 0 and addr will always be NULL. + */ + UV_UDP_MMSG_FREE = 16, + + /* + * Indicates that recvmmsg should be used, if available. + */ + UV_UDP_RECVMMSG = 256 +}; + +typedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status); +typedef void (*uv_udp_recv_cb)(uv_udp_t* handle, + ssize_t nread, + const uv_buf_t* buf, + const struct sockaddr* addr, + unsigned flags); + +/* uv_udp_t is a subclass of uv_handle_t. */ +struct uv_udp_s { + UV_HANDLE_FIELDS + /* read-only */ + /* + * Number of bytes queued for sending. This field strictly shows how much + * information is currently queued. + */ + size_t send_queue_size; + /* + * Number of send requests currently in the queue awaiting to be processed. + */ + size_t send_queue_count; + UV_UDP_PRIVATE_FIELDS +}; + +/* uv_udp_send_t is a subclass of uv_req_t. */ +struct uv_udp_send_s { + UV_REQ_FIELDS + uv_udp_t* handle; + uv_udp_send_cb cb; + UV_UDP_SEND_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_udp_init(uv_loop_t*, uv_udp_t* handle); +UV_EXTERN int uv_udp_init_ex(uv_loop_t*, uv_udp_t* handle, unsigned int flags); +UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock); +UV_EXTERN int uv_udp_bind(uv_udp_t* handle, + const struct sockaddr* addr, + unsigned int flags); +UV_EXTERN int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr); + +UV_EXTERN int uv_udp_getpeername(const uv_udp_t* handle, + struct sockaddr* name, + int* namelen); +UV_EXTERN int uv_udp_getsockname(const uv_udp_t* handle, + struct sockaddr* name, + int* namelen); +UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle, + const char* multicast_addr, + const char* interface_addr, + uv_membership membership); +UV_EXTERN int uv_udp_set_source_membership(uv_udp_t* handle, + const char* multicast_addr, + const char* interface_addr, + const char* source_addr, + uv_membership membership); +UV_EXTERN int uv_udp_set_multicast_loop(uv_udp_t* handle, int on); +UV_EXTERN int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl); +UV_EXTERN int uv_udp_set_multicast_interface(uv_udp_t* handle, + const char* interface_addr); +UV_EXTERN int uv_udp_set_broadcast(uv_udp_t* handle, int on); +UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl); +UV_EXTERN int uv_udp_send(uv_udp_send_t* req, + uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr, + uv_udp_send_cb send_cb); +UV_EXTERN int uv_udp_try_send(uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr); +UV_EXTERN int uv_udp_recv_start(uv_udp_t* handle, + uv_alloc_cb alloc_cb, + uv_udp_recv_cb recv_cb); +UV_EXTERN int uv_udp_using_recvmmsg(const uv_udp_t* handle); +UV_EXTERN int uv_udp_recv_stop(uv_udp_t* handle); +UV_EXTERN size_t uv_udp_get_send_queue_size(const uv_udp_t* handle); +UV_EXTERN size_t uv_udp_get_send_queue_count(const uv_udp_t* handle); + + +/* + * uv_tty_t is a subclass of uv_stream_t. + * + * Representing a stream for the console. + */ +struct uv_tty_s { + UV_HANDLE_FIELDS + UV_STREAM_FIELDS + UV_TTY_PRIVATE_FIELDS +}; + +typedef enum { + /* Initial/normal terminal mode */ + UV_TTY_MODE_NORMAL, + /* Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled) */ + UV_TTY_MODE_RAW, + /* Binary-safe I/O mode for IPC (Unix-only) */ + UV_TTY_MODE_IO +} uv_tty_mode_t; + +typedef enum { + /* + * The console supports handling of virtual terminal sequences + * (Windows10 new console, ConEmu) + */ + UV_TTY_SUPPORTED, + /* The console cannot process the virtual terminal sequence. (Legacy + * console) + */ + UV_TTY_UNSUPPORTED +} uv_tty_vtermstate_t; + + +UV_EXTERN int uv_tty_init(uv_loop_t*, uv_tty_t*, uv_file fd, int readable); +UV_EXTERN int uv_tty_set_mode(uv_tty_t*, uv_tty_mode_t mode); +UV_EXTERN int uv_tty_reset_mode(void); +UV_EXTERN int uv_tty_get_winsize(uv_tty_t*, int* width, int* height); +UV_EXTERN void uv_tty_set_vterm_state(uv_tty_vtermstate_t state); +UV_EXTERN int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state); + +#ifdef __cplusplus +extern "C++" { + +inline int uv_tty_set_mode(uv_tty_t* handle, int mode) { + return uv_tty_set_mode(handle, static_cast(mode)); +} + +} +#endif + +UV_EXTERN uv_handle_type uv_guess_handle(uv_file file); + +/* + * uv_pipe_t is a subclass of uv_stream_t. + * + * Representing a pipe stream or pipe server. On Windows this is a Named + * Pipe. On Unix this is a Unix domain socket. + */ +struct uv_pipe_s { + UV_HANDLE_FIELDS + UV_STREAM_FIELDS + int ipc; /* non-zero if this pipe is used for passing handles */ + UV_PIPE_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle, int ipc); +UV_EXTERN int uv_pipe_open(uv_pipe_t*, uv_file file); +UV_EXTERN int uv_pipe_bind(uv_pipe_t* handle, const char* name); +UV_EXTERN void uv_pipe_connect(uv_connect_t* req, + uv_pipe_t* handle, + const char* name, + uv_connect_cb cb); +UV_EXTERN int uv_pipe_getsockname(const uv_pipe_t* handle, + char* buffer, + size_t* size); +UV_EXTERN int uv_pipe_getpeername(const uv_pipe_t* handle, + char* buffer, + size_t* size); +UV_EXTERN void uv_pipe_pending_instances(uv_pipe_t* handle, int count); +UV_EXTERN int uv_pipe_pending_count(uv_pipe_t* handle); +UV_EXTERN uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle); +UV_EXTERN int uv_pipe_chmod(uv_pipe_t* handle, int flags); + + +struct uv_poll_s { + UV_HANDLE_FIELDS + uv_poll_cb poll_cb; + UV_POLL_PRIVATE_FIELDS +}; + +enum uv_poll_event { + UV_READABLE = 1, + UV_WRITABLE = 2, + UV_DISCONNECT = 4, + UV_PRIORITIZED = 8 +}; + +UV_EXTERN int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd); +UV_EXTERN int uv_poll_init_socket(uv_loop_t* loop, + uv_poll_t* handle, + uv_os_sock_t socket); +UV_EXTERN int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb); +UV_EXTERN int uv_poll_stop(uv_poll_t* handle); + + +struct uv_prepare_s { + UV_HANDLE_FIELDS + UV_PREPARE_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_prepare_init(uv_loop_t*, uv_prepare_t* prepare); +UV_EXTERN int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb); +UV_EXTERN int uv_prepare_stop(uv_prepare_t* prepare); + + +struct uv_check_s { + UV_HANDLE_FIELDS + UV_CHECK_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_check_init(uv_loop_t*, uv_check_t* check); +UV_EXTERN int uv_check_start(uv_check_t* check, uv_check_cb cb); +UV_EXTERN int uv_check_stop(uv_check_t* check); + + +struct uv_idle_s { + UV_HANDLE_FIELDS + UV_IDLE_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_idle_init(uv_loop_t*, uv_idle_t* idle); +UV_EXTERN int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb); +UV_EXTERN int uv_idle_stop(uv_idle_t* idle); + + +struct uv_async_s { + UV_HANDLE_FIELDS + UV_ASYNC_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_async_init(uv_loop_t*, + uv_async_t* async, + uv_async_cb async_cb); +UV_EXTERN int uv_async_send(uv_async_t* async); + + +/* + * uv_timer_t is a subclass of uv_handle_t. + * + * Used to get woken up at a specified time in the future. + */ +struct uv_timer_s { + UV_HANDLE_FIELDS + UV_TIMER_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_timer_init(uv_loop_t*, uv_timer_t* handle); +UV_EXTERN int uv_timer_start(uv_timer_t* handle, + uv_timer_cb cb, + uint64_t timeout, + uint64_t repeat); +UV_EXTERN int uv_timer_stop(uv_timer_t* handle); +UV_EXTERN int uv_timer_again(uv_timer_t* handle); +UV_EXTERN void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat); +UV_EXTERN uint64_t uv_timer_get_repeat(const uv_timer_t* handle); +UV_EXTERN uint64_t uv_timer_get_due_in(const uv_timer_t* handle); + + +/* + * uv_getaddrinfo_t is a subclass of uv_req_t. + * + * Request object for uv_getaddrinfo. + */ +struct uv_getaddrinfo_s { + UV_REQ_FIELDS + /* read-only */ + uv_loop_t* loop; + /* struct addrinfo* addrinfo is marked as private, but it really isn't. */ + UV_GETADDRINFO_PRIVATE_FIELDS +}; + + +UV_EXTERN int uv_getaddrinfo(uv_loop_t* loop, + uv_getaddrinfo_t* req, + uv_getaddrinfo_cb getaddrinfo_cb, + const char* node, + const char* service, + const struct addrinfo* hints); +UV_EXTERN void uv_freeaddrinfo(struct addrinfo* ai); + + +/* +* uv_getnameinfo_t is a subclass of uv_req_t. +* +* Request object for uv_getnameinfo. +*/ +struct uv_getnameinfo_s { + UV_REQ_FIELDS + /* read-only */ + uv_loop_t* loop; + /* host and service are marked as private, but they really aren't. */ + UV_GETNAMEINFO_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_getnameinfo(uv_loop_t* loop, + uv_getnameinfo_t* req, + uv_getnameinfo_cb getnameinfo_cb, + const struct sockaddr* addr, + int flags); + + +/* uv_spawn() options. */ +typedef enum { + UV_IGNORE = 0x00, + UV_CREATE_PIPE = 0x01, + UV_INHERIT_FD = 0x02, + UV_INHERIT_STREAM = 0x04, + + /* + * When UV_CREATE_PIPE is specified, UV_READABLE_PIPE and UV_WRITABLE_PIPE + * determine the direction of flow, from the child process' perspective. Both + * flags may be specified to create a duplex data stream. + */ + UV_READABLE_PIPE = 0x10, + UV_WRITABLE_PIPE = 0x20, + + /* + * When UV_CREATE_PIPE is specified, specifying UV_NONBLOCK_PIPE opens the + * handle in non-blocking mode in the child. This may cause loss of data, + * if the child is not designed to handle to encounter this mode, + * but can also be significantly more efficient. + */ + UV_NONBLOCK_PIPE = 0x40, + UV_OVERLAPPED_PIPE = 0x40 /* old name, for compatibility */ +} uv_stdio_flags; + +typedef struct uv_stdio_container_s { + uv_stdio_flags flags; + + union { + uv_stream_t* stream; + int fd; + } data; +} uv_stdio_container_t; + +typedef struct uv_process_options_s { + uv_exit_cb exit_cb; /* Called after the process exits. */ + const char* file; /* Path to program to execute. */ + /* + * Command line arguments. args[0] should be the path to the program. On + * Windows this uses CreateProcess which concatenates the arguments into a + * string this can cause some strange errors. See the note at + * windows_verbatim_arguments. + */ + char** args; + /* + * This will be set as the environ variable in the subprocess. If this is + * NULL then the parents environ will be used. + */ + char** env; + /* + * If non-null this represents a directory the subprocess should execute + * in. Stands for current working directory. + */ + const char* cwd; + /* + * Various flags that control how uv_spawn() behaves. See the definition of + * `enum uv_process_flags` below. + */ + unsigned int flags; + /* + * The `stdio` field points to an array of uv_stdio_container_t structs that + * describe the file descriptors that will be made available to the child + * process. The convention is that stdio[0] points to stdin, fd 1 is used for + * stdout, and fd 2 is stderr. + * + * Note that on windows file descriptors greater than 2 are available to the + * child process only if the child processes uses the MSVCRT runtime. + */ + int stdio_count; + uv_stdio_container_t* stdio; + /* + * Libuv can change the child process' user/group id. This happens only when + * the appropriate bits are set in the flags fields. This is not supported on + * windows; uv_spawn() will fail and set the error to UV_ENOTSUP. + */ + uv_uid_t uid; + uv_gid_t gid; +} uv_process_options_t; + +/* + * These are the flags that can be used for the uv_process_options.flags field. + */ +enum uv_process_flags { + /* + * Set the child process' user id. The user id is supplied in the `uid` field + * of the options struct. This does not work on windows; setting this flag + * will cause uv_spawn() to fail. + */ + UV_PROCESS_SETUID = (1 << 0), + /* + * Set the child process' group id. The user id is supplied in the `gid` + * field of the options struct. This does not work on windows; setting this + * flag will cause uv_spawn() to fail. + */ + UV_PROCESS_SETGID = (1 << 1), + /* + * Do not wrap any arguments in quotes, or perform any other escaping, when + * converting the argument list into a command line string. This option is + * only meaningful on Windows systems. On Unix it is silently ignored. + */ + UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2), + /* + * Spawn the child process in a detached state - this will make it a process + * group leader, and will effectively enable the child to keep running after + * the parent exits. Note that the child process will still keep the + * parent's event loop alive unless the parent process calls uv_unref() on + * the child's process handle. + */ + UV_PROCESS_DETACHED = (1 << 3), + /* + * Hide the subprocess window that would normally be created. This option is + * only meaningful on Windows systems. On Unix it is silently ignored. + */ + UV_PROCESS_WINDOWS_HIDE = (1 << 4), + /* + * Hide the subprocess console window that would normally be created. This + * option is only meaningful on Windows systems. On Unix it is silently + * ignored. + */ + UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5), + /* + * Hide the subprocess GUI window that would normally be created. This + * option is only meaningful on Windows systems. On Unix it is silently + * ignored. + */ + UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6) +}; + +/* + * uv_process_t is a subclass of uv_handle_t. + */ +struct uv_process_s { + UV_HANDLE_FIELDS + uv_exit_cb exit_cb; + int pid; + UV_PROCESS_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_spawn(uv_loop_t* loop, + uv_process_t* handle, + const uv_process_options_t* options); +UV_EXTERN int uv_process_kill(uv_process_t*, int signum); +UV_EXTERN int uv_kill(int pid, int signum); +UV_EXTERN uv_pid_t uv_process_get_pid(const uv_process_t*); + + +/* + * uv_work_t is a subclass of uv_req_t. + */ +struct uv_work_s { + UV_REQ_FIELDS + uv_loop_t* loop; + uv_work_cb work_cb; + uv_after_work_cb after_work_cb; + UV_WORK_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_queue_work(uv_loop_t* loop, + uv_work_t* req, + uv_work_cb work_cb, + uv_after_work_cb after_work_cb); + +UV_EXTERN int uv_cancel(uv_req_t* req); + + +struct uv_cpu_times_s { + uint64_t user; /* milliseconds */ + uint64_t nice; /* milliseconds */ + uint64_t sys; /* milliseconds */ + uint64_t idle; /* milliseconds */ + uint64_t irq; /* milliseconds */ +}; + +struct uv_cpu_info_s { + char* model; + int speed; + struct uv_cpu_times_s cpu_times; +}; + +struct uv_interface_address_s { + char* name; + char phys_addr[6]; + int is_internal; + union { + struct sockaddr_in address4; + struct sockaddr_in6 address6; + } address; + union { + struct sockaddr_in netmask4; + struct sockaddr_in6 netmask6; + } netmask; +}; + +struct uv_passwd_s { + char* username; + long uid; + long gid; + char* shell; + char* homedir; +}; + +struct uv_utsname_s { + char sysname[256]; + char release[256]; + char version[256]; + char machine[256]; + /* This struct does not contain the nodename and domainname fields present in + the utsname type. domainname is a GNU extension. Both fields are referred + to as meaningless in the docs. */ +}; + +struct uv_statfs_s { + uint64_t f_type; + uint64_t f_bsize; + uint64_t f_blocks; + uint64_t f_bfree; + uint64_t f_bavail; + uint64_t f_files; + uint64_t f_ffree; + uint64_t f_spare[4]; +}; + +typedef enum { + UV_DIRENT_UNKNOWN, + UV_DIRENT_FILE, + UV_DIRENT_DIR, + UV_DIRENT_LINK, + UV_DIRENT_FIFO, + UV_DIRENT_SOCKET, + UV_DIRENT_CHAR, + UV_DIRENT_BLOCK +} uv_dirent_type_t; + +struct uv_dirent_s { + const char* name; + uv_dirent_type_t type; +}; + +UV_EXTERN char** uv_setup_args(int argc, char** argv); +UV_EXTERN int uv_get_process_title(char* buffer, size_t size); +UV_EXTERN int uv_set_process_title(const char* title); +UV_EXTERN int uv_resident_set_memory(size_t* rss); +UV_EXTERN int uv_uptime(double* uptime); +UV_EXTERN uv_os_fd_t uv_get_osfhandle(int fd); +UV_EXTERN int uv_open_osfhandle(uv_os_fd_t os_fd); + +typedef struct { + long tv_sec; + long tv_usec; +} uv_timeval_t; + +typedef struct { + int64_t tv_sec; + int32_t tv_usec; +} uv_timeval64_t; + +typedef struct { + uv_timeval_t ru_utime; /* user CPU time used */ + uv_timeval_t ru_stime; /* system CPU time used */ + uint64_t ru_maxrss; /* maximum resident set size */ + uint64_t ru_ixrss; /* integral shared memory size */ + uint64_t ru_idrss; /* integral unshared data size */ + uint64_t ru_isrss; /* integral unshared stack size */ + uint64_t ru_minflt; /* page reclaims (soft page faults) */ + uint64_t ru_majflt; /* page faults (hard page faults) */ + uint64_t ru_nswap; /* swaps */ + uint64_t ru_inblock; /* block input operations */ + uint64_t ru_oublock; /* block output operations */ + uint64_t ru_msgsnd; /* IPC messages sent */ + uint64_t ru_msgrcv; /* IPC messages received */ + uint64_t ru_nsignals; /* signals received */ + uint64_t ru_nvcsw; /* voluntary context switches */ + uint64_t ru_nivcsw; /* involuntary context switches */ +} uv_rusage_t; + +UV_EXTERN int uv_getrusage(uv_rusage_t* rusage); + +UV_EXTERN int uv_os_homedir(char* buffer, size_t* size); +UV_EXTERN int uv_os_tmpdir(char* buffer, size_t* size); +UV_EXTERN int uv_os_get_passwd(uv_passwd_t* pwd); +UV_EXTERN void uv_os_free_passwd(uv_passwd_t* pwd); +UV_EXTERN uv_pid_t uv_os_getpid(void); +UV_EXTERN uv_pid_t uv_os_getppid(void); + +#if defined(__PASE__) +/* On IBM i PASE, the highest process priority is -10 */ +# define UV_PRIORITY_LOW 39 /* RUNPTY(99) */ +# define UV_PRIORITY_BELOW_NORMAL 15 /* RUNPTY(50) */ +# define UV_PRIORITY_NORMAL 0 /* RUNPTY(20) */ +# define UV_PRIORITY_ABOVE_NORMAL -4 /* RUNTY(12) */ +# define UV_PRIORITY_HIGH -7 /* RUNPTY(6) */ +# define UV_PRIORITY_HIGHEST -10 /* RUNPTY(1) */ +#else +# define UV_PRIORITY_LOW 19 +# define UV_PRIORITY_BELOW_NORMAL 10 +# define UV_PRIORITY_NORMAL 0 +# define UV_PRIORITY_ABOVE_NORMAL -7 +# define UV_PRIORITY_HIGH -14 +# define UV_PRIORITY_HIGHEST -20 +#endif + +UV_EXTERN int uv_os_getpriority(uv_pid_t pid, int* priority); +UV_EXTERN int uv_os_setpriority(uv_pid_t pid, int priority); + +UV_EXTERN int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count); +UV_EXTERN void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count); + +UV_EXTERN int uv_interface_addresses(uv_interface_address_t** addresses, + int* count); +UV_EXTERN void uv_free_interface_addresses(uv_interface_address_t* addresses, + int count); + +struct uv_env_item_s { + char* name; + char* value; +}; + +UV_EXTERN int uv_os_environ(uv_env_item_t** envitems, int* count); +UV_EXTERN void uv_os_free_environ(uv_env_item_t* envitems, int count); +UV_EXTERN int uv_os_getenv(const char* name, char* buffer, size_t* size); +UV_EXTERN int uv_os_setenv(const char* name, const char* value); +UV_EXTERN int uv_os_unsetenv(const char* name); + +#ifdef MAXHOSTNAMELEN +# define UV_MAXHOSTNAMESIZE (MAXHOSTNAMELEN + 1) +#else + /* + Fallback for the maximum hostname size, including the null terminator. The + Windows gethostname() documentation states that 256 bytes will always be + large enough to hold the null-terminated hostname. + */ +# define UV_MAXHOSTNAMESIZE 256 +#endif + +UV_EXTERN int uv_os_gethostname(char* buffer, size_t* size); + +UV_EXTERN int uv_os_uname(uv_utsname_t* buffer); + +UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop); + +typedef enum { + UV_FS_UNKNOWN = -1, + UV_FS_CUSTOM, + UV_FS_OPEN, + UV_FS_CLOSE, + UV_FS_READ, + UV_FS_WRITE, + UV_FS_SENDFILE, + UV_FS_STAT, + UV_FS_LSTAT, + UV_FS_FSTAT, + UV_FS_FTRUNCATE, + UV_FS_UTIME, + UV_FS_FUTIME, + UV_FS_ACCESS, + UV_FS_CHMOD, + UV_FS_FCHMOD, + UV_FS_FSYNC, + UV_FS_FDATASYNC, + UV_FS_UNLINK, + UV_FS_RMDIR, + UV_FS_MKDIR, + UV_FS_MKDTEMP, + UV_FS_RENAME, + UV_FS_SCANDIR, + UV_FS_LINK, + UV_FS_SYMLINK, + UV_FS_READLINK, + UV_FS_CHOWN, + UV_FS_FCHOWN, + UV_FS_REALPATH, + UV_FS_COPYFILE, + UV_FS_LCHOWN, + UV_FS_OPENDIR, + UV_FS_READDIR, + UV_FS_CLOSEDIR, + UV_FS_STATFS, + UV_FS_MKSTEMP, + UV_FS_LUTIME +} uv_fs_type; + +struct uv_dir_s { + uv_dirent_t* dirents; + size_t nentries; + void* reserved[4]; + UV_DIR_PRIVATE_FIELDS +}; + +/* uv_fs_t is a subclass of uv_req_t. */ +struct uv_fs_s { + UV_REQ_FIELDS + uv_fs_type fs_type; + uv_loop_t* loop; + uv_fs_cb cb; + ssize_t result; + void* ptr; + const char* path; + uv_stat_t statbuf; /* Stores the result of uv_fs_stat() and uv_fs_fstat(). */ + UV_FS_PRIVATE_FIELDS +}; + +UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t*); +UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t*); +UV_EXTERN int uv_fs_get_system_error(const uv_fs_t*); +UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t*); +UV_EXTERN const char* uv_fs_get_path(const uv_fs_t*); +UV_EXTERN uv_stat_t* uv_fs_get_statbuf(uv_fs_t*); + +UV_EXTERN void uv_fs_req_cleanup(uv_fs_t* req); +UV_EXTERN int uv_fs_close(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb); +UV_EXTERN int uv_fs_open(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int flags, + int mode, + uv_fs_cb cb); +UV_EXTERN int uv_fs_read(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + const uv_buf_t bufs[], + unsigned int nbufs, + int64_t offset, + uv_fs_cb cb); +UV_EXTERN int uv_fs_unlink(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_write(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + const uv_buf_t bufs[], + unsigned int nbufs, + int64_t offset, + uv_fs_cb cb); +/* + * This flag can be used with uv_fs_copyfile() to return an error if the + * destination already exists. + */ +#define UV_FS_COPYFILE_EXCL 0x0001 + +/* + * This flag can be used with uv_fs_copyfile() to attempt to create a reflink. + * If copy-on-write is not supported, a fallback copy mechanism is used. + */ +#define UV_FS_COPYFILE_FICLONE 0x0002 + +/* + * This flag can be used with uv_fs_copyfile() to attempt to create a reflink. + * If copy-on-write is not supported, an error is returned. + */ +#define UV_FS_COPYFILE_FICLONE_FORCE 0x0004 + +UV_EXTERN int uv_fs_copyfile(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + const char* new_path, + int flags, + uv_fs_cb cb); +UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int mode, + uv_fs_cb cb); +UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop, + uv_fs_t* req, + const char* tpl, + uv_fs_cb cb); +UV_EXTERN int uv_fs_mkstemp(uv_loop_t* loop, + uv_fs_t* req, + const char* tpl, + uv_fs_cb cb); +UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_scandir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int flags, + uv_fs_cb cb); +UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req, + uv_dirent_t* ent); +UV_EXTERN int uv_fs_opendir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_readdir(uv_loop_t* loop, + uv_fs_t* req, + uv_dir_t* dir, + uv_fs_cb cb); +UV_EXTERN int uv_fs_closedir(uv_loop_t* loop, + uv_fs_t* req, + uv_dir_t* dir, + uv_fs_cb cb); +UV_EXTERN int uv_fs_stat(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_fstat(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb); +UV_EXTERN int uv_fs_rename(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + const char* new_path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_fsync(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb); +UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb); +UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + int64_t offset, + uv_fs_cb cb); +UV_EXTERN int uv_fs_sendfile(uv_loop_t* loop, + uv_fs_t* req, + uv_file out_fd, + uv_file in_fd, + int64_t in_offset, + size_t length, + uv_fs_cb cb); +UV_EXTERN int uv_fs_access(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int mode, + uv_fs_cb cb); +UV_EXTERN int uv_fs_chmod(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int mode, + uv_fs_cb cb); +UV_EXTERN int uv_fs_utime(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + double atime, + double mtime, + uv_fs_cb cb); +UV_EXTERN int uv_fs_futime(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + double atime, + double mtime, + uv_fs_cb cb); +UV_EXTERN int uv_fs_lutime(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + double atime, + double mtime, + uv_fs_cb cb); +UV_EXTERN int uv_fs_lstat(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_link(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + const char* new_path, + uv_fs_cb cb); + +/* + * This flag can be used with uv_fs_symlink() on Windows to specify whether + * path argument points to a directory. + */ +#define UV_FS_SYMLINK_DIR 0x0001 + +/* + * This flag can be used with uv_fs_symlink() on Windows to specify whether + * the symlink is to be created using junction points. + */ +#define UV_FS_SYMLINK_JUNCTION 0x0002 + +UV_EXTERN int uv_fs_symlink(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + const char* new_path, + int flags, + uv_fs_cb cb); +UV_EXTERN int uv_fs_readlink(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_realpath(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); +UV_EXTERN int uv_fs_fchmod(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + int mode, + uv_fs_cb cb); +UV_EXTERN int uv_fs_chown(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_uid_t uid, + uv_gid_t gid, + uv_fs_cb cb); +UV_EXTERN int uv_fs_fchown(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_uid_t uid, + uv_gid_t gid, + uv_fs_cb cb); +UV_EXTERN int uv_fs_lchown(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_uid_t uid, + uv_gid_t gid, + uv_fs_cb cb); +UV_EXTERN int uv_fs_statfs(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb); + + +enum uv_fs_event { + UV_RENAME = 1, + UV_CHANGE = 2 +}; + + +struct uv_fs_event_s { + UV_HANDLE_FIELDS + /* private */ + char* path; + UV_FS_EVENT_PRIVATE_FIELDS +}; + + +/* + * uv_fs_stat() based polling file watcher. + */ +struct uv_fs_poll_s { + UV_HANDLE_FIELDS + /* Private, don't touch. */ + void* poll_ctx; +}; + +UV_EXTERN int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle); +UV_EXTERN int uv_fs_poll_start(uv_fs_poll_t* handle, + uv_fs_poll_cb poll_cb, + const char* path, + unsigned int interval); +UV_EXTERN int uv_fs_poll_stop(uv_fs_poll_t* handle); +UV_EXTERN int uv_fs_poll_getpath(uv_fs_poll_t* handle, + char* buffer, + size_t* size); + + +struct uv_signal_s { + UV_HANDLE_FIELDS + uv_signal_cb signal_cb; + int signum; + UV_SIGNAL_PRIVATE_FIELDS +}; + +UV_EXTERN int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle); +UV_EXTERN int uv_signal_start(uv_signal_t* handle, + uv_signal_cb signal_cb, + int signum); +UV_EXTERN int uv_signal_start_oneshot(uv_signal_t* handle, + uv_signal_cb signal_cb, + int signum); +UV_EXTERN int uv_signal_stop(uv_signal_t* handle); + +UV_EXTERN void uv_loadavg(double avg[3]); + + +/* + * Flags to be passed to uv_fs_event_start(). + */ +enum uv_fs_event_flags { + /* + * By default, if the fs event watcher is given a directory name, we will + * watch for all events in that directory. This flags overrides this behavior + * and makes fs_event report only changes to the directory entry itself. This + * flag does not affect individual files watched. + * This flag is currently not implemented yet on any backend. + */ + UV_FS_EVENT_WATCH_ENTRY = 1, + + /* + * By default uv_fs_event will try to use a kernel interface such as inotify + * or kqueue to detect events. This may not work on remote filesystems such + * as NFS mounts. This flag makes fs_event fall back to calling stat() on a + * regular interval. + * This flag is currently not implemented yet on any backend. + */ + UV_FS_EVENT_STAT = 2, + + /* + * By default, event watcher, when watching directory, is not registering + * (is ignoring) changes in it's subdirectories. + * This flag will override this behaviour on platforms that support it. + */ + UV_FS_EVENT_RECURSIVE = 4 +}; + + +UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle); +UV_EXTERN int uv_fs_event_start(uv_fs_event_t* handle, + uv_fs_event_cb cb, + const char* path, + unsigned int flags); +UV_EXTERN int uv_fs_event_stop(uv_fs_event_t* handle); +UV_EXTERN int uv_fs_event_getpath(uv_fs_event_t* handle, + char* buffer, + size_t* size); + +UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr); +UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr); + +UV_EXTERN int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size); +UV_EXTERN int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size); + +UV_EXTERN int uv_inet_ntop(int af, const void* src, char* dst, size_t size); +UV_EXTERN int uv_inet_pton(int af, const char* src, void* dst); + + +struct uv_random_s { + UV_REQ_FIELDS + /* read-only */ + uv_loop_t* loop; + /* private */ + int status; + void* buf; + size_t buflen; + uv_random_cb cb; + struct uv__work work_req; +}; + +UV_EXTERN int uv_random(uv_loop_t* loop, + uv_random_t* req, + void *buf, + size_t buflen, + unsigned flags, /* For future extension; must be 0. */ + uv_random_cb cb); + +#if defined(IF_NAMESIZE) +# define UV_IF_NAMESIZE (IF_NAMESIZE + 1) +#elif defined(IFNAMSIZ) +# define UV_IF_NAMESIZE (IFNAMSIZ + 1) +#else +# define UV_IF_NAMESIZE (16 + 1) +#endif + +UV_EXTERN int uv_if_indextoname(unsigned int ifindex, + char* buffer, + size_t* size); +UV_EXTERN int uv_if_indextoiid(unsigned int ifindex, + char* buffer, + size_t* size); + +UV_EXTERN int uv_exepath(char* buffer, size_t* size); + +UV_EXTERN int uv_cwd(char* buffer, size_t* size); + +UV_EXTERN int uv_chdir(const char* dir); + +UV_EXTERN uint64_t uv_get_free_memory(void); +UV_EXTERN uint64_t uv_get_total_memory(void); +UV_EXTERN uint64_t uv_get_constrained_memory(void); + +UV_EXTERN uint64_t uv_hrtime(void); +UV_EXTERN void uv_sleep(unsigned int msec); + +UV_EXTERN void uv_disable_stdio_inheritance(void); + +UV_EXTERN int uv_dlopen(const char* filename, uv_lib_t* lib); +UV_EXTERN void uv_dlclose(uv_lib_t* lib); +UV_EXTERN int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr); +UV_EXTERN const char* uv_dlerror(const uv_lib_t* lib); + +UV_EXTERN int uv_mutex_init(uv_mutex_t* handle); +UV_EXTERN int uv_mutex_init_recursive(uv_mutex_t* handle); +UV_EXTERN void uv_mutex_destroy(uv_mutex_t* handle); +UV_EXTERN void uv_mutex_lock(uv_mutex_t* handle); +UV_EXTERN int uv_mutex_trylock(uv_mutex_t* handle); +UV_EXTERN void uv_mutex_unlock(uv_mutex_t* handle); + +UV_EXTERN int uv_rwlock_init(uv_rwlock_t* rwlock); +UV_EXTERN void uv_rwlock_destroy(uv_rwlock_t* rwlock); +UV_EXTERN void uv_rwlock_rdlock(uv_rwlock_t* rwlock); +UV_EXTERN int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock); +UV_EXTERN void uv_rwlock_rdunlock(uv_rwlock_t* rwlock); +UV_EXTERN void uv_rwlock_wrlock(uv_rwlock_t* rwlock); +UV_EXTERN int uv_rwlock_trywrlock(uv_rwlock_t* rwlock); +UV_EXTERN void uv_rwlock_wrunlock(uv_rwlock_t* rwlock); + +UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value); +UV_EXTERN void uv_sem_destroy(uv_sem_t* sem); +UV_EXTERN void uv_sem_post(uv_sem_t* sem); +UV_EXTERN void uv_sem_wait(uv_sem_t* sem); +UV_EXTERN int uv_sem_trywait(uv_sem_t* sem); + +UV_EXTERN int uv_cond_init(uv_cond_t* cond); +UV_EXTERN void uv_cond_destroy(uv_cond_t* cond); +UV_EXTERN void uv_cond_signal(uv_cond_t* cond); +UV_EXTERN void uv_cond_broadcast(uv_cond_t* cond); + +UV_EXTERN int uv_barrier_init(uv_barrier_t* barrier, unsigned int count); +UV_EXTERN void uv_barrier_destroy(uv_barrier_t* barrier); +UV_EXTERN int uv_barrier_wait(uv_barrier_t* barrier); + +UV_EXTERN void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex); +UV_EXTERN int uv_cond_timedwait(uv_cond_t* cond, + uv_mutex_t* mutex, + uint64_t timeout); + +UV_EXTERN void uv_once(uv_once_t* guard, void (*callback)(void)); + +UV_EXTERN int uv_key_create(uv_key_t* key); +UV_EXTERN void uv_key_delete(uv_key_t* key); +UV_EXTERN void* uv_key_get(uv_key_t* key); +UV_EXTERN void uv_key_set(uv_key_t* key, void* value); + +UV_EXTERN int uv_gettimeofday(uv_timeval64_t* tv); + +typedef void (*uv_thread_cb)(void* arg); + +UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg); + +typedef enum { + UV_THREAD_NO_FLAGS = 0x00, + UV_THREAD_HAS_STACK_SIZE = 0x01 +} uv_thread_create_flags; + +struct uv_thread_options_s { + unsigned int flags; + size_t stack_size; + /* More fields may be added at any time. */ +}; + +typedef struct uv_thread_options_s uv_thread_options_t; + +UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid, + const uv_thread_options_t* params, + uv_thread_cb entry, + void* arg); +UV_EXTERN uv_thread_t uv_thread_self(void); +UV_EXTERN int uv_thread_join(uv_thread_t *tid); +UV_EXTERN int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2); + +/* The presence of these unions force similar struct layout. */ +#define XX(_, name) uv_ ## name ## _t name; +union uv_any_handle { + UV_HANDLE_TYPE_MAP(XX) +}; + +union uv_any_req { + UV_REQ_TYPE_MAP(XX) +}; +#undef XX + + +struct uv_loop_s { + /* User data - use this for whatever. */ + void* data; + /* Loop reference counting. */ + unsigned int active_handles; + void* handle_queue[2]; + union { + void* unused; + unsigned int count; + } active_reqs; + /* Internal storage for future extensions. */ + void* internal_fields; + /* Internal flag to signal loop stop. */ + unsigned int stop_flag; + UV_LOOP_PRIVATE_FIELDS +}; + +UV_EXTERN void* uv_loop_get_data(const uv_loop_t*); +UV_EXTERN void uv_loop_set_data(uv_loop_t*, void* data); + +/* Don't export the private CPP symbols. */ +#undef UV_HANDLE_TYPE_PRIVATE +#undef UV_REQ_TYPE_PRIVATE +#undef UV_REQ_PRIVATE_FIELDS +#undef UV_STREAM_PRIVATE_FIELDS +#undef UV_TCP_PRIVATE_FIELDS +#undef UV_PREPARE_PRIVATE_FIELDS +#undef UV_CHECK_PRIVATE_FIELDS +#undef UV_IDLE_PRIVATE_FIELDS +#undef UV_ASYNC_PRIVATE_FIELDS +#undef UV_TIMER_PRIVATE_FIELDS +#undef UV_GETADDRINFO_PRIVATE_FIELDS +#undef UV_GETNAMEINFO_PRIVATE_FIELDS +#undef UV_FS_REQ_PRIVATE_FIELDS +#undef UV_WORK_PRIVATE_FIELDS +#undef UV_FS_EVENT_PRIVATE_FIELDS +#undef UV_SIGNAL_PRIVATE_FIELDS +#undef UV_LOOP_PRIVATE_FIELDS +#undef UV_LOOP_PRIVATE_PLATFORM_FIELDS +#undef UV__ERR + +#ifdef __cplusplus +} +#endif +#endif /* UV_H */ diff --git a/extension/libuv/include/uv/aix.h b/extension/libuv/include/uv/aix.h new file mode 100644 index 0000000..7dc992f --- /dev/null +++ b/extension/libuv/include/uv/aix.h @@ -0,0 +1,32 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_AIX_H +#define UV_AIX_H + +#define UV_PLATFORM_LOOP_FIELDS \ + int fs_fd; \ + +#define UV_PLATFORM_FS_EVENT_FIELDS \ + uv__io_t event_watcher; \ + char *dir_filename; \ + +#endif /* UV_AIX_H */ diff --git a/extension/libuv/include/uv/android-ifaddrs.h b/extension/libuv/include/uv/android-ifaddrs.h new file mode 100644 index 0000000..9cd19fe --- /dev/null +++ b/extension/libuv/include/uv/android-ifaddrs.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 1995, 1999 + * Berkeley Software Design, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * BSDI ifaddrs.h,v 2.5 2000/02/23 14:51:59 dab Exp + */ + +#ifndef _IFADDRS_H_ +#define _IFADDRS_H_ + +struct ifaddrs { + struct ifaddrs *ifa_next; + char *ifa_name; + unsigned int ifa_flags; + struct sockaddr *ifa_addr; + struct sockaddr *ifa_netmask; + struct sockaddr *ifa_dstaddr; + void *ifa_data; +}; + +/* + * This may have been defined in . Note that if is + * to be included it must be included before this header file. + */ +#ifndef ifa_broadaddr +#define ifa_broadaddr ifa_dstaddr /* broadcast address interface */ +#endif + +#include + +__BEGIN_DECLS +extern int getifaddrs(struct ifaddrs **ifap); +extern void freeifaddrs(struct ifaddrs *ifa); +__END_DECLS + +#endif diff --git a/extension/libuv/include/uv/bsd.h b/extension/libuv/include/uv/bsd.h new file mode 100644 index 0000000..2d72b3d --- /dev/null +++ b/extension/libuv/include/uv/bsd.h @@ -0,0 +1,34 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_BSD_H +#define UV_BSD_H + +#define UV_PLATFORM_FS_EVENT_FIELDS \ + uv__io_t event_watcher; \ + +#define UV_IO_PRIVATE_PLATFORM_FIELDS \ + int rcount; \ + int wcount; \ + +#define UV_HAVE_KQUEUE 1 + +#endif /* UV_BSD_H */ diff --git a/extension/libuv/include/uv/darwin.h b/extension/libuv/include/uv/darwin.h new file mode 100644 index 0000000..d226415 --- /dev/null +++ b/extension/libuv/include/uv/darwin.h @@ -0,0 +1,61 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_DARWIN_H +#define UV_DARWIN_H + +#if defined(__APPLE__) && defined(__MACH__) +# include +# include +# include +# include +# define UV_PLATFORM_SEM_T semaphore_t +#endif + +#define UV_IO_PRIVATE_PLATFORM_FIELDS \ + int rcount; \ + int wcount; \ + +#define UV_PLATFORM_LOOP_FIELDS \ + uv_thread_t cf_thread; \ + void* _cf_reserved; \ + void* cf_state; \ + uv_mutex_t cf_mutex; \ + uv_sem_t cf_sem; \ + void* cf_signals[2]; \ + +#define UV_PLATFORM_FS_EVENT_FIELDS \ + uv__io_t event_watcher; \ + char* realpath; \ + int realpath_len; \ + int cf_flags; \ + uv_async_t* cf_cb; \ + void* cf_events[2]; \ + void* cf_member[2]; \ + int cf_error; \ + uv_mutex_t cf_mutex; \ + +#define UV_STREAM_PRIVATE_PLATFORM_FIELDS \ + void* select; \ + +#define UV_HAVE_KQUEUE 1 + +#endif /* UV_DARWIN_H */ diff --git a/extension/libuv/include/uv/errno.h b/extension/libuv/include/uv/errno.h new file mode 100644 index 0000000..aadce9c --- /dev/null +++ b/extension/libuv/include/uv/errno.h @@ -0,0 +1,448 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_ERRNO_H_ +#define UV_ERRNO_H_ + +#include +#if EDOM > 0 +# define UV__ERR(x) (-(x)) +#else +# define UV__ERR(x) (x) +#endif + +#define UV__EOF (-4095) +#define UV__UNKNOWN (-4094) + +#define UV__EAI_ADDRFAMILY (-3000) +#define UV__EAI_AGAIN (-3001) +#define UV__EAI_BADFLAGS (-3002) +#define UV__EAI_CANCELED (-3003) +#define UV__EAI_FAIL (-3004) +#define UV__EAI_FAMILY (-3005) +#define UV__EAI_MEMORY (-3006) +#define UV__EAI_NODATA (-3007) +#define UV__EAI_NONAME (-3008) +#define UV__EAI_OVERFLOW (-3009) +#define UV__EAI_SERVICE (-3010) +#define UV__EAI_SOCKTYPE (-3011) +#define UV__EAI_BADHINTS (-3013) +#define UV__EAI_PROTOCOL (-3014) + +/* Only map to the system errno on non-Windows platforms. It's apparently + * a fairly common practice for Windows programmers to redefine errno codes. + */ +#if defined(E2BIG) && !defined(_WIN32) +# define UV__E2BIG UV__ERR(E2BIG) +#else +# define UV__E2BIG (-4093) +#endif + +#if defined(EACCES) && !defined(_WIN32) +# define UV__EACCES UV__ERR(EACCES) +#else +# define UV__EACCES (-4092) +#endif + +#if defined(EADDRINUSE) && !defined(_WIN32) +# define UV__EADDRINUSE UV__ERR(EADDRINUSE) +#else +# define UV__EADDRINUSE (-4091) +#endif + +#if defined(EADDRNOTAVAIL) && !defined(_WIN32) +# define UV__EADDRNOTAVAIL UV__ERR(EADDRNOTAVAIL) +#else +# define UV__EADDRNOTAVAIL (-4090) +#endif + +#if defined(EAFNOSUPPORT) && !defined(_WIN32) +# define UV__EAFNOSUPPORT UV__ERR(EAFNOSUPPORT) +#else +# define UV__EAFNOSUPPORT (-4089) +#endif + +#if defined(EAGAIN) && !defined(_WIN32) +# define UV__EAGAIN UV__ERR(EAGAIN) +#else +# define UV__EAGAIN (-4088) +#endif + +#if defined(EALREADY) && !defined(_WIN32) +# define UV__EALREADY UV__ERR(EALREADY) +#else +# define UV__EALREADY (-4084) +#endif + +#if defined(EBADF) && !defined(_WIN32) +# define UV__EBADF UV__ERR(EBADF) +#else +# define UV__EBADF (-4083) +#endif + +#if defined(EBUSY) && !defined(_WIN32) +# define UV__EBUSY UV__ERR(EBUSY) +#else +# define UV__EBUSY (-4082) +#endif + +#if defined(ECANCELED) && !defined(_WIN32) +# define UV__ECANCELED UV__ERR(ECANCELED) +#else +# define UV__ECANCELED (-4081) +#endif + +#if defined(ECHARSET) && !defined(_WIN32) +# define UV__ECHARSET UV__ERR(ECHARSET) +#else +# define UV__ECHARSET (-4080) +#endif + +#if defined(ECONNABORTED) && !defined(_WIN32) +# define UV__ECONNABORTED UV__ERR(ECONNABORTED) +#else +# define UV__ECONNABORTED (-4079) +#endif + +#if defined(ECONNREFUSED) && !defined(_WIN32) +# define UV__ECONNREFUSED UV__ERR(ECONNREFUSED) +#else +# define UV__ECONNREFUSED (-4078) +#endif + +#if defined(ECONNRESET) && !defined(_WIN32) +# define UV__ECONNRESET UV__ERR(ECONNRESET) +#else +# define UV__ECONNRESET (-4077) +#endif + +#if defined(EDESTADDRREQ) && !defined(_WIN32) +# define UV__EDESTADDRREQ UV__ERR(EDESTADDRREQ) +#else +# define UV__EDESTADDRREQ (-4076) +#endif + +#if defined(EEXIST) && !defined(_WIN32) +# define UV__EEXIST UV__ERR(EEXIST) +#else +# define UV__EEXIST (-4075) +#endif + +#if defined(EFAULT) && !defined(_WIN32) +# define UV__EFAULT UV__ERR(EFAULT) +#else +# define UV__EFAULT (-4074) +#endif + +#if defined(EHOSTUNREACH) && !defined(_WIN32) +# define UV__EHOSTUNREACH UV__ERR(EHOSTUNREACH) +#else +# define UV__EHOSTUNREACH (-4073) +#endif + +#if defined(EINTR) && !defined(_WIN32) +# define UV__EINTR UV__ERR(EINTR) +#else +# define UV__EINTR (-4072) +#endif + +#if defined(EINVAL) && !defined(_WIN32) +# define UV__EINVAL UV__ERR(EINVAL) +#else +# define UV__EINVAL (-4071) +#endif + +#if defined(EIO) && !defined(_WIN32) +# define UV__EIO UV__ERR(EIO) +#else +# define UV__EIO (-4070) +#endif + +#if defined(EISCONN) && !defined(_WIN32) +# define UV__EISCONN UV__ERR(EISCONN) +#else +# define UV__EISCONN (-4069) +#endif + +#if defined(EISDIR) && !defined(_WIN32) +# define UV__EISDIR UV__ERR(EISDIR) +#else +# define UV__EISDIR (-4068) +#endif + +#if defined(ELOOP) && !defined(_WIN32) +# define UV__ELOOP UV__ERR(ELOOP) +#else +# define UV__ELOOP (-4067) +#endif + +#if defined(EMFILE) && !defined(_WIN32) +# define UV__EMFILE UV__ERR(EMFILE) +#else +# define UV__EMFILE (-4066) +#endif + +#if defined(EMSGSIZE) && !defined(_WIN32) +# define UV__EMSGSIZE UV__ERR(EMSGSIZE) +#else +# define UV__EMSGSIZE (-4065) +#endif + +#if defined(ENAMETOOLONG) && !defined(_WIN32) +# define UV__ENAMETOOLONG UV__ERR(ENAMETOOLONG) +#else +# define UV__ENAMETOOLONG (-4064) +#endif + +#if defined(ENETDOWN) && !defined(_WIN32) +# define UV__ENETDOWN UV__ERR(ENETDOWN) +#else +# define UV__ENETDOWN (-4063) +#endif + +#if defined(ENETUNREACH) && !defined(_WIN32) +# define UV__ENETUNREACH UV__ERR(ENETUNREACH) +#else +# define UV__ENETUNREACH (-4062) +#endif + +#if defined(ENFILE) && !defined(_WIN32) +# define UV__ENFILE UV__ERR(ENFILE) +#else +# define UV__ENFILE (-4061) +#endif + +#if defined(ENOBUFS) && !defined(_WIN32) +# define UV__ENOBUFS UV__ERR(ENOBUFS) +#else +# define UV__ENOBUFS (-4060) +#endif + +#if defined(ENODEV) && !defined(_WIN32) +# define UV__ENODEV UV__ERR(ENODEV) +#else +# define UV__ENODEV (-4059) +#endif + +#if defined(ENOENT) && !defined(_WIN32) +# define UV__ENOENT UV__ERR(ENOENT) +#else +# define UV__ENOENT (-4058) +#endif + +#if defined(ENOMEM) && !defined(_WIN32) +# define UV__ENOMEM UV__ERR(ENOMEM) +#else +# define UV__ENOMEM (-4057) +#endif + +#if defined(ENONET) && !defined(_WIN32) +# define UV__ENONET UV__ERR(ENONET) +#else +# define UV__ENONET (-4056) +#endif + +#if defined(ENOSPC) && !defined(_WIN32) +# define UV__ENOSPC UV__ERR(ENOSPC) +#else +# define UV__ENOSPC (-4055) +#endif + +#if defined(ENOSYS) && !defined(_WIN32) +# define UV__ENOSYS UV__ERR(ENOSYS) +#else +# define UV__ENOSYS (-4054) +#endif + +#if defined(ENOTCONN) && !defined(_WIN32) +# define UV__ENOTCONN UV__ERR(ENOTCONN) +#else +# define UV__ENOTCONN (-4053) +#endif + +#if defined(ENOTDIR) && !defined(_WIN32) +# define UV__ENOTDIR UV__ERR(ENOTDIR) +#else +# define UV__ENOTDIR (-4052) +#endif + +#if defined(ENOTEMPTY) && !defined(_WIN32) +# define UV__ENOTEMPTY UV__ERR(ENOTEMPTY) +#else +# define UV__ENOTEMPTY (-4051) +#endif + +#if defined(ENOTSOCK) && !defined(_WIN32) +# define UV__ENOTSOCK UV__ERR(ENOTSOCK) +#else +# define UV__ENOTSOCK (-4050) +#endif + +#if defined(ENOTSUP) && !defined(_WIN32) +# define UV__ENOTSUP UV__ERR(ENOTSUP) +#else +# define UV__ENOTSUP (-4049) +#endif + +#if defined(EPERM) && !defined(_WIN32) +# define UV__EPERM UV__ERR(EPERM) +#else +# define UV__EPERM (-4048) +#endif + +#if defined(EPIPE) && !defined(_WIN32) +# define UV__EPIPE UV__ERR(EPIPE) +#else +# define UV__EPIPE (-4047) +#endif + +#if defined(EPROTO) && !defined(_WIN32) +# define UV__EPROTO UV__ERR(EPROTO) +#else +# define UV__EPROTO (-4046) +#endif + +#if defined(EPROTONOSUPPORT) && !defined(_WIN32) +# define UV__EPROTONOSUPPORT UV__ERR(EPROTONOSUPPORT) +#else +# define UV__EPROTONOSUPPORT (-4045) +#endif + +#if defined(EPROTOTYPE) && !defined(_WIN32) +# define UV__EPROTOTYPE UV__ERR(EPROTOTYPE) +#else +# define UV__EPROTOTYPE (-4044) +#endif + +#if defined(EROFS) && !defined(_WIN32) +# define UV__EROFS UV__ERR(EROFS) +#else +# define UV__EROFS (-4043) +#endif + +#if defined(ESHUTDOWN) && !defined(_WIN32) +# define UV__ESHUTDOWN UV__ERR(ESHUTDOWN) +#else +# define UV__ESHUTDOWN (-4042) +#endif + +#if defined(ESPIPE) && !defined(_WIN32) +# define UV__ESPIPE UV__ERR(ESPIPE) +#else +# define UV__ESPIPE (-4041) +#endif + +#if defined(ESRCH) && !defined(_WIN32) +# define UV__ESRCH UV__ERR(ESRCH) +#else +# define UV__ESRCH (-4040) +#endif + +#if defined(ETIMEDOUT) && !defined(_WIN32) +# define UV__ETIMEDOUT UV__ERR(ETIMEDOUT) +#else +# define UV__ETIMEDOUT (-4039) +#endif + +#if defined(ETXTBSY) && !defined(_WIN32) +# define UV__ETXTBSY UV__ERR(ETXTBSY) +#else +# define UV__ETXTBSY (-4038) +#endif + +#if defined(EXDEV) && !defined(_WIN32) +# define UV__EXDEV UV__ERR(EXDEV) +#else +# define UV__EXDEV (-4037) +#endif + +#if defined(EFBIG) && !defined(_WIN32) +# define UV__EFBIG UV__ERR(EFBIG) +#else +# define UV__EFBIG (-4036) +#endif + +#if defined(ENOPROTOOPT) && !defined(_WIN32) +# define UV__ENOPROTOOPT UV__ERR(ENOPROTOOPT) +#else +# define UV__ENOPROTOOPT (-4035) +#endif + +#if defined(ERANGE) && !defined(_WIN32) +# define UV__ERANGE UV__ERR(ERANGE) +#else +# define UV__ERANGE (-4034) +#endif + +#if defined(ENXIO) && !defined(_WIN32) +# define UV__ENXIO UV__ERR(ENXIO) +#else +# define UV__ENXIO (-4033) +#endif + +#if defined(EMLINK) && !defined(_WIN32) +# define UV__EMLINK UV__ERR(EMLINK) +#else +# define UV__EMLINK (-4032) +#endif + +/* EHOSTDOWN is not visible on BSD-like systems when _POSIX_C_SOURCE is + * defined. Fortunately, its value is always 64 so it's possible albeit + * icky to hard-code it. + */ +#if defined(EHOSTDOWN) && !defined(_WIN32) +# define UV__EHOSTDOWN UV__ERR(EHOSTDOWN) +#elif defined(__APPLE__) || \ + defined(__DragonFly__) || \ + defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ + defined(__NetBSD__) || \ + defined(__OpenBSD__) +# define UV__EHOSTDOWN (-64) +#else +# define UV__EHOSTDOWN (-4031) +#endif + +#if defined(EREMOTEIO) && !defined(_WIN32) +# define UV__EREMOTEIO UV__ERR(EREMOTEIO) +#else +# define UV__EREMOTEIO (-4030) +#endif + +#if defined(ENOTTY) && !defined(_WIN32) +# define UV__ENOTTY UV__ERR(ENOTTY) +#else +# define UV__ENOTTY (-4029) +#endif + +#if defined(EFTYPE) && !defined(_WIN32) +# define UV__EFTYPE UV__ERR(EFTYPE) +#else +# define UV__EFTYPE (-4028) +#endif + +#if defined(EILSEQ) && !defined(_WIN32) +# define UV__EILSEQ UV__ERR(EILSEQ) +#else +# define UV__EILSEQ (-4027) +#endif + +#endif /* UV_ERRNO_H_ */ diff --git a/extension/libuv/include/uv/linux.h b/extension/libuv/include/uv/linux.h new file mode 100644 index 0000000..9b38405 --- /dev/null +++ b/extension/libuv/include/uv/linux.h @@ -0,0 +1,34 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_LINUX_H +#define UV_LINUX_H + +#define UV_PLATFORM_LOOP_FIELDS \ + uv__io_t inotify_read_watcher; \ + void* inotify_watchers; \ + int inotify_fd; \ + +#define UV_PLATFORM_FS_EVENT_FIELDS \ + void* watchers[2]; \ + int wd; \ + +#endif /* UV_LINUX_H */ diff --git a/extension/libuv/include/uv/os390.h b/extension/libuv/include/uv/os390.h new file mode 100644 index 0000000..0267d74 --- /dev/null +++ b/extension/libuv/include/uv/os390.h @@ -0,0 +1,33 @@ +/* Copyright libuv project contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_MVS_H +#define UV_MVS_H + +#define UV_PLATFORM_SEM_T long + +#define UV_PLATFORM_LOOP_FIELDS \ + void* ep; \ + +#define UV_PLATFORM_FS_EVENT_FIELDS \ + char rfis_rftok[8]; \ + +#endif /* UV_MVS_H */ diff --git a/extension/libuv/include/uv/posix.h b/extension/libuv/include/uv/posix.h new file mode 100644 index 0000000..9a96634 --- /dev/null +++ b/extension/libuv/include/uv/posix.h @@ -0,0 +1,31 @@ +/* Copyright libuv project contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_POSIX_H +#define UV_POSIX_H + +#define UV_PLATFORM_LOOP_FIELDS \ + struct pollfd* poll_fds; \ + size_t poll_fds_used; \ + size_t poll_fds_size; \ + unsigned char poll_fds_iterating; \ + +#endif /* UV_POSIX_H */ diff --git a/extension/libuv/include/uv/stdint-msvc2008.h b/extension/libuv/include/uv/stdint-msvc2008.h new file mode 100644 index 0000000..d02608a --- /dev/null +++ b/extension/libuv/include/uv/stdint-msvc2008.h @@ -0,0 +1,247 @@ +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2008 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. The name of the author may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_STDINT_H_ // [ +#define _MSC_STDINT_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we should wrap include with 'extern "C++" {}' +// or compiler give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#ifdef __cplusplus +extern "C" { +#endif +# include +#ifdef __cplusplus +} +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +#define INTMAX_C INT64_C +#define UINTMAX_C UINT64_C + +#endif // __STDC_CONSTANT_MACROS ] + + +#endif // _MSC_STDINT_H_ ] diff --git a/extension/libuv/include/uv/sunos.h b/extension/libuv/include/uv/sunos.h new file mode 100644 index 0000000..0421664 --- /dev/null +++ b/extension/libuv/include/uv/sunos.h @@ -0,0 +1,44 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_SUNOS_H +#define UV_SUNOS_H + +#include +#include + +/* For the sake of convenience and reduced #ifdef-ery in src/unix/sunos.c, + * add the fs_event fields even when this version of SunOS doesn't support + * file watching. + */ +#define UV_PLATFORM_LOOP_FIELDS \ + uv__io_t fs_event_watcher; \ + int fs_fd; \ + +#if defined(PORT_SOURCE_FILE) + +# define UV_PLATFORM_FS_EVENT_FIELDS \ + file_obj_t fo; \ + int fd; \ + +#endif /* defined(PORT_SOURCE_FILE) */ + +#endif /* UV_SUNOS_H */ diff --git a/extension/libuv/include/uv/threadpool.h b/extension/libuv/include/uv/threadpool.h new file mode 100644 index 0000000..9708ebd --- /dev/null +++ b/extension/libuv/include/uv/threadpool.h @@ -0,0 +1,37 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +/* + * This file is private to libuv. It provides common functionality to both + * Windows and Unix backends. + */ + +#ifndef UV_THREADPOOL_H_ +#define UV_THREADPOOL_H_ + +struct uv__work { + void (*work)(struct uv__work *w); + void (*done)(struct uv__work *w, int status); + struct uv_loop_s* loop; + void* wq[2]; +}; + +#endif /* UV_THREADPOOL_H_ */ diff --git a/extension/libuv/include/uv/tree.h b/extension/libuv/include/uv/tree.h new file mode 100644 index 0000000..f936416 --- /dev/null +++ b/extension/libuv/include/uv/tree.h @@ -0,0 +1,768 @@ +/*- + * Copyright 2002 Niels Provos + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef UV_TREE_H_ +#define UV_TREE_H_ + +#ifndef UV__UNUSED +# if __GNUC__ +# define UV__UNUSED __attribute__((unused)) +# else +# define UV__UNUSED +# endif +#endif + +/* + * This file defines data structures for different types of trees: + * splay trees and red-black trees. + * + * A splay tree is a self-organizing data structure. Every operation + * on the tree causes a splay to happen. The splay moves the requested + * node to the root of the tree and partly rebalances it. + * + * This has the benefit that request locality causes faster lookups as + * the requested nodes move to the top of the tree. On the other hand, + * every lookup causes memory writes. + * + * The Balance Theorem bounds the total access time for m operations + * and n inserts on an initially empty tree as O((m + n)lg n). The + * amortized cost for a sequence of m accesses to a splay tree is O(lg n); + * + * A red-black tree is a binary search tree with the node color as an + * extra attribute. It fulfills a set of conditions: + * - every search path from the root to a leaf consists of the + * same number of black nodes, + * - each red node (except for the root) has a black parent, + * - each leaf node is black. + * + * Every operation on a red-black tree is bounded as O(lg n). + * The maximum height of a red-black tree is 2lg (n+1). + */ + +#define SPLAY_HEAD(name, type) \ +struct name { \ + struct type *sph_root; /* root of the tree */ \ +} + +#define SPLAY_INITIALIZER(root) \ + { NULL } + +#define SPLAY_INIT(root) do { \ + (root)->sph_root = NULL; \ +} while (/*CONSTCOND*/ 0) + +#define SPLAY_ENTRY(type) \ +struct { \ + struct type *spe_left; /* left element */ \ + struct type *spe_right; /* right element */ \ +} + +#define SPLAY_LEFT(elm, field) (elm)->field.spe_left +#define SPLAY_RIGHT(elm, field) (elm)->field.spe_right +#define SPLAY_ROOT(head) (head)->sph_root +#define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL) + +/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */ +#define SPLAY_ROTATE_RIGHT(head, tmp, field) do { \ + SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \ + SPLAY_RIGHT(tmp, field) = (head)->sph_root; \ + (head)->sph_root = tmp; \ +} while (/*CONSTCOND*/ 0) + +#define SPLAY_ROTATE_LEFT(head, tmp, field) do { \ + SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \ + SPLAY_LEFT(tmp, field) = (head)->sph_root; \ + (head)->sph_root = tmp; \ +} while (/*CONSTCOND*/ 0) + +#define SPLAY_LINKLEFT(head, tmp, field) do { \ + SPLAY_LEFT(tmp, field) = (head)->sph_root; \ + tmp = (head)->sph_root; \ + (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \ +} while (/*CONSTCOND*/ 0) + +#define SPLAY_LINKRIGHT(head, tmp, field) do { \ + SPLAY_RIGHT(tmp, field) = (head)->sph_root; \ + tmp = (head)->sph_root; \ + (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \ +} while (/*CONSTCOND*/ 0) + +#define SPLAY_ASSEMBLE(head, node, left, right, field) do { \ + SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field); \ + SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field); \ + SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field); \ + SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field); \ +} while (/*CONSTCOND*/ 0) + +/* Generates prototypes and inline functions */ + +#define SPLAY_PROTOTYPE(name, type, field, cmp) \ +void name##_SPLAY(struct name *, struct type *); \ +void name##_SPLAY_MINMAX(struct name *, int); \ +struct type *name##_SPLAY_INSERT(struct name *, struct type *); \ +struct type *name##_SPLAY_REMOVE(struct name *, struct type *); \ + \ +/* Finds the node with the same key as elm */ \ +static __inline struct type * \ +name##_SPLAY_FIND(struct name *head, struct type *elm) \ +{ \ + if (SPLAY_EMPTY(head)) \ + return(NULL); \ + name##_SPLAY(head, elm); \ + if ((cmp)(elm, (head)->sph_root) == 0) \ + return (head->sph_root); \ + return (NULL); \ +} \ + \ +static __inline struct type * \ +name##_SPLAY_NEXT(struct name *head, struct type *elm) \ +{ \ + name##_SPLAY(head, elm); \ + if (SPLAY_RIGHT(elm, field) != NULL) { \ + elm = SPLAY_RIGHT(elm, field); \ + while (SPLAY_LEFT(elm, field) != NULL) { \ + elm = SPLAY_LEFT(elm, field); \ + } \ + } else \ + elm = NULL; \ + return (elm); \ +} \ + \ +static __inline struct type * \ +name##_SPLAY_MIN_MAX(struct name *head, int val) \ +{ \ + name##_SPLAY_MINMAX(head, val); \ + return (SPLAY_ROOT(head)); \ +} + +/* Main splay operation. + * Moves node close to the key of elm to top + */ +#define SPLAY_GENERATE(name, type, field, cmp) \ +struct type * \ +name##_SPLAY_INSERT(struct name *head, struct type *elm) \ +{ \ + if (SPLAY_EMPTY(head)) { \ + SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL; \ + } else { \ + int __comp; \ + name##_SPLAY(head, elm); \ + __comp = (cmp)(elm, (head)->sph_root); \ + if(__comp < 0) { \ + SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field); \ + SPLAY_RIGHT(elm, field) = (head)->sph_root; \ + SPLAY_LEFT((head)->sph_root, field) = NULL; \ + } else if (__comp > 0) { \ + SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field); \ + SPLAY_LEFT(elm, field) = (head)->sph_root; \ + SPLAY_RIGHT((head)->sph_root, field) = NULL; \ + } else \ + return ((head)->sph_root); \ + } \ + (head)->sph_root = (elm); \ + return (NULL); \ +} \ + \ +struct type * \ +name##_SPLAY_REMOVE(struct name *head, struct type *elm) \ +{ \ + struct type *__tmp; \ + if (SPLAY_EMPTY(head)) \ + return (NULL); \ + name##_SPLAY(head, elm); \ + if ((cmp)(elm, (head)->sph_root) == 0) { \ + if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \ + (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \ + } else { \ + __tmp = SPLAY_RIGHT((head)->sph_root, field); \ + (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \ + name##_SPLAY(head, elm); \ + SPLAY_RIGHT((head)->sph_root, field) = __tmp; \ + } \ + return (elm); \ + } \ + return (NULL); \ +} \ + \ +void \ +name##_SPLAY(struct name *head, struct type *elm) \ +{ \ + struct type __node, *__left, *__right, *__tmp; \ + int __comp; \ + \ + SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL; \ + __left = __right = &__node; \ + \ + while ((__comp = (cmp)(elm, (head)->sph_root)) != 0) { \ + if (__comp < 0) { \ + __tmp = SPLAY_LEFT((head)->sph_root, field); \ + if (__tmp == NULL) \ + break; \ + if ((cmp)(elm, __tmp) < 0){ \ + SPLAY_ROTATE_RIGHT(head, __tmp, field); \ + if (SPLAY_LEFT((head)->sph_root, field) == NULL) \ + break; \ + } \ + SPLAY_LINKLEFT(head, __right, field); \ + } else if (__comp > 0) { \ + __tmp = SPLAY_RIGHT((head)->sph_root, field); \ + if (__tmp == NULL) \ + break; \ + if ((cmp)(elm, __tmp) > 0){ \ + SPLAY_ROTATE_LEFT(head, __tmp, field); \ + if (SPLAY_RIGHT((head)->sph_root, field) == NULL) \ + break; \ + } \ + SPLAY_LINKRIGHT(head, __left, field); \ + } \ + } \ + SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \ +} \ + \ +/* Splay with either the minimum or the maximum element \ + * Used to find minimum or maximum element in tree. \ + */ \ +void name##_SPLAY_MINMAX(struct name *head, int __comp) \ +{ \ + struct type __node, *__left, *__right, *__tmp; \ + \ + SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL; \ + __left = __right = &__node; \ + \ + while (1) { \ + if (__comp < 0) { \ + __tmp = SPLAY_LEFT((head)->sph_root, field); \ + if (__tmp == NULL) \ + break; \ + if (__comp < 0){ \ + SPLAY_ROTATE_RIGHT(head, __tmp, field); \ + if (SPLAY_LEFT((head)->sph_root, field) == NULL) \ + break; \ + } \ + SPLAY_LINKLEFT(head, __right, field); \ + } else if (__comp > 0) { \ + __tmp = SPLAY_RIGHT((head)->sph_root, field); \ + if (__tmp == NULL) \ + break; \ + if (__comp > 0) { \ + SPLAY_ROTATE_LEFT(head, __tmp, field); \ + if (SPLAY_RIGHT((head)->sph_root, field) == NULL) \ + break; \ + } \ + SPLAY_LINKRIGHT(head, __left, field); \ + } \ + } \ + SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \ +} + +#define SPLAY_NEGINF -1 +#define SPLAY_INF 1 + +#define SPLAY_INSERT(name, x, y) name##_SPLAY_INSERT(x, y) +#define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y) +#define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y) +#define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y) +#define SPLAY_MIN(name, x) (SPLAY_EMPTY(x) ? NULL \ + : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF)) +#define SPLAY_MAX(name, x) (SPLAY_EMPTY(x) ? NULL \ + : name##_SPLAY_MIN_MAX(x, SPLAY_INF)) + +#define SPLAY_FOREACH(x, name, head) \ + for ((x) = SPLAY_MIN(name, head); \ + (x) != NULL; \ + (x) = SPLAY_NEXT(name, head, x)) + +/* Macros that define a red-black tree */ +#define RB_HEAD(name, type) \ +struct name { \ + struct type *rbh_root; /* root of the tree */ \ +} + +#define RB_INITIALIZER(root) \ + { NULL } + +#define RB_INIT(root) do { \ + (root)->rbh_root = NULL; \ +} while (/*CONSTCOND*/ 0) + +#define RB_BLACK 0 +#define RB_RED 1 +#define RB_ENTRY(type) \ +struct { \ + struct type *rbe_left; /* left element */ \ + struct type *rbe_right; /* right element */ \ + struct type *rbe_parent; /* parent element */ \ + int rbe_color; /* node color */ \ +} + +#define RB_LEFT(elm, field) (elm)->field.rbe_left +#define RB_RIGHT(elm, field) (elm)->field.rbe_right +#define RB_PARENT(elm, field) (elm)->field.rbe_parent +#define RB_COLOR(elm, field) (elm)->field.rbe_color +#define RB_ROOT(head) (head)->rbh_root +#define RB_EMPTY(head) (RB_ROOT(head) == NULL) + +#define RB_SET(elm, parent, field) do { \ + RB_PARENT(elm, field) = parent; \ + RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL; \ + RB_COLOR(elm, field) = RB_RED; \ +} while (/*CONSTCOND*/ 0) + +#define RB_SET_BLACKRED(black, red, field) do { \ + RB_COLOR(black, field) = RB_BLACK; \ + RB_COLOR(red, field) = RB_RED; \ +} while (/*CONSTCOND*/ 0) + +#ifndef RB_AUGMENT +#define RB_AUGMENT(x) do {} while (0) +#endif + +#define RB_ROTATE_LEFT(head, elm, tmp, field) do { \ + (tmp) = RB_RIGHT(elm, field); \ + if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) { \ + RB_PARENT(RB_LEFT(tmp, field), field) = (elm); \ + } \ + RB_AUGMENT(elm); \ + if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) { \ + if ((elm) == RB_LEFT(RB_PARENT(elm, field), field)) \ + RB_LEFT(RB_PARENT(elm, field), field) = (tmp); \ + else \ + RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \ + } else \ + (head)->rbh_root = (tmp); \ + RB_LEFT(tmp, field) = (elm); \ + RB_PARENT(elm, field) = (tmp); \ + RB_AUGMENT(tmp); \ + if ((RB_PARENT(tmp, field))) \ + RB_AUGMENT(RB_PARENT(tmp, field)); \ +} while (/*CONSTCOND*/ 0) + +#define RB_ROTATE_RIGHT(head, elm, tmp, field) do { \ + (tmp) = RB_LEFT(elm, field); \ + if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) { \ + RB_PARENT(RB_RIGHT(tmp, field), field) = (elm); \ + } \ + RB_AUGMENT(elm); \ + if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) { \ + if ((elm) == RB_LEFT(RB_PARENT(elm, field), field)) \ + RB_LEFT(RB_PARENT(elm, field), field) = (tmp); \ + else \ + RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \ + } else \ + (head)->rbh_root = (tmp); \ + RB_RIGHT(tmp, field) = (elm); \ + RB_PARENT(elm, field) = (tmp); \ + RB_AUGMENT(tmp); \ + if ((RB_PARENT(tmp, field))) \ + RB_AUGMENT(RB_PARENT(tmp, field)); \ +} while (/*CONSTCOND*/ 0) + +/* Generates prototypes and inline functions */ +#define RB_PROTOTYPE(name, type, field, cmp) \ + RB_PROTOTYPE_INTERNAL(name, type, field, cmp,) +#define RB_PROTOTYPE_STATIC(name, type, field, cmp) \ + RB_PROTOTYPE_INTERNAL(name, type, field, cmp, UV__UNUSED static) +#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \ +attr void name##_RB_INSERT_COLOR(struct name *, struct type *); \ +attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\ +attr struct type *name##_RB_REMOVE(struct name *, struct type *); \ +attr struct type *name##_RB_INSERT(struct name *, struct type *); \ +attr struct type *name##_RB_FIND(struct name *, struct type *); \ +attr struct type *name##_RB_NFIND(struct name *, struct type *); \ +attr struct type *name##_RB_NEXT(struct type *); \ +attr struct type *name##_RB_PREV(struct type *); \ +attr struct type *name##_RB_MINMAX(struct name *, int); \ + \ + +/* Main rb operation. + * Moves node close to the key of elm to top + */ +#define RB_GENERATE(name, type, field, cmp) \ + RB_GENERATE_INTERNAL(name, type, field, cmp,) +#define RB_GENERATE_STATIC(name, type, field, cmp) \ + RB_GENERATE_INTERNAL(name, type, field, cmp, UV__UNUSED static) +#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr) \ +attr void \ +name##_RB_INSERT_COLOR(struct name *head, struct type *elm) \ +{ \ + struct type *parent, *gparent, *tmp; \ + while ((parent = RB_PARENT(elm, field)) != NULL && \ + RB_COLOR(parent, field) == RB_RED) { \ + gparent = RB_PARENT(parent, field); \ + if (parent == RB_LEFT(gparent, field)) { \ + tmp = RB_RIGHT(gparent, field); \ + if (tmp && RB_COLOR(tmp, field) == RB_RED) { \ + RB_COLOR(tmp, field) = RB_BLACK; \ + RB_SET_BLACKRED(parent, gparent, field); \ + elm = gparent; \ + continue; \ + } \ + if (RB_RIGHT(parent, field) == elm) { \ + RB_ROTATE_LEFT(head, parent, tmp, field); \ + tmp = parent; \ + parent = elm; \ + elm = tmp; \ + } \ + RB_SET_BLACKRED(parent, gparent, field); \ + RB_ROTATE_RIGHT(head, gparent, tmp, field); \ + } else { \ + tmp = RB_LEFT(gparent, field); \ + if (tmp && RB_COLOR(tmp, field) == RB_RED) { \ + RB_COLOR(tmp, field) = RB_BLACK; \ + RB_SET_BLACKRED(parent, gparent, field); \ + elm = gparent; \ + continue; \ + } \ + if (RB_LEFT(parent, field) == elm) { \ + RB_ROTATE_RIGHT(head, parent, tmp, field); \ + tmp = parent; \ + parent = elm; \ + elm = tmp; \ + } \ + RB_SET_BLACKRED(parent, gparent, field); \ + RB_ROTATE_LEFT(head, gparent, tmp, field); \ + } \ + } \ + RB_COLOR(head->rbh_root, field) = RB_BLACK; \ +} \ + \ +attr void \ +name##_RB_REMOVE_COLOR(struct name *head, struct type *parent, \ + struct type *elm) \ +{ \ + struct type *tmp; \ + while ((elm == NULL || RB_COLOR(elm, field) == RB_BLACK) && \ + elm != RB_ROOT(head)) { \ + if (RB_LEFT(parent, field) == elm) { \ + tmp = RB_RIGHT(parent, field); \ + if (RB_COLOR(tmp, field) == RB_RED) { \ + RB_SET_BLACKRED(tmp, parent, field); \ + RB_ROTATE_LEFT(head, parent, tmp, field); \ + tmp = RB_RIGHT(parent, field); \ + } \ + if ((RB_LEFT(tmp, field) == NULL || \ + RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) && \ + (RB_RIGHT(tmp, field) == NULL || \ + RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) { \ + RB_COLOR(tmp, field) = RB_RED; \ + elm = parent; \ + parent = RB_PARENT(elm, field); \ + } else { \ + if (RB_RIGHT(tmp, field) == NULL || \ + RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) { \ + struct type *oleft; \ + if ((oleft = RB_LEFT(tmp, field)) \ + != NULL) \ + RB_COLOR(oleft, field) = RB_BLACK; \ + RB_COLOR(tmp, field) = RB_RED; \ + RB_ROTATE_RIGHT(head, tmp, oleft, field); \ + tmp = RB_RIGHT(parent, field); \ + } \ + RB_COLOR(tmp, field) = RB_COLOR(parent, field); \ + RB_COLOR(parent, field) = RB_BLACK; \ + if (RB_RIGHT(tmp, field)) \ + RB_COLOR(RB_RIGHT(tmp, field), field) = RB_BLACK; \ + RB_ROTATE_LEFT(head, parent, tmp, field); \ + elm = RB_ROOT(head); \ + break; \ + } \ + } else { \ + tmp = RB_LEFT(parent, field); \ + if (RB_COLOR(tmp, field) == RB_RED) { \ + RB_SET_BLACKRED(tmp, parent, field); \ + RB_ROTATE_RIGHT(head, parent, tmp, field); \ + tmp = RB_LEFT(parent, field); \ + } \ + if ((RB_LEFT(tmp, field) == NULL || \ + RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) && \ + (RB_RIGHT(tmp, field) == NULL || \ + RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) { \ + RB_COLOR(tmp, field) = RB_RED; \ + elm = parent; \ + parent = RB_PARENT(elm, field); \ + } else { \ + if (RB_LEFT(tmp, field) == NULL || \ + RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) { \ + struct type *oright; \ + if ((oright = RB_RIGHT(tmp, field)) \ + != NULL) \ + RB_COLOR(oright, field) = RB_BLACK; \ + RB_COLOR(tmp, field) = RB_RED; \ + RB_ROTATE_LEFT(head, tmp, oright, field); \ + tmp = RB_LEFT(parent, field); \ + } \ + RB_COLOR(tmp, field) = RB_COLOR(parent, field); \ + RB_COLOR(parent, field) = RB_BLACK; \ + if (RB_LEFT(tmp, field)) \ + RB_COLOR(RB_LEFT(tmp, field), field) = RB_BLACK; \ + RB_ROTATE_RIGHT(head, parent, tmp, field); \ + elm = RB_ROOT(head); \ + break; \ + } \ + } \ + } \ + if (elm) \ + RB_COLOR(elm, field) = RB_BLACK; \ +} \ + \ +attr struct type * \ +name##_RB_REMOVE(struct name *head, struct type *elm) \ +{ \ + struct type *child, *parent, *old = elm; \ + int color; \ + if (RB_LEFT(elm, field) == NULL) \ + child = RB_RIGHT(elm, field); \ + else if (RB_RIGHT(elm, field) == NULL) \ + child = RB_LEFT(elm, field); \ + else { \ + struct type *left; \ + elm = RB_RIGHT(elm, field); \ + while ((left = RB_LEFT(elm, field)) != NULL) \ + elm = left; \ + child = RB_RIGHT(elm, field); \ + parent = RB_PARENT(elm, field); \ + color = RB_COLOR(elm, field); \ + if (child) \ + RB_PARENT(child, field) = parent; \ + if (parent) { \ + if (RB_LEFT(parent, field) == elm) \ + RB_LEFT(parent, field) = child; \ + else \ + RB_RIGHT(parent, field) = child; \ + RB_AUGMENT(parent); \ + } else \ + RB_ROOT(head) = child; \ + if (RB_PARENT(elm, field) == old) \ + parent = elm; \ + (elm)->field = (old)->field; \ + if (RB_PARENT(old, field)) { \ + if (RB_LEFT(RB_PARENT(old, field), field) == old) \ + RB_LEFT(RB_PARENT(old, field), field) = elm; \ + else \ + RB_RIGHT(RB_PARENT(old, field), field) = elm; \ + RB_AUGMENT(RB_PARENT(old, field)); \ + } else \ + RB_ROOT(head) = elm; \ + RB_PARENT(RB_LEFT(old, field), field) = elm; \ + if (RB_RIGHT(old, field)) \ + RB_PARENT(RB_RIGHT(old, field), field) = elm; \ + if (parent) { \ + left = parent; \ + do { \ + RB_AUGMENT(left); \ + } while ((left = RB_PARENT(left, field)) != NULL); \ + } \ + goto color; \ + } \ + parent = RB_PARENT(elm, field); \ + color = RB_COLOR(elm, field); \ + if (child) \ + RB_PARENT(child, field) = parent; \ + if (parent) { \ + if (RB_LEFT(parent, field) == elm) \ + RB_LEFT(parent, field) = child; \ + else \ + RB_RIGHT(parent, field) = child; \ + RB_AUGMENT(parent); \ + } else \ + RB_ROOT(head) = child; \ +color: \ + if (color == RB_BLACK) \ + name##_RB_REMOVE_COLOR(head, parent, child); \ + return (old); \ +} \ + \ +/* Inserts a node into the RB tree */ \ +attr struct type * \ +name##_RB_INSERT(struct name *head, struct type *elm) \ +{ \ + struct type *tmp; \ + struct type *parent = NULL; \ + int comp = 0; \ + tmp = RB_ROOT(head); \ + while (tmp) { \ + parent = tmp; \ + comp = (cmp)(elm, parent); \ + if (comp < 0) \ + tmp = RB_LEFT(tmp, field); \ + else if (comp > 0) \ + tmp = RB_RIGHT(tmp, field); \ + else \ + return (tmp); \ + } \ + RB_SET(elm, parent, field); \ + if (parent != NULL) { \ + if (comp < 0) \ + RB_LEFT(parent, field) = elm; \ + else \ + RB_RIGHT(parent, field) = elm; \ + RB_AUGMENT(parent); \ + } else \ + RB_ROOT(head) = elm; \ + name##_RB_INSERT_COLOR(head, elm); \ + return (NULL); \ +} \ + \ +/* Finds the node with the same key as elm */ \ +attr struct type * \ +name##_RB_FIND(struct name *head, struct type *elm) \ +{ \ + struct type *tmp = RB_ROOT(head); \ + int comp; \ + while (tmp) { \ + comp = cmp(elm, tmp); \ + if (comp < 0) \ + tmp = RB_LEFT(tmp, field); \ + else if (comp > 0) \ + tmp = RB_RIGHT(tmp, field); \ + else \ + return (tmp); \ + } \ + return (NULL); \ +} \ + \ +/* Finds the first node greater than or equal to the search key */ \ +attr struct type * \ +name##_RB_NFIND(struct name *head, struct type *elm) \ +{ \ + struct type *tmp = RB_ROOT(head); \ + struct type *res = NULL; \ + int comp; \ + while (tmp) { \ + comp = cmp(elm, tmp); \ + if (comp < 0) { \ + res = tmp; \ + tmp = RB_LEFT(tmp, field); \ + } \ + else if (comp > 0) \ + tmp = RB_RIGHT(tmp, field); \ + else \ + return (tmp); \ + } \ + return (res); \ +} \ + \ +/* ARGSUSED */ \ +attr struct type * \ +name##_RB_NEXT(struct type *elm) \ +{ \ + if (RB_RIGHT(elm, field)) { \ + elm = RB_RIGHT(elm, field); \ + while (RB_LEFT(elm, field)) \ + elm = RB_LEFT(elm, field); \ + } else { \ + if (RB_PARENT(elm, field) && \ + (elm == RB_LEFT(RB_PARENT(elm, field), field))) \ + elm = RB_PARENT(elm, field); \ + else { \ + while (RB_PARENT(elm, field) && \ + (elm == RB_RIGHT(RB_PARENT(elm, field), field))) \ + elm = RB_PARENT(elm, field); \ + elm = RB_PARENT(elm, field); \ + } \ + } \ + return (elm); \ +} \ + \ +/* ARGSUSED */ \ +attr struct type * \ +name##_RB_PREV(struct type *elm) \ +{ \ + if (RB_LEFT(elm, field)) { \ + elm = RB_LEFT(elm, field); \ + while (RB_RIGHT(elm, field)) \ + elm = RB_RIGHT(elm, field); \ + } else { \ + if (RB_PARENT(elm, field) && \ + (elm == RB_RIGHT(RB_PARENT(elm, field), field))) \ + elm = RB_PARENT(elm, field); \ + else { \ + while (RB_PARENT(elm, field) && \ + (elm == RB_LEFT(RB_PARENT(elm, field), field))) \ + elm = RB_PARENT(elm, field); \ + elm = RB_PARENT(elm, field); \ + } \ + } \ + return (elm); \ +} \ + \ +attr struct type * \ +name##_RB_MINMAX(struct name *head, int val) \ +{ \ + struct type *tmp = RB_ROOT(head); \ + struct type *parent = NULL; \ + while (tmp) { \ + parent = tmp; \ + if (val < 0) \ + tmp = RB_LEFT(tmp, field); \ + else \ + tmp = RB_RIGHT(tmp, field); \ + } \ + return (parent); \ +} + +#define RB_NEGINF -1 +#define RB_INF 1 + +#define RB_INSERT(name, x, y) name##_RB_INSERT(x, y) +#define RB_REMOVE(name, x, y) name##_RB_REMOVE(x, y) +#define RB_FIND(name, x, y) name##_RB_FIND(x, y) +#define RB_NFIND(name, x, y) name##_RB_NFIND(x, y) +#define RB_NEXT(name, x, y) name##_RB_NEXT(y) +#define RB_PREV(name, x, y) name##_RB_PREV(y) +#define RB_MIN(name, x) name##_RB_MINMAX(x, RB_NEGINF) +#define RB_MAX(name, x) name##_RB_MINMAX(x, RB_INF) + +#define RB_FOREACH(x, name, head) \ + for ((x) = RB_MIN(name, head); \ + (x) != NULL; \ + (x) = name##_RB_NEXT(x)) + +#define RB_FOREACH_FROM(x, name, y) \ + for ((x) = (y); \ + ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL); \ + (x) = (y)) + +#define RB_FOREACH_SAFE(x, name, head, y) \ + for ((x) = RB_MIN(name, head); \ + ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL); \ + (x) = (y)) + +#define RB_FOREACH_REVERSE(x, name, head) \ + for ((x) = RB_MAX(name, head); \ + (x) != NULL; \ + (x) = name##_RB_PREV(x)) + +#define RB_FOREACH_REVERSE_FROM(x, name, y) \ + for ((x) = (y); \ + ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL); \ + (x) = (y)) + +#define RB_FOREACH_REVERSE_SAFE(x, name, head, y) \ + for ((x) = RB_MAX(name, head); \ + ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL); \ + (x) = (y)) + +#endif /* UV_TREE_H_ */ diff --git a/extension/libuv/include/uv/unix.h b/extension/libuv/include/uv/unix.h new file mode 100644 index 0000000..e3cf7bd --- /dev/null +++ b/extension/libuv/include/uv/unix.h @@ -0,0 +1,507 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_UNIX_H +#define UV_UNIX_H + +#include +#include +#include +#include + +#include +#include +#include +#include +#include /* MAXHOSTNAMELEN on Solaris */ + +#include +#include + +#if !defined(__MVS__) +#include +#include /* MAXHOSTNAMELEN on Linux and the BSDs */ +#endif +#include +#include + +#include "uv/threadpool.h" + +#if defined(__linux__) +# include "uv/linux.h" +#elif defined (__MVS__) +# include "uv/os390.h" +#elif defined(__PASE__) /* __PASE__ and _AIX are both defined on IBM i */ +# include "uv/posix.h" /* IBM i needs uv/posix.h, not uv/aix.h */ +#elif defined(_AIX) +# include "uv/aix.h" +#elif defined(__sun) +# include "uv/sunos.h" +#elif defined(__APPLE__) +# include "uv/darwin.h" +#elif defined(__DragonFly__) || \ + defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ + defined(__OpenBSD__) || \ + defined(__NetBSD__) +# include "uv/bsd.h" +#elif defined(__CYGWIN__) || \ + defined(__MSYS__) || \ + defined(__GNU__) +# include "uv/posix.h" +#elif defined(__HAIKU__) +# include "uv/posix.h" +#elif defined(__QNX__) +# include "uv/posix.h" +#endif + +#ifndef NI_MAXHOST +# define NI_MAXHOST 1025 +#endif + +#ifndef NI_MAXSERV +# define NI_MAXSERV 32 +#endif + +#ifndef UV_IO_PRIVATE_PLATFORM_FIELDS +# define UV_IO_PRIVATE_PLATFORM_FIELDS /* empty */ +#endif + +struct uv__io_s; +struct uv_loop_s; + +typedef void (*uv__io_cb)(struct uv_loop_s* loop, + struct uv__io_s* w, + unsigned int events); +typedef struct uv__io_s uv__io_t; + +struct uv__io_s { + uv__io_cb cb; + void* pending_queue[2]; + void* watcher_queue[2]; + unsigned int pevents; /* Pending event mask i.e. mask at next tick. */ + unsigned int events; /* Current event mask. */ + int fd; + UV_IO_PRIVATE_PLATFORM_FIELDS +}; + +#ifndef UV_PLATFORM_SEM_T +# define UV_PLATFORM_SEM_T sem_t +#endif + +#ifndef UV_PLATFORM_LOOP_FIELDS +# define UV_PLATFORM_LOOP_FIELDS /* empty */ +#endif + +#ifndef UV_PLATFORM_FS_EVENT_FIELDS +# define UV_PLATFORM_FS_EVENT_FIELDS /* empty */ +#endif + +#ifndef UV_STREAM_PRIVATE_PLATFORM_FIELDS +# define UV_STREAM_PRIVATE_PLATFORM_FIELDS /* empty */ +#endif + +/* Note: May be cast to struct iovec. See writev(2). */ +typedef struct uv_buf_t { + char* base; + size_t len; +} uv_buf_t; + +typedef int uv_file; +typedef int uv_os_sock_t; +typedef int uv_os_fd_t; +typedef pid_t uv_pid_t; + +#define UV_ONCE_INIT PTHREAD_ONCE_INIT + +typedef pthread_once_t uv_once_t; +typedef pthread_t uv_thread_t; +typedef pthread_mutex_t uv_mutex_t; +typedef pthread_rwlock_t uv_rwlock_t; +typedef UV_PLATFORM_SEM_T uv_sem_t; +typedef pthread_cond_t uv_cond_t; +typedef pthread_key_t uv_key_t; + +/* Note: guard clauses should match uv_barrier_init's in src/unix/thread.c. */ +#if defined(_AIX) || \ + defined(__OpenBSD__) || \ + !defined(PTHREAD_BARRIER_SERIAL_THREAD) +/* TODO(bnoordhuis) Merge into uv_barrier_t in v2. */ +struct _uv_barrier { + uv_mutex_t mutex; + uv_cond_t cond; + unsigned threshold; + unsigned in; + unsigned out; +}; + +typedef struct { + struct _uv_barrier* b; +# if defined(PTHREAD_BARRIER_SERIAL_THREAD) + /* TODO(bnoordhuis) Remove padding in v2. */ + char pad[sizeof(pthread_barrier_t) - sizeof(struct _uv_barrier*)]; +# endif +} uv_barrier_t; +#else +typedef pthread_barrier_t uv_barrier_t; +#endif + +/* Platform-specific definitions for uv_spawn support. */ +typedef gid_t uv_gid_t; +typedef uid_t uv_uid_t; + +typedef struct dirent uv__dirent_t; + +#define UV_DIR_PRIVATE_FIELDS \ + DIR* dir; + +#if defined(DT_UNKNOWN) +# define HAVE_DIRENT_TYPES +# if defined(DT_REG) +# define UV__DT_FILE DT_REG +# else +# define UV__DT_FILE -1 +# endif +# if defined(DT_DIR) +# define UV__DT_DIR DT_DIR +# else +# define UV__DT_DIR -2 +# endif +# if defined(DT_LNK) +# define UV__DT_LINK DT_LNK +# else +# define UV__DT_LINK -3 +# endif +# if defined(DT_FIFO) +# define UV__DT_FIFO DT_FIFO +# else +# define UV__DT_FIFO -4 +# endif +# if defined(DT_SOCK) +# define UV__DT_SOCKET DT_SOCK +# else +# define UV__DT_SOCKET -5 +# endif +# if defined(DT_CHR) +# define UV__DT_CHAR DT_CHR +# else +# define UV__DT_CHAR -6 +# endif +# if defined(DT_BLK) +# define UV__DT_BLOCK DT_BLK +# else +# define UV__DT_BLOCK -7 +# endif +#endif + +/* Platform-specific definitions for uv_dlopen support. */ +#define UV_DYNAMIC /* empty */ + +typedef struct { + void* handle; + char* errmsg; +} uv_lib_t; + +#define UV_LOOP_PRIVATE_FIELDS \ + unsigned long flags; \ + int backend_fd; \ + void* pending_queue[2]; \ + void* watcher_queue[2]; \ + uv__io_t** watchers; \ + unsigned int nwatchers; \ + unsigned int nfds; \ + void* wq[2]; \ + uv_mutex_t wq_mutex; \ + uv_async_t wq_async; \ + uv_rwlock_t cloexec_lock; \ + uv_handle_t* closing_handles; \ + void* process_handles[2]; \ + void* prepare_handles[2]; \ + void* check_handles[2]; \ + void* idle_handles[2]; \ + void* async_handles[2]; \ + void (*async_unused)(void); /* TODO(bnoordhuis) Remove in libuv v2. */ \ + uv__io_t async_io_watcher; \ + int async_wfd; \ + struct { \ + void* min; \ + unsigned int nelts; \ + } timer_heap; \ + uint64_t timer_counter; \ + uint64_t time; \ + int signal_pipefd[2]; \ + uv__io_t signal_io_watcher; \ + uv_signal_t child_watcher; \ + int emfile_fd; \ + UV_PLATFORM_LOOP_FIELDS \ + +#define UV_REQ_TYPE_PRIVATE /* empty */ + +#define UV_REQ_PRIVATE_FIELDS /* empty */ + +#define UV_PRIVATE_REQ_TYPES /* empty */ + +#define UV_WRITE_PRIVATE_FIELDS \ + void* queue[2]; \ + unsigned int write_index; \ + uv_buf_t* bufs; \ + unsigned int nbufs; \ + int error; \ + uv_buf_t bufsml[4]; \ + +#define UV_CONNECT_PRIVATE_FIELDS \ + void* queue[2]; \ + +#define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */ + +#define UV_UDP_SEND_PRIVATE_FIELDS \ + void* queue[2]; \ + struct sockaddr_storage addr; \ + unsigned int nbufs; \ + uv_buf_t* bufs; \ + ssize_t status; \ + uv_udp_send_cb send_cb; \ + uv_buf_t bufsml[4]; \ + +#define UV_HANDLE_PRIVATE_FIELDS \ + uv_handle_t* next_closing; \ + unsigned int flags; \ + +#define UV_STREAM_PRIVATE_FIELDS \ + uv_connect_t *connect_req; \ + uv_shutdown_t *shutdown_req; \ + uv__io_t io_watcher; \ + void* write_queue[2]; \ + void* write_completed_queue[2]; \ + uv_connection_cb connection_cb; \ + int delayed_error; \ + int accepted_fd; \ + void* queued_fds; \ + UV_STREAM_PRIVATE_PLATFORM_FIELDS \ + +#define UV_TCP_PRIVATE_FIELDS /* empty */ + +#define UV_UDP_PRIVATE_FIELDS \ + uv_alloc_cb alloc_cb; \ + uv_udp_recv_cb recv_cb; \ + uv__io_t io_watcher; \ + void* write_queue[2]; \ + void* write_completed_queue[2]; \ + +#define UV_PIPE_PRIVATE_FIELDS \ + const char* pipe_fname; /* strdup'ed */ + +#define UV_POLL_PRIVATE_FIELDS \ + uv__io_t io_watcher; + +#define UV_PREPARE_PRIVATE_FIELDS \ + uv_prepare_cb prepare_cb; \ + void* queue[2]; \ + +#define UV_CHECK_PRIVATE_FIELDS \ + uv_check_cb check_cb; \ + void* queue[2]; \ + +#define UV_IDLE_PRIVATE_FIELDS \ + uv_idle_cb idle_cb; \ + void* queue[2]; \ + +#define UV_ASYNC_PRIVATE_FIELDS \ + uv_async_cb async_cb; \ + void* queue[2]; \ + int pending; \ + +#define UV_TIMER_PRIVATE_FIELDS \ + uv_timer_cb timer_cb; \ + void* heap_node[3]; \ + uint64_t timeout; \ + uint64_t repeat; \ + uint64_t start_id; + +#define UV_GETADDRINFO_PRIVATE_FIELDS \ + struct uv__work work_req; \ + uv_getaddrinfo_cb cb; \ + struct addrinfo* hints; \ + char* hostname; \ + char* service; \ + struct addrinfo* addrinfo; \ + int retcode; + +#define UV_GETNAMEINFO_PRIVATE_FIELDS \ + struct uv__work work_req; \ + uv_getnameinfo_cb getnameinfo_cb; \ + struct sockaddr_storage storage; \ + int flags; \ + char host[NI_MAXHOST]; \ + char service[NI_MAXSERV]; \ + int retcode; + +#define UV_PROCESS_PRIVATE_FIELDS \ + void* queue[2]; \ + int status; \ + +#define UV_FS_PRIVATE_FIELDS \ + const char *new_path; \ + uv_file file; \ + int flags; \ + mode_t mode; \ + unsigned int nbufs; \ + uv_buf_t* bufs; \ + off_t off; \ + uv_uid_t uid; \ + uv_gid_t gid; \ + double atime; \ + double mtime; \ + struct uv__work work_req; \ + uv_buf_t bufsml[4]; \ + +#define UV_WORK_PRIVATE_FIELDS \ + struct uv__work work_req; + +#define UV_TTY_PRIVATE_FIELDS \ + struct termios orig_termios; \ + int mode; + +#define UV_SIGNAL_PRIVATE_FIELDS \ + /* RB_ENTRY(uv_signal_s) tree_entry; */ \ + struct { \ + struct uv_signal_s* rbe_left; \ + struct uv_signal_s* rbe_right; \ + struct uv_signal_s* rbe_parent; \ + int rbe_color; \ + } tree_entry; \ + /* Use two counters here so we don have to fiddle with atomics. */ \ + unsigned int caught_signals; \ + unsigned int dispatched_signals; + +#define UV_FS_EVENT_PRIVATE_FIELDS \ + uv_fs_event_cb cb; \ + UV_PLATFORM_FS_EVENT_FIELDS \ + +/* fs open() flags supported on this platform: */ +#if defined(O_APPEND) +# define UV_FS_O_APPEND O_APPEND +#else +# define UV_FS_O_APPEND 0 +#endif +#if defined(O_CREAT) +# define UV_FS_O_CREAT O_CREAT +#else +# define UV_FS_O_CREAT 0 +#endif + +#if defined(__linux__) && defined(__arm__) +# define UV_FS_O_DIRECT 0x10000 +#elif defined(__linux__) && defined(__m68k__) +# define UV_FS_O_DIRECT 0x10000 +#elif defined(__linux__) && defined(__mips__) +# define UV_FS_O_DIRECT 0x08000 +#elif defined(__linux__) && defined(__powerpc__) +# define UV_FS_O_DIRECT 0x20000 +#elif defined(__linux__) && defined(__s390x__) +# define UV_FS_O_DIRECT 0x04000 +#elif defined(__linux__) && defined(__x86_64__) +# define UV_FS_O_DIRECT 0x04000 +#elif defined(O_DIRECT) +# define UV_FS_O_DIRECT O_DIRECT +#else +# define UV_FS_O_DIRECT 0 +#endif + +#if defined(O_DIRECTORY) +# define UV_FS_O_DIRECTORY O_DIRECTORY +#else +# define UV_FS_O_DIRECTORY 0 +#endif +#if defined(O_DSYNC) +# define UV_FS_O_DSYNC O_DSYNC +#else +# define UV_FS_O_DSYNC 0 +#endif +#if defined(O_EXCL) +# define UV_FS_O_EXCL O_EXCL +#else +# define UV_FS_O_EXCL 0 +#endif +#if defined(O_EXLOCK) +# define UV_FS_O_EXLOCK O_EXLOCK +#else +# define UV_FS_O_EXLOCK 0 +#endif +#if defined(O_NOATIME) +# define UV_FS_O_NOATIME O_NOATIME +#else +# define UV_FS_O_NOATIME 0 +#endif +#if defined(O_NOCTTY) +# define UV_FS_O_NOCTTY O_NOCTTY +#else +# define UV_FS_O_NOCTTY 0 +#endif +#if defined(O_NOFOLLOW) +# define UV_FS_O_NOFOLLOW O_NOFOLLOW +#else +# define UV_FS_O_NOFOLLOW 0 +#endif +#if defined(O_NONBLOCK) +# define UV_FS_O_NONBLOCK O_NONBLOCK +#else +# define UV_FS_O_NONBLOCK 0 +#endif +#if defined(O_RDONLY) +# define UV_FS_O_RDONLY O_RDONLY +#else +# define UV_FS_O_RDONLY 0 +#endif +#if defined(O_RDWR) +# define UV_FS_O_RDWR O_RDWR +#else +# define UV_FS_O_RDWR 0 +#endif +#if defined(O_SYMLINK) +# define UV_FS_O_SYMLINK O_SYMLINK +#else +# define UV_FS_O_SYMLINK 0 +#endif +#if defined(O_SYNC) +# define UV_FS_O_SYNC O_SYNC +#else +# define UV_FS_O_SYNC 0 +#endif +#if defined(O_TRUNC) +# define UV_FS_O_TRUNC O_TRUNC +#else +# define UV_FS_O_TRUNC 0 +#endif +#if defined(O_WRONLY) +# define UV_FS_O_WRONLY O_WRONLY +#else +# define UV_FS_O_WRONLY 0 +#endif + +/* fs open() flags supported on other platforms: */ +#define UV_FS_O_FILEMAP 0 +#define UV_FS_O_RANDOM 0 +#define UV_FS_O_SHORT_LIVED 0 +#define UV_FS_O_SEQUENTIAL 0 +#define UV_FS_O_TEMPORARY 0 + +#endif /* UV_UNIX_H */ diff --git a/extension/libuv/include/uv/version.h b/extension/libuv/include/uv/version.h new file mode 100644 index 0000000..e94f1e0 --- /dev/null +++ b/extension/libuv/include/uv/version.h @@ -0,0 +1,43 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef UV_VERSION_H +#define UV_VERSION_H + + /* + * Versions with the same major number are ABI stable. API is allowed to + * evolve between minor releases, but only in a backwards compatible way. + * Make sure you update the -soname directives in configure.ac + * whenever you bump UV_VERSION_MAJOR or UV_VERSION_MINOR (but + * not UV_VERSION_PATCH.) + */ + +#define UV_VERSION_MAJOR 1 +#define UV_VERSION_MINOR 41 +#define UV_VERSION_PATCH 0 +#define UV_VERSION_IS_RELEASE 1 +#define UV_VERSION_SUFFIX "" + +#define UV_VERSION_HEX ((UV_VERSION_MAJOR << 16) | \ + (UV_VERSION_MINOR << 8) | \ + (UV_VERSION_PATCH)) + +#endif /* UV_VERSION_H */ diff --git a/extension/libuv/include/uv/win.h b/extension/libuv/include/uv/win.h new file mode 100644 index 0000000..f5f1d3a --- /dev/null +++ b/extension/libuv/include/uv/win.h @@ -0,0 +1,691 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef _WIN32_WINNT +# define _WIN32_WINNT 0x0600 +#endif + +#if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED) +typedef intptr_t ssize_t; +# define SSIZE_MAX INTPTR_MAX +# define _SSIZE_T_ +# define _SSIZE_T_DEFINED +#endif + +#include + +#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) +typedef struct pollfd { + SOCKET fd; + short events; + short revents; +} WSAPOLLFD, *PWSAPOLLFD, *LPWSAPOLLFD; +#endif + +#ifndef LOCALE_INVARIANT +# define LOCALE_INVARIANT 0x007f +#endif + +#include +#include +#include + +#include +#include +#include +#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif + +#include "uv/tree.h" +#include "uv/threadpool.h" + +#define MAX_PIPENAME_LEN 256 + +#ifndef S_IFLNK +# define S_IFLNK 0xA000 +#endif + +/* Additional signals supported by uv_signal and or uv_kill. The CRT defines + * the following signals already: + * + * #define SIGINT 2 + * #define SIGILL 4 + * #define SIGABRT_COMPAT 6 + * #define SIGFPE 8 + * #define SIGSEGV 11 + * #define SIGTERM 15 + * #define SIGBREAK 21 + * #define SIGABRT 22 + * + * The additional signals have values that are common on other Unix + * variants (Linux and Darwin) + */ +#define SIGHUP 1 +#define SIGKILL 9 +#define SIGWINCH 28 + +/* Redefine NSIG to take SIGWINCH into consideration */ +#if defined(NSIG) && NSIG <= SIGWINCH +# undef NSIG +#endif +#ifndef NSIG +# define NSIG SIGWINCH + 1 +#endif + +/* The CRT defines SIGABRT_COMPAT as 6, which equals SIGABRT on many unix-like + * platforms. However MinGW doesn't define it, so we do. */ +#ifndef SIGABRT_COMPAT +# define SIGABRT_COMPAT 6 +#endif + +/* + * Guids and typedefs for winsock extension functions + * Mingw32 doesn't have these :-( + */ +#ifndef WSAID_ACCEPTEX +# define WSAID_ACCEPTEX \ + {0xb5367df1, 0xcbac, 0x11cf, \ + {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}} + +# define WSAID_CONNECTEX \ + {0x25a207b9, 0xddf3, 0x4660, \ + {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}} + +# define WSAID_GETACCEPTEXSOCKADDRS \ + {0xb5367df2, 0xcbac, 0x11cf, \ + {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}} + +# define WSAID_DISCONNECTEX \ + {0x7fda2e11, 0x8630, 0x436f, \ + {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}} + +# define WSAID_TRANSMITFILE \ + {0xb5367df0, 0xcbac, 0x11cf, \ + {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}} + + typedef BOOL (PASCAL *LPFN_ACCEPTEX) + (SOCKET sListenSocket, + SOCKET sAcceptSocket, + PVOID lpOutputBuffer, + DWORD dwReceiveDataLength, + DWORD dwLocalAddressLength, + DWORD dwRemoteAddressLength, + LPDWORD lpdwBytesReceived, + LPOVERLAPPED lpOverlapped); + + typedef BOOL (PASCAL *LPFN_CONNECTEX) + (SOCKET s, + const struct sockaddr* name, + int namelen, + PVOID lpSendBuffer, + DWORD dwSendDataLength, + LPDWORD lpdwBytesSent, + LPOVERLAPPED lpOverlapped); + + typedef void (PASCAL *LPFN_GETACCEPTEXSOCKADDRS) + (PVOID lpOutputBuffer, + DWORD dwReceiveDataLength, + DWORD dwLocalAddressLength, + DWORD dwRemoteAddressLength, + LPSOCKADDR* LocalSockaddr, + LPINT LocalSockaddrLength, + LPSOCKADDR* RemoteSockaddr, + LPINT RemoteSockaddrLength); + + typedef BOOL (PASCAL *LPFN_DISCONNECTEX) + (SOCKET hSocket, + LPOVERLAPPED lpOverlapped, + DWORD dwFlags, + DWORD reserved); + + typedef BOOL (PASCAL *LPFN_TRANSMITFILE) + (SOCKET hSocket, + HANDLE hFile, + DWORD nNumberOfBytesToWrite, + DWORD nNumberOfBytesPerSend, + LPOVERLAPPED lpOverlapped, + LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers, + DWORD dwFlags); + + typedef PVOID RTL_SRWLOCK; + typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK; +#endif + +typedef int (WSAAPI* LPFN_WSARECV) + (SOCKET socket, + LPWSABUF buffers, + DWORD buffer_count, + LPDWORD bytes, + LPDWORD flags, + LPWSAOVERLAPPED overlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine); + +typedef int (WSAAPI* LPFN_WSARECVFROM) + (SOCKET socket, + LPWSABUF buffers, + DWORD buffer_count, + LPDWORD bytes, + LPDWORD flags, + struct sockaddr* addr, + LPINT addr_len, + LPWSAOVERLAPPED overlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine); + +#ifndef _NTDEF_ + typedef LONG NTSTATUS; + typedef NTSTATUS *PNTSTATUS; +#endif + +#ifndef RTL_CONDITION_VARIABLE_INIT + typedef PVOID CONDITION_VARIABLE, *PCONDITION_VARIABLE; +#endif + +typedef struct _AFD_POLL_HANDLE_INFO { + HANDLE Handle; + ULONG Events; + NTSTATUS Status; +} AFD_POLL_HANDLE_INFO, *PAFD_POLL_HANDLE_INFO; + +typedef struct _AFD_POLL_INFO { + LARGE_INTEGER Timeout; + ULONG NumberOfHandles; + ULONG Exclusive; + AFD_POLL_HANDLE_INFO Handles[1]; +} AFD_POLL_INFO, *PAFD_POLL_INFO; + +#define UV_MSAFD_PROVIDER_COUNT 3 + + +/** + * It should be possible to cast uv_buf_t[] to WSABUF[] + * see http://msdn.microsoft.com/en-us/library/ms741542(v=vs.85).aspx + */ +typedef struct uv_buf_t { + ULONG len; + char* base; +} uv_buf_t; + +typedef int uv_file; +typedef SOCKET uv_os_sock_t; +typedef HANDLE uv_os_fd_t; +typedef int uv_pid_t; + +typedef HANDLE uv_thread_t; + +typedef HANDLE uv_sem_t; + +typedef CRITICAL_SECTION uv_mutex_t; + +/* This condition variable implementation is based on the SetEvent solution + * (section 3.2) at http://www.cs.wustl.edu/~schmidt/win32-cv-1.html + * We could not use the SignalObjectAndWait solution (section 3.4) because + * it want the 2nd argument (type uv_mutex_t) of uv_cond_wait() and + * uv_cond_timedwait() to be HANDLEs, but we use CRITICAL_SECTIONs. + */ + +typedef union { + CONDITION_VARIABLE cond_var; + struct { + unsigned int waiters_count; + CRITICAL_SECTION waiters_count_lock; + HANDLE signal_event; + HANDLE broadcast_event; + } unused_; /* TODO: retained for ABI compatibility; remove me in v2.x. */ +} uv_cond_t; + +typedef union { + struct { + unsigned int num_readers_; + CRITICAL_SECTION num_readers_lock_; + HANDLE write_semaphore_; + } state_; + /* TODO: remove me in v2.x. */ + struct { + SRWLOCK unused_; + } unused1_; + /* TODO: remove me in v2.x. */ + struct { + uv_mutex_t unused1_; + uv_mutex_t unused2_; + } unused2_; +} uv_rwlock_t; + +typedef struct { + unsigned int n; + unsigned int count; + uv_mutex_t mutex; + uv_sem_t turnstile1; + uv_sem_t turnstile2; +} uv_barrier_t; + +typedef struct { + DWORD tls_index; +} uv_key_t; + +#define UV_ONCE_INIT { 0, NULL } + +typedef struct uv_once_s { + unsigned char ran; + HANDLE event; +} uv_once_t; + +/* Platform-specific definitions for uv_spawn support. */ +typedef unsigned char uv_uid_t; +typedef unsigned char uv_gid_t; + +typedef struct uv__dirent_s { + int d_type; + char d_name[1]; +} uv__dirent_t; + +#define UV_DIR_PRIVATE_FIELDS \ + HANDLE dir_handle; \ + WIN32_FIND_DATAW find_data; \ + BOOL need_find_call; + +#define HAVE_DIRENT_TYPES +#define UV__DT_DIR UV_DIRENT_DIR +#define UV__DT_FILE UV_DIRENT_FILE +#define UV__DT_LINK UV_DIRENT_LINK +#define UV__DT_FIFO UV_DIRENT_FIFO +#define UV__DT_SOCKET UV_DIRENT_SOCKET +#define UV__DT_CHAR UV_DIRENT_CHAR +#define UV__DT_BLOCK UV_DIRENT_BLOCK + +/* Platform-specific definitions for uv_dlopen support. */ +#define UV_DYNAMIC FAR WINAPI +typedef struct { + HMODULE handle; + char* errmsg; +} uv_lib_t; + +#define UV_LOOP_PRIVATE_FIELDS \ + /* The loop's I/O completion port */ \ + HANDLE iocp; \ + /* The current time according to the event loop. in msecs. */ \ + uint64_t time; \ + /* Tail of a single-linked circular queue of pending reqs. If the queue */ \ + /* is empty, tail_ is NULL. If there is only one item, */ \ + /* tail_->next_req == tail_ */ \ + uv_req_t* pending_reqs_tail; \ + /* Head of a single-linked list of closed handles */ \ + uv_handle_t* endgame_handles; \ + /* TODO(bnoordhuis) Stop heap-allocating |timer_heap| in libuv v2.x. */ \ + void* timer_heap; \ + /* Lists of active loop (prepare / check / idle) watchers */ \ + uv_prepare_t* prepare_handles; \ + uv_check_t* check_handles; \ + uv_idle_t* idle_handles; \ + /* This pointer will refer to the prepare/check/idle handle whose */ \ + /* callback is scheduled to be called next. This is needed to allow */ \ + /* safe removal from one of the lists above while that list being */ \ + /* iterated over. */ \ + uv_prepare_t* next_prepare_handle; \ + uv_check_t* next_check_handle; \ + uv_idle_t* next_idle_handle; \ + /* This handle holds the peer sockets for the fast variant of uv_poll_t */ \ + SOCKET poll_peer_sockets[UV_MSAFD_PROVIDER_COUNT]; \ + /* Counter to keep track of active tcp streams */ \ + unsigned int active_tcp_streams; \ + /* Counter to keep track of active udp streams */ \ + unsigned int active_udp_streams; \ + /* Counter to started timer */ \ + uint64_t timer_counter; \ + /* Threadpool */ \ + void* wq[2]; \ + uv_mutex_t wq_mutex; \ + uv_async_t wq_async; + +#define UV_REQ_TYPE_PRIVATE \ + /* TODO: remove the req suffix */ \ + UV_ACCEPT, \ + UV_FS_EVENT_REQ, \ + UV_POLL_REQ, \ + UV_PROCESS_EXIT, \ + UV_READ, \ + UV_UDP_RECV, \ + UV_WAKEUP, \ + UV_SIGNAL_REQ, + +#define UV_REQ_PRIVATE_FIELDS \ + union { \ + /* Used by I/O operations */ \ + struct { \ + OVERLAPPED overlapped; \ + size_t queued_bytes; \ + } io; \ + } u; \ + struct uv_req_s* next_req; + +#define UV_WRITE_PRIVATE_FIELDS \ + int coalesced; \ + uv_buf_t write_buffer; \ + HANDLE event_handle; \ + HANDLE wait_handle; + +#define UV_CONNECT_PRIVATE_FIELDS \ + /* empty */ + +#define UV_SHUTDOWN_PRIVATE_FIELDS \ + /* empty */ + +#define UV_UDP_SEND_PRIVATE_FIELDS \ + /* empty */ + +#define UV_PRIVATE_REQ_TYPES \ + typedef struct uv_pipe_accept_s { \ + UV_REQ_FIELDS \ + HANDLE pipeHandle; \ + struct uv_pipe_accept_s* next_pending; \ + } uv_pipe_accept_t; \ + \ + typedef struct uv_tcp_accept_s { \ + UV_REQ_FIELDS \ + SOCKET accept_socket; \ + char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32]; \ + HANDLE event_handle; \ + HANDLE wait_handle; \ + struct uv_tcp_accept_s* next_pending; \ + } uv_tcp_accept_t; \ + \ + typedef struct uv_read_s { \ + UV_REQ_FIELDS \ + HANDLE event_handle; \ + HANDLE wait_handle; \ + } uv_read_t; + +#define uv_stream_connection_fields \ + unsigned int write_reqs_pending; \ + uv_shutdown_t* shutdown_req; + +#define uv_stream_server_fields \ + uv_connection_cb connection_cb; + +#define UV_STREAM_PRIVATE_FIELDS \ + unsigned int reqs_pending; \ + int activecnt; \ + uv_read_t read_req; \ + union { \ + struct { uv_stream_connection_fields } conn; \ + struct { uv_stream_server_fields } serv; \ + } stream; + +#define uv_tcp_server_fields \ + uv_tcp_accept_t* accept_reqs; \ + unsigned int processed_accepts; \ + uv_tcp_accept_t* pending_accepts; \ + LPFN_ACCEPTEX func_acceptex; + +#define uv_tcp_connection_fields \ + uv_buf_t read_buffer; \ + LPFN_CONNECTEX func_connectex; + +#define UV_TCP_PRIVATE_FIELDS \ + SOCKET socket; \ + int delayed_error; \ + union { \ + struct { uv_tcp_server_fields } serv; \ + struct { uv_tcp_connection_fields } conn; \ + } tcp; + +#define UV_UDP_PRIVATE_FIELDS \ + SOCKET socket; \ + unsigned int reqs_pending; \ + int activecnt; \ + uv_req_t recv_req; \ + uv_buf_t recv_buffer; \ + struct sockaddr_storage recv_from; \ + int recv_from_len; \ + uv_udp_recv_cb recv_cb; \ + uv_alloc_cb alloc_cb; \ + LPFN_WSARECV func_wsarecv; \ + LPFN_WSARECVFROM func_wsarecvfrom; + +#define uv_pipe_server_fields \ + int pending_instances; \ + uv_pipe_accept_t* accept_reqs; \ + uv_pipe_accept_t* pending_accepts; + +#define uv_pipe_connection_fields \ + uv_timer_t* eof_timer; \ + uv_write_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \ + DWORD ipc_remote_pid; \ + union { \ + uint32_t payload_remaining; \ + uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \ + } ipc_data_frame; \ + void* ipc_xfer_queue[2]; \ + int ipc_xfer_queue_length; \ + uv_write_t* non_overlapped_writes_tail; \ + CRITICAL_SECTION readfile_thread_lock; \ + volatile HANDLE readfile_thread_handle; + +#define UV_PIPE_PRIVATE_FIELDS \ + HANDLE handle; \ + WCHAR* name; \ + union { \ + struct { uv_pipe_server_fields } serv; \ + struct { uv_pipe_connection_fields } conn; \ + } pipe; + +/* TODO: put the parser states in an union - TTY handles are always half-duplex + * so read-state can safely overlap write-state. */ +#define UV_TTY_PRIVATE_FIELDS \ + HANDLE handle; \ + union { \ + struct { \ + /* Used for readable TTY handles */ \ + /* TODO: remove me in v2.x. */ \ + HANDLE unused_; \ + uv_buf_t read_line_buffer; \ + HANDLE read_raw_wait; \ + /* Fields used for translating win keystrokes into vt100 characters */ \ + char last_key[8]; \ + unsigned char last_key_offset; \ + unsigned char last_key_len; \ + WCHAR last_utf16_high_surrogate; \ + INPUT_RECORD last_input_record; \ + } rd; \ + struct { \ + /* Used for writable TTY handles */ \ + /* utf8-to-utf16 conversion state */ \ + unsigned int utf8_codepoint; \ + unsigned char utf8_bytes_left; \ + /* eol conversion state */ \ + unsigned char previous_eol; \ + /* ansi parser state */ \ + unsigned short ansi_parser_state; \ + unsigned char ansi_csi_argc; \ + unsigned short ansi_csi_argv[4]; \ + COORD saved_position; \ + WORD saved_attributes; \ + } wr; \ + } tty; + +#define UV_POLL_PRIVATE_FIELDS \ + SOCKET socket; \ + /* Used in fast mode */ \ + SOCKET peer_socket; \ + AFD_POLL_INFO afd_poll_info_1; \ + AFD_POLL_INFO afd_poll_info_2; \ + /* Used in fast and slow mode. */ \ + uv_req_t poll_req_1; \ + uv_req_t poll_req_2; \ + unsigned char submitted_events_1; \ + unsigned char submitted_events_2; \ + unsigned char mask_events_1; \ + unsigned char mask_events_2; \ + unsigned char events; + +#define UV_TIMER_PRIVATE_FIELDS \ + void* heap_node[3]; \ + int unused; \ + uint64_t timeout; \ + uint64_t repeat; \ + uint64_t start_id; \ + uv_timer_cb timer_cb; + +#define UV_ASYNC_PRIVATE_FIELDS \ + struct uv_req_s async_req; \ + uv_async_cb async_cb; \ + /* char to avoid alignment issues */ \ + char volatile async_sent; + +#define UV_PREPARE_PRIVATE_FIELDS \ + uv_prepare_t* prepare_prev; \ + uv_prepare_t* prepare_next; \ + uv_prepare_cb prepare_cb; + +#define UV_CHECK_PRIVATE_FIELDS \ + uv_check_t* check_prev; \ + uv_check_t* check_next; \ + uv_check_cb check_cb; + +#define UV_IDLE_PRIVATE_FIELDS \ + uv_idle_t* idle_prev; \ + uv_idle_t* idle_next; \ + uv_idle_cb idle_cb; + +#define UV_HANDLE_PRIVATE_FIELDS \ + uv_handle_t* endgame_next; \ + unsigned int flags; + +#define UV_GETADDRINFO_PRIVATE_FIELDS \ + struct uv__work work_req; \ + uv_getaddrinfo_cb getaddrinfo_cb; \ + void* alloc; \ + WCHAR* node; \ + WCHAR* service; \ + /* The addrinfoW field is used to store a pointer to the hints, and */ \ + /* later on to store the result of GetAddrInfoW. The final result will */ \ + /* be converted to struct addrinfo* and stored in the addrinfo field. */ \ + struct addrinfoW* addrinfow; \ + struct addrinfo* addrinfo; \ + int retcode; + +#define UV_GETNAMEINFO_PRIVATE_FIELDS \ + struct uv__work work_req; \ + uv_getnameinfo_cb getnameinfo_cb; \ + struct sockaddr_storage storage; \ + int flags; \ + char host[NI_MAXHOST]; \ + char service[NI_MAXSERV]; \ + int retcode; + +#define UV_PROCESS_PRIVATE_FIELDS \ + struct uv_process_exit_s { \ + UV_REQ_FIELDS \ + } exit_req; \ + BYTE* child_stdio_buffer; \ + int exit_signal; \ + HANDLE wait_handle; \ + HANDLE process_handle; \ + volatile char exit_cb_pending; + +#define UV_FS_PRIVATE_FIELDS \ + struct uv__work work_req; \ + int flags; \ + DWORD sys_errno_; \ + union { \ + /* TODO: remove me in 0.9. */ \ + WCHAR* pathw; \ + int fd; \ + } file; \ + union { \ + struct { \ + int mode; \ + WCHAR* new_pathw; \ + int file_flags; \ + int fd_out; \ + unsigned int nbufs; \ + uv_buf_t* bufs; \ + int64_t offset; \ + uv_buf_t bufsml[4]; \ + } info; \ + struct { \ + double atime; \ + double mtime; \ + } time; \ + } fs; + +#define UV_WORK_PRIVATE_FIELDS \ + struct uv__work work_req; + +#define UV_FS_EVENT_PRIVATE_FIELDS \ + struct uv_fs_event_req_s { \ + UV_REQ_FIELDS \ + } req; \ + HANDLE dir_handle; \ + int req_pending; \ + uv_fs_event_cb cb; \ + WCHAR* filew; \ + WCHAR* short_filew; \ + WCHAR* dirw; \ + char* buffer; + +#define UV_SIGNAL_PRIVATE_FIELDS \ + RB_ENTRY(uv_signal_s) tree_entry; \ + struct uv_req_s signal_req; \ + unsigned long pending_signum; + +#ifndef F_OK +#define F_OK 0 +#endif +#ifndef R_OK +#define R_OK 4 +#endif +#ifndef W_OK +#define W_OK 2 +#endif +#ifndef X_OK +#define X_OK 1 +#endif + +/* fs open() flags supported on this platform: */ +#define UV_FS_O_APPEND _O_APPEND +#define UV_FS_O_CREAT _O_CREAT +#define UV_FS_O_EXCL _O_EXCL +#define UV_FS_O_FILEMAP 0x20000000 +#define UV_FS_O_RANDOM _O_RANDOM +#define UV_FS_O_RDONLY _O_RDONLY +#define UV_FS_O_RDWR _O_RDWR +#define UV_FS_O_SEQUENTIAL _O_SEQUENTIAL +#define UV_FS_O_SHORT_LIVED _O_SHORT_LIVED +#define UV_FS_O_TEMPORARY _O_TEMPORARY +#define UV_FS_O_TRUNC _O_TRUNC +#define UV_FS_O_WRONLY _O_WRONLY + +/* fs open() flags supported on other platforms (or mapped on this platform): */ +#define UV_FS_O_DIRECT 0x02000000 /* FILE_FLAG_NO_BUFFERING */ +#define UV_FS_O_DIRECTORY 0 +#define UV_FS_O_DSYNC 0x04000000 /* FILE_FLAG_WRITE_THROUGH */ +#define UV_FS_O_EXLOCK 0x10000000 /* EXCLUSIVE SHARING MODE */ +#define UV_FS_O_NOATIME 0 +#define UV_FS_O_NOCTTY 0 +#define UV_FS_O_NOFOLLOW 0 +#define UV_FS_O_NONBLOCK 0 +#define UV_FS_O_SYMLINK 0 +#define UV_FS_O_SYNC 0x08000000 /* FILE_FLAG_WRITE_THROUGH */ diff --git a/extension/libuv/libuv.a b/extension/libuv/libuv.a new file mode 100644 index 0000000000000000000000000000000000000000..4436891c6396bb7f10d4ab196ac9aa56976dfe8a GIT binary patch literal 1039316 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