@lakutata/ffi 0.0.0-stage → 3.1.2

package/dist/esm/lib/declarations/Platform.js

@@ -0,0 +1,23 @@
+/**
+ * The platform of a system and an architecture
+ * @param os
+ * @param arch
+ */
+export function platformOf(os, arch) {
+    const bits64 = !['ia32', 'arm', 'x32'].includes(arch);
+    const windows = os === 'win32';
+    return {
+        os: os,
+        arch: arch,
+        pointerSize: bits64 ? 8 : 4,
+        longSize: bits64 && !windows ? 8 : 4,
+        wcharSize: windows ? 2 : 4,
+        int64Alignment: !bits64 && !windows && arch === 'ia32' ? 4 : 8,
+        bitfields: windows ? 'msvc' : (arch === 'arm' || arch === 'arm64') && os !== 'darwin' ? 'aapcs' : 'sysv',
+        underscoredSymbols: os === 'darwin'
+    };
+}
+/**
+ * The platform the process runs on
+ */
+export const CURRENT_PLATFORM = platformOf(process.platform, process.arch);

package/dist/esm/lib/declarations/Types.js

@@ -0,0 +1,170 @@
+/**
+ * An empty set of declarations
+ */
+export function emptyDeclarations() {
+    return { types: new Map(), tags: new Map(), functions: new Map(), variables: new Map(), constants: new Map(), macros: new Map() };
+}
+export const VOID = { kind: 'primitive', name: 'void' };
+/**
+ * The size of an arithmetic type, in bytes
+ * @param name
+ * @param platform
+ */
+export function primitiveSize(name, platform) {
+    switch (name) {
+        case 'void':
+            return 0;
+        case 'bool':
+        case 'char':
+        case 'schar':
+        case 'uchar':
+        case 'int8':
+        case 'uint8':
+            return 1;
+        case 'short':
+        case 'ushort':
+        case 'int16':
+        case 'uint16':
+        case 'char16':
+            return 2;
+        case 'int':
+        case 'uint':
+        case 'int32':
+        case 'uint32':
+        case 'char32':
+        case 'float':
+            return 4;
+        case 'long':
+        case 'ulong':
+            return platform.longSize;
+        case 'longlong':
+        case 'ulonglong':
+        case 'int64':
+        case 'uint64':
+        case 'double':
+            return 8;
+        case 'size':
+        case 'ssize':
+        case 'intptr':
+        case 'uintptr':
+        case 'ptrdiff':
+            return platform.pointerSize;
+        case 'wchar':
+            return platform.wcharSize;
+    }
+}
+/**
+ * Whether an arithmetic type is signed
+ * @param name
+ * @param platform
+ */
+export function primitiveSigned(name, platform) {
+    switch (name) {
+        case 'char':
+            //char is signed but on the ARM systems other than Apple's and Microsoft's (koffi reads it as signed everywhere)
+            return true;
+        case 'schar':
+        case 'short':
+        case 'int':
+        case 'long':
+        case 'longlong':
+        case 'int8':
+        case 'int16':
+        case 'int32':
+        case 'int64':
+        case 'ssize':
+        case 'intptr':
+        case 'ptrdiff':
+        case 'float':
+        case 'double':
+            return true;
+        case 'wchar':
+            return platform.os !== 'win32';
+        default:
+            return false;
+    }
+}
+/**
+ * Whether an arithmetic type is an integer
+ * @param name
+ */
+export function primitiveInteger(name) {
+    return name !== 'void' && name !== 'float' && name !== 'double';
+}
+/**
+ * Whether an integer type is 64-bit on one of the platforms at least: its values are bigints (long is 64-bit but on
+ * Windows, size_t but on 32-bit systems)
+ * @param name
+ */
+export function primitiveBig(name) {
+    switch (name) {
+        case 'long':
+        case 'ulong':
+        case 'longlong':
+        case 'ulonglong':
+        case 'int64':
+        case 'uint64':
+        case 'size':
+        case 'ssize':
+        case 'intptr':
+        case 'uintptr':
+        case 'ptrdiff':
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * A type, as C writes it (for the messages)
+ * @param type
+ */
+export function typeText(type) {
+    switch (type.kind) {
+        case 'primitive':
+            return PRIMITIVE_TEXT[type.name];
+        case 'pointer':
+            return `${type.constTarget ? 'const ' : ''}${typeText(type.to)} *`;
+        case 'array':
+            return `${typeText(type.of)}[${type.length}]`;
+        case 'struct':
+        case 'union':
+            return `${type.kind} ${type.tag ?? '(anonymous)'}`;
+        case 'enum':
+            return `enum ${type.tag ?? '(anonymous)'}`;
+        case 'function':
+            return `${typeText(type.result)} (${type.parameters.map((parameter) => typeText(parameter.type)).concat(type.variadic ? ['...'] : []).join(', ')})`;
+    }
+}
+const PRIMITIVE_TEXT = {
+    void: 'void',
+    bool: 'bool',
+    char: 'char',
+    schar: 'signed char',
+    uchar: 'unsigned char',
+    short: 'short',
+    ushort: 'unsigned short',
+    int: 'int',
+    uint: 'unsigned int',
+    long: 'long',
+    ulong: 'unsigned long',
+    longlong: 'long long',
+    ulonglong: 'unsigned long long',
+    int8: 'int8_t',
+    uint8: 'uint8_t',
+    int16: 'int16_t',
+    uint16: 'uint16_t',
+    int32: 'int32_t',
+    uint32: 'uint32_t',
+    int64: 'int64_t',
+    uint64: 'uint64_t',
+    size: 'size_t',
+    ssize: 'ssize_t',
+    intptr: 'intptr_t',
+    uintptr: 'uintptr_t',
+    ptrdiff: 'ptrdiff_t',
+    char16: 'char16_t',
+    char32: 'char32_t',
+    wchar: 'wchar_t',
+    float: 'float',
+    double: 'double'
+};

package/dist/esm/lib/generator/CText.js

@@ -0,0 +1,129 @@
+/**
+ * The words that change nothing of what a declaration declares, removed from the declarations written
+ */
+const NOISE = new Set([
+    '__extension__', '__restrict', '__restrict__', 'restrict', '_Nullable', '_Nonnull', '_Null_unspecified', '__nullable', '__nonnull',
+    '__null_unspecified', '_Nullable_result', '__ptr32', '__ptr64', '__unaligned', '__w64'
+]);
+/**
+ * The words that can follow the parenthesis of a declarator of a pointer to a function: void (*f)(void), void (__stdcall *f)(void)
+ */
+const DECLARATOR_STARTS = new Set(['*', '__stdcall', '_stdcall', '__cdecl', '_cdecl', '__fastcall', '_fastcall', '__thiscall', '__vectorcall', '__clrcall']);
+/**
+ * The end of the balanced brackets opened at an index: the index of the closing one
+ * @param tokens
+ * @param open
+ */
+function closing(tokens, open) {
+    let depth = 0;
+    for (let index = open; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token.kind !== 'punctuator')
+            continue;
+        if (token.text === '(' || token.text === '[' || token.text === '{')
+            depth++;
+        else if ((token.text === ')' || token.text === ']' || token.text === '}') && --depth === 0)
+            return index;
+    }
+    return tokens.length - 1;
+}
+/**
+ * The tokens of a declaration without what changes nothing of what it declares: the attributes but packed and aligned,
+ * the __declspec but align, the qualifiers the parser ignores
+ * @param tokens
+ */
+export function prunedTokens(tokens) {
+    const kept = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token.kind === 'identifier' && NOISE.has(token.text))
+            continue;
+        const attribute = token.kind === 'identifier' && (token.text === '__attribute__' || token.text === '__attribute' || token.text === '__declspec');
+        if (attribute && tokens[index + 1]?.text === '(') {
+            const end = closing(tokens, index + 1);
+            const inner = tokens.slice(index + 2, end).map((part) => part.text.replace(/^__|__$/g, ''));
+            const meaningful = token.text === '__declspec' ? inner.includes('align') : inner.includes('packed') || inner.includes('aligned');
+            if (meaningful)
+                kept.push(...tokens.slice(index, end + 1));
+            index = end;
+            continue;
+        }
+        kept.push(token);
+    }
+    return kept;
+}
+/**
+ * The text of a token as C writes it
+ * @param token
+ */
+function textOf(token) {
+    if (token.kind === 'string')
+        return token.source ?? JSON.stringify(token.text);
+    if (token.kind === 'pragma')
+        return `#pragma ${token.text}`;
+    return token.text;
+}
+/**
+ * A declaration written as C, one member of a struct or a value of an enum by line
+ * @param tokens Its tokens.
+ * @param indent The indentation of a level.
+ * @returns Its lines.
+ */
+export function declarationText(tokens, indent = '    ') {
+    const lines = [];
+    let line = '';
+    //The braces open: whether each one is the body of an enum
+    const braces = [];
+    let parens = 0;
+    const breakLine = () => {
+        if (line.trim())
+            lines.push(line.replace(/\s+$/, ''));
+        line = indent.repeat(braces.length);
+    };
+    let previous;
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        const text = textOf(token);
+        if (token.kind === 'pragma') {
+            breakLine();
+            line += text;
+            breakLine();
+            previous = undefined;
+            continue;
+        }
+        const punctuator = token.kind === 'punctuator' ? token.text : undefined;
+        if (punctuator === '{') {
+            const enumBody = tokens.slice(Math.max(0, index - 2), index).some((part) => part.kind === 'identifier' && part.text === 'enum');
+            line += `${line.trim() ? ' ' : ''}{`;
+            braces.push(enumBody);
+            breakLine();
+            previous = token;
+            continue;
+        }
+        if (punctuator === '}') {
+            braces.pop();
+            breakLine();
+            line += '}';
+            previous = token;
+            continue;
+        }
+        if (punctuator === '(' || punctuator === '[')
+            parens++;
+        if (punctuator === ')' || punctuator === ']')
+            parens--;
+        const glued = !previous
+            || [',', ';', ')', ']', '['].includes(punctuator ?? '')
+            || (previous.kind === 'punctuator' && ['(', '[', '*', '~', '!'].includes(previous.text))
+            || (punctuator === '(' && (previous.kind === 'identifier' || previous.text === ')') && !DECLARATOR_STARTS.has(tokens[index + 1]?.text ?? ''))
+            || !line.trim();
+        line += `${glued ? '' : ' '}${text}`;
+        previous = token;
+        //A member of a struct, a value of an enum: one by line
+        if (braces.length && !parens && (punctuator === ';' || (punctuator === ',' && braces[braces.length - 1]))) {
+            breakLine();
+            previous = undefined;
+        }
+    }
+    breakLine();
+    return lines;
+}