@lakutata/ffi 0.0.0-stage → 3.1.2

package/dist/cjs/lib/declarations/Layout.d.ts

@@ -0,0 +1,41 @@
+import type { Platform } from './Platform.js';
+import { type CType, type Member, type RecordType } from './Types.js';
+/**
+ * Where a member of a struct is: its offset in bytes; for a bitfield, its first bit (from the start of the struct, the
+ * lowest bits first) and its width
+ */
+export interface MemberLayout {
+    readonly member: Member;
+    readonly offset: number;
+    readonly size: number;
+    readonly bitOffset?: number;
+    readonly bits?: number;
+}
+export interface RecordLayout {
+    readonly size: number;
+    readonly alignment: number;
+    readonly members: readonly MemberLayout[];
+    /**
+     * Whether it has bitfields (koffi does not lay them out: the package does)
+     */
+    readonly bitfields: boolean;
+}
+/**
+ * The size of a type, in bytes
+ * @param type
+ * @param platform
+ */
+export declare function sizeOf(type: CType, platform: Platform): number;
+/**
+ * The alignment of a type, in bytes
+ * @param type
+ * @param platform
+ */
+export declare function alignmentOf(type: CType, platform: Platform): number;
+/**
+ * The layout of a struct or of a union, as the compilers of the platform lay it out (GCC and Clang, or Microsoft's for
+ * the bitfields): the alignment of each member capped by #pragma pack, raised by its aligned attribute
+ * @param record
+ * @param platform
+ */
+export declare function layoutOf(record: RecordType, platform: Platform): RecordLayout;

package/dist/cjs/lib/declarations/Layout.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeOf = sizeOf;
+exports.alignmentOf = alignmentOf;
+exports.layoutOf = layoutOf;
+const NativeDeclarationException_js_1 = require("../../exceptions/NativeDeclarationException.js");
+const Types_js_1 = require("./Types.js");
+const layouts = new WeakMap();
+/**
+ * The size of a type, in bytes
+ * @param type
+ * @param platform
+ */
+function sizeOf(type, platform) {
+    switch (type.kind) {
+        case 'primitive':
+            return (0, Types_js_1.primitiveSize)(type.name, platform);
+        case 'pointer':
+            return platform.pointerSize;
+        case 'array':
+            return sizeOf(type.of, platform) * type.length;
+        case 'enum':
+            return (0, Types_js_1.primitiveSize)(type.base, platform);
+        case 'struct':
+        case 'union':
+            return layoutOf(type, platform).size;
+        case 'function':
+            throw new NativeDeclarationException_js_1.NativeDeclarationException(`A function has no size: ${(0, Types_js_1.typeText)(type)}`);
+    }
+}
+/**
+ * The alignment of a type, in bytes
+ * @param type
+ * @param platform
+ */
+function alignmentOf(type, platform) {
+    switch (type.kind) {
+        case 'primitive':
+        case 'enum': {
+            const size = (0, Types_js_1.primitiveSize)(type.kind === 'primitive' ? type.name : type.base, platform);
+            return size === 8 ? platform.int64Alignment : Math.max(size, 1);
+        }
+        case 'pointer':
+            return platform.pointerSize;
+        case 'array':
+            return alignmentOf(type.of, platform);
+        case 'struct':
+        case 'union':
+            return layoutOf(type, platform).alignment;
+        case 'function':
+            throw new NativeDeclarationException_js_1.NativeDeclarationException(`A function has no alignment: ${(0, Types_js_1.typeText)(type)}`);
+    }
+}
+/**
+ * Round up to a multiple
+ * @param value
+ * @param multiple
+ */
+function alignUp(value, multiple) {
+    return Math.ceil(value / multiple) * multiple;
+}
+/**
+ * The layout of a struct or of a union, as the compilers of the platform lay it out (GCC and Clang, or Microsoft's for
+ * the bitfields): the alignment of each member capped by #pragma pack, raised by its aligned attribute
+ * @param record
+ * @param platform
+ */
+function layoutOf(record, platform) {
+    let cached = layouts.get(record);
+    const found = cached?.get(platform);
+    if (found)
+        return found;
+    if (!record.members)
+        throw new NativeDeclarationException_js_1.NativeDeclarationException(`The ${record.kind} ${record.tag ?? '(anonymous)'} is declared but not defined: it is used through pointers only`);
+    const layout = record.kind === 'union' ? unionLayout(record, platform) : structLayout(record, platform);
+    if (!cached)
+        layouts.set(record, cached = new Map());
+    cached.set(platform, layout);
+    return layout;
+}
+/**
+ * The alignment of a member: its type's, raised by its aligned attribute, capped by the packing of its struct
+ * @param member
+ * @param record
+ * @param platform
+ */
+function memberAlignment(member, record, platform) {
+    const natural = Math.max(alignmentOf(member.type, platform), member.align ?? 1);
+    return record.pack ? Math.min(natural, record.pack) : natural;
+}
+/**
+ * The layout of a union: every member at 0
+ * @param record
+ * @param platform
+ */
+function unionLayout(record, platform) {
+    let size = 0;
+    let alignment = record.align ?? 1;
+    const members = [];
+    for (const member of record.members) {
+        if (member.bits !== undefined)
+            throw new NativeDeclarationException_js_1.NativeDeclarationException(`The bitfield ${member.name || '(unnamed)'} of a union is not supported`);
+        const memberSize = sizeOf(member.type, platform);
+        alignment = Math.max(alignment, memberAlignment(member, record, platform));
+        size = Math.max(size, memberSize);
+        members.push({ member: member, offset: 0, size: memberSize });
+    }
+    return { size: alignUp(size, alignment), alignment: alignment, members: members, bitfields: false };
+}
+/**
+ * The layout of a struct: the members one after the other, each at its alignment; the bitfields in the storage units of
+ * their types, by the rules of the platform
+ * @param record
+ * @param platform
+ */
+function structLayout(record, platform) {
+    let bit = 0;
+    let alignment = record.align ?? 1;
+    let bitfields = false;
+    //The storage unit of the bitfields being filled (Microsoft's rules): its offset in bytes, its size, the bits used
+    let unit;
+    const members = [];
+    for (const member of record.members) {
+        if (member.bits === undefined) {
+            unit = undefined;
+            const aligned = memberAlignment(member, record, platform);
+            const offset = alignUp(Math.ceil(bit / 8), aligned);
+            const size = sizeOf(member.type, platform);
+            members.push({ member: member, offset: offset, size: size });
+            bit = (offset + size) * 8;
+            alignment = Math.max(alignment, aligned);
+            continue;
+        }
+        bitfields = true;
+        if (record.pack !== undefined)
+            throw new NativeDeclarationException_js_1.NativeDeclarationException(`The bitfield ${member.name || '(unnamed)'} of a packed struct is not supported`);
+        if (member.type.kind !== 'primitive' && member.type.kind !== 'enum')
+            throw new NativeDeclarationException_js_1.NativeDeclarationException(`The bitfield ${member.name || '(unnamed)'} must have an integer type`);
+        const size = sizeOf(member.type, platform);
+        const typeAlignment = alignmentOf(member.type, platform);
+        const width = member.bits;
+        if (width > size * 8)
+            throw new NativeDeclarationException_js_1.NativeDeclarationException(`The bitfield ${member.name || '(unnamed)'} is wider than its type (${width} bits)`);
+        if (platform.bitfields === 'msvc') {
+            if (width === 0) {
+                //After a bitfield: ends its storage unit, the next member at the alignment of its type; ignored otherwise
+                if (unit) {
+                    bit = alignUp((unit.offset + unit.size) * 8, typeAlignment * 8);
+                    alignment = Math.max(alignment, typeAlignment);
+                }
+                unit = undefined;
+                continue;
+            }
+            if (!unit || unit.size !== size || unit.used + width > size * 8) {
+                const start = unit ? unit.offset + unit.size : Math.ceil(bit / 8);
+                unit = { offset: alignUp(start, typeAlignment), size: size, used: 0 };
+                alignment = Math.max(alignment, typeAlignment);
+            }
+            members.push({ member: member, offset: unit.offset, size: size, bitOffset: unit.offset * 8 + unit.used, bits: width });
+            unit.used += width;
+            bit = (unit.offset + unit.size) * 8;
+            continue;
+        }
+        //GCC and Clang: in the first unit of the size of its type where it fits, from the current bit. The type of an
+        //unnamed bitfield aligns the struct by the rules of ARM only
+        if (member.name || platform.bitfields === 'aapcs')
+            alignment = Math.max(alignment, typeAlignment);
+        if (width === 0) {
+            bit = alignUp(bit, typeAlignment * 8);
+            continue;
+        }
+        if ((bit % (size * 8)) + width > size * 8)
+            bit = alignUp(bit, typeAlignment * 8);
+        members.push({ member: member, offset: Math.floor(bit / (size * 8)) * size, size: size, bitOffset: bit, bits: width });
+        bit += width;
+    }
+    if (unit)
+        bit = (unit.offset + unit.size) * 8;
+    return { size: alignUp(Math.ceil(bit / 8), alignment), alignment: alignment, members: members, bitfields: bitfields };
+}

package/dist/cjs/lib/declarations/Lexer.d.ts

@@ -0,0 +1,40 @@
+import { NativeDeclarationException } from '../../exceptions/NativeDeclarationException.js';
+export type TokenKind = 'identifier' | 'number' | 'char' | 'string' | 'punctuator' | 'pragma' | 'define' | 'undef' | 'end';
+export interface Token {
+    readonly kind: TokenKind;
+    readonly text: string;
+    /**
+     * The value of an integer or of a character
+     */
+    readonly value?: bigint;
+    /**
+     * Whether a number is a floating-point one
+     */
+    readonly float?: boolean;
+    readonly line: number;
+    readonly column: number;
+    /**
+     * In a preprocessed text, the file it comes from and its line there (from the line markers)
+     */
+    readonly file?: string;
+    readonly fileLine?: number;
+    /**
+     * The text of a string as written, its quotes and escapes included
+     */
+    readonly source?: string;
+}
+/**
+ * The exception of a declaration that cannot be read, at a line and a column
+ * @param message
+ * @param line
+ * @param column
+ */
+export declare function declarationError(message: string, line: number, column: number): NativeDeclarationException;
+/**
+ * The tokens of C declarations. Comments are skipped; of the directives of the preprocessor, #pragma pack, #define and
+ * #undef are kept (as tokens holding the rest of their line), #include and the other #pragma are skipped, and the
+ * conditional ones (#if, #ifdef…) are refused: what they select is the work of a preprocessor. The line markers of a
+ * preprocessed text give each token the file and the line it comes from
+ * @param text
+ */
+export declare function tokenize(text: string): Token[];

package/dist/cjs/lib/declarations/Lexer.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declarationError = declarationError;
+exports.tokenize = tokenize;
+const NativeDeclarationException_js_1 = require("../../exceptions/NativeDeclarationException.js");
+const PUNCTUATORS = ['...', '<<=', '>>=', '<<', '>>', '<=', '>=', '==', '!=', '&&', '||', '->', '++', '--', '##', '::'];
+const SINGLE = '{}()[];,*:=+-/%&|^~!?<>.#';
+const ESCAPES = { n: 10, t: 9, r: 13, '0': 0, a: 7, b: 8, f: 12, v: 11, '\\': 92, '\'': 39, '"': 34, '?': 63, e: 27 };
+/**
+ * The directives of the preprocessor that change what is declared: the declarations given must be preprocessed
+ */
+const CONDITIONALS = ['if', 'ifdef', 'ifndef', 'elif', 'elifdef', 'elifndef', 'else', 'endif'];
+/**
+ * The end of a directive of the preprocessor: the end of its line, its continued lines and the block comments that go on
+ * past it included (not the ones inside its strings)
+ * @param text
+ * @param start
+ */
+function directiveEnd(text, start) {
+    let end = start;
+    while (end < text.length && text[end] !== '\n') {
+        const char = text[end];
+        if (char === '\\' && text[end + 1] === '\n') {
+            end += 2;
+        }
+        else if (char === '\\' && text[end + 1] === '\r' && text[end + 2] === '\n') {
+            end += 3;
+        }
+        else if (char === '/' && text[end + 1] === '*') {
+            const close = text.indexOf('*/', end + 2);
+            end = close < 0 ? text.length : close + 2;
+        }
+        else if (char === '/' && text[end + 1] === '/') {
+            while (end < text.length && text[end] !== '\n')
+                end++;
+        }
+        else if (char === '"' || char === '\'') {
+            end++;
+            while (end < text.length && text[end] !== char && text[end] !== '\n')
+                end += text[end] === '\\' ? 2 : 1;
+            if (text[end] === char)
+                end++;
+        }
+        else {
+            end++;
+        }
+    }
+    return end;
+}
+/**
+ * The text of a directive without its comments (the ones inside its strings and characters kept), its continued lines
+ * joined
+ * @param text
+ */
+function withoutComments(text) {
+    let result = '';
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === '/' && text[i + 1] === '*') {
+            const close = text.indexOf('*/', i + 2);
+            i = close < 0 ? text.length : close + 2;
+            result += ' ';
+        }
+        else if (char === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+        }
+        else if (char === '"' || char === '\'') {
+            let end = i + 1;
+            while (end < text.length && text[end] !== char && text[end] !== '\n')
+                end += text[end] === '\\' ? 2 : 1;
+            result += text.slice(i, Math.min(end + 1, text.length));
+            i = end + 1;
+        }
+        else if (char === '\\' && (text[i + 1] === '\n' || (text[i + 1] === '\r' && text[i + 2] === '\n'))) {
+            i += text[i + 1] === '\n' ? 2 : 3;
+            result += ' ';
+        }
+        else {
+            result += char;
+            i++;
+        }
+    }
+    return result.trim();
+}
+/**
+ * The offsets the lines of a text start at
+ * @param text
+ */
+function lineStartsOf(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text.charCodeAt(i) === 10)
+            starts.push(i + 1);
+    return starts;
+}
+/**
+ * Where an offset of a text is, for the messages: its line and its column (from 1)
+ * @param starts the offsets the lines start at
+ * @param offset
+ */
+function positionOf(starts, offset) {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (starts[middle] <= offset)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return { line: low + 1, column: offset - starts[low] + 1 };
+}
+/**
+ * The exception of a declaration that cannot be read, at a line and a column
+ * @param message
+ * @param line
+ * @param column
+ */
+function declarationError(message, line, column) {
+    return new NativeDeclarationException_js_1.NativeDeclarationException(`${message} (line ${line}, column ${column})`);
+}
+/**
+ * The file and the line a line marker of a preprocessor gives to the line after it: `# 12 "file.h" 2` (GCC, Clang),
+ * `#line 12 "file.h"` (Microsoft); undefined for another directive
+ * @param directive the directive, without its #
+ */
+function lineMarker(directive) {
+    const marker = directive.match(/^(?:line\s+)?(\d+)(?:\s+"((?:[^"\\]|\\.)*)")?/);
+    if (!marker)
+        return undefined;
+    return { line: Number(marker[1]), ...marker[2] !== undefined ? { file: marker[2].replace(/\\(.)/g, '$1') } : {} };
+}
+/**
+ * The tokens of C declarations. Comments are skipped; of the directives of the preprocessor, #pragma pack, #define and
+ * #undef are kept (as tokens holding the rest of their line), #include and the other #pragma are skipped, and the
+ * conditional ones (#if, #ifdef…) are refused: what they select is the work of a preprocessor. The line markers of a
+ * preprocessed text give each token the file and the line it comes from
+ * @param text
+ */
+function tokenize(text) {
+    const tokens = [];
+    const length = text.length;
+    let i = 0;
+    let lineStart = true;
+    const starts = lineStartsOf(text);
+    //The file of the line markers, and what to add to a line of the text to get its line in that file
+    let file;
+    let lineOffset = 0;
+    let marked = false;
+    const fail = (message, offset) => {
+        const { line, column } = positionOf(starts, offset);
+        throw declarationError(message, line, column);
+    };
+    const push = (kind, start, end, extra = {}) => {
+        const { line, column } = positionOf(starts, start);
+        tokens.push({
+            kind: kind,
+            text: extra.text ?? text.slice(start, end),
+            value: extra.value,
+            float: extra.float,
+            line: line,
+            column: column,
+            ...marked ? { file: file, fileLine: line + lineOffset } : {},
+            ...extra.source !== undefined ? { source: extra.source } : {}
+        });
+    };
+    while (i < length) {
+        const char = text[i];
+        //Whitespace, the continuations of lines
+        if (char === '\n') {
+            lineStart = true;
+            i++;
+            continue;
+        }
+        if (char === ' ' || char === '\t' || char === '\r' || char === '\f' || char === '\v') {
+            i++;
+            continue;
+        }
+        if (char === '\\' && (text[i + 1] === '\n' || (text[i + 1] === '\r' && text[i + 2] === '\n'))) {
+            i += text[i + 1] === '\n' ? 2 : 3;
+            continue;
+        }
+        //Comments
+        if (char === '/' && text[i + 1] === '/') {
+            while (i < length && text[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (char === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            if (end < 0)
+                fail('A comment is not closed', i);
+            i = end + 2;
+            continue;
+        }
+        //Directives of the preprocessor, at the start of a line
+        if (char === '#' && lineStart) {
+            const start = i;
+            const end = directiveEnd(text, i);
+            const directive = withoutComments(text.slice(start + 1, end));
+            const name = directive.match(/^[A-Za-z_]\w*/)?.[0] ?? '';
+            if (CONDITIONALS.includes(name))
+                fail(`The directive #${name} is not supported: run the header through the preprocessor first (cc -E, cl /P)`, start);
+            const marker = name === '' || name === 'line' ? lineMarker(directive) : undefined;
+            if (marker) {
+                marked = true;
+                if (marker.file !== undefined)
+                    file = marker.file;
+                lineOffset = marker.line - (positionOf(starts, start).line + 1);
+            }
+            const pack = directive.match(/^pragma\s+pack\s*\(([^)]*)\)/);
+            if (pack)
+                push('pragma', start, end, { text: `pack(${pack[1].replace(/\s+/g, '')})` });
+            //The text of a macro after its name, its comments removed; the name directly followed by ( takes arguments
+            if (name === 'define' || name === 'undef')
+                push(name, start, end, { text: directive.slice(name.length).trim() });
+            i = end;
+            continue;
+        }
+        lineStart = false;
+        //Identifiers, and the prefixes of the wide strings and characters
+        if (/[A-Za-z_$]/.test(char)) {
+            let end = i + 1;
+            while (end < length && /[\w$]/.test(text[end]))
+                end++;
+            const word = text.slice(i, end);
+            if ((text[end] === '\'' || text[end] === '"') && ['L', 'u', 'U', 'u8'].includes(word)) {
+                i = end;
+                continue;
+            }
+            push('identifier', i, end);
+            i = end;
+            continue;
+        }
+        //Numbers
+        if (/[0-9]/.test(char) || (char === '.' && /[0-9]/.test(text[i + 1] ?? ''))) {
+            let end = i;
+            const hex = /^0[xX]/.test(text.slice(i, i + 2));
+            if (hex)
+                end += 2;
+            while (end < length && (/[\w.]/.test(text[end]) || (/[eEpP]/.test(text[end - 1]) && /[+-]/.test(text[end]) && (!hex || /[pP]/.test(text[end - 1])))))
+                end++;
+            const literal = text.slice(i, end);
+            //The suffixes of C, and the ones of Microsoft (i64, ui64, I32…)
+            const body = literal.replace(/(?:[uU](?:ll|LL|l|L)?|(?:ll|LL|l|L)[uU]?|[uU]?[iI](?:8|16|32|64))$/, '');
+            const float = hex ? /[.pP]/.test(body) : /[.eE]/.test(body) || /[fF]$/.test(literal);
+            if (float) {
+                push('number', i, end, { float: true });
+            }
+            else {
+                let value;
+                try {
+                    if (/^0[bB]/.test(body))
+                        value = BigInt(body);
+                    else if (/^0[0-7]+$/.test(body))
+                        value = BigInt(`0o${body.slice(1)}`);
+                    else
+                        value = BigInt(body);
+                }
+                catch {
+                    return fail(`The number ${literal} is not valid`, i);
+                }
+                push('number', i, end, { value: value });
+            }
+            i = end;
+            continue;
+        }
+        //Characters and strings
+        if (char === '\'' || char === '"') {
+            let end = i + 1;
+            const codes = [];
+            while (end < length && text[end] !== char) {
+                if (text[end] === '\n')
+                    fail(char === '"' ? 'A string is not closed' : 'A character is not closed', i);
+                if (text[end] === '\\') {
+                    const next = text[end + 1];
+                    if (next === 'x') {
+                        const digits = text.slice(end + 2).match(/^[0-9a-fA-F]+/)?.[0] ?? '';
+                        codes.push(parseInt(digits || '0', 16));
+                        end += 2 + digits.length;
+                    }
+                    else if (/[0-7]/.test(next)) {
+                        const digits = text.slice(end + 1).match(/^[0-7]{1,3}/)[0];
+                        codes.push(parseInt(digits, 8));
+                        end += 1 + digits.length;
+                    }
+                    else {
+                        codes.push(ESCAPES[next] ?? next.charCodeAt(0));
+                        end += 2;
+                    }
+                }
+                else {
+                    codes.push(text.codePointAt(end));
+                    end += text.codePointAt(end) > 0xFFFF ? 2 : 1;
+                }
+            }
+            if (end >= length)
+                fail(char === '"' ? 'A string is not closed' : 'A character is not closed', i);
+            if (char === '\'')
+                push('char', i, end + 1, { value: BigInt(codes[0] ?? 0) });
+            else
+                push('string', i, end + 1, { text: String.fromCodePoint(...codes), source: text.slice(i, end + 1) });
+            i = end + 1;
+            continue;
+        }
+        //Punctuators
+        const punctuator = PUNCTUATORS.find((candidate) => text.startsWith(candidate, i));
+        if (punctuator) {
+            push('punctuator', i, i + punctuator.length);
+            i += punctuator.length;
+            continue;
+        }
+        if (SINGLE.includes(char)) {
+            push('punctuator', i, i + 1);
+            i++;
+            continue;
+        }
+        fail(`Unexpected character ${JSON.stringify(char)}`, i);
+    }
+    const { line, column } = positionOf(starts, length);
+    tokens.push({ kind: 'end', text: '', line: line, column: column });
+    return tokens;
+}

package/dist/cjs/lib/declarations/Parser.d.ts

@@ -0,0 +1,90 @@
+import { type Token } from './Lexer.js';
+import type { Platform } from './Platform.js';
+import { type CType, type Declarations, type FunctionDeclaration } from './Types.js';
+/**
+ * A declaration of a preprocessed header, as readSource reads it (for the generator of libraries)
+ */
+export interface SourceDeclaration {
+    /**
+     * The file it comes from, and its line there (from the line markers of the preprocessor)
+     */
+    readonly file?: string;
+    readonly line?: number;
+    /**
+     * Its tokens, the macros expanded
+     */
+    readonly tokens: readonly Token[];
+    /**
+     * What it declares: `type name`, `struct tag`, `union tag`, `enum tag` (defined, not only named), `function name`,
+     * `variable name`, `constant name`
+     */
+    readonly names: readonly string[];
+    /**
+     * The packing of #pragma pack it was read with
+     */
+    readonly pack?: number;
+    /**
+     * Why it could not be read
+     */
+    readonly error?: string;
+}
+/**
+ * Where a macro is defined, in a preprocessed header
+ */
+export interface MacroOrigin {
+    readonly file?: string;
+    readonly line?: number;
+}
+/**
+ * A preprocessed header read by readSource: its declarations, each one as it is written, and where its macros are
+ */
+export interface SourceDeclarations {
+    readonly declarations: Declarations;
+    readonly items: readonly SourceDeclaration[];
+    readonly macros: ReadonlyMap<string, MacroOrigin>;
+}
+/**
+ * Reads C declarations: typedefs, structs, unions, enums, function prototypes and variables, for one platform. Each
+ * library has its own declarations: their names do not meet the ones of another library
+ */
+export declare class DeclarationParser {
+    #private;
+    /**
+     * Read declarations for a platform.
+     * @param platform The platform: the sizes of the types and the layout of the structs depend on it.
+     * @param declarations Declarations already read, added to (the ones of the library, when a prototype is read).
+     */
+    constructor(platform: Platform, declarations?: Declarations);
+    /**
+     * The declarations read so far.
+     */
+    get declarations(): Declarations;
+    /**
+     * Read a text of declarations, adding what it declares.
+     * @param text The declarations, as a header writes them (preprocessed or not: #pragma pack is read, #define and
+     * #include are skipped, #if and its kind are refused).
+     */
+    parse(text: string): Declarations;
+    /**
+     * Read a preprocessed header for the generator of libraries: each declaration kept with the file it comes from and
+     * what it declares; one that cannot be read is skipped, its error kept, and the next ones are read.
+     * @param text The output of the preprocessor (`cc -E -dD`, `cl /P`): its line markers give the files.
+     * @returns The declarations, each declaration as it is written, and where the macros are defined.
+     */
+    readSource(text: string): SourceDeclarations;
+    /**
+     * Read the prototype of one function (a trailing semicolon is optional).
+     * @param text The prototype: `int sqlite3_open(const char *filename, _Out_ sqlite3 **db)`.
+     */
+    prototype(text: string): FunctionDeclaration;
+    /**
+     * Read a type name: `struct timeval`, `const char *`, `int[4]`.
+     * @param text The type.
+     */
+    typeName(text: string): CType;
+    /**
+     * The value of a constant expression of the declarations (`SQLITE_OK + 1`, `1 << 4`).
+     * @param text The expression.
+     */
+    constant(text: string): bigint;
+}