@ohm-js/wasm 0.5.0 → 0.6.1

package/dist/src/AstBuilder.d.ts

@@ -0,0 +1,17 @@
+import type { CstNode, MatchResult } from './miniohm.ts';
+export type AstMapping = Record<string, unknown>;
+export declare class AstBuilder {
+    currNode?: CstNode;
+    private _mapping;
+    private _depth;
+    private _debug;
+    constructor(mapping: AstMapping, opts?: {
+        debug?: boolean;
+    });
+    private _debugLog;
+    _visitTerminal(node: CstNode): string;
+    _visitNonterminal(node: CstNode): unknown;
+    _visitIter(node: CstNode): unknown;
+    toAst(nodeOrResult: MatchResult | CstNode): unknown;
+}
+//# sourceMappingURL=AstBuilder.d.ts.map

package/dist/src/AstBuilder.js

@@ -0,0 +1,143 @@
+import { assert, checkNotNull } from "./assert.js";
+function childAt(children, idx, ruleName, propName = '') {
+    if (idx > children.length) {
+        const path = propName ? `${ruleName}.${propName}` : ruleName;
+        throw new Error(`${path}: Child index ${idx} out of range`);
+    }
+    return children[idx];
+}
+export class AstBuilder {
+    currNode;
+    _mapping;
+    _depth = -1;
+    _debug = false;
+    constructor(mapping, opts = {}) {
+        const handleListOf = (child) => this.toAst(child);
+        const handleEmptyListOf = () => [];
+        const handleNonemptyListOf = (first, iterSepAndElem) => [
+            this.toAst(first),
+            ...iterSepAndElem.map((_, elem) => this.toAst(elem)),
+        ];
+        this._mapping = {
+            listOf: handleListOf,
+            ListOf: handleListOf,
+            emptyListOf: handleEmptyListOf,
+            EmptyListOf: handleEmptyListOf,
+            nonemptyListOf: handleNonemptyListOf,
+            NonemptyListOf: handleNonemptyListOf,
+            ...mapping,
+        };
+        this._debug = opts.debug ?? false;
+    }
+    _debugLog(...data) {
+        if (this._debug)
+            console.log('  '.repeat(this._depth), ...data);
+    }
+    _visitTerminal(node) {
+        return node.sourceString;
+    }
+    _visitNonterminal(node) {
+        const { children, ruleName } = node;
+        const mapping = this._mapping;
+        this._debugLog(`> ${ruleName}`);
+        const dbgReturn = (val) => {
+            this._debugLog(`| ${ruleName} DONE`);
+            return val;
+        };
+        // without customization
+        if (!Object.hasOwn(mapping, ruleName)) {
+            // lexical rule
+            if (node.isLexical()) {
+                return node.sourceString;
+            }
+            // singular node (e.g. only surrounded by literals or lookaheads)
+            const realChildren = children.filter(c => !c.isTerminal());
+            if (realChildren.length === 1) {
+                return dbgReturn(this.toAst(realChildren[0]));
+            }
+            // rest: terms with multiple children
+        }
+        // direct forward
+        if (typeof mapping[ruleName] === 'number') {
+            const idx = mapping[ruleName];
+            return dbgReturn(this.toAst(childAt(children, idx, ruleName)));
+        }
+        assert(typeof mapping[ruleName] !== 'function', "shouldn't be possible");
+        // named/mapped children or unnamed children ('0', '1', '2', ...)
+        const propMap = mapping[ruleName] || children;
+        const ans = {
+            type: ruleName,
+        };
+        // eslint-disable-next-line guard-for-in
+        for (const prop in propMap) {
+            const mappedProp = mapping[ruleName] && mapping[ruleName][prop];
+            if (typeof mappedProp === 'number') {
+                // direct forward
+                ans[prop] = this.toAst(childAt(children, mappedProp, ruleName, prop));
+            }
+            else if (typeof mappedProp === 'string' ||
+                typeof mappedProp === 'boolean' ||
+                mappedProp === null) {
+                // primitive value
+                ans[prop] = mappedProp;
+            }
+            else if (typeof mappedProp === 'object' && mappedProp instanceof Number) {
+                // primitive number (must be unboxed)
+                ans[prop] = Number(mappedProp);
+            }
+            else if (typeof mappedProp === 'function') {
+                // computed value
+                ans[prop] = mappedProp.call(this, children);
+            }
+            else if (mappedProp === undefined) {
+                const child = children[Number(prop)];
+                if (child && !child.isTerminal()) {
+                    ans[prop] = this.toAst(child);
+                }
+                else {
+                    // delete predefined 'type' properties, like 'type', if explicitly removed
+                    delete ans[prop];
+                }
+            }
+        }
+        return dbgReturn(ans);
+    }
+    _visitIter(node) {
+        const { children } = node;
+        if (node.isOptional()) {
+            if (children.length === 0) {
+                return null;
+            }
+            return this.toAst(children[0]);
+        }
+        return children.map(c => this.toAst(c));
+    }
+    toAst(nodeOrResult) {
+        let node = nodeOrResult;
+        if (typeof nodeOrResult.succeeded === 'function') {
+            const matchResult = nodeOrResult;
+            assert(matchResult.succeeded(), 'Cannot convert failed match result to AST');
+            node = checkNotNull(matchResult._cst);
+        }
+        let ans;
+        this._depth++;
+        if (node.isTerminal()) {
+            ans = this._visitTerminal(node);
+        }
+        else if (node.isIter()) {
+            ans = this._visitIter(node);
+        }
+        else {
+            assert(node.isNonterminal(), `Unknown node type: ${node._type}`);
+            this.currNode = node;
+            ans =
+                typeof this._mapping[node.ctorName] === 'function'
+                    ? this._mapping[node.ctorName].apply(this, node.children)
+                    : this._visitNonterminal(node);
+            this.currNode = undefined;
+        }
+        this._depth--;
+        return ans;
+    }
+}
+//# sourceMappingURL=AstBuilder.js.map

package/dist/src/Compiler.d.ts

@@ -0,0 +1,195 @@
+export class Compiler {
+    constructor(grammar: any);
+    grammar: any;
+    importDecls: {
+        module: string;
+        name: string;
+        paramTypes: any[];
+        resultTypes: any[];
+    }[];
+    ruleIdByName: any;
+    _deferredRuleIds: Set<any>;
+    _maxMemoizedRuleId: number;
+    rules: Map<any, any> | undefined;
+    _nextLiftedId: number;
+    _lexContextStack: any[];
+    _applySpacesImplicit: ir.Apply;
+    importCount(): number;
+    ruleId(name: any): any;
+    _ensureRuleId(name: any, { notMemoized }?: {}): any;
+    _deferRuleId(name: any): void;
+    inLexicalContext(): any;
+    liftPExpr(exp: any, isSyntactic: any): any[];
+    ruleEvalFuncIdx(name: any): any;
+    getDebugImports(log: any): {};
+    normalize(): void;
+    compile(): Uint8Array<ArrayBuffer>;
+    typeMap: TypeMap | undefined;
+    asm: Assembler | undefined;
+    simplifyApplications(): void;
+    liftedTerminals: IndexedSet | undefined;
+    compileTerminalRule(name: any): any;
+    beginLexContext(initialVal: any): void;
+    endLexContext(): void;
+    compileRule(name: any): any;
+    specializeApplications(): void;
+    buildRuleNamesSection(ruleNames: any): any;
+    buildModule(typeMap: any, functionDecls: any): Uint8Array<ArrayBuffer>;
+    rewriteDebugLabels(decls: any): void;
+    functionDecls(): any[];
+    emitDispatch({ child: exp, patterns }: {
+        child: any;
+        patterns: any;
+    }): void;
+    emitPExpr(exp: any, { preHook, postHook }?: {}): void;
+    emitAlt(exp: any): void;
+    emitAny(): void;
+    emitApplyTerm({ terminalId }: {
+        terminalId: any;
+    }): void;
+    emitApplyGeneralized(exp: any): void;
+    emitApply(exp: any): void;
+    emitEnd(): void;
+    emitFail(): void;
+    emitLex({ child }: {
+        child: any;
+    }): void;
+    emitLookahead({ child }: {
+        child: any;
+    }): void;
+    emitNot({ child }: {
+        child: any;
+    }): void;
+    emitOpt({ child }: {
+        child: any;
+    }): void;
+    emitPlus(plusExp: any): void;
+    emitRange(exp: any): void;
+    emitSeq({ children }: {
+        children: any;
+    }): void;
+    maybeEmitSpaceSkipping(): void;
+    emitStar({ child }: {
+        child: any;
+    }, { reuseStackFrame }?: {}): void;
+    wrapTerminalLike(thunk: any): void;
+    emitCaseInsensitive({ value }: {
+        value: any;
+    }): void;
+    emitTerminal(exp: any): void;
+    emitUnicodeChar(exp: any): void;
+}
+export namespace Compiler {
+    export { WASM_PAGE_SIZE as STACK_START_OFFSET };
+}
+export namespace ConstantsForTesting {
+    let CST_NODE_SIZE_BYTES: any;
+    let MEMO_COL_SIZE_BYTES: any;
+}
+import * as ir from './ir.ts';
+declare class TypeMap {
+    constructor(startIdx?: number);
+    _map: Map<any, any>;
+    _startIdx: number;
+    add(paramTypes: any, resultTypes: any): any;
+    addDecls(decls: any): void;
+    getIdx(paramTypes: any, resultTypes: any): any;
+    getIdxForDecl(decl: any): any;
+    getTypes(): any[];
+}
+declare class Assembler {
+    constructor(typeMap: any);
+    _globals: Map<any, any>;
+    _functionDecls: any[];
+    _blockStack: any[];
+    _code: any[];
+    _locals: Map<any, any> | undefined;
+    _typeMap: any;
+    addBlocktype(paramTypes: any, resultTypes: any): void;
+    blocktype(paramTypes: any, resultTypes: any): any;
+    doEmit(thunk: any): any[];
+    addGlobal(name: any, type: any, mut: any, initThunk: any): number;
+    addLocal(name: any, type: any): number;
+    addFunction(name: any, paramTypes: any, resultTypes: any, bodyFn: any): void;
+    globalidx(name: any): any;
+    localidx(name: any): any;
+    emit(...bytes: any[]): void;
+    block(bt: any, bodyThunk: any, label?: string): void;
+    _blockOnly(bt: any, label: any): void;
+    _endBlock(): void;
+    loop(bt: any, bodyThunk: any): void;
+    if(bt: any, bodyThunk: any): void;
+    ifElse(bt: any, thenThunk: any, elseThunk?: undefined): void;
+    ifFalse(bt: any, bodyThunk: any): void;
+    br(depth: any): void;
+    i32Add(): void;
+    i32Const(value: any): void;
+    i32Load(offset?: number): void;
+    i32Load8u(offset?: number): void;
+    i32Mul(): void;
+    i32Eq(): void;
+    i32Ne(): void;
+    i32Store(offset?: number): void;
+    i32Sub(): void;
+    globalGet(name: any): void;
+    globalSet(name: any): void;
+    localGet(name: any): void;
+    localSet(name: any): void;
+    localTee(name: any): void;
+    break(depth: any): void;
+    condBreak(depth: any): void;
+    continue(depth: any): void;
+    brTable(labels: any, defaultLabelidx: any): void;
+    return(): void;
+    switch(bt: any, discrimThunk: any, numCases: any, caseCb: any, defaultThunk: any): void;
+    refNull(valtype: any): void;
+    i32Inc(): void;
+    i32Dec(): void;
+    dup(): void;
+    currCharCode(): void;
+    nextCharCode(): void;
+    setRet(val: any): void;
+    pushStackFrame(saveThunk: any): void;
+    popStackFrame(): void;
+    savePos(): void;
+    getSavedPos(): void;
+    restorePos(): void;
+    saveNumBindings(): void;
+    getSavedNumBindings(): void;
+    restoreBindingsLength(): void;
+    saveFailurePos(): void;
+    restoreFailurePos(): void;
+    saveGlobalFailurePos(): void;
+    restoreGlobalFailurePos(): void;
+    updateGlobalFailurePos(): void;
+    updateLocalFailurePos(origPosThunk: any): void;
+    incPos(): void;
+    callPrebuiltFunc(name: any): void;
+    newIterNodeWithSavedPosAndBindings(arity: any, isOpt?: boolean): void;
+    newCaseInsensitiveNode(ruleId: any): void;
+    newTerminalNode(): void;
+    i32Max(aThunk: any, bThunk: any): void;
+    depthOf(label: any): number;
+    ruleEvalReturn(): void;
+}
+declare namespace Assembler {
+    export let ALIGN_1_BYTE: number;
+    export let ALIGN_4_BYTES: number;
+    export let CST_NODE_HEADER_SIZE_BYTES: number;
+    let MEMO_COL_SIZE_BYTES_1: number;
+    export { MEMO_COL_SIZE_BYTES_1 as MEMO_COL_SIZE_BYTES };
+    export let STACK_FRAME_SIZE_BYTES: number;
+}
+declare class IndexedSet {
+    _map: Map<any, any>;
+    add(item: any): any;
+    getIndex(item: any): any;
+    has(item: any): boolean;
+    get size(): number;
+    keys(): any[];
+    values(): any[];
+    [Symbol.iterator](): MapIterator<[any, any]>;
+}
+declare const WASM_PAGE_SIZE: number;
+export {};
+//# sourceMappingURL=Compiler.d.ts.map