diff --git a/cmake/targets/BuildBun.cmake b/cmake/targets/BuildBun.cmake index d36cac0a5b..084dcc9054 100644 --- a/cmake/targets/BuildBun.cmake +++ b/cmake/targets/BuildBun.cmake @@ -785,6 +785,10 @@ target_include_directories(${bun} PRIVATE ${NODEJS_HEADERS_PATH}/include ) +if(NOT WIN32) + target_include_directories(${bun} PRIVATE ${CWD}/src/bun.js/bindings/libuv) +endif() + if(LINUX) include(CheckIncludeFiles) check_include_files("sys/queue.h" HAVE_SYS_QUEUE_H) diff --git a/package.json b/package.json index 5f7672e57a..1cf0640628 100644 --- a/package.json +++ b/package.json @@ -44,6 +44,7 @@ "build:release:with_logs": "cmake . -DCMAKE_BUILD_TYPE=Release -DENABLE_LOGS=true -GNinja -Bbuild-release && ninja -Cbuild-release", "build:debug-zig-release": "cmake . -DCMAKE_BUILD_TYPE=Release -DZIG_OPTIMIZE=Debug -GNinja -Bbuild-debug-zig-release && ninja -Cbuild-debug-zig-release", "css-properties": "bun run src/css/properties/generate_properties.ts", + "uv-posix-stubs": "bun run src/bun.js/bindings/libuv/generate_uv_posix_stubs.ts", "bump": "bun ./scripts/bump.ts", "typecheck": "tsc --noEmit && cd test && bun run typecheck", "fmt": "bun run prettier", diff --git a/src/analytics/analytics_thread.zig b/src/analytics/analytics_thread.zig index 6410a85836..e8b529c0ca 100644 --- a/src/analytics/analytics_thread.zig +++ b/src/analytics/analytics_thread.zig @@ -130,6 +130,7 @@ pub const Features = struct { pub var s3: usize = 0; pub var csrf_verify: usize = 0; pub var csrf_generate: usize = 0; + pub var unsupported_uv_function: usize = 0; comptime { @export(&napi_module_register, .{ .name = "Bun__napi_module_register_count" }); diff --git a/src/bun.js/bindings/BunProcess.cpp b/src/bun.js/bindings/BunProcess.cpp index d3dcefe6c0..840ea09dcd 100644 --- a/src/bun.js/bindings/BunProcess.cpp +++ b/src/bun.js/bindings/BunProcess.cpp @@ -363,6 +363,8 @@ static char* toFileURI(std::span span) extern "C" size_t Bun__process_dlopen_count; +extern "C" void CrashHandler__setDlOpenAction(const char* action); + JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen, (JSC::JSGlobalObject * globalObject_, JSC::CallFrame* callFrame)) { Zig::GlobalObject* globalObject = reinterpret_cast(globalObject_); @@ -438,7 +440,9 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen, (JSC::JSGlobalObject * globalOb HMODULE handle = Bun__LoadLibraryBunString(&filename_str); #else CString utf8 = filename.utf8(); + CrashHandler__setDlOpenAction(utf8.data()); void* handle = dlopen(utf8.data(), RTLD_LAZY); + CrashHandler__setDlOpenAction(nullptr); #endif globalObject->m_pendingNapiModuleDlopenHandle = handle; diff --git a/src/bun.js/bindings/libuv/README.md b/src/bun.js/bindings/libuv/README.md new file mode 100644 index 0000000000..0bf99cee85 --- /dev/null +++ b/src/bun.js/bindings/libuv/README.md @@ -0,0 +1,14 @@ +# libuv copied headers + +These are copied headers from libuv which are used by `bun uv-posix-stubs` to generate stubs which crash with a helpful error message when a NAPI +module tries to access a libuv function which is not supported in Bun. + +libuv commit hash: bb706f5fe71827f667f0bce532e95ce0698a498d + +## Generating symbol stubs + +1. Clone libuv repo using the above hash +2. Use the following command to get the list of symbols: `llvm-nm -g libuv.dylib | grep _uv &> symbols.txt`, you're gonna have to clean them up a bit this is not automated sorry ( ͡° ͜ʖ ͡°) +3. Update `src/symbol.txt` and `src/linker.lds` and `src/symbols.dyn` +4. Update the `symbols` list in `generate_uv_posix_stubs.ts` +5. Run `bun uv-posix-stubs` diff --git a/src/bun.js/bindings/libuv/bun.lock b/src/bun.js/bindings/libuv/bun.lock new file mode 100644 index 0000000000..fa0b67c995 --- /dev/null +++ b/src/bun.js/bindings/libuv/bun.lock @@ -0,0 +1,20 @@ +{ + "lockfileVersion": 1, + "workspaces": { + "": { + "dependencies": { + "tree-sitter": "^0.22.4", + "tree-sitter-c": "^0.23.5", + }, + }, + }, + "packages": { + "node-addon-api": ["node-addon-api@8.3.1", "", {}, "sha512-lytcDEdxKjGJPTLEfW4mYMigRezMlyJY8W4wxJK8zE533Jlb8L8dRuObJFWg2P+AuOIxoCgKF+2Oq4d4Zd0OUA=="], + + "node-gyp-build": ["node-gyp-build@4.8.4", "", { "bin": { "node-gyp-build": "bin.js", "node-gyp-build-optional": "optional.js", "node-gyp-build-test": "build-test.js" } }, "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ=="], + + "tree-sitter": ["tree-sitter@0.22.4", "", { "dependencies": { "node-addon-api": "^8.3.0", "node-gyp-build": "^4.8.4" } }, "sha512-usbHZP9/oxNsUY65MQUsduGRqDHQOou1cagUSwjhoSYAmSahjQDAVsh9s+SlZkn8X8+O1FULRGwHu7AFP3kjzg=="], + + "tree-sitter-c": ["tree-sitter-c@0.23.5", "", { "dependencies": { "node-addon-api": "^8.3.0", "node-gyp-build": "^4.8.4" }, "peerDependencies": { "tree-sitter": "^0.22.1" }, "optionalPeers": ["tree-sitter"] }, "sha512-riDWhqVIt8J14R7G0YMKlUy8E7eYR0Vp6DSGL90nX5CTAXkORCyp4WaOgNtfo8dEsHyZF5e/4E9Z9kWj+qLnTQ=="], + } +} diff --git a/src/bun.js/bindings/libuv/generate_uv_posix_stubs.ts b/src/bun.js/bindings/libuv/generate_uv_posix_stubs.ts new file mode 100644 index 0000000000..8ceee0fd62 --- /dev/null +++ b/src/bun.js/bindings/libuv/generate_uv_posix_stubs.ts @@ -0,0 +1,376 @@ +import path, { join } from "path"; +import { symbols, test_skipped } from "./generate_uv_posix_stubs_constants"; + +import Parser from "tree-sitter"; +import C from "tree-sitter-c"; + +const parser = new Parser(); +parser.setLanguage(C); + +const overrides = { + uv_setup_args: { + args: ["argc", "argv"], + decls: ["int argc", "char **argv"], + }, + uv_udp_try_send2: { + args: ["arg0", "arg1", "arg2", "arg3", "arg4", "arg5"], + decls: [ + "uv_udp_t* arg0", + "unsigned int arg1", + "uv_buf_t** arg2", + "unsigned int* arg3", + "struct sockaddr** arg4", + "unsigned int arg5", + ], + }, +}; + +type TestInfo = { + decls: string[]; + args: string[]; +}; + +function assert(condition: boolean, message: string) { + if (!condition) { + console.error(message); + process.exit(1); + } +} + +/** + * 1. Use ripgrep to find the filename + line number of the symbol's declaration is in the libuv headers + * 2. Find the range of text which makes up the declaration + * 3. Generate and return stub + */ +async function generate(symbol_name: string): Promise<[stub: string, symbol_name: string, types: TestInfo]> { + console.log("Looking for", symbol_name); + + const HEADER_PATH = import.meta.dir; + + const output = await Bun.$`rg -n ${symbol_name + "\\("}`.cwd(HEADER_PATH).text(); + + if (!output.includes("UV_EXTERN")) { + console.error("Symbol not found!"); + process.exit(1); + } + + let matches: { filename: string; lineNumber: number; rest: string }[] = []; + + const lines = output.split("\n"); + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + const match = parseOutput(line); + if (!match) continue; + const { filename, lineNumber, rest } = match; + if (!rest.includes("UV_EXTERN")) continue; + + // ending in one line + if (rest.indexOf(";") == rest.length - 1) { + // console.log("Found single liner!"); + matches.push({ filename, lineNumber, rest }); + } else { + const absoluteFilepath = join(HEADER_PATH, filename); + const fileContents = await Bun.file(absoluteFilepath).text(); + console.log(absoluteFilepath, "Found multi-liner!", lineNumber); + const fileLines = fileContents.split("\n"); + let found = false; + let j = lineNumber; + while (j < fileLines.length) { + if (fileLines[j].indexOf(";") == fileLines[j].length - 1) { + found = true; + break; + } + console.log("j", j); + j++; + } + if (!found) { + console.error("Multi-liner end not found!"); + process.exit(1); + } + const multiLine = fileLines.slice(lineNumber, j + 1).join("\n"); + console.log(`MULTILINE (${lineNumber} -> ${j + 1})`); + matches.push({ filename, lineNumber, rest: multiLine }); + // console.log(matches[matches.length - 1]); + i = j; + } + } + + if (matches.length !== 1) { + console.error("Found", matches.length, "matches!"); + console.error(matches); + process.exit(1); + } + + const { filename, lineNumber, rest } = matches[0]; + + function extractParameterTypes(decl: string): TestInfo { + if (overrides[symbol_name]) return overrides[symbol_name]; + console.log("DECL", decl); + decl = decl.replace("UV_EXTERN", ""); + const rootNode = parser.parse(decl).rootNode; + assert(rootNode.children[0].type === "declaration", "Root node must be a declaration"); + const declNode = rootNode.children[0]; + console.log("DECL NODE", declNode.children); + let functionDeclNode = declNode.children.find(n => n.type === "function_declarator")!; + // it can be a PointerDeclaratorNode: + // uv_loop_t* uv_default_loop + if (!functionDeclNode) { + const pointerDeclaratorNode = declNode.children.find(n => n.type === "pointer_declarator")!; + assert(!!pointerDeclaratorNode, "Pointer declarator not found"); + console.log("POINTER DECLARATOR", pointerDeclaratorNode.children); + functionDeclNode = pointerDeclaratorNode.children.find(n => n.type === "function_declarator")!; + } + assert(!!functionDeclNode, "Function declarator not found"); + const parameterListNode = functionDeclNode.children.find(n => n.type === "parameter_list")!; + assert(!!parameterListNode, "Parameter list not found"); + const parameterDeclarationNodes = parameterListNode.children.filter(n => n.type === "parameter_declaration")!; + assert(parameterDeclarationNodes.length > 0, "Must have exactly one parameter declaration"); + + let decls: string[] = []; + let args: string[] = []; + + let i = 0; + for (const parameterDeclarationNode of parameterDeclarationNodes) { + console.log("PARAM", parameterDeclarationNode.children.length, parameterDeclarationNode.text); + const last_idx = parameterDeclarationNode.children.length - 1; + const last = parameterDeclarationNode.children[last_idx]; + if (last.type === "primitive_type") { + if (last.text === "void") { + decls.push("(void) 0"); + args.push("void"); + continue; + } + const arg = `arg${i++}`; + decls.push(`${last.text} ${arg}`); + args.push(arg); + continue; + } + + if (last.type === "array_declarator") { + const arg = `arg${i++}`; + const ident = last.children[0].text; + const array_declarator = last.children + .slice(1) + .map(n => n.text) + .join(""); + const type = parameterDeclarationNode.children + .slice(0, last_idx) + .map(n => n.text) + .join(" "); + console.log("IDENT", ident, "TYPE", type, "ARRAY DECLARATOR", array_declarator); + decls.push(`${type} *${arg}`); + args.push(arg); + continue; + } + + // function pointer + if (last.type === "function_declarator") { + console.log("FUNCTION DECLARATOR", last.children); + const return_ty = parameterDeclarationNode.children[0].text; + // console.log("LMAO", ); + const arg = `arg${i++}`; + const param_list = last.children[1]; + if (param_list.type !== "parameter_list") { + throw new Error("expect param list man"); + } + args.push(arg); + const decl = `${return_ty} (*${arg})${param_list.text}`; + decls.push(decl); + continue; + } + + assert( + last.type === "identifier" || last.type === "pointer_declarator" || last.type === "abstract_pointer_declarator", // || + // last.type === "array_declarator", + `${symbol_name} Inalid param type, but got: ` + last.type, + ); + + let type = ""; + for (let i = 0; i < last_idx; i++) { + type += parameterDeclarationNode.children[i].text; + type += " "; + } + + console.log(type, "LAST TYPE lol", last.type); + if (last.type === "pointer_declarator" || last.type === "abstract_pointer_declarator") { + let cur = last; + do { + type += "*"; + assert(cur.children[0].type === "*", "Pointer declarator must have a *"); + cur = cur.children[1]; + } while (!!cur && cur.type === "pointer_declarator" && cur.children.length > 0); + } + + const arg = `arg${i++}`; + decls.push(`${type} ${arg}`); + args.push(arg); + } + + // function extractParam(node: Parser.SyntaxNode): [decl: string, arg: string] {} + + return { decls, args }; + } + + function addStub(symbolName: string, decl: string): [stub: string, symbol_name: string, types: TestInfo] { + assert(decl.includes("UV_EXTERN"), "Must include UV_EXTERN: \n" + decl); + + const types = extractParameterTypes(decl); + types.decls = types.decls.map(d => d + ";"); + if (types.args.length === 1 && types.args[0] === "void") { + types.decls = []; + types.args = []; + } + + const decl_without_semicolon = decl.replaceAll(";", "").trim(); + console.log(decl_without_semicolon); + + const contents = `${decl_without_semicolon} { + __bun_throw_not_implemented("${symbolName}"); + __builtin_unreachable(); +}`; + + // await Bun.write(stubPath, contents); + return [contents, symbolName, types]; + } + + function parseOutput(line: string): { filename: string; lineNumber: number; rest: string } | null { + // Match pattern: filename:linenumber:rest + const match = line.match(/^([^:]+):(\d+):(.*)$/); + + if (!match) { + return null; + } + + return { + filename: match[1], + lineNumber: parseInt(match[2], 10) - 1, + rest: match[3], + }; + } + + return addStub(symbol_name, rest); +} + +// const symbols = ["uv_async_init"]; + +if (!Bun.which("rg")) { + console.error("You need ripgrep bro"); + process.exit(1); +} + +for (const symbol of symbols) { + await generate(symbol); +} + +let parts = await Promise.all(symbols.map(s => generate(s))); + +const final_contents = `// GENERATED CODE - DO NOT MODIFY BY HAND +#include "uv-posix-polyfills.h" + + +#if OS(LINUX) || OS(DARWIN) +${parts.map(([stub, _]) => stub).join("\n\n")} +#endif + +`; + +await Bun.write(join(import.meta.dir, "../", "uv-posix-stubs.cpp"), final_contents); +if (Bun.which("clang-format")) { + await Bun.$`clang-format -i ${join(import.meta.dir, "../", "uv-posix-stubs.cpp")}`; +} + +const test_plugin_contents = ` // GENERATED CODE ... NO TOUCHY!! + #include + +#include +#include +#include +#include +#include + +napi_value call_uv_func(napi_env env, napi_callback_info info) { + napi_status status; + + size_t argc = 2; + napi_value args[2]; + status = napi_get_cb_info(env, info, &argc, args, NULL, NULL); + if (status != napi_ok) { + napi_throw_error(env, NULL, "Failed to parse arguments"); + return NULL; + } + + if (argc < 1) { + napi_throw_error(env, NULL, "Wrong number of arguments"); + return NULL; + } + + napi_value arg = args[0]; + char buffer[256]; + size_t buffer_size = sizeof(buffer); + size_t copied; + + status = napi_get_value_string_utf8(env, arg, buffer, buffer_size, &copied); + if (status != napi_ok) { + napi_throw_error(env, NULL, "Failed to get string value"); + return NULL; + } + + buffer[copied] = '\\0'; + printf("Got string: %s\\n", buffer); + +${parts + .map(([_, symbol_name, types]) => { + if (test_skipped.includes(symbol_name)) return ""; + return ` +if (strcmp(buffer, "${symbol_name}") == 0) { + ${types.decls.join("\n")} + + ${symbol_name}(${types.args.join(", ")}); + return NULL; +} +`; + }) + .join("\n\n")} + + napi_throw_error(env, NULL, "Function not found"); + + return NULL; +} + +napi_value Init(napi_env env, napi_value exports) { + napi_status status; + napi_value fn_call_uv_func; + + // Register call_uv_func function + status = + napi_create_function(env, NULL, 0, call_uv_func, NULL, &fn_call_uv_func); + if (status != napi_ok) { + napi_throw_error(env, NULL, "Failed to create call_uv_func function"); + return NULL; + } + + status = napi_set_named_property(env, exports, "callUVFunc", fn_call_uv_func); + if (status != napi_ok) { + napi_throw_error(env, NULL, + "Failed to add call_uv_func function to exports"); + return NULL; + } + + return exports; +} + +NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) +`; + +const plugin_path_ = join(import.meta.dir, "../", "../", "test", "napi", "uv-stub-stuff", "plugin.c"); +await Bun.write(plugin_path_, test_plugin_contents); + +if (Bun.which("clang-format")) { + await Bun.$`clang-format -i ${plugin_path_}`.quiet(); +} + +// for (const symbol of symbols) { +// await generate("uv_if_indextoiid"); +// } + +// console.log("DONE"); diff --git a/src/bun.js/bindings/libuv/generate_uv_posix_stubs_constants.ts b/src/bun.js/bindings/libuv/generate_uv_posix_stubs_constants.ts new file mode 100644 index 0000000000..966f50afea --- /dev/null +++ b/src/bun.js/bindings/libuv/generate_uv_posix_stubs_constants.ts @@ -0,0 +1,335 @@ +export const test_skipped = [ + "uv_getrusage_thread", + "uv_thread_detach", + "uv_thread_getname", + "uv_thread_getpriority", + "uv_thread_setname", + "uv_udp_try_send2", + "uv_utf16_length_as_wtf8", + "uv_utf16_to_wtf8", + "uv_wtf8_length_as_utf16", + "uv_wtf8_to_utf16", + "uv_thread_setpriority", +]; + +export const symbols = [ + "uv_accept", + "uv_async_init", + "uv_async_send", + "uv_available_parallelism", + "uv_backend_fd", + "uv_backend_timeout", + "uv_barrier_destroy", + "uv_barrier_init", + "uv_barrier_wait", + "uv_buf_init", + "uv_cancel", + "uv_chdir", + "uv_check_init", + "uv_check_start", + "uv_check_stop", + "uv_clock_gettime", + "uv_close", + "uv_cond_broadcast", + "uv_cond_destroy", + "uv_cond_init", + "uv_cond_signal", + "uv_cond_timedwait", + "uv_cond_wait", + "uv_cpu_info", + "uv_cpumask_size", + "uv_cwd", + "uv_default_loop", + "uv_disable_stdio_inheritance", + "uv_dlclose", + "uv_dlerror", + "uv_dlopen", + "uv_dlsym", + "uv_err_name", + "uv_err_name_r", + "uv_exepath", + "uv_fileno", + "uv_free_cpu_info", + "uv_free_interface_addresses", + "uv_freeaddrinfo", + "uv_fs_access", + "uv_fs_chmod", + "uv_fs_chown", + "uv_fs_close", + "uv_fs_closedir", + "uv_fs_copyfile", + "uv_fs_event_getpath", + "uv_fs_event_init", + "uv_fs_event_start", + "uv_fs_event_stop", + "uv_fs_fchmod", + "uv_fs_fchown", + "uv_fs_fdatasync", + "uv_fs_fstat", + "uv_fs_fsync", + "uv_fs_ftruncate", + "uv_fs_futime", + "uv_fs_get_path", + "uv_fs_get_ptr", + "uv_fs_get_result", + "uv_fs_get_statbuf", + "uv_fs_get_system_error", + "uv_fs_get_type", + "uv_fs_lchown", + "uv_fs_link", + "uv_fs_lstat", + "uv_fs_lutime", + "uv_fs_mkdir", + "uv_fs_mkdtemp", + "uv_fs_mkstemp", + "uv_fs_open", + "uv_fs_opendir", + "uv_fs_poll_getpath", + "uv_fs_poll_init", + "uv_fs_poll_start", + "uv_fs_poll_stop", + "uv_fs_read", + "uv_fs_readdir", + "uv_fs_readlink", + "uv_fs_realpath", + "uv_fs_rename", + "uv_fs_req_cleanup", + "uv_fs_rmdir", + "uv_fs_scandir", + "uv_fs_scandir_next", + "uv_fs_sendfile", + "uv_fs_stat", + "uv_fs_statfs", + "uv_fs_symlink", + "uv_fs_unlink", + "uv_fs_utime", + "uv_fs_write", + "uv_get_available_memory", + "uv_get_constrained_memory", + "uv_get_free_memory", + "uv_get_osfhandle", + "uv_get_process_title", + "uv_get_total_memory", + "uv_getaddrinfo", + "uv_getnameinfo", + "uv_getrusage", + "uv_getrusage_thread", + "uv_gettimeofday", + "uv_guess_handle", + "uv_handle_get_data", + "uv_handle_get_loop", + "uv_handle_get_type", + "uv_handle_set_data", + "uv_handle_size", + "uv_handle_type_name", + "uv_has_ref", + "uv_hrtime", + "uv_idle_init", + "uv_idle_start", + "uv_idle_stop", + "uv_if_indextoiid", + "uv_if_indextoname", + "uv_inet_ntop", + "uv_inet_pton", + "uv_interface_addresses", + "uv_ip4_addr", + "uv_ip4_name", + "uv_ip6_addr", + "uv_ip6_name", + "uv_ip_name", + "uv_is_active", + "uv_is_closing", + "uv_is_readable", + "uv_is_writable", + "uv_key_create", + "uv_key_delete", + "uv_key_get", + "uv_key_set", + "uv_kill", + "uv_library_shutdown", + "uv_listen", + "uv_loadavg", + "uv_loop_alive", + "uv_loop_close", + "uv_loop_configure", + "uv_loop_delete", + "uv_loop_fork", + "uv_loop_get_data", + "uv_loop_init", + "uv_loop_new", + "uv_loop_set_data", + "uv_loop_size", + "uv_metrics_idle_time", + "uv_metrics_info", + "uv_mutex_destroy", + "uv_mutex_init", + "uv_mutex_init_recursive", + "uv_mutex_lock", + "uv_mutex_trylock", + "uv_mutex_unlock", + "uv_now", + "uv_once", + "uv_open_osfhandle", + "uv_os_environ", + "uv_os_free_environ", + "uv_os_free_group", + "uv_os_free_passwd", + "uv_os_get_group", + "uv_os_get_passwd", + "uv_os_get_passwd2", + "uv_os_getenv", + "uv_os_gethostname", + // Defined in uv-posix-polyfills.cpp + // "uv_os_getpid", + // Defined in uv-posix-polyfills.cpp + // "uv_os_getppid", + "uv_os_getpriority", + "uv_os_homedir", + "uv_os_setenv", + "uv_os_setpriority", + "uv_os_tmpdir", + "uv_os_uname", + "uv_os_unsetenv", + "uv_pipe", + "uv_pipe_bind", + "uv_pipe_bind2", + "uv_pipe_chmod", + "uv_pipe_connect", + "uv_pipe_connect2", + "uv_pipe_getpeername", + "uv_pipe_getsockname", + "uv_pipe_init", + "uv_pipe_open", + "uv_pipe_pending_count", + "uv_pipe_pending_instances", + "uv_pipe_pending_type", + "uv_poll_init", + "uv_poll_init_socket", + "uv_poll_start", + "uv_poll_stop", + "uv_prepare_init", + "uv_prepare_start", + "uv_prepare_stop", + "uv_print_active_handles", + "uv_print_all_handles", + "uv_process_get_pid", + "uv_process_kill", + "uv_queue_work", + "uv_random", + "uv_read_start", + "uv_read_stop", + "uv_recv_buffer_size", + "uv_ref", + "uv_replace_allocator", + "uv_req_get_data", + "uv_req_get_type", + "uv_req_set_data", + "uv_req_size", + "uv_req_type_name", + "uv_resident_set_memory", + "uv_run", + "uv_rwlock_destroy", + "uv_rwlock_init", + "uv_rwlock_rdlock", + "uv_rwlock_rdunlock", + "uv_rwlock_tryrdlock", + "uv_rwlock_trywrlock", + "uv_rwlock_wrlock", + "uv_rwlock_wrunlock", + "uv_sem_destroy", + "uv_sem_init", + "uv_sem_post", + "uv_sem_trywait", + "uv_sem_wait", + "uv_send_buffer_size", + "uv_set_process_title", + "uv_setup_args", + "uv_shutdown", + "uv_signal_init", + "uv_signal_start", + "uv_signal_start_oneshot", + "uv_signal_stop", + "uv_sleep", + "uv_socketpair", + "uv_spawn", + "uv_stop", + "uv_stream_get_write_queue_size", + "uv_stream_set_blocking", + "uv_strerror", + "uv_strerror_r", + "uv_tcp_bind", + "uv_tcp_close_reset", + "uv_tcp_connect", + "uv_tcp_getpeername", + "uv_tcp_getsockname", + "uv_tcp_init", + "uv_tcp_init_ex", + "uv_tcp_keepalive", + "uv_tcp_nodelay", + "uv_tcp_open", + "uv_tcp_simultaneous_accepts", + "uv_thread_create", + "uv_thread_create_ex", + "uv_thread_detach", + "uv_thread_equal", + "uv_thread_getaffinity", + "uv_thread_getcpu", + "uv_thread_getname", + "uv_thread_getpriority", + "uv_thread_join", + "uv_thread_self", + "uv_thread_setaffinity", + "uv_thread_setname", + "uv_thread_setpriority", + "uv_timer_again", + "uv_timer_get_due_in", + "uv_timer_get_repeat", + "uv_timer_init", + "uv_timer_set_repeat", + "uv_timer_start", + "uv_timer_stop", + "uv_translate_sys_error", + "uv_try_write", + "uv_try_write2", + "uv_tty_get_vterm_state", + "uv_tty_get_winsize", + "uv_tty_init", + // Defined in wtf-bindings.cpp + // "uv_tty_reset_mode", + "uv_tty_set_mode", + "uv_tty_set_vterm_state", + "uv_udp_bind", + "uv_udp_connect", + "uv_udp_get_send_queue_count", + "uv_udp_get_send_queue_size", + "uv_udp_getpeername", + "uv_udp_getsockname", + "uv_udp_init", + "uv_udp_init_ex", + "uv_udp_open", + "uv_udp_recv_start", + "uv_udp_recv_stop", + "uv_udp_send", + "uv_udp_set_broadcast", + "uv_udp_set_membership", + "uv_udp_set_multicast_interface", + "uv_udp_set_multicast_loop", + "uv_udp_set_multicast_ttl", + "uv_udp_set_source_membership", + "uv_udp_set_ttl", + "uv_udp_try_send", + "uv_udp_try_send2", + "uv_udp_using_recvmmsg", + "uv_unref", + "uv_update_time", + "uv_uptime", + "uv_utf16_length_as_wtf8", + "uv_utf16_to_wtf8", + "uv_version", + "uv_version_string", + "uv_walk", + "uv_write", + "uv_write2", + "uv_wtf8_length_as_utf16", + "uv_wtf8_to_utf16", +]; diff --git a/src/bun.js/bindings/libuv/package.json b/src/bun.js/bindings/libuv/package.json new file mode 100644 index 0000000000..3dae5e9c94 --- /dev/null +++ b/src/bun.js/bindings/libuv/package.json @@ -0,0 +1,6 @@ +{ + "dependencies": { + "tree-sitter": "^0.22.4", + "tree-sitter-c": "^0.23.5" + } +} diff --git a/src/bun.js/bindings/libuv/uv.h b/src/bun.js/bindings/libuv/uv.h new file mode 100644 index 0000000000..938e998fdc --- /dev/null +++ b/src/bun.js/bindings/libuv/uv.h @@ -0,0 +1,1990 @@ +/* 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 + +#ifndef UV_EXTERN +#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"))) +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550) /* Sun Studio >= 8 */ +# define UV_EXTERN __global +#else +# define UV_EXTERN /* nothing */ +#endif +#endif /* UV_EXTERN */ + +#include "uv/errno.h" +#include "uv/version.h" +#include +#include +#include +#include + +/* Internal type, do not use. */ +struct uv__queue { + struct uv__queue* next; + struct uv__queue* prev; +}; + +#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(EOVERFLOW, "value too large for defined data type") \ + 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") \ + XX(ESOCKTNOSUPPORT, "socket type not supported") \ + XX(ENODATA, "no data available") \ + XX(EUNATCH, "protocol driver not attached") \ + XX(ENOEXEC, "exec format error") \ + +#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_group_s uv_group_t; +typedef struct uv_utsname_s uv_utsname_t; +typedef struct uv_statfs_s uv_statfs_t; + +typedef struct uv_metrics_s uv_metrics_t; + +typedef enum { + UV_LOOP_BLOCK_SIGNAL = 0, + UV_METRICS_IDLE_TIME, + UV_LOOP_USE_IO_URING_SQPOLL +#define UV_LOOP_USE_IO_URING_SQPOLL UV_LOOP_USE_IO_URING_SQPOLL +} 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, 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. 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 enum { + UV_CLOCK_MONOTONIC, + UV_CLOCK_REALTIME +} uv_clock_id; + +/* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 */ +typedef struct { + long tv_sec; + long tv_nsec; +} uv_timespec_t; + +typedef struct { + int64_t tv_sec; + int32_t tv_nsec; +} uv_timespec64_t; + +/* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 */ +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 { + 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; \ + struct uv__queue handle_queue; \ + 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_EXTERN int uv_try_write2(uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle); + +/* 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, + + /* Enable SO_REUSEPORT socket option when binding the handle. + * This allows completely duplicate bindings by multiple processes + * or threads if they all set SO_REUSEPORT before binding the port. + * Incoming connections are distributed across the participating + * listener sockets. + * + * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+, + * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now. + */ + UV_TCP_REUSEPORT = 2, +}; + +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 (except for + * DragonFlyBSD), OS X, and other platforms where SO_REUSEPORTs don't + * have the capability of load balancing, as the opposite of what + * UV_UDP_REUSEPORT would do. 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 if IP_RECVERR/IPV6_RECVERR will be set when binding the handle. + * This sets IP_RECVERR for IPv4 and IPV6_RECVERR for IPv6 UDP sockets on + * Linux. This stops the Linux kernel from suppressing some ICMP error + * messages and enables full ICMP error reporting for faster failover. + * This flag is no-op on platforms other than Linux. + */ + UV_UDP_LINUX_RECVERR = 32, + /* + * Indicates if SO_REUSEPORT will be set when binding the handle. + * This sets the SO_REUSEPORT socket option on supported platforms. + * Unlike UV_UDP_REUSEADDR, this flag will make multiple threads or + * processes that are binding to the same address and port "share" + * the port, which means incoming datagrams are distributed across + * the receiving sockets among threads or processes. + * + * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+, + * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now. + */ + UV_UDP_REUSEPORT = 64, + /* + * 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_try_send2(uv_udp_t* handle, + unsigned int count, + uv_buf_t* bufs[/*count*/], + unsigned int nbufs[/*count*/], + struct sockaddr* addrs[/*count*/], + unsigned int flags); +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). + * May become equivalent to UV_TTY_MODE_RAW_VT in future libuv versions. + */ + UV_TTY_MODE_RAW, + /* Binary-safe I/O mode for IPC (Unix-only) */ + UV_TTY_MODE_IO, + /* Raw input mode. On Windows ENABLE_VIRTUAL_TERMINAL_INPUT is also set. */ + UV_TTY_MODE_RAW_VT +} 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); + +enum { + UV_PIPE_NO_TRUNCATE = 1u << 0 +}; + +/* + * 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 int uv_pipe_bind2(uv_pipe_t* handle, + const char* name, + size_t namelen, + unsigned int flags); +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_connect2(uv_connect_t* req, + uv_pipe_t* handle, + const char* name, + size_t namelen, + unsigned int flags, + 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), + /* + * On Windows, if the path to the program to execute, specified in + * uv_process_options_t's file field, has a directory component, + * search for the exact file name before trying variants with + * extensions like '.exe' or '.cmd'. + */ + UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME = (1 << 7) +}; + +/* + * 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; + unsigned long uid; + unsigned long gid; + char* shell; + char* homedir; +}; + +struct uv_group_s { + char* groupname; + unsigned long gid; + char** members; +}; + +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 { + 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_getrusage_thread(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 int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid); +UV_EXTERN int uv_os_get_group(uv_group_t* grp, uv_uid_t gid); +UV_EXTERN void uv_os_free_group(uv_group_t* grp); +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); + +enum { + UV_THREAD_PRIORITY_HIGHEST = 2, + UV_THREAD_PRIORITY_ABOVE_NORMAL = 1, + UV_THREAD_PRIORITY_NORMAL = 0, + UV_THREAD_PRIORITY_BELOW_NORMAL = -1, + UV_THREAD_PRIORITY_LOWEST = -2, +}; + +UV_EXTERN int uv_thread_getpriority(uv_thread_t tid, int* priority); +UV_EXTERN int uv_thread_setpriority(uv_thread_t tid, int priority); + +UV_EXTERN unsigned int uv_available_parallelism(void); +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_cpumask_size(void); + +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); + +struct uv_metrics_s { + uint64_t loop_count; + uint64_t events; + uint64_t events_waiting; + /* private */ + uint64_t* reserved[13]; +}; + +UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics); +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); +#define UV_FS_UTIME_NOW (INFINITY) +#define UV_FS_UTIME_OMIT (NAN) +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_ip_name(const struct sockaddr* 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_get_available_memory(void); + +UV_EXTERN int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts); +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); +UV_EXTERN int uv_thread_detach(uv_thread_t* tid); + +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 int uv_thread_setaffinity(uv_thread_t* tid, + char* cpumask, + char* oldmask, + size_t mask_size); +UV_EXTERN int uv_thread_getaffinity(uv_thread_t* tid, + char* cpumask, + size_t mask_size); +UV_EXTERN int uv_thread_getcpu(void); +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); +UV_EXTERN int uv_thread_setname(const char* name); +UV_EXTERN int uv_thread_getname(uv_thread_t* tid, char* name, size_t size); + + +/* 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; + struct uv__queue handle_queue; + 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); + +/* Unicode utilities needed for dealing with Windows. */ +UV_EXTERN size_t uv_utf16_length_as_wtf8(const uint16_t* utf16, + ssize_t utf16_len); +UV_EXTERN int uv_utf16_to_wtf8(const uint16_t* utf16, + ssize_t utf16_len, + char** wtf8_ptr, + size_t* wtf8_len_ptr); +UV_EXTERN ssize_t uv_wtf8_length_as_utf16(const char* wtf8); +UV_EXTERN void uv_wtf8_to_utf16(const char* wtf8, + uint16_t* utf16, + size_t utf16_len); + +/* 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/src/bun.js/bindings/libuv/uv/aix.h b/src/bun.js/bindings/libuv/uv/aix.h new file mode 100644 index 0000000000..7dc992fa6d --- /dev/null +++ b/src/bun.js/bindings/libuv/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/src/bun.js/bindings/libuv/uv/bsd.h b/src/bun.js/bindings/libuv/uv/bsd.h new file mode 100644 index 0000000000..2d72b3d771 --- /dev/null +++ b/src/bun.js/bindings/libuv/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/src/bun.js/bindings/libuv/uv/darwin.h b/src/bun.js/bindings/libuv/uv/darwin.h new file mode 100644 index 0000000000..06962bfda8 --- /dev/null +++ b/src/bun.js/bindings/libuv/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; \ + struct uv__queue cf_signals; \ + +#define UV_PLATFORM_FS_EVENT_FIELDS \ + uv__io_t event_watcher; \ + char* realpath; \ + int realpath_len; \ + int cf_flags; \ + uv_async_t* cf_cb; \ + struct uv__queue cf_events; \ + struct uv__queue cf_member; \ + 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/src/bun.js/bindings/libuv/uv/errno.h b/src/bun.js/bindings/libuv/uv/errno.h new file mode 100644 index 0000000000..ac00778cfc --- /dev/null +++ b/src/bun.js/bindings/libuv/uv/errno.h @@ -0,0 +1,483 @@ +/* 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(__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 + +#if defined(EOVERFLOW) && !defined(_WIN32) +# define UV__EOVERFLOW UV__ERR(EOVERFLOW) +#else +# define UV__EOVERFLOW (-4026) +#endif + +#if defined(ESOCKTNOSUPPORT) && !defined(_WIN32) +# define UV__ESOCKTNOSUPPORT UV__ERR(ESOCKTNOSUPPORT) +#else +# define UV__ESOCKTNOSUPPORT (-4025) +#endif + +/* FreeBSD defines ENODATA in /usr/include/c++/v1/errno.h which is only visible + * if C++ is being used. Define it directly to avoid problems when integrating + * libuv in a C++ project. + */ +#if defined(ENODATA) && !defined(_WIN32) +# define UV__ENODATA UV__ERR(ENODATA) +#elif defined(__FreeBSD__) +# define UV__ENODATA (-9919) +#else +# define UV__ENODATA (-4024) +#endif + +#if defined(EUNATCH) && !defined(_WIN32) +# define UV__EUNATCH UV__ERR(EUNATCH) +#else +# define UV__EUNATCH (-4023) +#endif + +#if defined(ENOEXEC) && !defined(_WIN32) +# define UV__ENOEXEC UV__ERR(ENOEXEC) +#else +# define UV__ENOEXEC (-4022) +#endif + +#endif /* UV_ERRNO_H_ */ diff --git a/src/bun.js/bindings/libuv/uv/linux.h b/src/bun.js/bindings/libuv/uv/linux.h new file mode 100644 index 0000000000..9f22f8cf72 --- /dev/null +++ b/src/bun.js/bindings/libuv/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 \ + struct uv__queue watchers; \ + int wd; \ + +#endif /* UV_LINUX_H */ diff --git a/src/bun.js/bindings/libuv/uv/os390.h b/src/bun.js/bindings/libuv/uv/os390.h new file mode 100644 index 0000000000..0267d74cbd --- /dev/null +++ b/src/bun.js/bindings/libuv/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/src/bun.js/bindings/libuv/uv/posix.h b/src/bun.js/bindings/libuv/uv/posix.h new file mode 100644 index 0000000000..9a96634db0 --- /dev/null +++ b/src/bun.js/bindings/libuv/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/src/bun.js/bindings/libuv/uv/sunos.h b/src/bun.js/bindings/libuv/uv/sunos.h new file mode 100644 index 0000000000..042166424e --- /dev/null +++ b/src/bun.js/bindings/libuv/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/src/bun.js/bindings/libuv/uv/threadpool.h b/src/bun.js/bindings/libuv/uv/threadpool.h new file mode 100644 index 0000000000..24ce916fda --- /dev/null +++ b/src/bun.js/bindings/libuv/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; + struct uv__queue wq; +}; + +#endif /* UV_THREADPOOL_H_ */ diff --git a/src/bun.js/bindings/libuv/uv/tree.h b/src/bun.js/bindings/libuv/uv/tree.h new file mode 100644 index 0000000000..06bba084f3 --- /dev/null +++ b/src/bun.js/bindings/libuv/uv/tree.h @@ -0,0 +1,521 @@ +/*- + * 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 red-black trees. + * 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). + */ + +/* 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) name##_RB_NEXT(x) +#define RB_PREV(name, x) name##_RB_PREV(x) +#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/src/bun.js/bindings/libuv/uv/unix.h b/src/bun.js/bindings/libuv/uv/unix.h new file mode 100644 index 0000000000..7c972026f6 --- /dev/null +++ b/src/bun.js/bindings/libuv/uv/unix.h @@ -0,0 +1,512 @@ +/* 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(__OpenBSD__) || \ + defined(__NetBSD__) +# include "uv/bsd.h" +#elif defined(__CYGWIN__) || \ + defined(__MSYS__) || \ + defined(__HAIKU__) || \ + defined(__QNX__) || \ + defined(__GNU__) +# 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; + struct uv__queue pending_queue; + struct uv__queue watcher_queue; + 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; \ + struct uv__queue pending_queue; \ + struct uv__queue watcher_queue; \ + uv__io_t** watchers; \ + unsigned int nwatchers; \ + unsigned int nfds; \ + struct uv__queue wq; \ + uv_mutex_t wq_mutex; \ + uv_async_t wq_async; \ + uv_rwlock_t cloexec_lock; \ + uv_handle_t* closing_handles; \ + struct uv__queue process_handles; \ + struct uv__queue prepare_handles; \ + struct uv__queue check_handles; \ + struct uv__queue idle_handles; \ + struct uv__queue async_handles; \ + 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 \ + struct uv__queue queue; \ + unsigned int write_index; \ + uv_buf_t* bufs; \ + unsigned int nbufs; \ + int error; \ + uv_buf_t bufsml[4]; \ + +#define UV_CONNECT_PRIVATE_FIELDS \ + struct uv__queue queue; \ + +#define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */ + +#define UV_UDP_SEND_PRIVATE_FIELDS \ + struct uv__queue queue; \ + union { \ + struct sockaddr addr; \ + struct sockaddr_storage storage; \ + } u; \ + 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; \ + struct uv__queue write_queue; \ + struct uv__queue write_completed_queue; \ + 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; \ + struct uv__queue write_queue; \ + struct uv__queue write_completed_queue; \ + +#define UV_PIPE_PRIVATE_FIELDS \ + const char* pipe_fname; /* NULL or strdup'ed */ + +#define UV_POLL_PRIVATE_FIELDS \ + uv__io_t io_watcher; + +#define UV_PREPARE_PRIVATE_FIELDS \ + uv_prepare_cb prepare_cb; \ + struct uv__queue queue; \ + +#define UV_CHECK_PRIVATE_FIELDS \ + uv_check_cb check_cb; \ + struct uv__queue queue; \ + +#define UV_IDLE_PRIVATE_FIELDS \ + uv_idle_cb idle_cb; \ + struct uv__queue queue; \ + +#define UV_ASYNC_PRIVATE_FIELDS \ + uv_async_cb async_cb; \ + struct uv__queue queue; \ + int pending; \ + +#define UV_TIMER_PRIVATE_FIELDS \ + uv_timer_cb timer_cb; \ + union { \ + void* heap[3]; \ + struct uv__queue queue; \ + } node; \ + 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 \ + struct uv__queue queue; \ + 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(__linux__) && defined(__loongarch__) +# 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/src/bun.js/bindings/libuv/uv/version.h b/src/bun.js/bindings/libuv/uv/version.h new file mode 100644 index 0000000000..6356e1ee44 --- /dev/null +++ b/src/bun.js/bindings/libuv/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 50 +#define UV_VERSION_PATCH 1 +#define UV_VERSION_IS_RELEASE 0 +#define UV_VERSION_SUFFIX "dev" + +#define UV_VERSION_HEX ((UV_VERSION_MAJOR << 16) | \ + (UV_VERSION_MINOR << 8) | \ + (UV_VERSION_PATCH)) + +#endif /* UV_VERSION_H */ diff --git a/src/bun.js/bindings/libuv/uv/win.h b/src/bun.js/bindings/libuv/uv/win.h new file mode 100644 index 0000000000..a88bf29e9f --- /dev/null +++ b/src/bun.js/bindings/libuv/uv/win.h @@ -0,0 +1,698 @@ +/* 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 0x0A00 +#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 + +#ifndef LOCALE_INVARIANT +# define LOCALE_INVARIANT 0x007f +#endif + +#include +/* Disable the typedef in mstcpip.h of MinGW. */ +#define _TCP_INITIAL_RTO_PARAMETERS _TCP_INITIAL_RTO_PARAMETERS__AVOID +#define TCP_INITIAL_RTO_PARAMETERS TCP_INITIAL_RTO_PARAMETERS__AVOID +#define PTCP_INITIAL_RTO_PARAMETERS PTCP_INITIAL_RTO_PARAMETERS__AVOID +#include +#undef _TCP_INITIAL_RTO_PARAMETERS +#undef TCP_INITIAL_RTO_PARAMETERS +#undef PTCP_INITIAL_RTO_PARAMETERS +#include + +#include +#include +#include +#include +#include + +#include "uv/tree.h" +#include "uv/threadpool.h" + +#define MAX_PIPENAME_LEN 256 + +#ifndef S_IFLNK +# define S_IFLNK 0xA000 +#endif + +/* Define missing in Windows Kit Include\{VERSION}\ucrt\sys\stat.h */ +#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES && !defined(S_IFIFO) +# define S_IFIFO _S_IFIFO +#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 SIGQUIT 3 +#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 4 + + +/** + * 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 struct { + SRWLOCK read_write_lock_; + /* TODO: retained for ABI compatibility; remove me in v2.x */ +#ifdef _WIN64 + unsigned char padding_[72]; +#else + unsigned char padding_[44]; +#endif +} uv_rwlock_t; + +typedef struct { + unsigned threshold; + unsigned in; + uv_mutex_t mutex; + /* TODO: in v2 make this a uv_cond_t, without unused_ */ + CONDITION_VARIABLE cond; + unsigned out; +} uv_barrier_t; + +typedef struct { + DWORD tls_index; +} uv_key_t; + +#define UV_ONCE_INIT { 0, NULL } + +typedef struct uv_once_s { + unsigned char unused; + INIT_ONCE init_once; +} 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]; \ + /* No longer used. */ \ + unsigned int active_tcp_streams; \ + /* No longer used. */ \ + unsigned int active_udp_streams; \ + /* Counter to started timer */ \ + uint64_t timer_counter; \ + /* Threadpool */ \ + struct uv__queue wq; \ + 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; \ + /* in v2, we can move these to the UV_CONNECT_PRIVATE_FIELDS */ \ + struct { \ + ULONG_PTR result; /* overlapped.Internal is reused to hold the result */\ + HANDLE pipeHandle; \ + DWORD duplex_flags; \ + WCHAR* name; \ + } connect; \ + } 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; \ + struct uv__queue ipc_xfer_queue; \ + 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 a 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 */ \ + union { \ + /* TODO: remove me in v2.x. */ \ + HANDLE unused_; \ + int mode; \ + } mode; \ + 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 \ + union { \ + void* heap[3]; \ + struct uv__queue queue; \ + } node; \ + 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; \ + void* unused; /* TODO: retained for ABI compat; remove this in v2.x. */ \ + 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/src/bun.js/bindings/uv-posix-polyfills.cpp b/src/bun.js/bindings/uv-posix-polyfills.cpp index 6431dfa84b..ed09f32d74 100644 --- a/src/bun.js/bindings/uv-posix-polyfills.cpp +++ b/src/bun.js/bindings/uv-posix-polyfills.cpp @@ -2,6 +2,11 @@ #if OS(LINUX) || OS(DARWIN) +void __bun_throw_not_implemented(const char* symbol_name) +{ + CrashHandler__unsupportedUVFunction(symbol_name); +} + uv_pid_t uv_os_getpid() { return getpid(); diff --git a/src/bun.js/bindings/uv-posix-polyfills.h b/src/bun.js/bindings/uv-posix-polyfills.h index 8c2779ff94..bcdac5b312 100644 --- a/src/bun.js/bindings/uv-posix-polyfills.h +++ b/src/bun.js/bindings/uv-posix-polyfills.h @@ -1,15 +1,19 @@ #pragma once #include "root.h" +#include +#include #if OS(LINUX) || OS(DARWIN) -typedef int uv_pid_t; +// These functions are called by the stubs to crash with a nice error message +// when accessing a libuv functin which we do not support on posix +extern "C" void CrashHandler__unsupportedUVFunction(const char* function_name); +void __bun_throw_not_implemented(const char* symbol_name); -// Returns the current process ID. -extern "C" BUN_EXPORT uv_pid_t uv_os_getpid(); +// libuv headers will use UV_EXTERN +#define UV_EXTERN extern "C" __attribute__((visibility("default"))) __attribute__((used)) -// Returns the parent process ID. -extern "C" BUN_EXPORT uv_pid_t uv_os_getppid(); +#include #endif diff --git a/src/bun.js/bindings/uv-posix-stubs.cpp b/src/bun.js/bindings/uv-posix-stubs.cpp new file mode 100644 index 0000000000..1da812e570 --- /dev/null +++ b/src/bun.js/bindings/uv-posix-stubs.cpp @@ -0,0 +1,2168 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND +#include "uv-posix-polyfills.h" + +#if OS(LINUX) || OS(DARWIN) +UV_EXTERN int uv_accept(uv_stream_t* server, uv_stream_t* client) +{ + __bun_throw_not_implemented("uv_accept"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_async_init(uv_loop_t*, + uv_async_t* async, + uv_async_cb async_cb) +{ + __bun_throw_not_implemented("uv_async_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_async_send(uv_async_t* async) +{ + __bun_throw_not_implemented("uv_async_send"); + __builtin_unreachable(); +} + +UV_EXTERN unsigned int uv_available_parallelism(void) +{ + __bun_throw_not_implemented("uv_available_parallelism"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_backend_fd(const uv_loop_t*) +{ + __bun_throw_not_implemented("uv_backend_fd"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_backend_timeout(const uv_loop_t*) +{ + __bun_throw_not_implemented("uv_backend_timeout"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_barrier_destroy(uv_barrier_t* barrier) +{ + __bun_throw_not_implemented("uv_barrier_destroy"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) +{ + __bun_throw_not_implemented("uv_barrier_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_barrier_wait(uv_barrier_t* barrier) +{ + __bun_throw_not_implemented("uv_barrier_wait"); + __builtin_unreachable(); +} + +UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len) +{ + __bun_throw_not_implemented("uv_buf_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_cancel(uv_req_t* req) +{ + __bun_throw_not_implemented("uv_cancel"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_chdir(const char* dir) +{ + __bun_throw_not_implemented("uv_chdir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_check_init(uv_loop_t*, uv_check_t* check) +{ + __bun_throw_not_implemented("uv_check_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_check_start(uv_check_t* check, uv_check_cb cb) +{ + __bun_throw_not_implemented("uv_check_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_check_stop(uv_check_t* check) +{ + __bun_throw_not_implemented("uv_check_stop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts) +{ + __bun_throw_not_implemented("uv_clock_gettime"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb) +{ + __bun_throw_not_implemented("uv_close"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_cond_broadcast(uv_cond_t* cond) +{ + __bun_throw_not_implemented("uv_cond_broadcast"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_cond_destroy(uv_cond_t* cond) +{ + __bun_throw_not_implemented("uv_cond_destroy"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_cond_init(uv_cond_t* cond) +{ + __bun_throw_not_implemented("uv_cond_init"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_cond_signal(uv_cond_t* cond) +{ + __bun_throw_not_implemented("uv_cond_signal"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_cond_timedwait(uv_cond_t* cond, + uv_mutex_t* mutex, + uint64_t timeout) +{ + __bun_throw_not_implemented("uv_cond_timedwait"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) +{ + __bun_throw_not_implemented("uv_cond_wait"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) +{ + __bun_throw_not_implemented("uv_cpu_info"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_cpumask_size(void) +{ + __bun_throw_not_implemented("uv_cpumask_size"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_cwd(char* buffer, size_t* size) +{ + __bun_throw_not_implemented("uv_cwd"); + __builtin_unreachable(); +} + +UV_EXTERN uv_loop_t* uv_default_loop(void) +{ + __bun_throw_not_implemented("uv_default_loop"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_disable_stdio_inheritance(void) +{ + __bun_throw_not_implemented("uv_disable_stdio_inheritance"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_dlclose(uv_lib_t* lib) +{ + __bun_throw_not_implemented("uv_dlclose"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_dlerror(const uv_lib_t* lib) +{ + __bun_throw_not_implemented("uv_dlerror"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_dlopen(const char* filename, uv_lib_t* lib) +{ + __bun_throw_not_implemented("uv_dlopen"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr) +{ + __bun_throw_not_implemented("uv_dlsym"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_err_name(int err) +{ + __bun_throw_not_implemented("uv_err_name"); + __builtin_unreachable(); +} + +UV_EXTERN char* uv_err_name_r(int err, char* buf, size_t buflen) +{ + __bun_throw_not_implemented("uv_err_name_r"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_exepath(char* buffer, size_t* size) +{ + __bun_throw_not_implemented("uv_exepath"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) +{ + __bun_throw_not_implemented("uv_fileno"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) +{ + __bun_throw_not_implemented("uv_free_cpu_info"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_free_interface_addresses(uv_interface_address_t* addresses, + int count) +{ + __bun_throw_not_implemented("uv_free_interface_addresses"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_freeaddrinfo(struct addrinfo* ai) +{ + __bun_throw_not_implemented("uv_freeaddrinfo"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_access(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int mode, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_access"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_chmod(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int mode, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_chmod"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_chown"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_close(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_close"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_closedir(uv_loop_t* loop, + uv_fs_t* req, + uv_dir_t* dir, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_closedir"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_copyfile"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_event_getpath(uv_fs_event_t* handle, + char* buffer, + size_t* size) +{ + __bun_throw_not_implemented("uv_fs_event_getpath"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) +{ + __bun_throw_not_implemented("uv_fs_event_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_event_start(uv_fs_event_t* handle, + uv_fs_event_cb cb, + const char* path, + unsigned int flags) +{ + __bun_throw_not_implemented("uv_fs_event_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_event_stop(uv_fs_event_t* handle) +{ + __bun_throw_not_implemented("uv_fs_event_stop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_fchmod(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + int mode, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_fchmod"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_fchown"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_fdatasync"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_fstat(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_fstat"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_fsync(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_fsync"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop, + uv_fs_t* req, + uv_file file, + int64_t offset, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_ftruncate"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_futime"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_fs_get_path(const uv_fs_t*) +{ + __bun_throw_not_implemented("uv_fs_get_path"); + __builtin_unreachable(); +} + +UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t*) +{ + __bun_throw_not_implemented("uv_fs_get_ptr"); + __builtin_unreachable(); +} + +UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t*) +{ + __bun_throw_not_implemented("uv_fs_get_result"); + __builtin_unreachable(); +} + +UV_EXTERN uv_stat_t* uv_fs_get_statbuf(uv_fs_t*) +{ + __bun_throw_not_implemented("uv_fs_get_statbuf"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_get_system_error(const uv_fs_t*) +{ + __bun_throw_not_implemented("uv_fs_get_system_error"); + __builtin_unreachable(); +} + +UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t*) +{ + __bun_throw_not_implemented("uv_fs_get_type"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_lchown"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_link"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_lstat(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_lstat"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_lutime"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int mode, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_mkdir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop, + uv_fs_t* req, + const char* tpl, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_mkdtemp"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_mkstemp(uv_loop_t* loop, + uv_fs_t* req, + const char* tpl, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_mkstemp"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_open"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_opendir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_opendir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_poll_getpath(uv_fs_poll_t* handle, + char* buffer, + size_t* size) +{ + __bun_throw_not_implemented("uv_fs_poll_getpath"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle) +{ + __bun_throw_not_implemented("uv_fs_poll_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_poll_start(uv_fs_poll_t* handle, + uv_fs_poll_cb poll_cb, + const char* path, + unsigned int interval) +{ + __bun_throw_not_implemented("uv_fs_poll_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_poll_stop(uv_fs_poll_t* handle) +{ + __bun_throw_not_implemented("uv_fs_poll_stop"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_read"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_readdir(uv_loop_t* loop, + uv_fs_t* req, + uv_dir_t* dir, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_readdir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_readlink(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_readlink"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_realpath(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_realpath"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_rename"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_fs_req_cleanup(uv_fs_t* req) +{ + __bun_throw_not_implemented("uv_fs_req_cleanup"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_rmdir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_scandir(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + int flags, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_scandir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req, + uv_dirent_t* ent) +{ + __bun_throw_not_implemented("uv_fs_scandir_next"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_sendfile"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_stat(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_stat"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_statfs(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_statfs"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_symlink"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_fs_unlink(uv_loop_t* loop, + uv_fs_t* req, + const char* path, + uv_fs_cb cb) +{ + __bun_throw_not_implemented("uv_fs_unlink"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_utime"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_fs_write"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_get_available_memory(void) +{ + __bun_throw_not_implemented("uv_get_available_memory"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_get_constrained_memory(void) +{ + __bun_throw_not_implemented("uv_get_constrained_memory"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_get_free_memory(void) +{ + __bun_throw_not_implemented("uv_get_free_memory"); + __builtin_unreachable(); +} + +UV_EXTERN uv_os_fd_t uv_get_osfhandle(int fd) +{ + __bun_throw_not_implemented("uv_get_osfhandle"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_get_process_title(char* buffer, size_t size) +{ + __bun_throw_not_implemented("uv_get_process_title"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_get_total_memory(void) +{ + __bun_throw_not_implemented("uv_get_total_memory"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_getaddrinfo"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_getnameinfo(uv_loop_t* loop, + uv_getnameinfo_t* req, + uv_getnameinfo_cb getnameinfo_cb, + const struct sockaddr* addr, + int flags) +{ + __bun_throw_not_implemented("uv_getnameinfo"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_getrusage(uv_rusage_t* rusage) +{ + __bun_throw_not_implemented("uv_getrusage"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_getrusage_thread(uv_rusage_t* rusage) +{ + __bun_throw_not_implemented("uv_getrusage_thread"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_gettimeofday(uv_timeval64_t* tv) +{ + __bun_throw_not_implemented("uv_gettimeofday"); + __builtin_unreachable(); +} + +UV_EXTERN uv_handle_type uv_guess_handle(uv_file file) +{ + __bun_throw_not_implemented("uv_guess_handle"); + __builtin_unreachable(); +} + +UV_EXTERN void* uv_handle_get_data(const uv_handle_t* handle) +{ + __bun_throw_not_implemented("uv_handle_get_data"); + __builtin_unreachable(); +} + +UV_EXTERN uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle) +{ + __bun_throw_not_implemented("uv_handle_get_loop"); + __builtin_unreachable(); +} + +UV_EXTERN uv_handle_type uv_handle_get_type(const uv_handle_t* handle) +{ + __bun_throw_not_implemented("uv_handle_get_type"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_handle_set_data(uv_handle_t* handle, void* data) +{ + __bun_throw_not_implemented("uv_handle_set_data"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_handle_size(uv_handle_type type) +{ + __bun_throw_not_implemented("uv_handle_size"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_handle_type_name(uv_handle_type type) +{ + __bun_throw_not_implemented("uv_handle_type_name"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_has_ref(const uv_handle_t*) +{ + __bun_throw_not_implemented("uv_has_ref"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_hrtime(void) +{ + __bun_throw_not_implemented("uv_hrtime"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_idle_init(uv_loop_t*, uv_idle_t* idle) +{ + __bun_throw_not_implemented("uv_idle_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb) +{ + __bun_throw_not_implemented("uv_idle_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_idle_stop(uv_idle_t* idle) +{ + __bun_throw_not_implemented("uv_idle_stop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_if_indextoiid(unsigned int ifindex, + char* buffer, + size_t* size) +{ + __bun_throw_not_implemented("uv_if_indextoiid"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_if_indextoname(unsigned int ifindex, + char* buffer, + size_t* size) +{ + __bun_throw_not_implemented("uv_if_indextoname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_inet_ntop(int af, const void* src, char* dst, size_t size) +{ + __bun_throw_not_implemented("uv_inet_ntop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_inet_pton(int af, const char* src, void* dst) +{ + __bun_throw_not_implemented("uv_inet_pton"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_interface_addresses(uv_interface_address_t** addresses, + int* count) +{ + __bun_throw_not_implemented("uv_interface_addresses"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) +{ + __bun_throw_not_implemented("uv_ip4_addr"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size) +{ + __bun_throw_not_implemented("uv_ip4_name"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) +{ + __bun_throw_not_implemented("uv_ip6_addr"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size) +{ + __bun_throw_not_implemented("uv_ip6_name"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_ip_name(const struct sockaddr* src, char* dst, size_t size) +{ + __bun_throw_not_implemented("uv_ip_name"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_is_active(const uv_handle_t* handle) +{ + __bun_throw_not_implemented("uv_is_active"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_is_closing(const uv_handle_t* handle) +{ + __bun_throw_not_implemented("uv_is_closing"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_is_readable(const uv_stream_t* handle) +{ + __bun_throw_not_implemented("uv_is_readable"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_is_writable(const uv_stream_t* handle) +{ + __bun_throw_not_implemented("uv_is_writable"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_key_create(uv_key_t* key) +{ + __bun_throw_not_implemented("uv_key_create"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_key_delete(uv_key_t* key) +{ + __bun_throw_not_implemented("uv_key_delete"); + __builtin_unreachable(); +} + +UV_EXTERN void* uv_key_get(uv_key_t* key) +{ + __bun_throw_not_implemented("uv_key_get"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_key_set(uv_key_t* key, void* value) +{ + __bun_throw_not_implemented("uv_key_set"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_kill(int pid, int signum) +{ + __bun_throw_not_implemented("uv_kill"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_library_shutdown(void) +{ + __bun_throw_not_implemented("uv_library_shutdown"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) +{ + __bun_throw_not_implemented("uv_listen"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_loadavg(double avg[3]) +{ + __bun_throw_not_implemented("uv_loadavg"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_loop_alive(const uv_loop_t* loop) +{ + __bun_throw_not_implemented("uv_loop_alive"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_loop_close(uv_loop_t* loop) +{ + __bun_throw_not_implemented("uv_loop_close"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...) +{ + __bun_throw_not_implemented("uv_loop_configure"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_loop_delete(uv_loop_t*) +{ + __bun_throw_not_implemented("uv_loop_delete"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_loop_fork(uv_loop_t* loop) +{ + __bun_throw_not_implemented("uv_loop_fork"); + __builtin_unreachable(); +} + +UV_EXTERN void* uv_loop_get_data(const uv_loop_t*) +{ + __bun_throw_not_implemented("uv_loop_get_data"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_loop_init(uv_loop_t* loop) +{ + __bun_throw_not_implemented("uv_loop_init"); + __builtin_unreachable(); +} + +UV_EXTERN uv_loop_t* uv_loop_new(void) +{ + __bun_throw_not_implemented("uv_loop_new"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_loop_set_data(uv_loop_t*, void* data) +{ + __bun_throw_not_implemented("uv_loop_set_data"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_loop_size(void) +{ + __bun_throw_not_implemented("uv_loop_size"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop) +{ + __bun_throw_not_implemented("uv_metrics_idle_time"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics) +{ + __bun_throw_not_implemented("uv_metrics_info"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_mutex_destroy(uv_mutex_t* handle) +{ + __bun_throw_not_implemented("uv_mutex_destroy"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_mutex_init(uv_mutex_t* handle) +{ + __bun_throw_not_implemented("uv_mutex_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_mutex_init_recursive(uv_mutex_t* handle) +{ + __bun_throw_not_implemented("uv_mutex_init_recursive"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_mutex_lock(uv_mutex_t* handle) +{ + __bun_throw_not_implemented("uv_mutex_lock"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_mutex_trylock(uv_mutex_t* handle) +{ + __bun_throw_not_implemented("uv_mutex_trylock"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_mutex_unlock(uv_mutex_t* handle) +{ + __bun_throw_not_implemented("uv_mutex_unlock"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_now(const uv_loop_t*) +{ + __bun_throw_not_implemented("uv_now"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_once(uv_once_t* guard, void (*callback)(void)) +{ + __bun_throw_not_implemented("uv_once"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_open_osfhandle(uv_os_fd_t os_fd) +{ + __bun_throw_not_implemented("uv_open_osfhandle"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_environ(uv_env_item_t** envitems, int* count) +{ + __bun_throw_not_implemented("uv_os_environ"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_os_free_environ(uv_env_item_t* envitems, int count) +{ + __bun_throw_not_implemented("uv_os_free_environ"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_os_free_group(uv_group_t* grp) +{ + __bun_throw_not_implemented("uv_os_free_group"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_os_free_passwd(uv_passwd_t* pwd) +{ + __bun_throw_not_implemented("uv_os_free_passwd"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_get_group(uv_group_t* grp, uv_uid_t gid) +{ + __bun_throw_not_implemented("uv_os_get_group"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_get_passwd(uv_passwd_t* pwd) +{ + __bun_throw_not_implemented("uv_os_get_passwd"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid) +{ + __bun_throw_not_implemented("uv_os_get_passwd2"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_getenv(const char* name, char* buffer, size_t* size) +{ + __bun_throw_not_implemented("uv_os_getenv"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_gethostname(char* buffer, size_t* size) +{ + __bun_throw_not_implemented("uv_os_gethostname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_getpriority(uv_pid_t pid, int* priority) +{ + __bun_throw_not_implemented("uv_os_getpriority"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_homedir(char* buffer, size_t* size) +{ + __bun_throw_not_implemented("uv_os_homedir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_setenv(const char* name, const char* value) +{ + __bun_throw_not_implemented("uv_os_setenv"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_setpriority(uv_pid_t pid, int priority) +{ + __bun_throw_not_implemented("uv_os_setpriority"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_tmpdir(char* buffer, size_t* size) +{ + __bun_throw_not_implemented("uv_os_tmpdir"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_uname(uv_utsname_t* buffer) +{ + __bun_throw_not_implemented("uv_os_uname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_os_unsetenv(const char* name) +{ + __bun_throw_not_implemented("uv_os_unsetenv"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe(uv_file fds[2], int read_flags, int write_flags) +{ + __bun_throw_not_implemented("uv_pipe"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_bind(uv_pipe_t* handle, const char* name) +{ + __bun_throw_not_implemented("uv_pipe_bind"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_bind2(uv_pipe_t* handle, + const char* name, + size_t namelen, + unsigned int flags) +{ + __bun_throw_not_implemented("uv_pipe_bind2"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_chmod(uv_pipe_t* handle, int flags) +{ + __bun_throw_not_implemented("uv_pipe_chmod"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_pipe_connect(uv_connect_t* req, + uv_pipe_t* handle, + const char* name, + uv_connect_cb cb) +{ + __bun_throw_not_implemented("uv_pipe_connect"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_connect2(uv_connect_t* req, + uv_pipe_t* handle, + const char* name, + size_t namelen, + unsigned int flags, + uv_connect_cb cb) +{ + __bun_throw_not_implemented("uv_pipe_connect2"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_getpeername(const uv_pipe_t* handle, + char* buffer, + size_t* size) +{ + __bun_throw_not_implemented("uv_pipe_getpeername"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_getsockname(const uv_pipe_t* handle, + char* buffer, + size_t* size) +{ + __bun_throw_not_implemented("uv_pipe_getsockname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle, int ipc) +{ + __bun_throw_not_implemented("uv_pipe_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_open(uv_pipe_t*, uv_file file) +{ + __bun_throw_not_implemented("uv_pipe_open"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_pipe_pending_count(uv_pipe_t* handle) +{ + __bun_throw_not_implemented("uv_pipe_pending_count"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_pipe_pending_instances(uv_pipe_t* handle, int count) +{ + __bun_throw_not_implemented("uv_pipe_pending_instances"); + __builtin_unreachable(); +} + +UV_EXTERN uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle) +{ + __bun_throw_not_implemented("uv_pipe_pending_type"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) +{ + __bun_throw_not_implemented("uv_poll_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_poll_init_socket(uv_loop_t* loop, + uv_poll_t* handle, + uv_os_sock_t socket) +{ + __bun_throw_not_implemented("uv_poll_init_socket"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb) +{ + __bun_throw_not_implemented("uv_poll_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_poll_stop(uv_poll_t* handle) +{ + __bun_throw_not_implemented("uv_poll_stop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_prepare_init(uv_loop_t*, uv_prepare_t* prepare) +{ + __bun_throw_not_implemented("uv_prepare_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb) +{ + __bun_throw_not_implemented("uv_prepare_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_prepare_stop(uv_prepare_t* prepare) +{ + __bun_throw_not_implemented("uv_prepare_stop"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_print_active_handles(uv_loop_t* loop, FILE* stream) +{ + __bun_throw_not_implemented("uv_print_active_handles"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_print_all_handles(uv_loop_t* loop, FILE* stream) +{ + __bun_throw_not_implemented("uv_print_all_handles"); + __builtin_unreachable(); +} + +UV_EXTERN uv_pid_t uv_process_get_pid(const uv_process_t*) +{ + __bun_throw_not_implemented("uv_process_get_pid"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_process_kill(uv_process_t*, int signum) +{ + __bun_throw_not_implemented("uv_process_kill"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_queue_work"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_random"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_read_start(uv_stream_t*, + uv_alloc_cb alloc_cb, + uv_read_cb read_cb) +{ + __bun_throw_not_implemented("uv_read_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_read_stop(uv_stream_t*) +{ + __bun_throw_not_implemented("uv_read_stop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_recv_buffer_size(uv_handle_t* handle, int* value) +{ + __bun_throw_not_implemented("uv_recv_buffer_size"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_ref(uv_handle_t*) +{ + __bun_throw_not_implemented("uv_ref"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_replace_allocator"); + __builtin_unreachable(); +} + +UV_EXTERN void* uv_req_get_data(const uv_req_t* req) +{ + __bun_throw_not_implemented("uv_req_get_data"); + __builtin_unreachable(); +} + +UV_EXTERN uv_req_type uv_req_get_type(const uv_req_t* req) +{ + __bun_throw_not_implemented("uv_req_get_type"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_req_set_data(uv_req_t* req, void* data) +{ + __bun_throw_not_implemented("uv_req_set_data"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_req_size(uv_req_type type) +{ + __bun_throw_not_implemented("uv_req_size"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_req_type_name(uv_req_type type) +{ + __bun_throw_not_implemented("uv_req_type_name"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_resident_set_memory(size_t* rss) +{ + __bun_throw_not_implemented("uv_resident_set_memory"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_run(uv_loop_t*, uv_run_mode mode) +{ + __bun_throw_not_implemented("uv_run"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_rwlock_destroy(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_destroy"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_rwlock_init(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_init"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_rwlock_rdlock(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_rdlock"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_rwlock_rdunlock(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_rdunlock"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_tryrdlock"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_trywrlock"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_rwlock_wrlock(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_wrlock"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_rwlock_wrunlock(uv_rwlock_t* rwlock) +{ + __bun_throw_not_implemented("uv_rwlock_wrunlock"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_sem_destroy(uv_sem_t* sem) +{ + __bun_throw_not_implemented("uv_sem_destroy"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value) +{ + __bun_throw_not_implemented("uv_sem_init"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_sem_post(uv_sem_t* sem) +{ + __bun_throw_not_implemented("uv_sem_post"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_sem_trywait(uv_sem_t* sem) +{ + __bun_throw_not_implemented("uv_sem_trywait"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_sem_wait(uv_sem_t* sem) +{ + __bun_throw_not_implemented("uv_sem_wait"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_send_buffer_size(uv_handle_t* handle, int* value) +{ + __bun_throw_not_implemented("uv_send_buffer_size"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_set_process_title(const char* title) +{ + __bun_throw_not_implemented("uv_set_process_title"); + __builtin_unreachable(); +} + +UV_EXTERN char** uv_setup_args(int argc, char** argv) +{ + __bun_throw_not_implemented("uv_setup_args"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_shutdown(uv_shutdown_t* req, + uv_stream_t* handle, + uv_shutdown_cb cb) +{ + __bun_throw_not_implemented("uv_shutdown"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) +{ + __bun_throw_not_implemented("uv_signal_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_signal_start(uv_signal_t* handle, + uv_signal_cb signal_cb, + int signum) +{ + __bun_throw_not_implemented("uv_signal_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_signal_start_oneshot(uv_signal_t* handle, + uv_signal_cb signal_cb, + int signum) +{ + __bun_throw_not_implemented("uv_signal_start_oneshot"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_signal_stop(uv_signal_t* handle) +{ + __bun_throw_not_implemented("uv_signal_stop"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_sleep(unsigned int msec) +{ + __bun_throw_not_implemented("uv_sleep"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_socketpair(int type, + int protocol, + uv_os_sock_t socket_vector[2], + int flags0, + int flags1) +{ + __bun_throw_not_implemented("uv_socketpair"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_spawn(uv_loop_t* loop, + uv_process_t* handle, + const uv_process_options_t* options) +{ + __bun_throw_not_implemented("uv_spawn"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_stop(uv_loop_t*) +{ + __bun_throw_not_implemented("uv_stop"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_stream_get_write_queue_size(const uv_stream_t* stream) +{ + __bun_throw_not_implemented("uv_stream_get_write_queue_size"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_stream_set_blocking(uv_stream_t* handle, int blocking) +{ + __bun_throw_not_implemented("uv_stream_set_blocking"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_strerror(int err) +{ + __bun_throw_not_implemented("uv_strerror"); + __builtin_unreachable(); +} + +UV_EXTERN char* uv_strerror_r(int err, char* buf, size_t buflen) +{ + __bun_throw_not_implemented("uv_strerror_r"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int flags) +{ + __bun_throw_not_implemented("uv_tcp_bind"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb) +{ + __bun_throw_not_implemented("uv_tcp_close_reset"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_connect(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr* addr, + uv_connect_cb cb) +{ + __bun_throw_not_implemented("uv_tcp_connect"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_getpeername(const uv_tcp_t* handle, + struct sockaddr* name, + int* namelen) +{ + __bun_throw_not_implemented("uv_tcp_getpeername"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_getsockname(const uv_tcp_t* handle, + struct sockaddr* name, + int* namelen) +{ + __bun_throw_not_implemented("uv_tcp_getsockname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_init(uv_loop_t*, uv_tcp_t* handle) +{ + __bun_throw_not_implemented("uv_tcp_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_init_ex(uv_loop_t*, uv_tcp_t* handle, unsigned int flags) +{ + __bun_throw_not_implemented("uv_tcp_init_ex"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle, + int enable, + unsigned int delay) +{ + __bun_throw_not_implemented("uv_tcp_keepalive"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_nodelay(uv_tcp_t* handle, int enable) +{ + __bun_throw_not_implemented("uv_tcp_nodelay"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) +{ + __bun_throw_not_implemented("uv_tcp_open"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) +{ + __bun_throw_not_implemented("uv_tcp_simultaneous_accepts"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg) +{ + __bun_throw_not_implemented("uv_thread_create"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid, + const uv_thread_options_t* params, + uv_thread_cb entry, + void* arg) +{ + __bun_throw_not_implemented("uv_thread_create_ex"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_detach(uv_thread_t* tid) +{ + __bun_throw_not_implemented("uv_thread_detach"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2) +{ + __bun_throw_not_implemented("uv_thread_equal"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_getaffinity(uv_thread_t* tid, + char* cpumask, + size_t mask_size) +{ + __bun_throw_not_implemented("uv_thread_getaffinity"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_getcpu(void) +{ + __bun_throw_not_implemented("uv_thread_getcpu"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_getname(uv_thread_t* tid, char* name, size_t size) +{ + __bun_throw_not_implemented("uv_thread_getname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_getpriority(uv_thread_t tid, int* priority) +{ + __bun_throw_not_implemented("uv_thread_getpriority"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_join(uv_thread_t* tid) +{ + __bun_throw_not_implemented("uv_thread_join"); + __builtin_unreachable(); +} + +UV_EXTERN uv_thread_t uv_thread_self(void) +{ + __bun_throw_not_implemented("uv_thread_self"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_setaffinity(uv_thread_t* tid, + char* cpumask, + char* oldmask, + size_t mask_size) +{ + __bun_throw_not_implemented("uv_thread_setaffinity"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_setname(const char* name) +{ + __bun_throw_not_implemented("uv_thread_setname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_thread_setpriority(uv_thread_t tid, int priority) +{ + __bun_throw_not_implemented("uv_thread_setpriority"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_timer_again(uv_timer_t* handle) +{ + __bun_throw_not_implemented("uv_timer_again"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_timer_get_due_in(const uv_timer_t* handle) +{ + __bun_throw_not_implemented("uv_timer_get_due_in"); + __builtin_unreachable(); +} + +UV_EXTERN uint64_t uv_timer_get_repeat(const uv_timer_t* handle) +{ + __bun_throw_not_implemented("uv_timer_get_repeat"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_timer_init(uv_loop_t*, uv_timer_t* handle) +{ + __bun_throw_not_implemented("uv_timer_init"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) +{ + __bun_throw_not_implemented("uv_timer_set_repeat"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_timer_start(uv_timer_t* handle, + uv_timer_cb cb, + uint64_t timeout, + uint64_t repeat) +{ + __bun_throw_not_implemented("uv_timer_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_timer_stop(uv_timer_t* handle) +{ + __bun_throw_not_implemented("uv_timer_stop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_translate_sys_error(int sys_errno) +{ + __bun_throw_not_implemented("uv_translate_sys_error"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_try_write(uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs) +{ + __bun_throw_not_implemented("uv_try_write"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_try_write2(uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle) +{ + __bun_throw_not_implemented("uv_try_write2"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state) +{ + __bun_throw_not_implemented("uv_tty_get_vterm_state"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tty_get_winsize(uv_tty_t*, int* width, int* height) +{ + __bun_throw_not_implemented("uv_tty_get_winsize"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tty_init(uv_loop_t*, uv_tty_t*, uv_file fd, int readable) +{ + __bun_throw_not_implemented("uv_tty_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_tty_set_mode(uv_tty_t*, uv_tty_mode_t mode) +{ + __bun_throw_not_implemented("uv_tty_set_mode"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_tty_set_vterm_state(uv_tty_vtermstate_t state) +{ + __bun_throw_not_implemented("uv_tty_set_vterm_state"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_bind(uv_udp_t* handle, + const struct sockaddr* addr, + unsigned int flags) +{ + __bun_throw_not_implemented("uv_udp_bind"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr) +{ + __bun_throw_not_implemented("uv_udp_connect"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_udp_get_send_queue_count(const uv_udp_t* handle) +{ + __bun_throw_not_implemented("uv_udp_get_send_queue_count"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_udp_get_send_queue_size(const uv_udp_t* handle) +{ + __bun_throw_not_implemented("uv_udp_get_send_queue_size"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_getpeername(const uv_udp_t* handle, + struct sockaddr* name, + int* namelen) +{ + __bun_throw_not_implemented("uv_udp_getpeername"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_getsockname(const uv_udp_t* handle, + struct sockaddr* name, + int* namelen) +{ + __bun_throw_not_implemented("uv_udp_getsockname"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_init(uv_loop_t*, uv_udp_t* handle) +{ + __bun_throw_not_implemented("uv_udp_init"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_init_ex(uv_loop_t*, uv_udp_t* handle, unsigned int flags) +{ + __bun_throw_not_implemented("uv_udp_init_ex"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) +{ + __bun_throw_not_implemented("uv_udp_open"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_recv_start(uv_udp_t* handle, + uv_alloc_cb alloc_cb, + uv_udp_recv_cb recv_cb) +{ + __bun_throw_not_implemented("uv_udp_recv_start"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_recv_stop(uv_udp_t* handle) +{ + __bun_throw_not_implemented("uv_udp_recv_stop"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_udp_send"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_set_broadcast(uv_udp_t* handle, int on) +{ + __bun_throw_not_implemented("uv_udp_set_broadcast"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle, + const char* multicast_addr, + const char* interface_addr, + uv_membership membership) +{ + __bun_throw_not_implemented("uv_udp_set_membership"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_set_multicast_interface(uv_udp_t* handle, + const char* interface_addr) +{ + __bun_throw_not_implemented("uv_udp_set_multicast_interface"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_set_multicast_loop(uv_udp_t* handle, int on) +{ + __bun_throw_not_implemented("uv_udp_set_multicast_loop"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl) +{ + __bun_throw_not_implemented("uv_udp_set_multicast_ttl"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_udp_set_source_membership"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl) +{ + __bun_throw_not_implemented("uv_udp_set_ttl"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_try_send(uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr) +{ + __bun_throw_not_implemented("uv_udp_try_send"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_try_send2(uv_udp_t* handle, + unsigned int count, + uv_buf_t* bufs[/*count*/], + unsigned int nbufs[/*count*/], + struct sockaddr* addrs[/*count*/], + unsigned int flags) +{ + __bun_throw_not_implemented("uv_udp_try_send2"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_udp_using_recvmmsg(const uv_udp_t* handle) +{ + __bun_throw_not_implemented("uv_udp_using_recvmmsg"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_unref(uv_handle_t*) +{ + __bun_throw_not_implemented("uv_unref"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_update_time(uv_loop_t*) +{ + __bun_throw_not_implemented("uv_update_time"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_uptime(double* uptime) +{ + __bun_throw_not_implemented("uv_uptime"); + __builtin_unreachable(); +} + +UV_EXTERN size_t uv_utf16_length_as_wtf8(const uint16_t* utf16, + ssize_t utf16_len) +{ + __bun_throw_not_implemented("uv_utf16_length_as_wtf8"); + __builtin_unreachable(); +} + +UV_EXTERN int uv_utf16_to_wtf8(const uint16_t* utf16, + ssize_t utf16_len, + char** wtf8_ptr, + size_t* wtf8_len_ptr) +{ + __bun_throw_not_implemented("uv_utf16_to_wtf8"); + __builtin_unreachable(); +} + +UV_EXTERN unsigned int uv_version(void) +{ + __bun_throw_not_implemented("uv_version"); + __builtin_unreachable(); +} + +UV_EXTERN const char* uv_version_string(void) +{ + __bun_throw_not_implemented("uv_version_string"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) +{ + __bun_throw_not_implemented("uv_walk"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_write"); + __builtin_unreachable(); +} + +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) +{ + __bun_throw_not_implemented("uv_write2"); + __builtin_unreachable(); +} + +UV_EXTERN ssize_t uv_wtf8_length_as_utf16(const char* wtf8) +{ + __bun_throw_not_implemented("uv_wtf8_length_as_utf16"); + __builtin_unreachable(); +} + +UV_EXTERN void uv_wtf8_to_utf16(const char* wtf8, + uint16_t* utf16, + size_t utf16_len) +{ + __bun_throw_not_implemented("uv_wtf8_to_utf16"); + __builtin_unreachable(); +} +#endif diff --git a/src/crash_handler.zig b/src/crash_handler.zig index 10d40d7972..16dbdb1d5f 100644 --- a/src/crash_handler.zig +++ b/src/crash_handler.zig @@ -53,10 +53,7 @@ var panic_mutex = bun.Mutex{}; threadlocal var panic_stage: usize = 0; threadlocal var inside_native_plugin: ?[*:0]const u8 = null; - -export fn CrashHandler__setInsideNativePlugin(name: ?[*:0]const u8) callconv(.C) void { - inside_native_plugin = name; -} +threadlocal var unsupported_uv_function: ?[*:0]const u8 = null; /// This can be set by various parts of the codebase to indicate a broader /// action being taken. It is printed when a crash happens, which can help @@ -69,7 +66,6 @@ pub threadlocal var current_action: ?Action = null; var before_crash_handlers: std.ArrayListUnmanaged(struct { *anyopaque, *const OnBeforeCrash }) = .{}; -// TODO: I don't think it's safe to lock/unlock a mutex inside a signal handler. var before_crash_handlers_mutex: bun.Mutex = .{}; const CPUFeatures = @import("./bun.js/bindings/CPUFeatures.zig"); @@ -137,6 +133,8 @@ pub const Action = union(enum) { kind: bun.ImportKind, } else void, + dlopen: []const u8, + pub fn format(act: Action, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void { switch (act) { .parse => |path| try writer.print("parsing {s}", .{path}), @@ -168,6 +166,7 @@ pub const Action = union(enum) { res.kind.label(), }); }, + .dlopen => |path| try writer.print("while loading native module: {s}", .{path}), } } }; @@ -247,6 +246,20 @@ pub fn crashHandler( \\ ; writer.print(Output.prettyFmt(fmt, true), .{native_plugin_name}) catch std.posix.abort(); + } else if (bun.analytics.Features.unsupported_uv_function > 0) { + const name = unsupported_uv_function orelse ""; + const fmt = + \\Bun encountered a crash when running a NAPI module that tried to call + \\the {s} libuv function. + \\ + \\Bun is actively working on supporting all libuv functions for POSIX + \\systems, please see this issue to track our progress: + \\ + \\https://github.com/oven-sh/bun/issues/4290 + \\ + \\ + ; + writer.print(Output.prettyFmt(fmt, true), .{name}) catch std.posix.abort(); } } else { if (Output.enable_ansi_colors) { @@ -346,6 +359,20 @@ pub fn crashHandler( \\ \\ , true), .{native_plugin_name}) catch std.posix.abort(); + } else if (bun.analytics.Features.unsupported_uv_function > 0) { + const name = unsupported_uv_function orelse ""; + const fmt = + \\Bun encountered a crash when running a NAPI module that tried to call + \\the {s} libuv function. + \\ + \\Bun is actively working on supporting all libuv functions for POSIX + \\systems, please see this issue to track our progress: + \\ + \\https://github.com/oven-sh/bun/issues/4290 + \\ + \\ + ; + writer.print(Output.prettyFmt(fmt, true), .{name}) catch std.posix.abort(); } else if (reason == .out_of_memory) { writer.writeAll( \\Bun has run out of memory. @@ -1831,10 +1858,33 @@ pub fn isPanicking() bool { return panicking.load(.monotonic) > 0; } +export fn CrashHandler__setInsideNativePlugin(name: ?[*:0]const u8) callconv(.C) void { + inside_native_plugin = name; +} + +fn unsupportUVFunction(name: ?[*:0]const u8) callconv(.C) void { + bun.analytics.Features.unsupported_uv_function += 1; + unsupported_uv_function = name; + std.debug.panic("unsupported uv function: {s}", .{name.?}); +} + export fn Bun__crashHandler(message_ptr: [*]u8, message_len: usize) noreturn { crashHandler(.{ .panic = message_ptr[0..message_len] }, null, @returnAddress()); } +export fn CrashHandler__setDlOpenAction(action: ?[*:0]const u8) void { + if (action) |str| { + bun.debugAssert(current_action == null); + current_action = .{ .dlopen = bun.sliceTo(str, 0) }; + } else { + bun.debugAssert(current_action != null and current_action.? == .dlopen); + current_action = null; + } +} + comptime { _ = &Bun__crashHandler; + if (!bun.Environment.isWindows) { + @export(&unsupportUVFunction, .{ .name = "CrashHandler__unsupportedUVFunction" }); + } } diff --git a/src/linker.lds b/src/linker.lds index 11c8152831..401cc35b60 100644 --- a/src/linker.lds +++ b/src/linker.lds @@ -4,8 +4,324 @@ BUN_1.2 { node_api_*; node_module_register; - uv_os_getpid; - uv_os_getppid; + + uv_accept; + uv_async_init; + uv_async_send; + uv_available_parallelism; + uv_backend_fd; + uv_backend_timeout; + uv_barrier_destroy; + uv_barrier_init; + uv_barrier_wait; + uv_buf_init; + uv_cancel; + uv_chdir; + uv_check_init; + uv_check_start; + uv_check_stop; + uv_clock_gettime; + uv_close; + uv_cond_broadcast; + uv_cond_destroy; + uv_cond_init; + uv_cond_signal; + uv_cond_timedwait; + uv_cond_wait; + uv_cpu_info; + uv_cpumask_size; + uv_cwd; + uv_default_loop; + uv_disable_stdio_inheritance; + uv_dlclose; + uv_dlerror; + uv_dlopen; + uv_dlsym; + uv_err_name; + uv_err_name_r; + uv_exepath; + uv_fileno; + uv_free_cpu_info; + uv_free_interface_addresses; + uv_freeaddrinfo; + uv_fs_access; + uv_fs_chmod; + uv_fs_chown; + uv_fs_close; + uv_fs_closedir; + uv_fs_copyfile; + uv_fs_event_getpath; + uv_fs_event_init; + uv_fs_event_start; + uv_fs_event_stop; + uv_fs_fchmod; + uv_fs_fchown; + uv_fs_fdatasync; + uv_fs_fstat; + uv_fs_fsync; + uv_fs_ftruncate; + uv_fs_futime; + uv_fs_get_path; + uv_fs_get_ptr; + uv_fs_get_result; + uv_fs_get_statbuf; + uv_fs_get_system_error; + uv_fs_get_type; + uv_fs_lchown; + uv_fs_link; + uv_fs_lstat; + uv_fs_lutime; + uv_fs_mkdir; + uv_fs_mkdtemp; + uv_fs_mkstemp; + uv_fs_open; + uv_fs_opendir; + uv_fs_poll_getpath; + uv_fs_poll_init; + uv_fs_poll_start; + uv_fs_poll_stop; + uv_fs_read; + uv_fs_readdir; + uv_fs_readlink; + uv_fs_realpath; + uv_fs_rename; + uv_fs_req_cleanup; + uv_fs_rmdir; + uv_fs_scandir; + uv_fs_scandir_next; + uv_fs_sendfile; + uv_fs_stat; + uv_fs_statfs; + uv_fs_symlink; + uv_fs_unlink; + uv_fs_utime; + uv_fs_write; + uv_get_available_memory; + uv_get_constrained_memory; + uv_get_free_memory; + uv_get_osfhandle; + uv_get_process_title; + uv_get_total_memory; + uv_getaddrinfo; + uv_getnameinfo; + uv_getrusage; + uv_getrusage_thread; + uv_gettimeofday; + uv_guess_handle; + uv_handle_get_data; + uv_handle_get_loop; + uv_handle_get_type; + uv_handle_set_data; + uv_handle_size; + uv_handle_type_name; + uv_has_ref; + uv_hrtime; + uv_idle_init; + uv_idle_start; + uv_idle_stop; + uv_if_indextoiid; + uv_if_indextoname; + uv_inet_ntop; + uv_inet_pton; + uv_interface_addresses; + uv_ip_name; + uv_ip4_addr; + uv_ip4_name; + uv_ip6_addr; + uv_ip6_name; + uv_is_active; + uv_is_closing; + uv_is_readable; + uv_is_writable; + uv_key_create; + uv_key_delete; + uv_key_get; + uv_key_set; + uv_kill; + uv_library_shutdown; + uv_listen; + uv_loadavg; + uv_loop_alive; + uv_loop_close; + uv_loop_configure; + uv_loop_delete; + uv_loop_fork; + uv_loop_get_data; + uv_loop_init; + uv_loop_new; + uv_loop_set_data; + uv_loop_size; + uv_metrics_idle_time; + uv_metrics_info; + uv_mutex_destroy; + uv_mutex_init; + uv_mutex_init_recursive; + uv_mutex_lock; + uv_mutex_trylock; + uv_mutex_unlock; + uv_now; + uv_once; + uv_open_osfhandle; + uv_os_environ; + uv_os_free_environ; + uv_os_free_group; + uv_os_free_passwd; + uv_os_get_group; + uv_os_get_passwd; + uv_os_get_passwd2; + uv_os_getenv; + uv_os_gethostname; + uv_os_getpid; + uv_os_getppid; + uv_os_getpriority; + uv_os_homedir; + uv_os_setenv; + uv_os_setpriority; + uv_os_tmpdir; + uv_os_uname; + uv_os_unsetenv; + uv_pipe; + uv_pipe_bind; + uv_pipe_bind2; + uv_pipe_chmod; + uv_pipe_connect; + uv_pipe_connect2; + uv_pipe_getpeername; + uv_pipe_getsockname; + uv_pipe_init; + uv_pipe_open; + uv_pipe_pending_count; + uv_pipe_pending_instances; + uv_pipe_pending_type; + uv_poll_init; + uv_poll_init_socket; + uv_poll_start; + uv_poll_stop; + uv_prepare_init; + uv_prepare_start; + uv_prepare_stop; + uv_print_active_handles; + uv_print_all_handles; + uv_process_get_pid; + uv_process_kill; + uv_queue_work; + uv_random; + uv_read_start; + uv_read_stop; + uv_recv_buffer_size; + uv_ref; + uv_replace_allocator; + uv_req_get_data; + uv_req_get_type; + uv_req_set_data; + uv_req_size; + uv_req_type_name; + uv_resident_set_memory; + uv_run; + uv_rwlock_destroy; + uv_rwlock_init; + uv_rwlock_rdlock; + uv_rwlock_rdunlock; + uv_rwlock_tryrdlock; + uv_rwlock_trywrlock; + uv_rwlock_wrlock; + uv_rwlock_wrunlock; + uv_sem_destroy; + uv_sem_init; + uv_sem_post; + uv_sem_trywait; + uv_sem_wait; + uv_send_buffer_size; + uv_set_process_title; + uv_setup_args; + uv_shutdown; + uv_signal_init; + uv_signal_start; + uv_signal_start_oneshot; + uv_signal_stop; + uv_sleep; + uv_socketpair; + uv_spawn; + uv_stop; + uv_stream_get_write_queue_size; + uv_stream_set_blocking; + uv_strerror; + uv_strerror_r; + uv_tcp_bind; + uv_tcp_close_reset; + uv_tcp_connect; + uv_tcp_getpeername; + uv_tcp_getsockname; + uv_tcp_init; + uv_tcp_init_ex; + uv_tcp_keepalive; + uv_tcp_nodelay; + uv_tcp_open; + uv_tcp_simultaneous_accepts; + uv_thread_create; + uv_thread_create_ex; + uv_thread_detach; + uv_thread_equal; + uv_thread_getaffinity; + uv_thread_getcpu; + uv_thread_getname; + uv_thread_getpriority; + uv_thread_join; + uv_thread_self; + uv_thread_setaffinity; + uv_thread_setname; + uv_thread_setpriority; + uv_timer_again; + uv_timer_get_due_in; + uv_timer_get_repeat; + uv_timer_init; + uv_timer_set_repeat; + uv_timer_start; + uv_timer_stop; + uv_translate_sys_error; + uv_try_write; + uv_try_write2; + uv_tty_get_vterm_state; + uv_tty_get_winsize; + uv_tty_init; + uv_tty_reset_mode; + uv_tty_set_mode; + uv_tty_set_vterm_state; + uv_udp_bind; + uv_udp_connect; + uv_udp_get_send_queue_count; + uv_udp_get_send_queue_size; + uv_udp_getpeername; + uv_udp_getsockname; + uv_udp_init; + uv_udp_init_ex; + uv_udp_open; + uv_udp_recv_start; + uv_udp_recv_stop; + uv_udp_send; + uv_udp_set_broadcast; + uv_udp_set_membership; + uv_udp_set_multicast_interface; + uv_udp_set_multicast_loop; + uv_udp_set_multicast_ttl; + uv_udp_set_source_membership; + uv_udp_set_ttl; + uv_udp_try_send; + uv_udp_try_send2; + uv_udp_using_recvmmsg; + uv_unref; + uv_update_time; + uv_uptime; + uv_utf16_length_as_wtf8; + uv_utf16_to_wtf8; + uv_version; + uv_version_string; + uv_walk; + uv_write; + uv_write2; + uv_wtf8_length_as_utf16; + uv_wtf8_to_utf16; + extern "C++" { v8::*; diff --git a/src/napi/napi.zig b/src/napi/napi.zig index d80f5ca889..e2c48f9615 100644 --- a/src/napi/napi.zig +++ b/src/napi/napi.zig @@ -2109,6 +2109,325 @@ const napi_functions_to_export = .{ node_api_create_external_string_utf16, }; +const uv_functions_to_export = if (bun.Environment.isPosix) struct { + pub extern "c" fn uv_accept() void; + pub extern "c" fn uv_async_init() void; + pub extern "c" fn uv_async_send() void; + pub extern "c" fn uv_available_parallelism() void; + pub extern "c" fn uv_backend_fd() void; + pub extern "c" fn uv_backend_timeout() void; + pub extern "c" fn uv_barrier_destroy() void; + pub extern "c" fn uv_barrier_init() void; + pub extern "c" fn uv_barrier_wait() void; + pub extern "c" fn uv_buf_init() void; + pub extern "c" fn uv_cancel() void; + pub extern "c" fn uv_chdir() void; + pub extern "c" fn uv_check_init() void; + pub extern "c" fn uv_check_start() void; + pub extern "c" fn uv_check_stop() void; + pub extern "c" fn uv_clock_gettime() void; + pub extern "c" fn uv_close() void; + pub extern "c" fn uv_cond_broadcast() void; + pub extern "c" fn uv_cond_destroy() void; + pub extern "c" fn uv_cond_init() void; + pub extern "c" fn uv_cond_signal() void; + pub extern "c" fn uv_cond_timedwait() void; + pub extern "c" fn uv_cond_wait() void; + pub extern "c" fn uv_cpu_info() void; + pub extern "c" fn uv_cpumask_size() void; + pub extern "c" fn uv_cwd() void; + pub extern "c" fn uv_default_loop() void; + pub extern "c" fn uv_disable_stdio_inheritance() void; + pub extern "c" fn uv_dlclose() void; + pub extern "c" fn uv_dlerror() void; + pub extern "c" fn uv_dlopen() void; + pub extern "c" fn uv_dlsym() void; + pub extern "c" fn uv_err_name() void; + pub extern "c" fn uv_err_name_r() void; + pub extern "c" fn uv_exepath() void; + pub extern "c" fn uv_fileno() void; + pub extern "c" fn uv_free_cpu_info() void; + pub extern "c" fn uv_free_interface_addresses() void; + pub extern "c" fn uv_freeaddrinfo() void; + pub extern "c" fn uv_fs_access() void; + pub extern "c" fn uv_fs_chmod() void; + pub extern "c" fn uv_fs_chown() void; + pub extern "c" fn uv_fs_close() void; + pub extern "c" fn uv_fs_closedir() void; + pub extern "c" fn uv_fs_copyfile() void; + pub extern "c" fn uv_fs_event_getpath() void; + pub extern "c" fn uv_fs_event_init() void; + pub extern "c" fn uv_fs_event_start() void; + pub extern "c" fn uv_fs_event_stop() void; + pub extern "c" fn uv_fs_fchmod() void; + pub extern "c" fn uv_fs_fchown() void; + pub extern "c" fn uv_fs_fdatasync() void; + pub extern "c" fn uv_fs_fstat() void; + pub extern "c" fn uv_fs_fsync() void; + pub extern "c" fn uv_fs_ftruncate() void; + pub extern "c" fn uv_fs_futime() void; + pub extern "c" fn uv_fs_get_path() void; + pub extern "c" fn uv_fs_get_ptr() void; + pub extern "c" fn uv_fs_get_result() void; + pub extern "c" fn uv_fs_get_statbuf() void; + pub extern "c" fn uv_fs_get_system_error() void; + pub extern "c" fn uv_fs_get_type() void; + pub extern "c" fn uv_fs_lchown() void; + pub extern "c" fn uv_fs_link() void; + pub extern "c" fn uv_fs_lstat() void; + pub extern "c" fn uv_fs_lutime() void; + pub extern "c" fn uv_fs_mkdir() void; + pub extern "c" fn uv_fs_mkdtemp() void; + pub extern "c" fn uv_fs_mkstemp() void; + pub extern "c" fn uv_fs_open() void; + pub extern "c" fn uv_fs_opendir() void; + pub extern "c" fn uv_fs_poll_getpath() void; + pub extern "c" fn uv_fs_poll_init() void; + pub extern "c" fn uv_fs_poll_start() void; + pub extern "c" fn uv_fs_poll_stop() void; + pub extern "c" fn uv_fs_read() void; + pub extern "c" fn uv_fs_readdir() void; + pub extern "c" fn uv_fs_readlink() void; + pub extern "c" fn uv_fs_realpath() void; + pub extern "c" fn uv_fs_rename() void; + pub extern "c" fn uv_fs_req_cleanup() void; + pub extern "c" fn uv_fs_rmdir() void; + pub extern "c" fn uv_fs_scandir() void; + pub extern "c" fn uv_fs_scandir_next() void; + pub extern "c" fn uv_fs_sendfile() void; + pub extern "c" fn uv_fs_stat() void; + pub extern "c" fn uv_fs_statfs() void; + pub extern "c" fn uv_fs_symlink() void; + pub extern "c" fn uv_fs_unlink() void; + pub extern "c" fn uv_fs_utime() void; + pub extern "c" fn uv_fs_write() void; + pub extern "c" fn uv_get_available_memory() void; + pub extern "c" fn uv_get_constrained_memory() void; + pub extern "c" fn uv_get_free_memory() void; + pub extern "c" fn uv_get_osfhandle() void; + pub extern "c" fn uv_get_process_title() void; + pub extern "c" fn uv_get_total_memory() void; + pub extern "c" fn uv_getaddrinfo() void; + pub extern "c" fn uv_getnameinfo() void; + pub extern "c" fn uv_getrusage() void; + pub extern "c" fn uv_getrusage_thread() void; + pub extern "c" fn uv_gettimeofday() void; + pub extern "c" fn uv_guess_handle() void; + pub extern "c" fn uv_handle_get_data() void; + pub extern "c" fn uv_handle_get_loop() void; + pub extern "c" fn uv_handle_get_type() void; + pub extern "c" fn uv_handle_set_data() void; + pub extern "c" fn uv_handle_size() void; + pub extern "c" fn uv_handle_type_name() void; + pub extern "c" fn uv_has_ref() void; + pub extern "c" fn uv_hrtime() void; + pub extern "c" fn uv_idle_init() void; + pub extern "c" fn uv_idle_start() void; + pub extern "c" fn uv_idle_stop() void; + pub extern "c" fn uv_if_indextoiid() void; + pub extern "c" fn uv_if_indextoname() void; + pub extern "c" fn uv_inet_ntop() void; + pub extern "c" fn uv_inet_pton() void; + pub extern "c" fn uv_interface_addresses() void; + pub extern "c" fn uv_ip_name() void; + pub extern "c" fn uv_ip4_addr() void; + pub extern "c" fn uv_ip4_name() void; + pub extern "c" fn uv_ip6_addr() void; + pub extern "c" fn uv_ip6_name() void; + pub extern "c" fn uv_is_active() void; + pub extern "c" fn uv_is_closing() void; + pub extern "c" fn uv_is_readable() void; + pub extern "c" fn uv_is_writable() void; + pub extern "c" fn uv_key_create() void; + pub extern "c" fn uv_key_delete() void; + pub extern "c" fn uv_key_get() void; + pub extern "c" fn uv_key_set() void; + pub extern "c" fn uv_kill() void; + pub extern "c" fn uv_library_shutdown() void; + pub extern "c" fn uv_listen() void; + pub extern "c" fn uv_loadavg() void; + pub extern "c" fn uv_loop_alive() void; + pub extern "c" fn uv_loop_close() void; + pub extern "c" fn uv_loop_configure() void; + pub extern "c" fn uv_loop_delete() void; + pub extern "c" fn uv_loop_fork() void; + pub extern "c" fn uv_loop_get_data() void; + pub extern "c" fn uv_loop_init() void; + pub extern "c" fn uv_loop_new() void; + pub extern "c" fn uv_loop_set_data() void; + pub extern "c" fn uv_loop_size() void; + pub extern "c" fn uv_metrics_idle_time() void; + pub extern "c" fn uv_metrics_info() void; + pub extern "c" fn uv_mutex_destroy() void; + pub extern "c" fn uv_mutex_init() void; + pub extern "c" fn uv_mutex_init_recursive() void; + pub extern "c" fn uv_mutex_lock() void; + pub extern "c" fn uv_mutex_trylock() void; + pub extern "c" fn uv_mutex_unlock() void; + pub extern "c" fn uv_now() void; + pub extern "c" fn uv_once() void; + pub extern "c" fn uv_open_osfhandle() void; + pub extern "c" fn uv_os_environ() void; + pub extern "c" fn uv_os_free_environ() void; + pub extern "c" fn uv_os_free_group() void; + pub extern "c" fn uv_os_free_passwd() void; + pub extern "c" fn uv_os_get_group() void; + pub extern "c" fn uv_os_get_passwd() void; + pub extern "c" fn uv_os_get_passwd2() void; + pub extern "c" fn uv_os_getenv() void; + pub extern "c" fn uv_os_gethostname() void; + pub extern "c" fn uv_os_getpid() void; + pub extern "c" fn uv_os_getppid() void; + pub extern "c" fn uv_os_getpriority() void; + pub extern "c" fn uv_os_homedir() void; + pub extern "c" fn uv_os_setenv() void; + pub extern "c" fn uv_os_setpriority() void; + pub extern "c" fn uv_os_tmpdir() void; + pub extern "c" fn uv_os_uname() void; + pub extern "c" fn uv_os_unsetenv() void; + pub extern "c" fn uv_pipe() void; + pub extern "c" fn uv_pipe_bind() void; + pub extern "c" fn uv_pipe_bind2() void; + pub extern "c" fn uv_pipe_chmod() void; + pub extern "c" fn uv_pipe_connect() void; + pub extern "c" fn uv_pipe_connect2() void; + pub extern "c" fn uv_pipe_getpeername() void; + pub extern "c" fn uv_pipe_getsockname() void; + pub extern "c" fn uv_pipe_init() void; + pub extern "c" fn uv_pipe_open() void; + pub extern "c" fn uv_pipe_pending_count() void; + pub extern "c" fn uv_pipe_pending_instances() void; + pub extern "c" fn uv_pipe_pending_type() void; + pub extern "c" fn uv_poll_init() void; + pub extern "c" fn uv_poll_init_socket() void; + pub extern "c" fn uv_poll_start() void; + pub extern "c" fn uv_poll_stop() void; + pub extern "c" fn uv_prepare_init() void; + pub extern "c" fn uv_prepare_start() void; + pub extern "c" fn uv_prepare_stop() void; + pub extern "c" fn uv_print_active_handles() void; + pub extern "c" fn uv_print_all_handles() void; + pub extern "c" fn uv_process_get_pid() void; + pub extern "c" fn uv_process_kill() void; + pub extern "c" fn uv_queue_work() void; + pub extern "c" fn uv_random() void; + pub extern "c" fn uv_read_start() void; + pub extern "c" fn uv_read_stop() void; + pub extern "c" fn uv_recv_buffer_size() void; + pub extern "c" fn uv_ref() void; + pub extern "c" fn uv_replace_allocator() void; + pub extern "c" fn uv_req_get_data() void; + pub extern "c" fn uv_req_get_type() void; + pub extern "c" fn uv_req_set_data() void; + pub extern "c" fn uv_req_size() void; + pub extern "c" fn uv_req_type_name() void; + pub extern "c" fn uv_resident_set_memory() void; + pub extern "c" fn uv_run() void; + pub extern "c" fn uv_rwlock_destroy() void; + pub extern "c" fn uv_rwlock_init() void; + pub extern "c" fn uv_rwlock_rdlock() void; + pub extern "c" fn uv_rwlock_rdunlock() void; + pub extern "c" fn uv_rwlock_tryrdlock() void; + pub extern "c" fn uv_rwlock_trywrlock() void; + pub extern "c" fn uv_rwlock_wrlock() void; + pub extern "c" fn uv_rwlock_wrunlock() void; + pub extern "c" fn uv_sem_destroy() void; + pub extern "c" fn uv_sem_init() void; + pub extern "c" fn uv_sem_post() void; + pub extern "c" fn uv_sem_trywait() void; + pub extern "c" fn uv_sem_wait() void; + pub extern "c" fn uv_send_buffer_size() void; + pub extern "c" fn uv_set_process_title() void; + pub extern "c" fn uv_setup_args() void; + pub extern "c" fn uv_shutdown() void; + pub extern "c" fn uv_signal_init() void; + pub extern "c" fn uv_signal_start() void; + pub extern "c" fn uv_signal_start_oneshot() void; + pub extern "c" fn uv_signal_stop() void; + pub extern "c" fn uv_sleep() void; + pub extern "c" fn uv_socketpair() void; + pub extern "c" fn uv_spawn() void; + pub extern "c" fn uv_stop() void; + pub extern "c" fn uv_stream_get_write_queue_size() void; + pub extern "c" fn uv_stream_set_blocking() void; + pub extern "c" fn uv_strerror() void; + pub extern "c" fn uv_strerror_r() void; + pub extern "c" fn uv_tcp_bind() void; + pub extern "c" fn uv_tcp_close_reset() void; + pub extern "c" fn uv_tcp_connect() void; + pub extern "c" fn uv_tcp_getpeername() void; + pub extern "c" fn uv_tcp_getsockname() void; + pub extern "c" fn uv_tcp_init() void; + pub extern "c" fn uv_tcp_init_ex() void; + pub extern "c" fn uv_tcp_keepalive() void; + pub extern "c" fn uv_tcp_nodelay() void; + pub extern "c" fn uv_tcp_open() void; + pub extern "c" fn uv_tcp_simultaneous_accepts() void; + pub extern "c" fn uv_thread_create() void; + pub extern "c" fn uv_thread_create_ex() void; + pub extern "c" fn uv_thread_detach() void; + pub extern "c" fn uv_thread_equal() void; + pub extern "c" fn uv_thread_getaffinity() void; + pub extern "c" fn uv_thread_getcpu() void; + pub extern "c" fn uv_thread_getname() void; + pub extern "c" fn uv_thread_getpriority() void; + pub extern "c" fn uv_thread_join() void; + pub extern "c" fn uv_thread_self() void; + pub extern "c" fn uv_thread_setaffinity() void; + pub extern "c" fn uv_thread_setname() void; + pub extern "c" fn uv_thread_setpriority() void; + pub extern "c" fn uv_timer_again() void; + pub extern "c" fn uv_timer_get_due_in() void; + pub extern "c" fn uv_timer_get_repeat() void; + pub extern "c" fn uv_timer_init() void; + pub extern "c" fn uv_timer_set_repeat() void; + pub extern "c" fn uv_timer_start() void; + pub extern "c" fn uv_timer_stop() void; + pub extern "c" fn uv_translate_sys_error() void; + pub extern "c" fn uv_try_write() void; + pub extern "c" fn uv_try_write2() void; + pub extern "c" fn uv_tty_get_vterm_state() void; + pub extern "c" fn uv_tty_get_winsize() void; + pub extern "c" fn uv_tty_init() void; + pub extern "c" fn uv_tty_reset_mode() void; + pub extern "c" fn uv_tty_set_mode() void; + pub extern "c" fn uv_tty_set_vterm_state() void; + pub extern "c" fn uv_udp_bind() void; + pub extern "c" fn uv_udp_connect() void; + pub extern "c" fn uv_udp_get_send_queue_count() void; + pub extern "c" fn uv_udp_get_send_queue_size() void; + pub extern "c" fn uv_udp_getpeername() void; + pub extern "c" fn uv_udp_getsockname() void; + pub extern "c" fn uv_udp_init() void; + pub extern "c" fn uv_udp_init_ex() void; + pub extern "c" fn uv_udp_open() void; + pub extern "c" fn uv_udp_recv_start() void; + pub extern "c" fn uv_udp_recv_stop() void; + pub extern "c" fn uv_udp_send() void; + pub extern "c" fn uv_udp_set_broadcast() void; + pub extern "c" fn uv_udp_set_membership() void; + pub extern "c" fn uv_udp_set_multicast_interface() void; + pub extern "c" fn uv_udp_set_multicast_loop() void; + pub extern "c" fn uv_udp_set_multicast_ttl() void; + pub extern "c" fn uv_udp_set_source_membership() void; + pub extern "c" fn uv_udp_set_ttl() void; + pub extern "c" fn uv_udp_try_send() void; + pub extern "c" fn uv_udp_try_send2() void; + pub extern "c" fn uv_udp_using_recvmmsg() void; + pub extern "c" fn uv_unref() void; + pub extern "c" fn uv_update_time() void; + pub extern "c" fn uv_uptime() void; + pub extern "c" fn uv_utf16_length_as_wtf8() void; + pub extern "c" fn uv_utf16_to_wtf8() void; + pub extern "c" fn uv_version() void; + pub extern "c" fn uv_version_string() void; + pub extern "c" fn uv_walk() void; + pub extern "c" fn uv_write() void; + pub extern "c" fn uv_write2() void; + pub extern "c" fn uv_wtf8_length_as_utf16() void; + pub extern "c" fn uv_wtf8_to_utf16() void; +} else struct {}; + pub fn fixDeadCodeElimination() void { JSC.markBinding(@src()); @@ -2116,6 +2435,10 @@ pub fn fixDeadCodeElimination() void { std.mem.doNotOptimizeAway(&fn_name); } + inline for (comptime std.meta.declarations(uv_functions_to_export)) |decl| { + std.mem.doNotOptimizeAway(&@field(uv_functions_to_export, decl.name)); + } + inline for (comptime std.meta.declarations(V8API)) |decl| { std.mem.doNotOptimizeAway(&@field(V8API, decl.name)); } diff --git a/src/symbols.dyn b/src/symbols.dyn index c2aa3aca63..bd733b5ede 100644 --- a/src/symbols.dyn +++ b/src/symbols.dyn @@ -1,4 +1,71 @@ { + __ZN2v811HandleScope12CreateHandleEPNS_8internal7IsolateEm; + __ZN2v811HandleScopeC1EPNS_7IsolateE; + __ZN2v811HandleScopeD1Ev; + __ZN2v811HandleScopeD2Ev; + __ZN2v812api_internal12ToLocalEmptyEv; + __ZN2v812api_internal13DisposeGlobalEPm; + __ZN2v812api_internal17FromJustIsNothingEv; + __ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm; + __ZN2v814ObjectTemplate11NewInstanceENS_5LocalINS_7ContextEEE; + __ZN2v814ObjectTemplate21SetInternalFieldCountEi; + __ZN2v814ObjectTemplate3NewEPNS_7IsolateENS_5LocalINS_16FunctionTemplateEEE; + __ZN2v816FunctionTemplate11GetFunctionENS_5LocalINS_7ContextEEE; + __ZN2v816FunctionTemplate3NewEPNS_7IsolateEPFvRKNS_20FunctionCallbackInfoINS_5ValueEEEENS_5LocalIS4_EENSA_INS_9SignatureEEEiNS_19ConstructorBehaviorENS_14SideEffectTypeEPKNS_9CFunctionEttt; + __ZN2v820EscapableHandleScopeC1EPNS_7IsolateE; + __ZN2v820EscapableHandleScopeC2EPNS_7IsolateE; + __ZN2v820EscapableHandleScopeD1Ev; + __ZN2v820EscapableHandleScopeD2Ev; + __ZN2v824EscapableHandleScopeBase10EscapeSlotEPm; + __ZN2v824EscapableHandleScopeBaseC2EPNS_7IsolateE; + __ZN2v85Array3NewEPNS_7IsolateEPNS_5LocalINS_5ValueEEEm; + __ZN2v86Number3NewEPNS_7IsolateEd; + __ZN2v86Object16GetInternalFieldEi; + __ZN2v86Object16SetInternalFieldEiNS_5LocalINS_4DataEEE; + __ZN2v86Object20SlowGetInternalFieldEi; + __ZN2v86Object3NewEPNS_7IsolateE; + __ZN2v86Object3SetENS_5LocalINS_7ContextEEENS1_INS_5ValueEEES5_; + __ZN2v86String11NewFromUtf8EPNS_7IsolateEPKcNS_13NewStringTypeEi; + __ZN2v86String14NewFromOneByteEPNS_7IsolateEPKhNS_13NewStringTypeEi; + __ZN2v87Boolean3NewEPNS_7IsolateEb; + __ZN2v87Context10GetIsolateEv; + __ZN2v87Isolate10GetCurrentEv; + __ZN2v87Isolate13TryGetCurrentEv; + __ZN2v87Isolate17GetCurrentContextEv; + __ZN2v88External3NewEPNS_7IsolateEPv; + __ZN2v88Function7SetNameENS_5LocalINS_6StringEEE; + __ZN2v88internal35IsolateFromNeverReadOnlySpaceObjectEm; + __ZN3JSC9CallFrame13describeFrameEv; + __ZN4node25AddEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_; + __ZN4node28RemoveEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_; + __ZNK2v814ObjectTemplate18InternalFieldCountEv; + __ZNK2v85Value10FullIsTrueEv; + __ZNK2v85Value10IsFunctionEv; + __ZNK2v85Value11FullIsFalseEv; + __ZNK2v85Value11IsUndefinedEv; + __ZNK2v85Value11Uint32ValueENS_5LocalINS_7ContextEEE; + __ZNK2v85Value17IsNullOrUndefinedEv; + __ZNK2v85Value6IsNullEv; + __ZNK2v85Value6IsTrueEv; + __ZNK2v85Value7IsFalseEv; + __ZNK2v85Value8IsNumberEv; + __ZNK2v85Value8IsObjectEv; + __ZNK2v85Value8IsStringEv; + __ZNK2v85Value8IsUint32Ev; + __ZNK2v85Value9IsBooleanEv; + __ZNK2v86Number5ValueEv; + __ZNK2v86String10IsExternalEv; + __ZNK2v86String10Utf8LengthEPNS_7IsolateE; + __ZNK2v86String17IsExternalOneByteEv; + __ZNK2v86String17IsExternalTwoByteEv; + __ZNK2v86String19ContainsOnlyOneByteEv; + __ZNK2v86String6LengthEv; + __ZNK2v86String9IsOneByteEv; + __ZNK2v86String9WriteUtf8EPNS_7IsolateEPciPii; + __ZNK2v87Boolean5ValueEv; + __ZNK2v88External5ValueEv; + __ZNK2v88Function7GetNameEv; + _dumpBtjsTrace; _napi_acquire_threadsafe_function; _napi_add_async_cleanup_hook; _napi_add_env_cleanup_hook; @@ -17,22 +84,22 @@ _napi_coerce_to_number; _napi_coerce_to_object; _napi_coerce_to_string; - _napi_create_array; _napi_create_array_with_length; + _napi_create_array; _napi_create_arraybuffer; _napi_create_async_work; _napi_create_bigint_int64; _napi_create_bigint_uint64; _napi_create_bigint_words; - _napi_create_buffer; _napi_create_buffer_copy; + _napi_create_buffer; _napi_create_dataview; _napi_create_date; _napi_create_double; _napi_create_error; - _napi_create_external; _napi_create_external_arraybuffer; _napi_create_external_buffer; + _napi_create_external; _napi_create_function; _napi_create_int32; _napi_create_int64; @@ -75,8 +142,8 @@ _napi_get_new_target; _napi_get_node_version; _napi_get_null; - _napi_get_property; _napi_get_property_names; + _napi_get_property; _napi_get_prototype; _napi_get_reference_value; _napi_get_threadsafe_function_context; @@ -135,94 +202,341 @@ _napi_set_named_property; _napi_set_property; _napi_strict_equals; - _napi_throw; _napi_throw_error; _napi_throw_range_error; _napi_throw_type_error; + _napi_throw; _napi_type_tag_object; _napi_typeof; _napi_unref_threadsafe_function; _napi_unwrap; _napi_wrap; + _node_api_create_buffer_from_arraybuffer; _node_api_create_external_string_latin1; _node_api_create_external_string_utf16; - _node_api_create_syntax_error; - _node_api_symbol_for; - _node_api_throw_syntax_error; - _node_api_create_buffer_from_arraybuffer; - _node_api_get_module_file_name; - _node_api_post_finalizer; _node_api_create_property_key_latin1; _node_api_create_property_key_utf16; _node_api_create_property_key_utf8; - __ZN2v87Isolate10GetCurrentEv; - __ZN2v87Isolate13TryGetCurrentEv; - __ZN2v87Isolate17GetCurrentContextEv; - __ZN4node25AddEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_; - __ZN4node28RemoveEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_; - __ZN2v86Number3NewEPNS_7IsolateEd; - __ZNK2v86Number5ValueEv; - __ZN2v86String11NewFromUtf8EPNS_7IsolateEPKcNS_13NewStringTypeEi; - __ZNK2v86String9WriteUtf8EPNS_7IsolateEPciPii; - __ZN2v812api_internal12ToLocalEmptyEv; - __ZNK2v86String6LengthEv; - __ZN2v88External3NewEPNS_7IsolateEPv; - __ZNK2v88External5ValueEv; - __ZN2v86Object3NewEPNS_7IsolateE; - __ZN2v86Object3SetENS_5LocalINS_7ContextEEENS1_INS_5ValueEEES5_; - __ZN2v86Object16SetInternalFieldEiNS_5LocalINS_4DataEEE; - __ZN2v86Object20SlowGetInternalFieldEi; - __ZN2v811HandleScope12CreateHandleEPNS_8internal7IsolateEm; - __ZN2v811HandleScopeC1EPNS_7IsolateE; - __ZN2v811HandleScopeD1Ev; - __ZN2v811HandleScopeD2Ev; - __ZN2v816FunctionTemplate11GetFunctionENS_5LocalINS_7ContextEEE; - __ZN2v816FunctionTemplate3NewEPNS_7IsolateEPFvRKNS_20FunctionCallbackInfoINS_5ValueEEEENS_5LocalIS4_EENSA_INS_9SignatureEEEiNS_19ConstructorBehaviorENS_14SideEffectTypeEPKNS_9CFunctionEttt; - __ZN2v814ObjectTemplate11NewInstanceENS_5LocalINS_7ContextEEE; - __ZN2v814ObjectTemplate21SetInternalFieldCountEi; - __ZNK2v814ObjectTemplate18InternalFieldCountEv; - __ZN2v814ObjectTemplate3NewEPNS_7IsolateENS_5LocalINS_16FunctionTemplateEEE; - __ZN2v824EscapableHandleScopeBase10EscapeSlotEPm; - __ZN2v824EscapableHandleScopeBaseC2EPNS_7IsolateE; - __ZN2v88internal35IsolateFromNeverReadOnlySpaceObjectEm; + _node_api_create_syntax_error; + _node_api_get_module_file_name; + _node_api_post_finalizer; + _node_api_symbol_for; + _node_api_throw_syntax_error; _node_module_register; - __ZN3JSC9CallFrame13describeFrameEv; - __ZN2v85Array3NewEPNS_7IsolateEPNS_5LocalINS_5ValueEEEm; - __ZN2v88Function7SetNameENS_5LocalINS_6StringEEE; - __ZNK2v85Value9IsBooleanEv; - __ZNK2v87Boolean5ValueEv; - __ZNK2v85Value10FullIsTrueEv; - __ZNK2v85Value11FullIsFalseEv; - __ZN2v820EscapableHandleScopeC1EPNS_7IsolateE; - __ZN2v820EscapableHandleScopeC2EPNS_7IsolateE; - __ZN2v820EscapableHandleScopeD1Ev; - __ZN2v820EscapableHandleScopeD2Ev; - __ZNK2v85Value8IsObjectEv; - __ZNK2v85Value8IsNumberEv; - __ZNK2v85Value8IsUint32Ev; - __ZNK2v85Value11Uint32ValueENS_5LocalINS_7ContextEEE; - __ZNK2v85Value11IsUndefinedEv; - __ZNK2v85Value6IsNullEv; - __ZNK2v85Value17IsNullOrUndefinedEv; - __ZNK2v85Value6IsTrueEv; - __ZNK2v85Value7IsFalseEv; - __ZNK2v85Value8IsStringEv; - __ZN2v87Boolean3NewEPNS_7IsolateEb; - __ZN2v86Object16GetInternalFieldEi; - __ZN2v87Context10GetIsolateEv; - __ZN2v86String14NewFromOneByteEPNS_7IsolateEPKhNS_13NewStringTypeEi; - __ZNK2v86String10Utf8LengthEPNS_7IsolateE; - __ZNK2v86String10IsExternalEv; - __ZNK2v86String17IsExternalOneByteEv; - __ZNK2v86String17IsExternalTwoByteEv; - __ZNK2v86String9IsOneByteEv; - __ZNK2v86String19ContainsOnlyOneByteEv; - __ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm; - __ZN2v812api_internal13DisposeGlobalEPm; - __ZNK2v88Function7GetNameEv; - __ZNK2v85Value10IsFunctionEv; - __ZN2v812api_internal17FromJustIsNothingEv; + _uv_accept; + _uv_async_init; + _uv_async_send; + _uv_available_parallelism; + _uv_backend_fd; + _uv_backend_timeout; + _uv_barrier_destroy; + _uv_barrier_init; + _uv_barrier_wait; + _uv_buf_init; + _uv_cancel; + _uv_chdir; + _uv_check_init; + _uv_check_start; + _uv_check_stop; + _uv_clock_gettime; + _uv_close; + _uv_cond_broadcast; + _uv_cond_destroy; + _uv_cond_init; + _uv_cond_signal; + _uv_cond_timedwait; + _uv_cond_wait; + _uv_cpu_info; + _uv_cpumask_size; + _uv_cwd; + _uv_default_loop; + _uv_disable_stdio_inheritance; + _uv_dlclose; + _uv_dlerror; + _uv_dlopen; + _uv_dlsym; + _uv_err_name_r; + _uv_err_name; + _uv_exepath; + _uv_fileno; + _uv_free_cpu_info; + _uv_free_interface_addresses; + _uv_freeaddrinfo; + _uv_fs_access; + _uv_fs_chmod; + _uv_fs_chown; + _uv_fs_close; + _uv_fs_closedir; + _uv_fs_copyfile; + _uv_fs_event_getpath; + _uv_fs_event_init; + _uv_fs_event_start; + _uv_fs_event_stop; + _uv_fs_fchmod; + _uv_fs_fchown; + _uv_fs_fdatasync; + _uv_fs_fstat; + _uv_fs_fsync; + _uv_fs_ftruncate; + _uv_fs_futime; + _uv_fs_get_path; + _uv_fs_get_ptr; + _uv_fs_get_result; + _uv_fs_get_statbuf; + _uv_fs_get_system_error; + _uv_fs_get_type; + _uv_fs_lchown; + _uv_fs_link; + _uv_fs_lstat; + _uv_fs_lutime; + _uv_fs_mkdir; + _uv_fs_mkdtemp; + _uv_fs_mkstemp; + _uv_fs_open; + _uv_fs_opendir; + _uv_fs_poll_getpath; + _uv_fs_poll_init; + _uv_fs_poll_start; + _uv_fs_poll_stop; + _uv_fs_read; + _uv_fs_readdir; + _uv_fs_readlink; + _uv_fs_realpath; + _uv_fs_rename; + _uv_fs_req_cleanup; + _uv_fs_rmdir; + _uv_fs_scandir_next; + _uv_fs_scandir; + _uv_fs_sendfile; + _uv_fs_stat; + _uv_fs_statfs; + _uv_fs_symlink; + _uv_fs_unlink; + _uv_fs_utime; + _uv_fs_write; + _uv_get_available_memory; + _uv_get_constrained_memory; + _uv_get_free_memory; + _uv_get_osfhandle; + _uv_get_process_title; + _uv_get_total_memory; + _uv_getaddrinfo; + _uv_getnameinfo; + _uv_getrusage_thread; + _uv_getrusage; + _uv_gettimeofday; + _uv_guess_handle; + _uv_handle_get_data; + _uv_handle_get_loop; + _uv_handle_get_type; + _uv_handle_set_data; + _uv_handle_size; + _uv_handle_type_name; + _uv_has_ref; + _uv_hrtime; + _uv_idle_init; + _uv_idle_start; + _uv_idle_stop; + _uv_if_indextoiid; + _uv_if_indextoname; + _uv_inet_ntop; + _uv_inet_pton; + _uv_interface_addresses; + _uv_ip_name; + _uv_ip4_addr; + _uv_ip4_name; + _uv_ip6_addr; + _uv_ip6_name; + _uv_is_active; + _uv_is_closing; + _uv_is_readable; + _uv_is_writable; + _uv_key_create; + _uv_key_delete; + _uv_key_get; + _uv_key_set; + _uv_kill; + _uv_library_shutdown; + _uv_listen; + _uv_loadavg; + _uv_loop_alive; + _uv_loop_close; + _uv_loop_configure; + _uv_loop_delete; + _uv_loop_fork; + _uv_loop_get_data; + _uv_loop_init; + _uv_loop_new; + _uv_loop_set_data; + _uv_loop_size; + _uv_metrics_idle_time; + _uv_metrics_info; + _uv_mutex_destroy; + _uv_mutex_init_recursive; + _uv_mutex_init; + _uv_mutex_lock; + _uv_mutex_trylock; + _uv_mutex_unlock; + _uv_now; + _uv_once; + _uv_open_osfhandle; + _uv_os_environ; + _uv_os_free_environ; + _uv_os_free_group; + _uv_os_free_passwd; + _uv_os_get_group; + _uv_os_get_passwd; + _uv_os_get_passwd2; + _uv_os_getenv; + _uv_os_gethostname; _uv_os_getpid; _uv_os_getppid; - _dumpBtjsTrace; + _uv_os_getpriority; + _uv_os_homedir; + _uv_os_setenv; + _uv_os_setpriority; + _uv_os_tmpdir; + _uv_os_uname; + _uv_os_unsetenv; + _uv_pipe_bind; + _uv_pipe_bind2; + _uv_pipe_chmod; + _uv_pipe_connect; + _uv_pipe_connect2; + _uv_pipe_getpeername; + _uv_pipe_getsockname; + _uv_pipe_init; + _uv_pipe_open; + _uv_pipe_pending_count; + _uv_pipe_pending_instances; + _uv_pipe_pending_type; + _uv_pipe; + _uv_poll_init_socket; + _uv_poll_init; + _uv_poll_start; + _uv_poll_stop; + _uv_prepare_init; + _uv_prepare_start; + _uv_prepare_stop; + _uv_print_active_handles; + _uv_print_all_handles; + _uv_process_get_pid; + _uv_process_kill; + _uv_queue_work; + _uv_random; + _uv_read_start; + _uv_read_stop; + _uv_recv_buffer_size; + _uv_ref; + _uv_replace_allocator; + _uv_req_get_data; + _uv_req_get_type; + _uv_req_set_data; + _uv_req_size; + _uv_req_type_name; + _uv_resident_set_memory; + _uv_run; + _uv_rwlock_destroy; + _uv_rwlock_init; + _uv_rwlock_rdlock; + _uv_rwlock_rdunlock; + _uv_rwlock_tryrdlock; + _uv_rwlock_trywrlock; + _uv_rwlock_wrlock; + _uv_rwlock_wrunlock; + _uv_sem_destroy; + _uv_sem_init; + _uv_sem_post; + _uv_sem_trywait; + _uv_sem_wait; + _uv_send_buffer_size; + _uv_set_process_title; + _uv_setup_args; + _uv_shutdown; + _uv_signal_init; + _uv_signal_start_oneshot; + _uv_signal_start; + _uv_signal_stop; + _uv_sleep; + _uv_socketpair; + _uv_spawn; + _uv_stop; + _uv_stream_get_write_queue_size; + _uv_stream_set_blocking; + _uv_strerror_r; + _uv_strerror; + _uv_tcp_bind; + _uv_tcp_close_reset; + _uv_tcp_connect; + _uv_tcp_getpeername; + _uv_tcp_getsockname; + _uv_tcp_init_ex; + _uv_tcp_init; + _uv_tcp_keepalive; + _uv_tcp_nodelay; + _uv_tcp_open; + _uv_tcp_simultaneous_accepts; + _uv_thread_create_ex; + _uv_thread_create; + _uv_thread_detach; + _uv_thread_equal; + _uv_thread_getaffinity; + _uv_thread_getcpu; + _uv_thread_getname; + _uv_thread_getpriority; + _uv_thread_join; + _uv_thread_self; + _uv_thread_setaffinity; + _uv_thread_setname; + _uv_thread_setpriority; + _uv_timer_again; + _uv_timer_get_due_in; + _uv_timer_get_repeat; + _uv_timer_init; + _uv_timer_set_repeat; + _uv_timer_start; + _uv_timer_stop; + _uv_translate_sys_error; + _uv_try_write; + _uv_try_write2; + _uv_tty_get_vterm_state; + _uv_tty_get_winsize; + _uv_tty_init; + _uv_tty_reset_mode; + _uv_tty_set_mode; + _uv_tty_set_vterm_state; + _uv_udp_bind; + _uv_udp_connect; + _uv_udp_get_send_queue_count; + _uv_udp_get_send_queue_size; + _uv_udp_getpeername; + _uv_udp_getsockname; + _uv_udp_init_ex; + _uv_udp_init; + _uv_udp_open; + _uv_udp_recv_start; + _uv_udp_recv_stop; + _uv_udp_send; + _uv_udp_set_broadcast; + _uv_udp_set_membership; + _uv_udp_set_multicast_interface; + _uv_udp_set_multicast_loop; + _uv_udp_set_multicast_ttl; + _uv_udp_set_source_membership; + _uv_udp_set_ttl; + _uv_udp_try_send; + _uv_udp_try_send2; + _uv_udp_using_recvmmsg; + _uv_unref; + _uv_update_time; + _uv_uptime; + _uv_utf16_length_as_wtf8; + _uv_utf16_to_wtf8; + _uv_version_string; + _uv_version; + _uv_walk; + _uv_write; + _uv_write2; + _uv_wtf8_length_as_utf16; + _uv_wtf8_to_utf16; }; diff --git a/src/symbols.txt b/src/symbols.txt index 282f0bfd96..56f7a8f68b 100644 --- a/src/symbols.txt +++ b/src/symbols.txt @@ -1,3 +1,70 @@ +__ZN2v811HandleScope12CreateHandleEPNS_8internal7IsolateEm +__ZN2v811HandleScopeC1EPNS_7IsolateE +__ZN2v811HandleScopeD1Ev +__ZN2v811HandleScopeD2Ev +__ZN2v812api_internal12ToLocalEmptyEv +__ZN2v812api_internal13DisposeGlobalEPm +__ZN2v812api_internal17FromJustIsNothingEv +__ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm +__ZN2v814ObjectTemplate11NewInstanceENS_5LocalINS_7ContextEEE +__ZN2v814ObjectTemplate21SetInternalFieldCountEi +__ZN2v814ObjectTemplate3NewEPNS_7IsolateENS_5LocalINS_16FunctionTemplateEEE +__ZN2v816FunctionTemplate11GetFunctionENS_5LocalINS_7ContextEEE +__ZN2v816FunctionTemplate3NewEPNS_7IsolateEPFvRKNS_20FunctionCallbackInfoINS_5ValueEEEENS_5LocalIS4_EENSA_INS_9SignatureEEEiNS_19ConstructorBehaviorENS_14SideEffectTypeEPKNS_9CFunctionEttt +__ZN2v820EscapableHandleScopeC1EPNS_7IsolateE +__ZN2v820EscapableHandleScopeC2EPNS_7IsolateE +__ZN2v820EscapableHandleScopeD1Ev +__ZN2v820EscapableHandleScopeD2Ev +__ZN2v824EscapableHandleScopeBase10EscapeSlotEPm +__ZN2v824EscapableHandleScopeBaseC2EPNS_7IsolateE +__ZN2v85Array3NewEPNS_7IsolateEPNS_5LocalINS_5ValueEEEm +__ZN2v86Number3NewEPNS_7IsolateEd +__ZN2v86Object16GetInternalFieldEi +__ZN2v86Object16SetInternalFieldEiNS_5LocalINS_4DataEEE +__ZN2v86Object20SlowGetInternalFieldEi +__ZN2v86Object3NewEPNS_7IsolateE +__ZN2v86Object3SetENS_5LocalINS_7ContextEEENS1_INS_5ValueEEES5_ +__ZN2v86String11NewFromUtf8EPNS_7IsolateEPKcNS_13NewStringTypeEi +__ZN2v86String14NewFromOneByteEPNS_7IsolateEPKhNS_13NewStringTypeEi +__ZN2v87Boolean3NewEPNS_7IsolateEb +__ZN2v87Context10GetIsolateEv +__ZN2v87Isolate10GetCurrentEv +__ZN2v87Isolate13TryGetCurrentEv +__ZN2v87Isolate17GetCurrentContextEv +__ZN2v88External3NewEPNS_7IsolateEPv +__ZN2v88Function7SetNameENS_5LocalINS_6StringEEE +__ZN2v88internal35IsolateFromNeverReadOnlySpaceObjectEm +__ZN3JSC9CallFrame13describeFrameEv +__ZN4node25AddEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_ +__ZN4node28RemoveEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_ +__ZNK2v814ObjectTemplate18InternalFieldCountEv +__ZNK2v85Value10FullIsTrueEv +__ZNK2v85Value10IsFunctionEv +__ZNK2v85Value11FullIsFalseEv +__ZNK2v85Value11IsUndefinedEv +__ZNK2v85Value11Uint32ValueENS_5LocalINS_7ContextEEE +__ZNK2v85Value17IsNullOrUndefinedEv +__ZNK2v85Value6IsNullEv +__ZNK2v85Value6IsTrueEv +__ZNK2v85Value7IsFalseEv +__ZNK2v85Value8IsNumberEv +__ZNK2v85Value8IsObjectEv +__ZNK2v85Value8IsStringEv +__ZNK2v85Value8IsUint32Ev +__ZNK2v85Value9IsBooleanEv +__ZNK2v86Number5ValueEv +__ZNK2v86String10IsExternalEv +__ZNK2v86String10Utf8LengthEPNS_7IsolateE +__ZNK2v86String17IsExternalOneByteEv +__ZNK2v86String17IsExternalTwoByteEv +__ZNK2v86String19ContainsOnlyOneByteEv +__ZNK2v86String6LengthEv +__ZNK2v86String9IsOneByteEv +__ZNK2v86String9WriteUtf8EPNS_7IsolateEPciPii +__ZNK2v87Boolean5ValueEv +__ZNK2v88External5ValueEv +__ZNK2v88Function7GetNameEv +_dumpBtjsTrace _napi_acquire_threadsafe_function _napi_add_async_cleanup_hook _napi_add_env_cleanup_hook @@ -143,84 +210,331 @@ _napi_typeof _napi_unref_threadsafe_function _napi_unwrap _napi_wrap +_node_api_create_buffer_from_arraybuffer _node_api_create_external_string_latin1 _node_api_create_external_string_utf16 -_node_api_create_syntax_error -_node_api_symbol_for -_node_api_throw_syntax_error -_node_api_create_buffer_from_arraybuffer -_node_api_get_module_file_name -_node_api_post_finalizer _node_api_create_property_key_latin1 _node_api_create_property_key_utf16 _node_api_create_property_key_utf8 -__ZN2v87Isolate10GetCurrentEv -__ZN2v87Isolate13TryGetCurrentEv -__ZN2v87Isolate17GetCurrentContextEv -__ZN4node25AddEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_ -__ZN4node28RemoveEnvironmentCleanupHookEPN2v87IsolateEPFvPvES3_ -__ZN2v86Number3NewEPNS_7IsolateEd -__ZNK2v86Number5ValueEv -__ZN2v86String11NewFromUtf8EPNS_7IsolateEPKcNS_13NewStringTypeEi -__ZNK2v86String9WriteUtf8EPNS_7IsolateEPciPii -__ZN2v812api_internal12ToLocalEmptyEv -__ZNK2v86String6LengthEv -__ZN2v88External3NewEPNS_7IsolateEPv -__ZNK2v88External5ValueEv -__ZN2v86Object3NewEPNS_7IsolateE -__ZN2v86Object3SetENS_5LocalINS_7ContextEEENS1_INS_5ValueEEES5_ -__ZN2v86Object16SetInternalFieldEiNS_5LocalINS_4DataEEE -__ZN2v86Object20SlowGetInternalFieldEi -__ZN2v811HandleScope12CreateHandleEPNS_8internal7IsolateEm -__ZN2v811HandleScopeC1EPNS_7IsolateE -__ZN2v811HandleScopeD1Ev -__ZN2v811HandleScopeD2Ev -__ZN2v816FunctionTemplate11GetFunctionENS_5LocalINS_7ContextEEE -__ZN2v816FunctionTemplate3NewEPNS_7IsolateEPFvRKNS_20FunctionCallbackInfoINS_5ValueEEEENS_5LocalIS4_EENSA_INS_9SignatureEEEiNS_19ConstructorBehaviorENS_14SideEffectTypeEPKNS_9CFunctionEttt -__ZN2v814ObjectTemplate11NewInstanceENS_5LocalINS_7ContextEEE -__ZN2v814ObjectTemplate21SetInternalFieldCountEi -__ZNK2v814ObjectTemplate18InternalFieldCountEv -__ZN2v814ObjectTemplate3NewEPNS_7IsolateENS_5LocalINS_16FunctionTemplateEEE -__ZN2v824EscapableHandleScopeBase10EscapeSlotEPm -__ZN2v824EscapableHandleScopeBaseC2EPNS_7IsolateE -__ZN2v88internal35IsolateFromNeverReadOnlySpaceObjectEm +_node_api_create_syntax_error +_node_api_get_module_file_name +_node_api_post_finalizer +_node_api_symbol_for +_node_api_throw_syntax_error _node_module_register -__ZN3JSC9CallFrame13describeFrameEv -__ZN2v85Array3NewEPNS_7IsolateEPNS_5LocalINS_5ValueEEEm -__ZN2v88Function7SetNameENS_5LocalINS_6StringEEE -__ZNK2v85Value9IsBooleanEv -__ZNK2v87Boolean5ValueEv -__ZNK2v85Value10FullIsTrueEv -__ZNK2v85Value11FullIsFalseEv -__ZN2v820EscapableHandleScopeC1EPNS_7IsolateE -__ZN2v820EscapableHandleScopeC2EPNS_7IsolateE -__ZN2v820EscapableHandleScopeD1Ev -__ZN2v820EscapableHandleScopeD2Ev -__ZNK2v85Value8IsObjectEv -__ZNK2v85Value8IsNumberEv -__ZNK2v85Value8IsUint32Ev -__ZNK2v85Value11Uint32ValueENS_5LocalINS_7ContextEEE -__ZNK2v85Value11IsUndefinedEv -__ZNK2v85Value6IsNullEv -__ZNK2v85Value17IsNullOrUndefinedEv -__ZNK2v85Value6IsTrueEv -__ZNK2v85Value7IsFalseEv -__ZNK2v85Value8IsStringEv -__ZN2v87Boolean3NewEPNS_7IsolateEb -__ZN2v86Object16GetInternalFieldEi -__ZN2v87Context10GetIsolateEv -__ZN2v86String14NewFromOneByteEPNS_7IsolateEPKhNS_13NewStringTypeEi -__ZNK2v86String10Utf8LengthEPNS_7IsolateE -__ZNK2v86String10IsExternalEv -__ZNK2v86String17IsExternalOneByteEv -__ZNK2v86String17IsExternalTwoByteEv -__ZNK2v86String9IsOneByteEv -__ZNK2v86String19ContainsOnlyOneByteEv -__ZN2v812api_internal18GlobalizeReferenceEPNS_8internal7IsolateEm -__ZN2v812api_internal13DisposeGlobalEPm -__ZNK2v88Function7GetNameEv -__ZNK2v85Value10IsFunctionEv -__ZN2v812api_internal17FromJustIsNothingEv +_uv_accept +_uv_async_init +_uv_async_send +_uv_available_parallelism +_uv_backend_fd +_uv_backend_timeout +_uv_barrier_destroy +_uv_barrier_init +_uv_barrier_wait +_uv_buf_init +_uv_cancel +_uv_chdir +_uv_check_init +_uv_check_start +_uv_check_stop +_uv_clock_gettime +_uv_close +_uv_cond_broadcast +_uv_cond_destroy +_uv_cond_init +_uv_cond_signal +_uv_cond_timedwait +_uv_cond_wait +_uv_cpu_info +_uv_cpumask_size +_uv_cwd +_uv_default_loop +_uv_disable_stdio_inheritance +_uv_dlclose +_uv_dlerror +_uv_dlopen +_uv_dlsym +_uv_err_name +_uv_err_name_r +_uv_exepath +_uv_fileno +_uv_free_cpu_info +_uv_free_interface_addresses +_uv_freeaddrinfo +_uv_fs_access +_uv_fs_chmod +_uv_fs_chown +_uv_fs_close +_uv_fs_closedir +_uv_fs_copyfile +_uv_fs_event_getpath +_uv_fs_event_init +_uv_fs_event_start +_uv_fs_event_stop +_uv_fs_fchmod +_uv_fs_fchown +_uv_fs_fdatasync +_uv_fs_fstat +_uv_fs_fsync +_uv_fs_ftruncate +_uv_fs_futime +_uv_fs_get_path +_uv_fs_get_ptr +_uv_fs_get_result +_uv_fs_get_statbuf +_uv_fs_get_system_error +_uv_fs_get_type +_uv_fs_lchown +_uv_fs_link +_uv_fs_lstat +_uv_fs_lutime +_uv_fs_mkdir +_uv_fs_mkdtemp +_uv_fs_mkstemp +_uv_fs_open +_uv_fs_opendir +_uv_fs_poll_getpath +_uv_fs_poll_init +_uv_fs_poll_start +_uv_fs_poll_stop +_uv_fs_read +_uv_fs_readdir +_uv_fs_readlink +_uv_fs_realpath +_uv_fs_rename +_uv_fs_req_cleanup +_uv_fs_rmdir +_uv_fs_scandir +_uv_fs_scandir_next +_uv_fs_sendfile +_uv_fs_stat +_uv_fs_statfs +_uv_fs_symlink +_uv_fs_unlink +_uv_fs_utime +_uv_fs_write +_uv_get_available_memory +_uv_get_constrained_memory +_uv_get_free_memory +_uv_get_osfhandle +_uv_get_process_title +_uv_get_total_memory +_uv_getaddrinfo +_uv_getnameinfo +_uv_getrusage +_uv_getrusage_thread +_uv_gettimeofday +_uv_guess_handle +_uv_handle_get_data +_uv_handle_get_loop +_uv_handle_get_type +_uv_handle_set_data +_uv_handle_size +_uv_handle_type_name +_uv_has_ref +_uv_hrtime +_uv_idle_init +_uv_idle_start +_uv_idle_stop +_uv_if_indextoiid +_uv_if_indextoname +_uv_inet_ntop +_uv_inet_pton +_uv_interface_addresses +_uv_ip_name +_uv_ip4_addr +_uv_ip4_name +_uv_ip6_addr +_uv_ip6_name +_uv_is_active +_uv_is_closing +_uv_is_readable +_uv_is_writable +_uv_key_create +_uv_key_delete +_uv_key_get +_uv_key_set +_uv_kill +_uv_library_shutdown +_uv_listen +_uv_loadavg +_uv_loop_alive +_uv_loop_close +_uv_loop_configure +_uv_loop_delete +_uv_loop_fork +_uv_loop_get_data +_uv_loop_init +_uv_loop_new +_uv_loop_set_data +_uv_loop_size +_uv_metrics_idle_time +_uv_metrics_info +_uv_mutex_destroy +_uv_mutex_init +_uv_mutex_init_recursive +_uv_mutex_lock +_uv_mutex_trylock +_uv_mutex_unlock +_uv_now +_uv_once +_uv_open_osfhandle +_uv_os_environ +_uv_os_free_environ +_uv_os_free_group +_uv_os_free_passwd +_uv_os_get_group +_uv_os_get_passwd +_uv_os_get_passwd2 +_uv_os_getenv +_uv_os_gethostname _uv_os_getpid _uv_os_getppid -_dumpBtjsTrace \ No newline at end of file +_uv_os_getpriority +_uv_os_homedir +_uv_os_setenv +_uv_os_setpriority +_uv_os_tmpdir +_uv_os_uname +_uv_os_unsetenv +_uv_pipe +_uv_pipe_bind +_uv_pipe_bind2 +_uv_pipe_chmod +_uv_pipe_connect +_uv_pipe_connect2 +_uv_pipe_getpeername +_uv_pipe_getsockname +_uv_pipe_init +_uv_pipe_open +_uv_pipe_pending_count +_uv_pipe_pending_instances +_uv_pipe_pending_type +_uv_poll_init +_uv_poll_init_socket +_uv_poll_start +_uv_poll_stop +_uv_prepare_init +_uv_prepare_start +_uv_prepare_stop +_uv_print_active_handles +_uv_print_all_handles +_uv_process_get_pid +_uv_process_kill +_uv_queue_work +_uv_random +_uv_read_start +_uv_read_stop +_uv_recv_buffer_size +_uv_ref +_uv_replace_allocator +_uv_req_get_data +_uv_req_get_type +_uv_req_set_data +_uv_req_size +_uv_req_type_name +_uv_resident_set_memory +_uv_run +_uv_rwlock_destroy +_uv_rwlock_init +_uv_rwlock_rdlock +_uv_rwlock_rdunlock +_uv_rwlock_tryrdlock +_uv_rwlock_trywrlock +_uv_rwlock_wrlock +_uv_rwlock_wrunlock +_uv_sem_destroy +_uv_sem_init +_uv_sem_post +_uv_sem_trywait +_uv_sem_wait +_uv_send_buffer_size +_uv_set_process_title +_uv_setup_args +_uv_shutdown +_uv_signal_init +_uv_signal_start +_uv_signal_start_oneshot +_uv_signal_stop +_uv_sleep +_uv_socketpair +_uv_spawn +_uv_stop +_uv_stream_get_write_queue_size +_uv_stream_set_blocking +_uv_strerror +_uv_strerror_r +_uv_tcp_bind +_uv_tcp_close_reset +_uv_tcp_connect +_uv_tcp_getpeername +_uv_tcp_getsockname +_uv_tcp_init +_uv_tcp_init_ex +_uv_tcp_keepalive +_uv_tcp_nodelay +_uv_tcp_open +_uv_tcp_simultaneous_accepts +_uv_thread_create +_uv_thread_create_ex +_uv_thread_detach +_uv_thread_equal +_uv_thread_getaffinity +_uv_thread_getcpu +_uv_thread_getname +_uv_thread_getpriority +_uv_thread_join +_uv_thread_self +_uv_thread_setaffinity +_uv_thread_setname +_uv_thread_setpriority +_uv_timer_again +_uv_timer_get_due_in +_uv_timer_get_repeat +_uv_timer_init +_uv_timer_set_repeat +_uv_timer_start +_uv_timer_stop +_uv_translate_sys_error +_uv_try_write +_uv_try_write2 +_uv_tty_get_vterm_state +_uv_tty_get_winsize +_uv_tty_init +_uv_tty_reset_mode +_uv_tty_set_mode +_uv_tty_set_vterm_state +_uv_udp_bind +_uv_udp_connect +_uv_udp_get_send_queue_count +_uv_udp_get_send_queue_size +_uv_udp_getpeername +_uv_udp_getsockname +_uv_udp_init +_uv_udp_init_ex +_uv_udp_open +_uv_udp_recv_start +_uv_udp_recv_stop +_uv_udp_send +_uv_udp_set_broadcast +_uv_udp_set_membership +_uv_udp_set_multicast_interface +_uv_udp_set_multicast_loop +_uv_udp_set_multicast_ttl +_uv_udp_set_source_membership +_uv_udp_set_ttl +_uv_udp_try_send +_uv_udp_try_send2 +_uv_udp_using_recvmmsg +_uv_unref +_uv_update_time +_uv_uptime +_uv_utf16_length_as_wtf8 +_uv_utf16_to_wtf8 +_uv_version +_uv_version_string +_uv_walk +_uv_write +_uv_write2 +_uv_wtf8_length_as_utf16 +_uv_wtf8_to_utf16 diff --git a/test/napi/uv-stub-stuff/good_plugin.c b/test/napi/uv-stub-stuff/good_plugin.c new file mode 100644 index 0000000000..fd86ba83c7 --- /dev/null +++ b/test/napi/uv-stub-stuff/good_plugin.c @@ -0,0 +1,18 @@ +#include +#include + +#include +#include +#include + +typedef pid_t uv_pid_t; +uv_pid_t uv_os_getpid(); + +napi_value Init(napi_env env, napi_value exports) { + uv_pid_t pid = uv_os_getpid(); + printf("%d\n", pid); + + return NULL; +} + +NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) diff --git a/test/napi/uv-stub-stuff/plugin.c b/test/napi/uv-stub-stuff/plugin.c new file mode 100644 index 0000000000..4e7d38d094 --- /dev/null +++ b/test/napi/uv-stub-stuff/plugin.c @@ -0,0 +1,3197 @@ + // GENERATED CODE ... NO TOUCHY!! + #include + +#include +#include +#include +#include +#include + +napi_value call_uv_func(napi_env env, napi_callback_info info) { + napi_status status; + + size_t argc = 2; + napi_value args[2]; + status = napi_get_cb_info(env, info, &argc, args, NULL, NULL); + if (status != napi_ok) { + napi_throw_error(env, NULL, "Failed to parse arguments"); + return NULL; + } + + if (argc < 1) { + napi_throw_error(env, NULL, "Wrong number of arguments"); + return NULL; + } + + napi_value arg = args[0]; + char buffer[256]; + size_t buffer_size = sizeof(buffer); + size_t copied; + + status = napi_get_value_string_utf8(env, arg, buffer, buffer_size, &copied); + if (status != napi_ok) { + napi_throw_error(env, NULL, "Failed to get string value"); + return NULL; + } + + buffer[copied] = '\0'; + printf("Got string: %s\n", buffer); + + +if (strcmp(buffer, "uv_accept") == 0) { + uv_stream_t * arg0; +uv_stream_t * arg1; + + uv_accept(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_async_init") == 0) { + uv_loop_t * arg0; +uv_async_t * arg1; +uv_async_cb arg2; + + uv_async_init(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_async_send") == 0) { + uv_async_t * arg0; + + uv_async_send(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_available_parallelism") == 0) { + + + uv_available_parallelism(); + return NULL; +} + + + +if (strcmp(buffer, "uv_backend_fd") == 0) { + const uv_loop_t * arg0; + + uv_backend_fd(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_backend_timeout") == 0) { + const uv_loop_t * arg0; + + uv_backend_timeout(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_barrier_destroy") == 0) { + uv_barrier_t * arg0; + + uv_barrier_destroy(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_barrier_init") == 0) { + uv_barrier_t * arg0; +unsigned int arg1; + + uv_barrier_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_barrier_wait") == 0) { + uv_barrier_t * arg0; + + uv_barrier_wait(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_buf_init") == 0) { + char * arg0; +unsigned int arg1; + + uv_buf_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_cancel") == 0) { + uv_req_t * arg0; + + uv_cancel(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_chdir") == 0) { + const char * arg0; + + uv_chdir(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_check_init") == 0) { + uv_loop_t * arg0; +uv_check_t * arg1; + + uv_check_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_check_start") == 0) { + uv_check_t * arg0; +uv_check_cb arg1; + + uv_check_start(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_check_stop") == 0) { + uv_check_t * arg0; + + uv_check_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_clock_gettime") == 0) { + uv_clock_id arg0; +uv_timespec64_t * arg1; + + uv_clock_gettime(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_close") == 0) { + uv_handle_t * arg0; +uv_close_cb arg1; + + uv_close(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_cond_broadcast") == 0) { + uv_cond_t * arg0; + + uv_cond_broadcast(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_cond_destroy") == 0) { + uv_cond_t * arg0; + + uv_cond_destroy(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_cond_init") == 0) { + uv_cond_t * arg0; + + uv_cond_init(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_cond_signal") == 0) { + uv_cond_t * arg0; + + uv_cond_signal(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_cond_timedwait") == 0) { + uv_cond_t * arg0; +uv_mutex_t * arg1; +uint64_t arg2; + + uv_cond_timedwait(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_cond_wait") == 0) { + uv_cond_t * arg0; +uv_mutex_t * arg1; + + uv_cond_wait(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_cpu_info") == 0) { + uv_cpu_info_t ** arg0; +int * arg1; + + uv_cpu_info(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_cpumask_size") == 0) { + + + uv_cpumask_size(); + return NULL; +} + + + +if (strcmp(buffer, "uv_cwd") == 0) { + char * arg0; +size_t * arg1; + + uv_cwd(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_default_loop") == 0) { + + + uv_default_loop(); + return NULL; +} + + + +if (strcmp(buffer, "uv_disable_stdio_inheritance") == 0) { + + + uv_disable_stdio_inheritance(); + return NULL; +} + + + +if (strcmp(buffer, "uv_dlclose") == 0) { + uv_lib_t * arg0; + + uv_dlclose(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_dlerror") == 0) { + const uv_lib_t * arg0; + + uv_dlerror(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_dlopen") == 0) { + const char * arg0; +uv_lib_t * arg1; + + uv_dlopen(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_dlsym") == 0) { + uv_lib_t * arg0; +const char * arg1; +void ** arg2; + + uv_dlsym(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_err_name") == 0) { + int arg0; + + uv_err_name(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_err_name_r") == 0) { + int arg0; +char * arg1; +size_t arg2; + + uv_err_name_r(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_exepath") == 0) { + char * arg0; +size_t * arg1; + + uv_exepath(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_fileno") == 0) { + const uv_handle_t * arg0; +uv_os_fd_t * arg1; + + uv_fileno(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_free_cpu_info") == 0) { + uv_cpu_info_t * arg0; +int arg1; + + uv_free_cpu_info(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_free_interface_addresses") == 0) { + uv_interface_address_t * arg0; +int arg1; + + uv_free_interface_addresses(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_freeaddrinfo") == 0) { + struct addrinfo * arg0; + + uv_freeaddrinfo(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_access") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +int arg3; +uv_fs_cb arg4; + + uv_fs_access(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_chmod") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +int arg3; +uv_fs_cb arg4; + + uv_fs_chmod(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_chown") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_uid_t arg3; +uv_gid_t arg4; +uv_fs_cb arg5; + + uv_fs_chown(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_close") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +uv_fs_cb arg3; + + uv_fs_close(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_closedir") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_dir_t * arg2; +uv_fs_cb arg3; + + uv_fs_closedir(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_copyfile") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +const char * arg3; +int arg4; +uv_fs_cb arg5; + + uv_fs_copyfile(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_event_getpath") == 0) { + uv_fs_event_t * arg0; +char * arg1; +size_t * arg2; + + uv_fs_event_getpath(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_event_init") == 0) { + uv_loop_t * arg0; +uv_fs_event_t * arg1; + + uv_fs_event_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_event_start") == 0) { + uv_fs_event_t * arg0; +uv_fs_event_cb arg1; +const char * arg2; +unsigned int arg3; + + uv_fs_event_start(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_event_stop") == 0) { + uv_fs_event_t * arg0; + + uv_fs_event_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_fchmod") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +int arg3; +uv_fs_cb arg4; + + uv_fs_fchmod(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_fchown") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +uv_uid_t arg3; +uv_gid_t arg4; +uv_fs_cb arg5; + + uv_fs_fchown(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_fdatasync") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +uv_fs_cb arg3; + + uv_fs_fdatasync(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_fstat") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +uv_fs_cb arg3; + + uv_fs_fstat(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_fsync") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +uv_fs_cb arg3; + + uv_fs_fsync(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_ftruncate") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +int64_t arg3; +uv_fs_cb arg4; + + uv_fs_ftruncate(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_futime") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +double arg3; +double arg4; +uv_fs_cb arg5; + + uv_fs_futime(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_get_path") == 0) { + const uv_fs_t * arg0; + + uv_fs_get_path(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_get_ptr") == 0) { + const uv_fs_t * arg0; + + uv_fs_get_ptr(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_get_result") == 0) { + const uv_fs_t * arg0; + + uv_fs_get_result(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_get_statbuf") == 0) { + uv_fs_t * arg0; + + uv_fs_get_statbuf(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_get_system_error") == 0) { + const uv_fs_t * arg0; + + uv_fs_get_system_error(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_get_type") == 0) { + const uv_fs_t * arg0; + + uv_fs_get_type(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_lchown") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_uid_t arg3; +uv_gid_t arg4; +uv_fs_cb arg5; + + uv_fs_lchown(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_link") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +const char * arg3; +uv_fs_cb arg4; + + uv_fs_link(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_lstat") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_lstat(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_lutime") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +double arg3; +double arg4; +uv_fs_cb arg5; + + uv_fs_lutime(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_mkdir") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +int arg3; +uv_fs_cb arg4; + + uv_fs_mkdir(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_mkdtemp") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_mkdtemp(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_mkstemp") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_mkstemp(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_open") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +int arg3; +int arg4; +uv_fs_cb arg5; + + uv_fs_open(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_opendir") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_opendir(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_poll_getpath") == 0) { + uv_fs_poll_t * arg0; +char * arg1; +size_t * arg2; + + uv_fs_poll_getpath(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_poll_init") == 0) { + uv_loop_t * arg0; +uv_fs_poll_t * arg1; + + uv_fs_poll_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_poll_start") == 0) { + uv_fs_poll_t * arg0; +uv_fs_poll_cb arg1; +const char * arg2; +unsigned int arg3; + + uv_fs_poll_start(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_poll_stop") == 0) { + uv_fs_poll_t * arg0; + + uv_fs_poll_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_read") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +const uv_buf_t *arg3; +unsigned int arg4; +int64_t arg5; +uv_fs_cb arg6; + + uv_fs_read(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_readdir") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_dir_t * arg2; +uv_fs_cb arg3; + + uv_fs_readdir(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_readlink") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_readlink(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_realpath") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_realpath(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_rename") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +const char * arg3; +uv_fs_cb arg4; + + uv_fs_rename(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_req_cleanup") == 0) { + uv_fs_t * arg0; + + uv_fs_req_cleanup(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_rmdir") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_rmdir(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_scandir") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +int arg3; +uv_fs_cb arg4; + + uv_fs_scandir(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_scandir_next") == 0) { + uv_fs_t * arg0; +uv_dirent_t * arg1; + + uv_fs_scandir_next(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_sendfile") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +uv_file arg3; +int64_t arg4; +size_t arg5; +uv_fs_cb arg6; + + uv_fs_sendfile(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_stat") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_stat(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_statfs") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_statfs(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_symlink") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +const char * arg3; +int arg4; +uv_fs_cb arg5; + + uv_fs_symlink(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_unlink") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +uv_fs_cb arg3; + + uv_fs_unlink(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_utime") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +const char * arg2; +double arg3; +double arg4; +uv_fs_cb arg5; + + uv_fs_utime(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_fs_write") == 0) { + uv_loop_t * arg0; +uv_fs_t * arg1; +uv_file arg2; +const uv_buf_t *arg3; +unsigned int arg4; +int64_t arg5; +uv_fs_cb arg6; + + uv_fs_write(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + return NULL; +} + + + +if (strcmp(buffer, "uv_get_available_memory") == 0) { + + + uv_get_available_memory(); + return NULL; +} + + + +if (strcmp(buffer, "uv_get_constrained_memory") == 0) { + + + uv_get_constrained_memory(); + return NULL; +} + + + +if (strcmp(buffer, "uv_get_free_memory") == 0) { + + + uv_get_free_memory(); + return NULL; +} + + + +if (strcmp(buffer, "uv_get_osfhandle") == 0) { + int arg0; + + uv_get_osfhandle(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_get_process_title") == 0) { + char * arg0; +size_t arg1; + + uv_get_process_title(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_get_total_memory") == 0) { + + + uv_get_total_memory(); + return NULL; +} + + + +if (strcmp(buffer, "uv_getaddrinfo") == 0) { + uv_loop_t * arg0; +uv_getaddrinfo_t * arg1; +uv_getaddrinfo_cb arg2; +const char * arg3; +const char * arg4; +const struct addrinfo * arg5; + + uv_getaddrinfo(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_getnameinfo") == 0) { + uv_loop_t * arg0; +uv_getnameinfo_t * arg1; +uv_getnameinfo_cb arg2; +const struct sockaddr * arg3; +int arg4; + + uv_getnameinfo(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_getrusage") == 0) { + uv_rusage_t * arg0; + + uv_getrusage(arg0); + return NULL; +} + + + + + +if (strcmp(buffer, "uv_gettimeofday") == 0) { + uv_timeval64_t * arg0; + + uv_gettimeofday(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_guess_handle") == 0) { + uv_file arg0; + + uv_guess_handle(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_handle_get_data") == 0) { + const uv_handle_t * arg0; + + uv_handle_get_data(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_handle_get_loop") == 0) { + const uv_handle_t * arg0; + + uv_handle_get_loop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_handle_get_type") == 0) { + const uv_handle_t * arg0; + + uv_handle_get_type(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_handle_set_data") == 0) { + uv_handle_t * arg0; +void * arg1; + + uv_handle_set_data(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_handle_size") == 0) { + uv_handle_type arg0; + + uv_handle_size(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_handle_type_name") == 0) { + uv_handle_type arg0; + + uv_handle_type_name(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_has_ref") == 0) { + const uv_handle_t * arg0; + + uv_has_ref(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_hrtime") == 0) { + + + uv_hrtime(); + return NULL; +} + + + +if (strcmp(buffer, "uv_idle_init") == 0) { + uv_loop_t * arg0; +uv_idle_t * arg1; + + uv_idle_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_idle_start") == 0) { + uv_idle_t * arg0; +uv_idle_cb arg1; + + uv_idle_start(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_idle_stop") == 0) { + uv_idle_t * arg0; + + uv_idle_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_if_indextoiid") == 0) { + unsigned int arg0; +char * arg1; +size_t * arg2; + + uv_if_indextoiid(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_if_indextoname") == 0) { + unsigned int arg0; +char * arg1; +size_t * arg2; + + uv_if_indextoname(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_inet_ntop") == 0) { + int arg0; +const void * arg1; +char * arg2; +size_t arg3; + + uv_inet_ntop(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_inet_pton") == 0) { + int arg0; +const char * arg1; +void * arg2; + + uv_inet_pton(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_interface_addresses") == 0) { + uv_interface_address_t ** arg0; +int * arg1; + + uv_interface_addresses(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_ip4_addr") == 0) { + const char * arg0; +int arg1; +struct sockaddr_in * arg2; + + uv_ip4_addr(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_ip4_name") == 0) { + const struct sockaddr_in * arg0; +char * arg1; +size_t arg2; + + uv_ip4_name(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_ip6_addr") == 0) { + const char * arg0; +int arg1; +struct sockaddr_in6 * arg2; + + uv_ip6_addr(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_ip6_name") == 0) { + const struct sockaddr_in6 * arg0; +char * arg1; +size_t arg2; + + uv_ip6_name(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_ip_name") == 0) { + const struct sockaddr * arg0; +char * arg1; +size_t arg2; + + uv_ip_name(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_is_active") == 0) { + const uv_handle_t * arg0; + + uv_is_active(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_is_closing") == 0) { + const uv_handle_t * arg0; + + uv_is_closing(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_is_readable") == 0) { + const uv_stream_t * arg0; + + uv_is_readable(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_is_writable") == 0) { + const uv_stream_t * arg0; + + uv_is_writable(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_key_create") == 0) { + uv_key_t * arg0; + + uv_key_create(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_key_delete") == 0) { + uv_key_t * arg0; + + uv_key_delete(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_key_get") == 0) { + uv_key_t * arg0; + + uv_key_get(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_key_set") == 0) { + uv_key_t * arg0; +void * arg1; + + uv_key_set(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_kill") == 0) { + int arg0; +int arg1; + + uv_kill(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_library_shutdown") == 0) { + + + uv_library_shutdown(); + return NULL; +} + + + +if (strcmp(buffer, "uv_listen") == 0) { + uv_stream_t * arg0; +int arg1; +uv_connection_cb arg2; + + uv_listen(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_loadavg") == 0) { + double *arg0; + + uv_loadavg(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_alive") == 0) { + const uv_loop_t * arg0; + + uv_loop_alive(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_close") == 0) { + uv_loop_t * arg0; + + uv_loop_close(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_configure") == 0) { + uv_loop_t * arg0; +uv_loop_option arg1; + + uv_loop_configure(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_delete") == 0) { + uv_loop_t * arg0; + + uv_loop_delete(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_fork") == 0) { + uv_loop_t * arg0; + + uv_loop_fork(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_get_data") == 0) { + const uv_loop_t * arg0; + + uv_loop_get_data(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_init") == 0) { + uv_loop_t * arg0; + + uv_loop_init(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_new") == 0) { + + + uv_loop_new(); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_set_data") == 0) { + uv_loop_t * arg0; +void * arg1; + + uv_loop_set_data(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_loop_size") == 0) { + + + uv_loop_size(); + return NULL; +} + + + +if (strcmp(buffer, "uv_metrics_idle_time") == 0) { + uv_loop_t * arg0; + + uv_metrics_idle_time(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_metrics_info") == 0) { + uv_loop_t * arg0; +uv_metrics_t * arg1; + + uv_metrics_info(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_mutex_destroy") == 0) { + uv_mutex_t * arg0; + + uv_mutex_destroy(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_mutex_init") == 0) { + uv_mutex_t * arg0; + + uv_mutex_init(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_mutex_init_recursive") == 0) { + uv_mutex_t * arg0; + + uv_mutex_init_recursive(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_mutex_lock") == 0) { + uv_mutex_t * arg0; + + uv_mutex_lock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_mutex_trylock") == 0) { + uv_mutex_t * arg0; + + uv_mutex_trylock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_mutex_unlock") == 0) { + uv_mutex_t * arg0; + + uv_mutex_unlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_now") == 0) { + const uv_loop_t * arg0; + + uv_now(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_once") == 0) { + uv_once_t * arg0; +void (*arg1)(void); + + uv_once(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_open_osfhandle") == 0) { + uv_os_fd_t arg0; + + uv_open_osfhandle(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_environ") == 0) { + uv_env_item_t ** arg0; +int * arg1; + + uv_os_environ(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_free_environ") == 0) { + uv_env_item_t * arg0; +int arg1; + + uv_os_free_environ(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_free_group") == 0) { + uv_group_t * arg0; + + uv_os_free_group(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_free_passwd") == 0) { + uv_passwd_t * arg0; + + uv_os_free_passwd(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_get_group") == 0) { + uv_group_t * arg0; +uv_uid_t arg1; + + uv_os_get_group(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_get_passwd") == 0) { + uv_passwd_t * arg0; + + uv_os_get_passwd(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_get_passwd2") == 0) { + uv_passwd_t * arg0; +uv_uid_t arg1; + + uv_os_get_passwd2(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_getenv") == 0) { + const char * arg0; +char * arg1; +size_t * arg2; + + uv_os_getenv(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_gethostname") == 0) { + char * arg0; +size_t * arg1; + + uv_os_gethostname(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_getpriority") == 0) { + uv_pid_t arg0; +int * arg1; + + uv_os_getpriority(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_homedir") == 0) { + char * arg0; +size_t * arg1; + + uv_os_homedir(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_setenv") == 0) { + const char * arg0; +const char * arg1; + + uv_os_setenv(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_setpriority") == 0) { + uv_pid_t arg0; +int arg1; + + uv_os_setpriority(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_tmpdir") == 0) { + char * arg0; +size_t * arg1; + + uv_os_tmpdir(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_uname") == 0) { + uv_utsname_t * arg0; + + uv_os_uname(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_os_unsetenv") == 0) { + const char * arg0; + + uv_os_unsetenv(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe") == 0) { + uv_file *arg0; +int arg1; +int arg2; + + uv_pipe(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_bind") == 0) { + uv_pipe_t * arg0; +const char * arg1; + + uv_pipe_bind(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_bind2") == 0) { + uv_pipe_t * arg0; +const char * arg1; +size_t arg2; +unsigned int arg3; + + uv_pipe_bind2(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_chmod") == 0) { + uv_pipe_t * arg0; +int arg1; + + uv_pipe_chmod(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_connect") == 0) { + uv_connect_t * arg0; +uv_pipe_t * arg1; +const char * arg2; +uv_connect_cb arg3; + + uv_pipe_connect(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_connect2") == 0) { + uv_connect_t * arg0; +uv_pipe_t * arg1; +const char * arg2; +size_t arg3; +unsigned int arg4; +uv_connect_cb arg5; + + uv_pipe_connect2(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_getpeername") == 0) { + const uv_pipe_t * arg0; +char * arg1; +size_t * arg2; + + uv_pipe_getpeername(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_getsockname") == 0) { + const uv_pipe_t * arg0; +char * arg1; +size_t * arg2; + + uv_pipe_getsockname(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_init") == 0) { + uv_loop_t * arg0; +uv_pipe_t * arg1; +int arg2; + + uv_pipe_init(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_open") == 0) { + uv_pipe_t * arg0; +uv_file arg1; + + uv_pipe_open(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_pending_count") == 0) { + uv_pipe_t * arg0; + + uv_pipe_pending_count(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_pending_instances") == 0) { + uv_pipe_t * arg0; +int arg1; + + uv_pipe_pending_instances(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_pipe_pending_type") == 0) { + uv_pipe_t * arg0; + + uv_pipe_pending_type(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_poll_init") == 0) { + uv_loop_t * arg0; +uv_poll_t * arg1; +int arg2; + + uv_poll_init(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_poll_init_socket") == 0) { + uv_loop_t * arg0; +uv_poll_t * arg1; +uv_os_sock_t arg2; + + uv_poll_init_socket(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_poll_start") == 0) { + uv_poll_t * arg0; +int arg1; +uv_poll_cb arg2; + + uv_poll_start(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_poll_stop") == 0) { + uv_poll_t * arg0; + + uv_poll_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_prepare_init") == 0) { + uv_loop_t * arg0; +uv_prepare_t * arg1; + + uv_prepare_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_prepare_start") == 0) { + uv_prepare_t * arg0; +uv_prepare_cb arg1; + + uv_prepare_start(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_prepare_stop") == 0) { + uv_prepare_t * arg0; + + uv_prepare_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_print_active_handles") == 0) { + uv_loop_t * arg0; +FILE * arg1; + + uv_print_active_handles(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_print_all_handles") == 0) { + uv_loop_t * arg0; +FILE * arg1; + + uv_print_all_handles(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_process_get_pid") == 0) { + const uv_process_t * arg0; + + uv_process_get_pid(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_process_kill") == 0) { + uv_process_t * arg0; +int arg1; + + uv_process_kill(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_queue_work") == 0) { + uv_loop_t * arg0; +uv_work_t * arg1; +uv_work_cb arg2; +uv_after_work_cb arg3; + + uv_queue_work(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_random") == 0) { + uv_loop_t * arg0; +uv_random_t * arg1; +void * arg2; +size_t arg3; +unsigned arg4; +uv_random_cb arg5; + + uv_random(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_read_start") == 0) { + uv_stream_t * arg0; +uv_alloc_cb arg1; +uv_read_cb arg2; + + uv_read_start(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_read_stop") == 0) { + uv_stream_t * arg0; + + uv_read_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_recv_buffer_size") == 0) { + uv_handle_t * arg0; +int * arg1; + + uv_recv_buffer_size(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_ref") == 0) { + uv_handle_t * arg0; + + uv_ref(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_replace_allocator") == 0) { + uv_malloc_func arg0; +uv_realloc_func arg1; +uv_calloc_func arg2; +uv_free_func arg3; + + uv_replace_allocator(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_req_get_data") == 0) { + const uv_req_t * arg0; + + uv_req_get_data(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_req_get_type") == 0) { + const uv_req_t * arg0; + + uv_req_get_type(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_req_set_data") == 0) { + uv_req_t * arg0; +void * arg1; + + uv_req_set_data(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_req_size") == 0) { + uv_req_type arg0; + + uv_req_size(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_req_type_name") == 0) { + uv_req_type arg0; + + uv_req_type_name(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_resident_set_memory") == 0) { + size_t * arg0; + + uv_resident_set_memory(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_run") == 0) { + uv_loop_t * arg0; +uv_run_mode arg1; + + uv_run(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_destroy") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_destroy(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_init") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_init(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_rdlock") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_rdlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_rdunlock") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_rdunlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_tryrdlock") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_tryrdlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_trywrlock") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_trywrlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_wrlock") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_wrlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_rwlock_wrunlock") == 0) { + uv_rwlock_t * arg0; + + uv_rwlock_wrunlock(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_sem_destroy") == 0) { + uv_sem_t * arg0; + + uv_sem_destroy(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_sem_init") == 0) { + uv_sem_t * arg0; +unsigned int arg1; + + uv_sem_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_sem_post") == 0) { + uv_sem_t * arg0; + + uv_sem_post(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_sem_trywait") == 0) { + uv_sem_t * arg0; + + uv_sem_trywait(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_sem_wait") == 0) { + uv_sem_t * arg0; + + uv_sem_wait(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_send_buffer_size") == 0) { + uv_handle_t * arg0; +int * arg1; + + uv_send_buffer_size(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_set_process_title") == 0) { + const char * arg0; + + uv_set_process_title(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_setup_args") == 0) { + int argc;; +char **argv;; + + uv_setup_args(argc, argv); + return NULL; +} + + + +if (strcmp(buffer, "uv_shutdown") == 0) { + uv_shutdown_t * arg0; +uv_stream_t * arg1; +uv_shutdown_cb arg2; + + uv_shutdown(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_signal_init") == 0) { + uv_loop_t * arg0; +uv_signal_t * arg1; + + uv_signal_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_signal_start") == 0) { + uv_signal_t * arg0; +uv_signal_cb arg1; +int arg2; + + uv_signal_start(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_signal_start_oneshot") == 0) { + uv_signal_t * arg0; +uv_signal_cb arg1; +int arg2; + + uv_signal_start_oneshot(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_signal_stop") == 0) { + uv_signal_t * arg0; + + uv_signal_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_sleep") == 0) { + unsigned int arg0; + + uv_sleep(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_socketpair") == 0) { + int arg0; +int arg1; +uv_os_sock_t *arg2; +int arg3; +int arg4; + + uv_socketpair(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_spawn") == 0) { + uv_loop_t * arg0; +uv_process_t * arg1; +const uv_process_options_t * arg2; + + uv_spawn(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_stop") == 0) { + uv_loop_t * arg0; + + uv_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_stream_get_write_queue_size") == 0) { + const uv_stream_t * arg0; + + uv_stream_get_write_queue_size(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_stream_set_blocking") == 0) { + uv_stream_t * arg0; +int arg1; + + uv_stream_set_blocking(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_strerror") == 0) { + int arg0; + + uv_strerror(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_strerror_r") == 0) { + int arg0; +char * arg1; +size_t arg2; + + uv_strerror_r(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_bind") == 0) { + uv_tcp_t * arg0; +const struct sockaddr * arg1; +unsigned int arg2; + + uv_tcp_bind(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_close_reset") == 0) { + uv_tcp_t * arg0; +uv_close_cb arg1; + + uv_tcp_close_reset(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_connect") == 0) { + uv_connect_t * arg0; +uv_tcp_t * arg1; +const struct sockaddr * arg2; +uv_connect_cb arg3; + + uv_tcp_connect(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_getpeername") == 0) { + const uv_tcp_t * arg0; +struct sockaddr * arg1; +int * arg2; + + uv_tcp_getpeername(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_getsockname") == 0) { + const uv_tcp_t * arg0; +struct sockaddr * arg1; +int * arg2; + + uv_tcp_getsockname(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_init") == 0) { + uv_loop_t * arg0; +uv_tcp_t * arg1; + + uv_tcp_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_init_ex") == 0) { + uv_loop_t * arg0; +uv_tcp_t * arg1; +unsigned int arg2; + + uv_tcp_init_ex(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_keepalive") == 0) { + uv_tcp_t * arg0; +int arg1; +unsigned int arg2; + + uv_tcp_keepalive(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_nodelay") == 0) { + uv_tcp_t * arg0; +int arg1; + + uv_tcp_nodelay(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_open") == 0) { + uv_tcp_t * arg0; +uv_os_sock_t arg1; + + uv_tcp_open(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_tcp_simultaneous_accepts") == 0) { + uv_tcp_t * arg0; +int arg1; + + uv_tcp_simultaneous_accepts(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_thread_create") == 0) { + uv_thread_t * arg0; +uv_thread_cb arg1; +void * arg2; + + uv_thread_create(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_thread_create_ex") == 0) { + uv_thread_t * arg0; +const uv_thread_options_t * arg1; +uv_thread_cb arg2; +void * arg3; + + uv_thread_create_ex(arg0, arg1, arg2, arg3); + return NULL; +} + + + + + +if (strcmp(buffer, "uv_thread_equal") == 0) { + const uv_thread_t * arg0; +const uv_thread_t * arg1; + + uv_thread_equal(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_thread_getaffinity") == 0) { + uv_thread_t * arg0; +char * arg1; +size_t arg2; + + uv_thread_getaffinity(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_thread_getcpu") == 0) { + + + uv_thread_getcpu(); + return NULL; +} + + + + + + + +if (strcmp(buffer, "uv_thread_join") == 0) { + uv_thread_t * arg0; + + uv_thread_join(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_thread_self") == 0) { + + + uv_thread_self(); + return NULL; +} + + + +if (strcmp(buffer, "uv_thread_setaffinity") == 0) { + uv_thread_t * arg0; +char * arg1; +char * arg2; +size_t arg3; + + uv_thread_setaffinity(arg0, arg1, arg2, arg3); + return NULL; +} + + + + + + + +if (strcmp(buffer, "uv_timer_again") == 0) { + uv_timer_t * arg0; + + uv_timer_again(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_timer_get_due_in") == 0) { + const uv_timer_t * arg0; + + uv_timer_get_due_in(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_timer_get_repeat") == 0) { + const uv_timer_t * arg0; + + uv_timer_get_repeat(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_timer_init") == 0) { + uv_loop_t * arg0; +uv_timer_t * arg1; + + uv_timer_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_timer_set_repeat") == 0) { + uv_timer_t * arg0; +uint64_t arg1; + + uv_timer_set_repeat(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_timer_start") == 0) { + uv_timer_t * arg0; +uv_timer_cb arg1; +uint64_t arg2; +uint64_t arg3; + + uv_timer_start(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_timer_stop") == 0) { + uv_timer_t * arg0; + + uv_timer_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_translate_sys_error") == 0) { + int arg0; + + uv_translate_sys_error(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_try_write") == 0) { + uv_stream_t * arg0; +const uv_buf_t *arg1; +unsigned int arg2; + + uv_try_write(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_try_write2") == 0) { + uv_stream_t * arg0; +const uv_buf_t *arg1; +unsigned int arg2; +uv_stream_t * arg3; + + uv_try_write2(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_tty_get_vterm_state") == 0) { + uv_tty_vtermstate_t * arg0; + + uv_tty_get_vterm_state(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_tty_get_winsize") == 0) { + uv_tty_t * arg0; +int * arg1; +int * arg2; + + uv_tty_get_winsize(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_tty_init") == 0) { + uv_loop_t * arg0; +uv_tty_t * arg1; +uv_file arg2; +int arg3; + + uv_tty_init(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_tty_set_mode") == 0) { + uv_tty_t * arg0; +uv_tty_mode_t arg1; + + uv_tty_set_mode(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_tty_set_vterm_state") == 0) { + uv_tty_vtermstate_t arg0; + + uv_tty_set_vterm_state(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_bind") == 0) { + uv_udp_t * arg0; +const struct sockaddr * arg1; +unsigned int arg2; + + uv_udp_bind(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_connect") == 0) { + uv_udp_t * arg0; +const struct sockaddr * arg1; + + uv_udp_connect(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_get_send_queue_count") == 0) { + const uv_udp_t * arg0; + + uv_udp_get_send_queue_count(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_get_send_queue_size") == 0) { + const uv_udp_t * arg0; + + uv_udp_get_send_queue_size(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_getpeername") == 0) { + const uv_udp_t * arg0; +struct sockaddr * arg1; +int * arg2; + + uv_udp_getpeername(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_getsockname") == 0) { + const uv_udp_t * arg0; +struct sockaddr * arg1; +int * arg2; + + uv_udp_getsockname(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_init") == 0) { + uv_loop_t * arg0; +uv_udp_t * arg1; + + uv_udp_init(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_init_ex") == 0) { + uv_loop_t * arg0; +uv_udp_t * arg1; +unsigned int arg2; + + uv_udp_init_ex(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_open") == 0) { + uv_udp_t * arg0; +uv_os_sock_t arg1; + + uv_udp_open(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_recv_start") == 0) { + uv_udp_t * arg0; +uv_alloc_cb arg1; +uv_udp_recv_cb arg2; + + uv_udp_recv_start(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_recv_stop") == 0) { + uv_udp_t * arg0; + + uv_udp_recv_stop(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_send") == 0) { + uv_udp_send_t * arg0; +uv_udp_t * arg1; +const uv_buf_t *arg2; +unsigned int arg3; +const struct sockaddr * arg4; +uv_udp_send_cb arg5; + + uv_udp_send(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_broadcast") == 0) { + uv_udp_t * arg0; +int arg1; + + uv_udp_set_broadcast(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_membership") == 0) { + uv_udp_t * arg0; +const char * arg1; +const char * arg2; +uv_membership arg3; + + uv_udp_set_membership(arg0, arg1, arg2, arg3); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_multicast_interface") == 0) { + uv_udp_t * arg0; +const char * arg1; + + uv_udp_set_multicast_interface(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_multicast_loop") == 0) { + uv_udp_t * arg0; +int arg1; + + uv_udp_set_multicast_loop(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_multicast_ttl") == 0) { + uv_udp_t * arg0; +int arg1; + + uv_udp_set_multicast_ttl(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_source_membership") == 0) { + uv_udp_t * arg0; +const char * arg1; +const char * arg2; +const char * arg3; +uv_membership arg4; + + uv_udp_set_source_membership(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_set_ttl") == 0) { + uv_udp_t * arg0; +int arg1; + + uv_udp_set_ttl(arg0, arg1); + return NULL; +} + + + +if (strcmp(buffer, "uv_udp_try_send") == 0) { + uv_udp_t * arg0; +const uv_buf_t *arg1; +unsigned int arg2; +const struct sockaddr * arg3; + + uv_udp_try_send(arg0, arg1, arg2, arg3); + return NULL; +} + + + + + +if (strcmp(buffer, "uv_udp_using_recvmmsg") == 0) { + const uv_udp_t * arg0; + + uv_udp_using_recvmmsg(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_unref") == 0) { + uv_handle_t * arg0; + + uv_unref(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_update_time") == 0) { + uv_loop_t * arg0; + + uv_update_time(arg0); + return NULL; +} + + + +if (strcmp(buffer, "uv_uptime") == 0) { + double * arg0; + + uv_uptime(arg0); + return NULL; +} + + + + + + + +if (strcmp(buffer, "uv_version") == 0) { + + + uv_version(); + return NULL; +} + + + +if (strcmp(buffer, "uv_version_string") == 0) { + + + uv_version_string(); + return NULL; +} + + + +if (strcmp(buffer, "uv_walk") == 0) { + uv_loop_t * arg0; +uv_walk_cb arg1; +void * arg2; + + uv_walk(arg0, arg1, arg2); + return NULL; +} + + + +if (strcmp(buffer, "uv_write") == 0) { + uv_write_t * arg0; +uv_stream_t * arg1; +const uv_buf_t *arg2; +unsigned int arg3; +uv_write_cb arg4; + + uv_write(arg0, arg1, arg2, arg3, arg4); + return NULL; +} + + + +if (strcmp(buffer, "uv_write2") == 0) { + uv_write_t * arg0; +uv_stream_t * arg1; +const uv_buf_t *arg2; +unsigned int arg3; +uv_stream_t * arg4; +uv_write_cb arg5; + + uv_write2(arg0, arg1, arg2, arg3, arg4, arg5); + return NULL; +} + + + + + + + napi_throw_error(env, NULL, "Function not found"); + + return NULL; +} + +napi_value Init(napi_env env, napi_value exports) { + napi_status status; + napi_value fn_call_uv_func; + + // Register call_uv_func function + status = + napi_create_function(env, NULL, 0, call_uv_func, NULL, &fn_call_uv_func); + if (status != napi_ok) { + napi_throw_error(env, NULL, "Failed to create call_uv_func function"); + return NULL; + } + + status = napi_set_named_property(env, exports, "callUVFunc", fn_call_uv_func); + if (status != napi_ok) { + napi_throw_error(env, NULL, + "Failed to add call_uv_func function to exports"); + return NULL; + } + + return exports; +} + +NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) diff --git a/test/napi/uv_stub.test.ts b/test/napi/uv_stub.test.ts new file mode 100644 index 0000000000..17cc906251 --- /dev/null +++ b/test/napi/uv_stub.test.ts @@ -0,0 +1,92 @@ +import { beforeAll, describe, expect, afterEach, test } from "bun:test"; +import path from "node:path"; +import { bunEnv, bunExe, makeTree, tempDirWithFiles, isWindows } from "harness"; +import source from "./uv-stub-stuff/plugin.c"; +import goodSource from "./uv-stub-stuff/good_plugin.c"; +import { symbols, test_skipped } from "../../src/bun.js/bindings/libuv/generate_uv_posix_stubs_constants"; + +const symbols_to_test = symbols.filter(s => !test_skipped.includes(s)); + +// We use libuv on Windows +describe.if(!isWindows)("uv stubs", () => { + const cwd = process.cwd(); + let tempdir: string = ""; + let outdir: string = ""; + + beforeAll(async () => { + const files = { + "plugin.c": await Bun.file(source).text(), + "good_plugin.c": await Bun.file(goodSource).text(), + "package.json": JSON.stringify({ + "name": "fake-plugin", + "module": "index.ts", + "type": "module", + "devDependencies": { + "@types/bun": "latest", + }, + "peerDependencies": { + "typescript": "^5.0.0", + }, + "scripts": { + "build:napi": "node-gyp configure && node-gyp build", + }, + "dependencies": { + "node-gyp": "10.2.0", + }, + }), + "index.ts": `const symbol = process.argv[2]; const foo = require("./build/Release/xXx123_foo_counter_321xXx.node"); foo.callUVFunc(symbol)`, + "nocrash.ts": `const foo = require("./build/Release/good_plugin.node");console.log('HI!')`, + "binding.gyp": `{ + "targets": [ + { + "target_name": "xXx123_foo_counter_321xXx", + "sources": [ "plugin.c" ], + "include_dirs": [ ".", "./libuv" ], + "cflags": ["-fPIC"], + "ldflags": ["-Wl,--export-dynamic"] + }, + { + "target_name": "good_plugin", + "sources": [ "good_plugin.c" ], + "include_dirs": [ ".", "./libuv" ], + "cflags": ["-fPIC"], + "ldflags": ["-Wl,--export-dynamic"] + } + ] +} +`, + }; + + tempdir = tempDirWithFiles("native-plugins", files); + + await makeTree(tempdir, files); + outdir = path.join(tempdir, "dist"); + + process.chdir(tempdir); + + const libuvDir = path.join(__dirname, "../../src/bun.js/bindings/libuv"); + await Bun.$`cp -R ${libuvDir} ${path.join(tempdir, "libuv")}`; + await Bun.$`${bunExe()} i && ${bunExe()} build:napi`.env(bunEnv).cwd(tempdir); + console.log("tempdir:", tempdir); + }); + + afterEach(async () => { + process.chdir(cwd); + }); + + for (const symbol of symbols_to_test) { + test(`should crash when calling unsupported uv functions: ${symbol}`, async () => { + console.log("GO:", symbol); + const { stderr } = await Bun.$`${bunExe()} run index.ts ${symbol}`.cwd(tempdir).throws(false).quiet(); + const stderrStr = stderr.toString(); + expect(stderrStr).toContain("Bun encountered a crash when running a NAPI module that tried to call"); + expect(stderrStr).toContain(symbol); + }); + } + + test("should not crash when calling supported uv functions", async () => { + const { stdout, exitCode } = await Bun.$`${bunExe()} run nocrash.ts`.cwd(tempdir).throws(false).quiet(); + expect(exitCode).toBe(0); + expect(stdout.toString()).toContain("HI!"); + }); +});