koffi 2.8.8 → 2.8.10

package/vendor/node-api-headers/scripts/update-headers.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const { writeFile } = require('fs/promises');
+const { Readable } = require('stream');
+const { resolve } = require('path');
+const { parseArgs } = require('util')
+const { createInterface } = require('readline');
+const { inspect } = require('util');
+const { runClang } = require('./clang-utils');
+
+/**
+ * @returns {Promise<string>} Version string, eg. `'v19.6.0'`.
+ */
+async function getLatestReleaseVersion() {
+    const response = await fetch('https://nodejs.org/download/release/index.json');
+    const json = await response.json();
+    return json[0].version;
+}
+
+/**
+ * @param {NodeJS.ReadableStream} stream
+ * @param {string} destination
+ * @param {boolean} verbose
+ * @returns {Promise<void>} The `writeFile` Promise.
+ */
+function removeExperimentals(stream, destination, verbose = false) {
+    return new Promise((resolve, reject) => {
+        const debug = (...args) => {
+            if (verbose) {
+                console.log(...args);
+            }
+        };
+        const rl = createInterface(stream);
+
+        /** @type {Array<'write' | 'ignore'>} */
+        let mode = ['write'];
+
+        /** @type {Array<string>} */
+        const macroStack = [];
+
+        /** @type {RegExpMatchArray | null} */
+        let matches;
+
+        let lineNumber = 0;
+        let toWrite = '';
+
+        rl.on('line', function lineHandler(line) {
+            ++lineNumber;
+            if (matches = line.match(/^\s*#if(n)?def\s+([A-Za-z_][A-Za-z0-9_]*)/)) {
+                const negated = Boolean(matches[1]);
+                const identifier = matches[2];
+                macroStack.push(identifier);
+
+                debug(`Line ${lineNumber} Pushed ${identifier}`);
+
+                if (identifier === 'NAPI_EXPERIMENTAL') {
+                    if (negated) {
+                        mode.push('write');
+                    } else {
+                        mode.push('ignore');
+                    }
+                    return;
+                } else {
+                    mode.push('write');
+                }
+
+            }
+            else if (matches = line.match(/^\s*#if\s+(.+)$/)) {
+                const identifier = matches[1];
+                macroStack.push(identifier);
+                mode.push('write');
+
+                debug(`Line ${lineNumber} Pushed ${identifier}`);
+            }
+            else if (line.match(/^#else(?:\s+|$)/)) {
+                const identifier = macroStack[macroStack.length - 1];
+
+                debug(`Line ${lineNumber} Peeked ${identifier}`);
+
+                if (!identifier) {
+                    rl.off('line', lineHandler);
+                    reject(new Error(`Macro stack is empty handling #else on line ${lineNumber}`));
+                    return;
+                }
+
+                if (identifier === 'NAPI_EXPERIMENTAL') {
+                    const lastMode = mode[mode.length - 1];
+                    mode[mode.length - 1] = (lastMode === 'ignore') ? 'write' : 'ignore';
+                    return;
+                }
+            }
+            else if (line.match(/^\s*#endif(?:\s+|$)/)) {
+                const identifier = macroStack.pop();
+                mode.pop();
+
+                debug(`Line ${lineNumber} Popped ${identifier}`);
+
+                if (!identifier) {
+                    rl.off('line', lineHandler);
+                    reject(new Error(`Macro stack is empty handling #endif on line ${lineNumber}`));
+                }
+
+                if (identifier === 'NAPI_EXPERIMENTAL') {
+                    return;
+                }
+            }
+
+            if (mode.length === 0) {
+                rl.off('line', lineHandler);
+                reject(new Error(`Write mode empty handling #endif on line ${lineNumber}`));
+                return;
+            }
+
+            if (mode[mode.length - 1] === 'write') {
+                toWrite += `${line}\n`;
+            }
+        });
+
+        rl.on('close', () => {
+            if (macroStack.length > 0) {
+                reject(new Error(`Macro stack is not empty at EOF: ${inspect(macroStack)}`));
+            }
+            else if (mode.length > 1) {
+                reject(new Error(`Write mode greater than 1 at EOF: ${inspect(mode)}`));
+            }
+            else if (toWrite.match(/^\s*#if(?:n)?def\s+NAPI_EXPERIMENTAL/m)) {
+                reject(new Error(`Output has match for NAPI_EXPERIMENTAL`));
+            }
+            else {
+                resolve(writeFile(destination, toWrite));
+            }
+        });
+    });
+}
+
+/**
+ * Validate syntax for a file using clang.
+ * @param {string} path Path for file to validate with clang.
+ */
+async function validateSyntax(path) {
+    try { 
+        await runClang(['-fsyntax-only', path]);
+    } catch (e) {
+        throw new Error(`Syntax validation failed for ${path}: ${e}`);
+    }
+}
+
+async function main() {
+    const { values: { tag, verbose } } = parseArgs({
+        options: {
+            tag: {
+                type: 'string',
+                short: 't',
+                default: await getLatestReleaseVersion()
+            },
+            verbose: {
+                type: 'boolean',
+                short: 'v',
+            },
+        },
+    });
+
+    console.log(`Update headers from nodejs/node tag ${tag}`);
+
+    const files = ['js_native_api_types.h', 'js_native_api.h', 'node_api_types.h', 'node_api.h'];
+
+    for (const filename of files) {
+        const url = `https://raw.githubusercontent.com/nodejs/node/${tag}/src/${filename}`;
+        const path = resolve(__dirname, '..', 'include', filename);
+
+        if (verbose) {
+            console.log(`  ${url} -> ${path}`);
+        }
+
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Fetch of ${url} returned ${response.status} ${response.statusText}`);
+        }
+
+        await removeExperimentals(Readable.fromWeb(response.body), path, verbose);
+
+        await validateSyntax(path);
+    }
+}
+
+main().catch(e => {
+    console.error(e);
+    process.exitCode = 1;
+});

package/vendor/node-api-headers/scripts/write-symbols.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const { resolve: resolvePath } = require('path');
+const { writeFile } = require('fs/promises');
+const { runClang } = require('./clang-utils');
+
+/** @typedef {{ js_native_api_symbols: string[]; node_api_symbols: string[]; }} SymbolInfo */
+
+/**
+ * @param {number} [version]
+ * @returns {Promise<SymbolInfo>}
+ */
+async function getSymbolsForVersion(version) {
+    try {
+        const { stdout } = await runClang([ '-ast-dump=json', '-fsyntax-only', '-fno-diagnostics-color', `-DNAPI_VERSION=${version}`, resolvePath(__dirname, '..', 'include', 'node_api.h')])
+
+        const ast = JSON.parse(stdout);
+
+        /** @type {SymbolInfo} */
+        const symbols = { js_native_api_symbols: [], node_api_symbols: [] };
+
+        for (const statement of ast.inner) {
+            if (statement.kind !== 'FunctionDecl') {
+                continue;
+            }
+
+            const name = statement.name;
+            const file = statement.loc.includedFrom?.file;
+
+            if (file) {
+                symbols.js_native_api_symbols.push(name);
+            } else {
+                symbols.node_api_symbols.push(name);
+            }
+        }
+
+        symbols.js_native_api_symbols.sort();
+        symbols.node_api_symbols.sort();
+
+        return symbols;
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            throw new Error('This tool requires clang to be installed.');
+        }
+        throw err;
+    }
+}
+
+/** @returns {Promise<{maxVersion: number, symbols: {[x: string]: SymbolInfo}}>} */
+async function getAllSymbols() {
+    /** @type {{[x: string]: SymbolInfo}} */
+    const allSymbols = {};
+    let version = 1;
+
+    console.log('Processing symbols from clang:')
+    while (true) {
+        const symbols = await getSymbolsForVersion(version);
+
+        if (version > 1) {
+            const previousSymbols = allSymbols[`v${version - 1}`];
+            if (previousSymbols.js_native_api_symbols.length == symbols.js_native_api_symbols.length && previousSymbols.node_api_symbols.length === symbols.node_api_symbols.length) {
+                --version;
+                break;
+            }
+        }
+        allSymbols[`v${version}`] = symbols;
+        console.log(`  v${version}: ${symbols.js_native_api_symbols.length} js_native_api_symbols, ${symbols.node_api_symbols.length} node_api_symbols`);
+        ++version;
+    }
+
+    return {
+        maxVersion: version,
+        symbols: allSymbols
+    };
+}
+
+/**
+ * @param {SymbolInfo} previousSymbols
+ * @param {SymbolInfo} currentSymbols
+ * @returns {SymbolInfo}
+ */
+function getUniqueSymbols(previousSymbols, currentSymbols) {
+    /** @type {SymbolInfo} */
+    const symbols = { js_native_api_symbols: [], node_api_symbols: [] };
+    for (const symbol of currentSymbols.js_native_api_symbols) {
+        if (!previousSymbols.js_native_api_symbols.includes(symbol)) {
+            symbols.js_native_api_symbols.push(symbol);
+        }
+    }
+    for (const symbol of currentSymbols.node_api_symbols) {
+        if (!previousSymbols.node_api_symbols.includes(symbol)) {
+            symbols.node_api_symbols.push(symbol);
+        }
+    }
+    return symbols;
+}
+
+/**
+ * @param {string[]} strings
+ */
+function joinStrings(strings, prependNewLine = false) {
+    if (strings.length === 0) return '';
+    return `${prependNewLine ? ',\n        ' : ''}'${strings.join("',\n        '")}'`;
+}
+
+async function getSymbolData() {
+    const { maxVersion, symbols } = await getAllSymbols();
+
+    let data = `'use strict'
+
+const v1 = {
+    js_native_api_symbols: [
+        ${joinStrings(symbols.v1.js_native_api_symbols)}
+    ],
+    node_api_symbols: [
+        ${joinStrings(symbols.v1.node_api_symbols)}
+    ]
+}
+`;
+
+    for (let version = 2; version <= maxVersion; ++version) {
+        const newSymbols = getUniqueSymbols(symbols[`v${version - 1}`], symbols[`v${version}`]);
+
+        data += `
+const v${version} = {
+    js_native_api_symbols: [
+        ...v${version - 1}.js_native_api_symbols${joinStrings(newSymbols.js_native_api_symbols, true)}
+    ],
+    node_api_symbols: [
+        ...v${version - 1}.node_api_symbols${joinStrings(newSymbols.node_api_symbols, true)}
+    ]
+}
+`;
+    }
+
+    data += `
+module.exports = {
+    ${new Array(maxVersion).fill(undefined).map((_, i) => `v${i + 1}`).join(',\n    ')}
+}
+`
+    return data;
+}
+
+async function main() {
+    const path = resolvePath(__dirname, '../symbols.js');
+    const data = await getSymbolData();
+    console.log(`Writing symbols to ${path}`)
+    return writeFile(path, data);
+}
+
+main().catch(e => {
+    console.error(e);
+    process.exitCode = 1;
+});

package/vendor/node-api-headers/scripts/write-win32-def.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { resolve: resolvePath, join: joinPath } = require('path');
+const { writeFile, mkdir } = require('fs/promises');
+const { symbols } = require('..');
+
+function getNodeApiDef() {
+    const symbolsSet = new Set();
+    for (const ver of Object.values(symbols)) {
+        for (const sym of ver.node_api_symbols) {
+            symbolsSet.add(sym);
+        }
+        for (const sym of ver.js_native_api_symbols) {
+            symbolsSet.add(sym);
+        }
+    }
+    return 'NAME NODE.EXE\nEXPORTS\n' + Array.from(symbolsSet).join('\n');
+}
+
+function getJsNativeApiDef() {
+    const symbolsSet = new Set();
+    for (const ver of Object.values(symbols)) {
+        for (const sym of ver.js_native_api_symbols) {
+            symbolsSet.add(sym);
+        }
+    }
+    return 'NAME NODE.EXE\nEXPORTS\n' + Array.from(symbolsSet).join('\n');
+}
+
+async function main() {
+    const def = resolvePath(__dirname, '../def'); 
+    try {
+        await mkdir(def)
+    } catch (e) {
+        if (e.code !== 'EEXIST') {
+            throw e;
+        }
+    }
+   
+    const nodeApiDefPath = joinPath(def, 'node_api.def');
+    console.log(`Writing Windows .def file to ${nodeApiDefPath}`);
+    await writeFile(nodeApiDefPath, getNodeApiDef());
+
+    const jsNativeApiDefPath = joinPath(def, 'js_native_api.def');
+    console.log(`Writing Windows .def file to ${jsNativeApiDefPath}`);
+    await writeFile(jsNativeApiDefPath, getJsNativeApiDef());
+}
+
+main().catch(e => {
+    console.error(e);
+    process.exitCode = 1;
+});

package/vendor/node-api-headers/symbols.js

@@ -0,0 +1,241 @@
+'use strict'
+
+const v1 = {
+    js_native_api_symbols: [
+        'napi_adjust_external_memory',
+        'napi_call_function',
+        'napi_close_escapable_handle_scope',
+        'napi_close_handle_scope',
+        'napi_coerce_to_bool',
+        'napi_coerce_to_number',
+        'napi_coerce_to_object',
+        'napi_coerce_to_string',
+        'napi_create_array',
+        'napi_create_array_with_length',
+        'napi_create_arraybuffer',
+        'napi_create_dataview',
+        'napi_create_double',
+        'napi_create_error',
+        'napi_create_external',
+        'napi_create_external_arraybuffer',
+        'napi_create_function',
+        'napi_create_int32',
+        'napi_create_int64',
+        'napi_create_object',
+        'napi_create_promise',
+        'napi_create_range_error',
+        'napi_create_reference',
+        'napi_create_string_latin1',
+        'napi_create_string_utf16',
+        'napi_create_string_utf8',
+        'napi_create_symbol',
+        'napi_create_type_error',
+        'napi_create_typedarray',
+        'napi_create_uint32',
+        'napi_define_class',
+        'napi_define_properties',
+        'napi_delete_element',
+        'napi_delete_property',
+        'napi_delete_reference',
+        'napi_escape_handle',
+        'napi_get_and_clear_last_exception',
+        'napi_get_array_length',
+        'napi_get_arraybuffer_info',
+        'napi_get_boolean',
+        'napi_get_cb_info',
+        'napi_get_dataview_info',
+        'napi_get_element',
+        'napi_get_global',
+        'napi_get_last_error_info',
+        'napi_get_named_property',
+        'napi_get_new_target',
+        'napi_get_null',
+        'napi_get_property',
+        'napi_get_property_names',
+        'napi_get_prototype',
+        'napi_get_reference_value',
+        'napi_get_typedarray_info',
+        'napi_get_undefined',
+        'napi_get_value_bool',
+        'napi_get_value_double',
+        'napi_get_value_external',
+        'napi_get_value_int32',
+        'napi_get_value_int64',
+        'napi_get_value_string_latin1',
+        'napi_get_value_string_utf16',
+        'napi_get_value_string_utf8',
+        'napi_get_value_uint32',
+        'napi_get_version',
+        'napi_has_element',
+        'napi_has_named_property',
+        'napi_has_own_property',
+        'napi_has_property',
+        'napi_instanceof',
+        'napi_is_array',
+        'napi_is_arraybuffer',
+        'napi_is_dataview',
+        'napi_is_error',
+        'napi_is_exception_pending',
+        'napi_is_promise',
+        'napi_is_typedarray',
+        'napi_new_instance',
+        'napi_open_escapable_handle_scope',
+        'napi_open_handle_scope',
+        'napi_reference_ref',
+        'napi_reference_unref',
+        'napi_reject_deferred',
+        'napi_remove_wrap',
+        'napi_resolve_deferred',
+        'napi_run_script',
+        'napi_set_element',
+        'napi_set_named_property',
+        'napi_set_property',
+        'napi_strict_equals',
+        'napi_throw',
+        'napi_throw_error',
+        'napi_throw_range_error',
+        'napi_throw_type_error',
+        'napi_typeof',
+        'napi_unwrap',
+        'napi_wrap'
+    ],
+    node_api_symbols: [
+        'napi_async_destroy',
+        'napi_async_init',
+        'napi_cancel_async_work',
+        'napi_create_async_work',
+        'napi_create_buffer',
+        'napi_create_buffer_copy',
+        'napi_create_external_buffer',
+        'napi_delete_async_work',
+        'napi_fatal_error',
+        'napi_get_buffer_info',
+        'napi_get_node_version',
+        'napi_is_buffer',
+        'napi_make_callback',
+        'napi_module_register',
+        'napi_queue_async_work'
+    ]
+}
+
+const v2 = {
+    js_native_api_symbols: [
+        ...v1.js_native_api_symbols
+    ],
+    node_api_symbols: [
+        ...v1.node_api_symbols,
+        'napi_get_uv_event_loop'
+    ]
+}
+
+const v3 = {
+    js_native_api_symbols: [
+        ...v2.js_native_api_symbols
+    ],
+    node_api_symbols: [
+        ...v2.node_api_symbols,
+        'napi_add_env_cleanup_hook',
+        'napi_close_callback_scope',
+        'napi_fatal_exception',
+        'napi_open_callback_scope',
+        'napi_remove_env_cleanup_hook'
+    ]
+}
+
+const v4 = {
+    js_native_api_symbols: [
+        ...v3.js_native_api_symbols
+    ],
+    node_api_symbols: [
+        ...v3.node_api_symbols,
+        'napi_acquire_threadsafe_function',
+        'napi_call_threadsafe_function',
+        'napi_create_threadsafe_function',
+        'napi_get_threadsafe_function_context',
+        'napi_ref_threadsafe_function',
+        'napi_release_threadsafe_function',
+        'napi_unref_threadsafe_function'
+    ]
+}
+
+const v5 = {
+    js_native_api_symbols: [
+        ...v4.js_native_api_symbols,
+        'napi_add_finalizer',
+        'napi_create_date',
+        'napi_get_date_value',
+        'napi_is_date'
+    ],
+    node_api_symbols: [
+        ...v4.node_api_symbols
+    ]
+}
+
+const v6 = {
+    js_native_api_symbols: [
+        ...v5.js_native_api_symbols,
+        'napi_create_bigint_int64',
+        'napi_create_bigint_uint64',
+        'napi_create_bigint_words',
+        'napi_get_all_property_names',
+        'napi_get_instance_data',
+        'napi_get_value_bigint_int64',
+        'napi_get_value_bigint_uint64',
+        'napi_get_value_bigint_words',
+        'napi_set_instance_data'
+    ],
+    node_api_symbols: [
+        ...v5.node_api_symbols
+    ]
+}
+
+const v7 = {
+    js_native_api_symbols: [
+        ...v6.js_native_api_symbols,
+        'napi_detach_arraybuffer',
+        'napi_is_detached_arraybuffer'
+    ],
+    node_api_symbols: [
+        ...v6.node_api_symbols
+    ]
+}
+
+const v8 = {
+    js_native_api_symbols: [
+        ...v7.js_native_api_symbols,
+        'napi_check_object_type_tag',
+        'napi_object_freeze',
+        'napi_object_seal',
+        'napi_type_tag_object'
+    ],
+    node_api_symbols: [
+        ...v7.node_api_symbols,
+        'napi_add_async_cleanup_hook',
+        'napi_remove_async_cleanup_hook'
+    ]
+}
+
+const v9 = {
+    js_native_api_symbols: [
+        ...v8.js_native_api_symbols,
+        'node_api_create_syntax_error',
+        'node_api_symbol_for',
+        'node_api_throw_syntax_error'
+    ],
+    node_api_symbols: [
+        ...v8.node_api_symbols,
+        'node_api_get_module_file_name'
+    ]
+}
+
+module.exports = {
+    v1,
+    v2,
+    v3,
+    v4,
+    v5,
+    v6,
+    v7,
+    v8,
+    v9
+}