microvium/dist/lib/src-to-il/src-to-il.d.ts

A compact, embeddable scripting engine for microcontrollers for executing small scripts written in a subset of JavaScript.

import * as babylon from '@babel/parser';
import * as B from './supported-babel-types';
import * as IL from '../il';
import { AnalysisModel, SlotAccessInfo, PrologueStep, BlockScope, Scope } from './analyze-scopes';
import { SourceCursor } from './common';
interface Context {
    filename: string;
    nextBlockID: number;
    scopeAnalysis: AnalysisModel;
    awaitStackDepths?: Map<string, number>;
}
interface ScopeStack {
    helper: ScopeHelper;
    scope: Scope;
    parent: ScopeStack | undefined;
    catchTarget?: IL.Block;
    stackDepth?: number;
}
interface Cursor extends SourceCursor {
    ctx: Context;
    breakScope: BreakScope | undefined;
    scopeStack: ScopeStack | undefined;
    unit: IL.Unit;
    func: IL.Function;
    block: IL.Block;
    node: B.Node;
    endOfNode?: boolean;
    stackDepth: number;
    commentNext?: string[];
    reachable: boolean;
}
interface ScopeHelper {
    leaveScope(cur: Cursor, currentOperation: 'break' | 'return' | 'normal'): void;
}
interface LazyValue {
    /** Emits code that pushes the value to the stack. Generally only valid within
     * the function in which the LazyValue was created, since the emitted sequence
     * could include references to values on the stack. */
    load(cur: Cursor): void;
}
interface ValueAccessor extends LazyValue {
    store: (cur: Cursor, value: LazyValue) => void;
}
interface BreakScope {
    statement: B.SupportedLoopStatement | B.SwitchStatement;
    breakToTarget: IL.Block;
    scope: Scope | undefined;
    parent: BreakScope | undefined;
}
/**
 * Compile the given source code.
 *
 * Note: if opts.awaitStackDepths is only used internally (this function
 * recursively calls itself).
 */
export declare function compileScript(filename: string, scriptText: string, opts?: {
    awaitStackDepths?: Map<string, number>;
}): {
    unit: IL.Unit;
    scopeAnalysis: AnalysisModel;
};
export declare function parseToAst(filename: string, scriptText: string): babylon.ParseResult<B.File>;
export declare function compileModuleStatement(cur: Cursor, statement: B.Statement): IL.Function | undefined;
export declare function compileExportNamedDeclaration(cur: Cursor, statement: B.ExportNamedDeclaration): undefined;
export declare function compileModuleVariableDeclaration(cur: Cursor, decl: B.VariableDeclaration): undefined;
declare function LazyValue(load: (cur: Cursor) => void): {
    load: (cur: Cursor) => void;
};
export declare function compileFunction(cur: Cursor, func: B.SupportedFunctionNode): IL.Function;
export declare function compilePrologue(cur: Cursor, prolog: PrologueStep[]): void;
export declare function compileExpressionStatement(cur: Cursor, statement: B.ExpressionStatement): void;
export declare function compileReturnStatement(cur: Cursor, statement: B.ReturnStatement): void;
export declare function compileThrowStatement(cur: Cursor, statement: B.ThrowStatement): void;
export declare function compileForStatement(cur: Cursor, statement: B.ForStatement): void;
export declare function compileBlockEpilogue(cur: Cursor, block: BlockScope, currentOperation: 'break' | 'return' | 'normal'): void;
export declare function compileWhileStatement(cur: Cursor, statement: B.WhileStatement): void;
export declare function compileDoWhileStatement(cur: Cursor, statement: B.DoWhileStatement): void;
export declare function compileBlockStatement(cur: Cursor, statement: B.BlockStatement, opts?: {
    catchTarget?: IL.Block;
    stackDepth?: number;
}): void;
export declare function compileIfStatement(cur: Cursor, statement: B.IfStatement): void;
export declare function labelOfBlock(block: IL.Block): IL.LabelOperand;
export declare function literalOperand(value: IL.LiteralValueType): IL.LiteralOperand;
export declare function labelOperand(targetBlockId: IL.BlockID): IL.LabelOperand;
export declare function countOperand(count: number): IL.CountOperand;
export declare function flagOperand(flag: boolean): IL.FlagOperand;
export declare function indexOperand(index: number): IL.IndexOperand;
export declare function nameOperand(name: string): IL.NameOperand;
export declare function compileStatement(cur: Cursor, statement_: B.Statement): void;
export declare function compileClassDeclaration(cur: Cursor, classDecl: B.ClassDeclaration): void;
export declare function getFieldKey(field: B.ClassMethod | B.ClassProperty): LazyValue;
export declare function compileClassMethod(cur: Cursor, field: B.ClassMethod): {
    load: (cur: Cursor) => void;
};
export declare function compileClassConstructor(cur: Cursor, classDecl: B.ClassDeclaration): void;
export declare function compileTryStatement(cur: Cursor, statement: B.TryStatement): undefined;
export declare function compileBreakStatement(cur: Cursor, statement: B.BreakStatement): undefined;
export declare function compileSwitchStatement(cur: Cursor, statement: B.SwitchStatement): undefined;
export declare function compileExpression(cur: Cursor, expression_: B.Expression | B.PrivateName): void | IL.Operation;
export declare function compileAwaitExpression(cur: Cursor, expression: B.AwaitExpression): void;
export declare function compileTemplateLiteral(cur: Cursor, expression: B.TemplateLiteral): undefined;
export declare function compileArrowFunctionExpression(cur: Cursor, expression: B.ArrowFunctionExpression): void;
export declare function compileFunctionExpression(cur: Cursor, expression: B.FunctionExpression): void;
export declare function compileThisExpression(cur: Cursor, expression: B.ThisExpression): void;
export declare function compileConditionalExpression(cur: Cursor, expression: B.ConditionalExpression): void;
export declare function compileArrayExpression(cur: Cursor, expression: B.ArrayExpression): undefined;
export declare function compileObjectExpression(cur: Cursor, expression: B.ObjectExpression): undefined;
export declare function compileMemberExpression(cur: Cursor, expression: B.MemberExpression): undefined;
export declare function compileNewExpression(cur: Cursor, expression: B.NewExpression): undefined;
export declare function compileCallExpression(cur: Cursor, expression: B.CallExpression, isVoidCall: boolean, isAwaitCall: boolean): undefined;
export declare function compileLogicalExpression(cur: Cursor, expression: B.LogicalExpression): undefined;
export declare function compileAssignmentExpression(cur: Cursor, expression: B.AssignmentExpression): undefined;
export declare function getGlobalAccessor(name: string): ValueAccessor;
/** Given SlotAccessInfo, this produces a ValueAccessor that encapsulates the IL
 * sequences required to read or write to the given slot.  */
export declare function getSlotAccessor(cur: Cursor, slotAccess: SlotAccessInfo, readonly?: boolean, nameHint?: string): ValueAccessor;
export declare function compileUnaryExpression(cur: Cursor, expression: B.UnaryExpression): IL.Operation | undefined;
export declare function compileUpdateExpression(cur: Cursor, expression: B.UpdateExpression): undefined;
export declare function compileBinaryExpression(cur: Cursor, expression: B.BinaryExpression): void;
export declare function compileIdentifier(cur: Cursor, expression: B.Identifier): void;
export declare function compilingNode(cur: Cursor, node: B.Node): void;
export declare function compilingEndOfNode(cur: Cursor, node: B.Node): void;
export declare function compileVariableDeclaration(cur: Cursor, decl: B.VariableDeclaration): undefined;
export declare function computeMaximumStackDepth(func: IL.Function): void;
export {};