@neo-one/smart-contract-compiler/dist/cjs/compile/sb/BaseScriptBuilder.d.ts

NEO•ONE TypeScript smart contract compiler.

/// <reference types="node" />
import { OpCode, SysCallName, UInt160 } from '@neo-one/client-common';
import BN from 'bn.js';
import { RawSourceMap } from 'source-map';
import ts from 'typescript';
import { Context } from '../../Context';
import { ContractInfo } from '../../contract';
import { Helper, Helpers } from '../helper';
import { ProgramCounter, ProgramCounterHelper } from '../pc';
import { Name, Scope } from '../scope';
import { HandleSuperConstruct, LinkedContracts, ScriptBuilderResult, VisitOptions } from '../types';
import { JumpTable } from './JumpTable';
import { Bytecode, CaptureResult, ScriptBuilder } from './ScriptBuilder';
export declare abstract class BaseScriptBuilder<TScope extends Scope> implements ScriptBuilder {
    readonly context: Context;
    readonly helpers: Helpers;
    private readonly sourceFile;
    private readonly contractInfo?;
    private readonly linked;
    private readonly allHelpers;
    readonly jumpTable: JumpTable;
    private mutableCurrentScope;
    private readonly compilers;
    private readonly mutableBytecode;
    private mutablePC;
    private readonly jumpTablePC;
    private mutableCapturedBytecode;
    private mutableProcessedByteCode;
    private mutableCurrentTags;
    private readonly nodes;
    private readonly mutableModuleMap;
    private readonly mutableReverseModuleMap;
    private readonly mutableExportMap;
    private mutableNextModuleIndex;
    private mutableCurrentModuleIndex;
    private mutableFeatures;
    constructor(context: Context, helpers: Helpers, sourceFile: ts.SourceFile, contractInfo?: ContractInfo | undefined, linked?: LinkedContracts, allHelpers?: ReadonlyArray<Helper>);
    get scope(): TScope;
    get moduleIndex(): number;
    process(): void;
    getFinalResult(sourceMaps: {
        readonly [filePath: string]: RawSourceMap;
    }): ScriptBuilderResult;
    visit(node: ts.Node, options: VisitOptions): void;
    withScope(node: ts.Node, options: VisitOptions, func: (options: VisitOptions) => void): void;
    withProgramCounter(func: (pc: ProgramCounterHelper) => void): void;
    emitOp(node: ts.Node, code: OpCode, buffer?: Buffer | undefined): void;
    emitPushInt(node: ts.Node, valueIn: number | BN): void;
    emitPushBoolean(node: ts.Node, value: boolean): void;
    emitPushString(node: ts.Node, value: string): void;
    emitPushBuffer(node: ts.Node, value: Buffer): void;
    emitJmp(node: ts.Node, code: 'JMP' | 'JMPIF' | 'JMPIFNOT', pc: ProgramCounter): void;
    emitHelper<T extends ts.Node>(node: T, options: VisitOptions, helper: Helper<T>): void;
    emitBytecode(bytecode: Bytecode): void;
    emitCall(node: ts.Node): void;
    emitSysCall(node: ts.Node, name: SysCallName): void;
    emitLine(node: ts.Node): void;
    isCurrentSmartContract(node: ts.Node): boolean;
    loadModule(sourceFile: ts.SourceFile): void;
    capture(func: () => void): CaptureResult;
    getLinkedScriptHash(node: ts.Node, filePath: string, smartContractClass: string): UInt160 | undefined;
    pushValueOptions(options: VisitOptions): VisitOptions;
    noPushValueOptions(options: VisitOptions): VisitOptions;
    setValueOptions(options: VisitOptions): VisitOptions;
    noSetValueOptions(options: VisitOptions): VisitOptions;
    noValueOptions(options: VisitOptions): VisitOptions;
    breakPCOptions(options: VisitOptions, pc: ProgramCounter): VisitOptions;
    continuePCOptions(options: VisitOptions, pc: ProgramCounter): VisitOptions;
    catchPCOptions(options: VisitOptions, pc: ProgramCounter): VisitOptions;
    noCatchPCOptions(options: VisitOptions): VisitOptions;
    finallyPCOptions(options: VisitOptions, pc: ProgramCounter): VisitOptions;
    handleSuperConstructOptions(options: VisitOptions, handleSuperConstruct: HandleSuperConstruct): VisitOptions;
    castOptions(options: VisitOptions, cast?: ts.Type | undefined): VisitOptions;
    noCastOptions(options: VisitOptions): VisitOptions;
    superClassOptions(options: VisitOptions, superClass: Name): VisitOptions;
    noSuperClassOptions(options: VisitOptions): VisitOptions;
    hasExport(sourceFile: ts.SourceFile, name: string): boolean;
    addExport(name: string): void;
    protected abstract createScope(node: ts.Node, index: number, parent: TScope | undefined): TScope;
    private toBuffer;
    private emitPush;
    private emitOpByte;
    private emitRaw;
    private emitJump;
    private emitLineRaw;
    private push;
}