greybel-interpreter 3.5.0 → 4.0.0

package/dist/bytecode-generator.js

@@ -0,0 +1,1165 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytecodeGenerator = void 0;
+const greybel_core_1 = require("greybel-core");
+const miniscript_core_1 = require("miniscript-core");
+const error_1 = require("./utils/error");
+const instruction_1 = require("./byte-compiler/instruction");
+const number_1 = require("./types/number");
+const boolean_1 = require("./types/boolean");
+const string_1 = require("./types/string");
+const default_1 = require("./types/default");
+const stack_1 = require("./utils/stack");
+function generateCustomValueFromASTLiteral(node) {
+    switch (node.type) {
+        case miniscript_core_1.ASTType.BooleanLiteral:
+            return new boolean_1.CustomBoolean(node.value);
+        case miniscript_core_1.ASTType.StringLiteral:
+            return new string_1.CustomString(node.value);
+        case miniscript_core_1.ASTType.NumericLiteral:
+            return new number_1.CustomNumber(node.value);
+        case miniscript_core_1.ASTType.NilLiteral:
+            return default_1.DefaultType.Void;
+        default:
+            throw new Error('Unexpected literal type.');
+    }
+}
+class BytecodeGenerator {
+    constructor(options) {
+        var _a;
+        this.target = new stack_1.Stack(options.target);
+        this.handler = options.handler;
+        this.context = new stack_1.Stack({
+            code: [],
+            jumpPoints: []
+        });
+        this.imports = new Map();
+        this.debugMode = (_a = options.debugMode) !== null && _a !== void 0 ? _a : false;
+    }
+    parse(code) {
+        const parser = new greybel_core_1.Parser(code);
+        return parser.parseChunk();
+    }
+    compile(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const node = this.parse(code);
+            yield this.processNode(node);
+            this.push({
+                op: instruction_1.OpCode.HALT,
+                source: this.getSourceLocation(node)
+            });
+            return {
+                code: this.context.peek().code,
+                imports: this.imports
+            };
+        });
+    }
+    getCurrentPointer() {
+        return this.context.peek().code.length - 1;
+    }
+    getSourceLocation(node) {
+        const target = this.target.peek();
+        return {
+            path: target,
+            start: node.start,
+            end: node.end
+        };
+    }
+    getInternalLocation() {
+        return {
+            path: 'internal',
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 0 }
+        };
+    }
+    pushContext() {
+        this.context.push({
+            code: [],
+            jumpPoints: []
+        });
+    }
+    popContext() {
+        return this.context.pop();
+    }
+    getLastJumpoint() {
+        const jumpPoints = this.context.peek().jumpPoints;
+        return jumpPoints[jumpPoints.length - 1];
+    }
+    pushJumppoint(start, end) {
+        this.context.peek().jumpPoints.push([start, end]);
+    }
+    popJumppoint() {
+        return this.context.peek().jumpPoints.pop();
+    }
+    push(item) {
+        item.ip = this.getCurrentPointer() + 1;
+        this.context.peek().code.push(item);
+    }
+    processNode(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.debugMode) {
+                this.push({
+                    op: instruction_1.OpCode.BREAKPOINT,
+                    source: this.getSourceLocation(node)
+                });
+            }
+            switch (node.type) {
+                case miniscript_core_1.ASTType.MemberExpression:
+                    yield this.processMemberExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.IndexExpression:
+                    yield this.processIndexExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.SliceExpression:
+                    yield this.processSliceExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.Identifier:
+                    yield this.processIdentifier(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.AssignmentStatement:
+                    yield this.processAssignmentStatement(node);
+                    return;
+                case miniscript_core_1.ASTType.Chunk:
+                    const chunk = node;
+                    for (const item of chunk.body) {
+                        yield this.processNode(item);
+                    }
+                    return;
+                case miniscript_core_1.ASTType.BooleanLiteral:
+                case miniscript_core_1.ASTType.StringLiteral:
+                case miniscript_core_1.ASTType.NumericLiteral:
+                case miniscript_core_1.ASTType.NilLiteral:
+                    yield this.processLiteral(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.IsaExpression:
+                case miniscript_core_1.ASTType.BinaryExpression:
+                case miniscript_core_1.ASTType.LogicalExpression:
+                    yield this.processEvaluationExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.ReturnStatement:
+                    yield this.processReturn(node);
+                    return;
+                case miniscript_core_1.ASTType.BreakStatement:
+                    yield this.processBreak(node);
+                    return;
+                case miniscript_core_1.ASTType.ContinueStatement:
+                    yield this.processContinue(node);
+                    return;
+                case miniscript_core_1.ASTType.MapConstructorExpression:
+                    yield this.processMapConstructorExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.ListConstructorExpression:
+                    yield this.processListConstructorExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.FunctionDeclaration:
+                    yield this.processFunctionDeclaration(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.WhileStatement:
+                    yield this.processWhileStatement(node);
+                    return;
+                case miniscript_core_1.ASTType.ParenthesisExpression:
+                    yield this.processNode(node.expression);
+                    return;
+                case miniscript_core_1.ASTType.BinaryNegatedExpression:
+                case miniscript_core_1.ASTType.UnaryExpression:
+                case miniscript_core_1.ASTType.NegationExpression:
+                    yield this.processUnaryExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.CallStatement:
+                    yield this.processNode(node.expression);
+                    return;
+                case miniscript_core_1.ASTType.CallExpression:
+                    yield this.processCallExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case miniscript_core_1.ASTType.IfStatement:
+                case miniscript_core_1.ASTType.IfShortcutStatement:
+                    yield this.processIfStatement(node);
+                    return;
+                case miniscript_core_1.ASTType.ForGenericStatement:
+                    yield this.processForGenericStatement(node);
+                    return;
+                case miniscript_core_1.ASTType.EmptyExpression:
+                case miniscript_core_1.ASTType.Comment:
+                    return;
+                case greybel_core_1.ASTType.FeatureEnvarExpression:
+                    yield this.processEnvarExpression(node);
+                    this.push({
+                        op: instruction_1.OpCode.POP,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                case greybel_core_1.ASTType.FeatureImportExpression:
+                    yield this.processImportExpression(node);
+                    return;
+                case greybel_core_1.ASTType.FeatureIncludeExpression:
+                    yield this.processIncludeExpression(node);
+                    return;
+                case greybel_core_1.ASTType.FeatureDebuggerExpression:
+                    yield this.processDebuggerExpression(node);
+                    return;
+                default: {
+                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
+                        target: this.target.peek(),
+                        range
+                    });
+                }
+            }
+        });
+    }
+    processSubNode(node, ignoreOuter = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (node.type) {
+                case miniscript_core_1.ASTType.MemberExpression:
+                    yield this.processMemberExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.IndexExpression:
+                    yield this.processIndexExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.SliceExpression:
+                    yield this.processSliceExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.Identifier:
+                    yield this.processIdentifier(node);
+                    return;
+                case miniscript_core_1.ASTType.BooleanLiteral:
+                case miniscript_core_1.ASTType.StringLiteral:
+                case miniscript_core_1.ASTType.NumericLiteral:
+                case miniscript_core_1.ASTType.NilLiteral:
+                    yield this.processLiteral(node);
+                    return;
+                case miniscript_core_1.ASTType.IsaExpression:
+                case miniscript_core_1.ASTType.BinaryExpression:
+                case miniscript_core_1.ASTType.LogicalExpression:
+                    yield this.processEvaluationExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.MapConstructorExpression:
+                    yield this.processMapConstructorExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.ListConstructorExpression:
+                    yield this.processListConstructorExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.FunctionDeclaration:
+                    yield this.processFunctionDeclaration(node, ignoreOuter);
+                    return;
+                case miniscript_core_1.ASTType.ParenthesisExpression:
+                    yield this.processSubNode(node.expression);
+                    return;
+                case miniscript_core_1.ASTType.BinaryNegatedExpression:
+                case miniscript_core_1.ASTType.UnaryExpression:
+                case miniscript_core_1.ASTType.NegationExpression:
+                    yield this.processUnaryExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.CallStatement:
+                    yield this.processNode(node.expression);
+                    return;
+                case miniscript_core_1.ASTType.CallExpression:
+                    yield this.processCallExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.EmptyExpression:
+                    this.push({
+                        op: instruction_1.OpCode.PUSH,
+                        source: this.getSourceLocation(node),
+                        value: default_1.DefaultType.Void
+                    });
+                    return;
+                case greybel_core_1.ASTType.FeatureEnvarExpression:
+                    yield this.processEnvarExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.Comment:
+                    return;
+                default: {
+                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
+                        target: this.target.peek(),
+                        range
+                    });
+                }
+            }
+        });
+    }
+    processMemberExpression(node, isInvoke = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (node.base instanceof miniscript_core_1.ASTIdentifier && node.base.name === 'super') {
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getSourceLocation(node.identifier),
+                    value: new string_1.CustomString(node.identifier.name)
+                });
+                this.push({
+                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
+                    source: this.getSourceLocation(node.identifier),
+                    invoke: isInvoke
+                });
+            }
+            else {
+                yield this.processSubNode(node.base);
+                if (node.identifier instanceof miniscript_core_1.ASTIdentifier) {
+                    yield this.processIdentifier(node.identifier, false, isInvoke);
+                }
+                else {
+                    yield this.processSubNode(node.identifier);
+                }
+            }
+        });
+    }
+    processIndexExpression(node, isInvoke = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (node.base instanceof miniscript_core_1.ASTIdentifier && node.base.name === 'super') {
+                yield this.processSubNode(node.index);
+                this.push({
+                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
+                    source: this.getSourceLocation(node),
+                    invoke: isInvoke
+                });
+            }
+            else {
+                yield this.processSubNode(node.base);
+                yield this.processSubNode(node.index);
+                this.push({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: this.getSourceLocation(node.index),
+                    invoke: isInvoke
+                });
+            }
+        });
+    }
+    processSliceExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.processSubNode(node.base);
+            yield this.processSubNode(node.left);
+            yield this.processSubNode(node.right);
+            this.push({
+                op: instruction_1.OpCode.SLICE,
+                source: this.getSourceLocation(node)
+            });
+        });
+    }
+    processIdentifier(node, isFirst = true, isInvoke = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isFirst) {
+                switch (node.name) {
+                    case 'self': {
+                        this.push({
+                            op: instruction_1.OpCode.GET_SELF,
+                            source: this.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case 'super': {
+                        this.push({
+                            op: instruction_1.OpCode.GET_SUPER,
+                            source: this.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case 'outer': {
+                        this.push({
+                            op: instruction_1.OpCode.GET_OUTER,
+                            source: this.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case 'locals': {
+                        this.push({
+                            op: instruction_1.OpCode.GET_LOCALS,
+                            source: this.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    case 'globals': {
+                        this.push({
+                            op: instruction_1.OpCode.GET_GLOBALS,
+                            source: this.getSourceLocation(node)
+                        });
+                        return;
+                    }
+                    default: {
+                        this.push({
+                            op: instruction_1.OpCode.GET_VARIABLE,
+                            source: this.getSourceLocation(node),
+                            property: new string_1.CustomString(node.name),
+                            invoke: isInvoke
+                        });
+                    }
+                }
+            }
+            else {
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getSourceLocation(node),
+                    value: new string_1.CustomString(node.name)
+                });
+                this.push({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: this.getSourceLocation(node),
+                    invoke: isInvoke
+                });
+            }
+        });
+    }
+    processAssignmentStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let variable = node.variable;
+            if (variable instanceof miniscript_core_1.ASTUnaryExpression) {
+                variable = variable.argument;
+            }
+            if (variable instanceof miniscript_core_1.ASTMemberExpression) {
+                yield this.processSubNode(variable.base);
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getSourceLocation(variable.identifier),
+                    value: new string_1.CustomString(variable.identifier.name)
+                });
+            }
+            else if (variable instanceof miniscript_core_1.ASTIndexExpression) {
+                yield this.processSubNode(variable.base);
+                yield this.processSubNode(variable.index);
+            }
+            else if (variable instanceof miniscript_core_1.ASTIdentifier) {
+                this.push({
+                    op: instruction_1.OpCode.GET_LOCALS,
+                    source: this.getSourceLocation(variable)
+                });
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getSourceLocation(variable),
+                    value: new string_1.CustomString(variable.name)
+                });
+            }
+            else {
+                yield this.processSubNode(variable);
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getSourceLocation(variable),
+                    value: default_1.DefaultType.Void
+                });
+            }
+            yield this.processSubNode(node.init, false);
+            this.push({
+                op: instruction_1.OpCode.ASSIGN,
+                source: this.getSourceLocation(node)
+            });
+        });
+    }
+    processLiteral(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = generateCustomValueFromASTLiteral(node);
+            this.push({
+                op: instruction_1.OpCode.PUSH,
+                source: this.getSourceLocation(node),
+                value
+            });
+        });
+    }
+    processEvaluationExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.processSubNode(node.left);
+            yield this.processSubNode(node.right);
+            switch (node.operator) {
+                case miniscript_core_1.Operator.Isa: {
+                    this.push({
+                        op: instruction_1.OpCode.ISA,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Equal: {
+                    this.push({
+                        op: instruction_1.OpCode.EQUAL,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.NotEqual: {
+                    this.push({
+                        op: instruction_1.OpCode.NOT_EQUAL,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.LessThan: {
+                    this.push({
+                        op: instruction_1.OpCode.LESS_THAN,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.LessThanOrEqual: {
+                    this.push({
+                        op: instruction_1.OpCode.LESS_THAN_OR_EQUAL,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.GreaterThan: {
+                    this.push({
+                        op: instruction_1.OpCode.GREATER_THAN,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.GreaterThanOrEqual: {
+                    this.push({
+                        op: instruction_1.OpCode.GREATER_THAN_OR_EQUAL,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.And: {
+                    this.push({
+                        op: instruction_1.OpCode.AND,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Or: {
+                    this.push({
+                        op: instruction_1.OpCode.OR,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Plus: {
+                    this.push({
+                        op: instruction_1.OpCode.ADD,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Minus: {
+                    this.push({
+                        op: instruction_1.OpCode.SUB,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Asterik: {
+                    this.push({
+                        op: instruction_1.OpCode.MUL,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Slash: {
+                    this.push({
+                        op: instruction_1.OpCode.DIV,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Modulo: {
+                    this.push({
+                        op: instruction_1.OpCode.MOD,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case miniscript_core_1.Operator.Power: {
+                    this.push({
+                        op: instruction_1.OpCode.POW,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.BitwiseAnd: {
+                    this.push({
+                        op: instruction_1.OpCode.BITWISE_AND,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.BitwiseOr: {
+                    this.push({
+                        op: instruction_1.OpCode.BITWISE_OR,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.LeftShift: {
+                    this.push({
+                        op: instruction_1.OpCode.BITWISE_LEFT_SHIFT,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.RightShift: {
+                    this.push({
+                        op: instruction_1.OpCode.BITWISE_RIGHT_SHIFT,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                case greybel_core_1.Operator.UnsignedRightShift: {
+                    this.push({
+                        op: instruction_1.OpCode.BITWISE_UNSIGNED_RIGHT_SHIFT,
+                        source: this.getSourceLocation(node)
+                    });
+                    break;
+                }
+                default:
+                    throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
+            }
+        });
+    }
+    processReturn(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (node.argument) {
+                yield this.processSubNode(node.argument);
+            }
+            else {
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getSourceLocation(node),
+                    value: default_1.DefaultType.Void
+                });
+            }
+            this.push({
+                op: instruction_1.OpCode.RETURN,
+                source: this.getSourceLocation(node)
+            });
+        });
+    }
+    processBreak(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [_, end] = this.getLastJumpoint();
+            this.push({
+                op: instruction_1.OpCode.GOTO_A,
+                source: this.getSourceLocation(node),
+                goto: end
+            });
+        });
+    }
+    processContinue(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [start] = this.getLastJumpoint();
+            this.push({
+                op: instruction_1.OpCode.GOTO_A,
+                source: this.getSourceLocation(node),
+                goto: start
+            });
+        });
+    }
+    processMapConstructorExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const field of node.fields) {
+                yield this.processSubNode(field.key);
+                yield this.processSubNode(field.value);
+            }
+            this.push({
+                op: instruction_1.OpCode.CONSTRUCT_MAP,
+                source: this.getSourceLocation(node),
+                length: node.fields.length
+            });
+        });
+    }
+    processListConstructorExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const field of node.fields) {
+                yield this.processSubNode(field.value);
+            }
+            this.push({
+                op: instruction_1.OpCode.CONSTRUCT_LIST,
+                source: this.getSourceLocation(node),
+                length: node.fields.length
+            });
+        });
+    }
+    processFunctionDeclaration(node, ignoreOuter = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = [];
+            for (const item of node.parameters) {
+                if (item instanceof miniscript_core_1.ASTIdentifier) {
+                    args.push({
+                        name: new string_1.CustomString(item.name),
+                        defaultValue: default_1.DefaultType.Void
+                    });
+                }
+                else if (item instanceof miniscript_core_1.ASTAssignmentStatement) {
+                    let defaultValue = default_1.DefaultType.Void;
+                    if (item.init instanceof miniscript_core_1.ASTLiteral) {
+                        defaultValue = generateCustomValueFromASTLiteral(item.init);
+                    }
+                    args.push({
+                        name: new string_1.CustomString(item.variable.name),
+                        defaultValue
+                    });
+                }
+            }
+            this.pushContext();
+            for (const item of node.body) {
+                yield this.processNode(item);
+            }
+            const fnCode = this.popContext().code;
+            this.push({
+                op: instruction_1.OpCode.FUNCTION_DEFINITION,
+                source: this.getSourceLocation(node),
+                arguments: args,
+                code: fnCode,
+                /*
+                  Can be removed after MiniScript fixed outer context bug.
+                */
+                ignoreOuter
+            });
+        });
+    }
+    processWhileStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const start = {
+                op: instruction_1.OpCode.NOOP,
+                source: this.getSourceLocation(node.condition)
+            };
+            const end = {
+                op: instruction_1.OpCode.NOOP,
+                source: this.getSourceLocation(node)
+            };
+            this.push(start);
+            yield this.processSubNode(node.condition);
+            this.push({
+                op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                source: this.getSourceLocation(node.condition),
+                goto: end
+            });
+            this.pushJumppoint(start, end);
+            for (const item of node.body) {
+                yield this.processNode(item);
+            }
+            this.popJumppoint();
+            this.push({
+                op: instruction_1.OpCode.GOTO_A,
+                source: this.getSourceLocation(node.condition),
+                goto: start
+            });
+            this.push(end);
+        });
+    }
+    processUnaryExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const arg = node.argument;
+            switch (node.operator) {
+                case miniscript_core_1.Operator.Reference:
+                    if (arg instanceof miniscript_core_1.ASTMemberExpression) {
+                        yield this.processMemberExpression(arg, false);
+                    }
+                    else if (arg instanceof miniscript_core_1.ASTIndexExpression) {
+                        yield this.processIndexExpression(arg, false);
+                    }
+                    else if (arg instanceof miniscript_core_1.ASTIdentifier) {
+                        yield this.processIdentifier(arg, true, false);
+                    }
+                    else {
+                        yield this.processSubNode(arg);
+                    }
+                    return;
+                case miniscript_core_1.Operator.Not: {
+                    yield this.processSubNode(arg);
+                    this.push({
+                        op: instruction_1.OpCode.FALSIFY,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                }
+                case miniscript_core_1.Operator.Minus: {
+                    yield this.processSubNode(arg);
+                    this.push({
+                        op: instruction_1.OpCode.NEGATE,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                }
+                case miniscript_core_1.Operator.New: {
+                    yield this.processSubNode(arg);
+                    this.push({
+                        op: instruction_1.OpCode.NEW,
+                        source: this.getSourceLocation(node)
+                    });
+                    return;
+                }
+            }
+        });
+    }
+    processCallExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pushArgs = () => __awaiter(this, void 0, void 0, function* () {
+                for (const arg of node.arguments) {
+                    yield this.processSubNode(arg);
+                }
+            });
+            const left = node.base;
+            if (left instanceof miniscript_core_1.ASTMemberExpression) {
+                if (left.base instanceof miniscript_core_1.ASTIdentifier && left.base.name === 'super') {
+                    this.push({
+                        op: instruction_1.OpCode.PUSH,
+                        source: this.getSourceLocation(left.identifier),
+                        value: new string_1.CustomString(left.identifier.name)
+                    });
+                    yield pushArgs();
+                    this.push({
+                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
+                        source: this.getSourceLocation(node),
+                        length: node.arguments.length
+                    });
+                }
+                else {
+                    yield this.processSubNode(left.base);
+                    this.push({
+                        op: instruction_1.OpCode.PUSH,
+                        source: this.getSourceLocation(left.identifier),
+                        value: new string_1.CustomString(left.identifier.name)
+                    });
+                    yield pushArgs();
+                    this.push({
+                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
+                        source: this.getSourceLocation(node),
+                        length: node.arguments.length
+                    });
+                }
+            }
+            else if (left instanceof miniscript_core_1.ASTIndexExpression) {
+                if (left.base instanceof miniscript_core_1.ASTIdentifier && left.base.name === 'super') {
+                    yield this.processSubNode(left.index);
+                    yield pushArgs();
+                    this.push({
+                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
+                        source: this.getSourceLocation(node),
+                        length: node.arguments.length
+                    });
+                }
+                else {
+                    yield this.processSubNode(left.base);
+                    yield this.processSubNode(left.index);
+                    yield pushArgs();
+                    this.push({
+                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
+                        source: this.getSourceLocation(node),
+                        length: node.arguments.length
+                    });
+                }
+            }
+            else if (left instanceof miniscript_core_1.ASTIdentifier) {
+                yield this.processIdentifier(left, true, false);
+                yield pushArgs();
+                this.push({
+                    op: instruction_1.OpCode.CALL,
+                    source: this.getSourceLocation(node),
+                    length: node.arguments.length
+                });
+            }
+            else {
+                yield this.processSubNode(left);
+                yield pushArgs();
+                this.push({
+                    op: instruction_1.OpCode.CALL,
+                    source: this.getSourceLocation(node),
+                    length: node.arguments.length
+                });
+            }
+        });
+    }
+    processIfStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const end = {
+                op: instruction_1.OpCode.NOOP,
+                source: this.getSourceLocation(node)
+            };
+            for (const clause of node.clauses) {
+                if (clause instanceof miniscript_core_1.ASTIfClause) {
+                    const next = {
+                        op: instruction_1.OpCode.NOOP,
+                        source: this.getSourceLocation(clause)
+                    };
+                    yield this.processSubNode(clause.condition);
+                    this.push({
+                        op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                        source: this.getSourceLocation(node),
+                        goto: next
+                    });
+                    for (const item of clause.body) {
+                        yield this.processNode(item);
+                    }
+                    this.push({
+                        op: instruction_1.OpCode.GOTO_A,
+                        source: this.getSourceLocation(node),
+                        goto: end
+                    });
+                    this.push(next);
+                }
+                else if (clause instanceof miniscript_core_1.ASTElseClause) {
+                    for (const item of clause.body) {
+                        yield this.processNode(item);
+                    }
+                }
+            }
+            this.push(end);
+        });
+    }
+    processForGenericStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const variable = node.variable;
+            const idxVariable = new string_1.CustomString(`__${variable.name}_idx`);
+            const start = {
+                op: instruction_1.OpCode.NEXT,
+                source: this.getSourceLocation(node.iterator),
+                idxVariable,
+                variable: new string_1.CustomString(variable.name)
+            };
+            const end = {
+                op: instruction_1.OpCode.POP_ITERATOR,
+                source: this.getSourceLocation(node.iterator)
+            };
+            this.push({
+                op: instruction_1.OpCode.GET_LOCALS,
+                source: this.getSourceLocation(node)
+            });
+            this.push({
+                op: instruction_1.OpCode.PUSH,
+                source: this.getSourceLocation(node),
+                value: idxVariable
+            });
+            this.push({
+                op: instruction_1.OpCode.PUSH,
+                source: this.getSourceLocation(node),
+                value: new number_1.CustomNumber(-1)
+            });
+            this.push({
+                op: instruction_1.OpCode.ASSIGN,
+                source: this.getSourceLocation(node)
+            });
+            yield this.processSubNode(node.iterator);
+            this.push({
+                op: instruction_1.OpCode.PUSH_ITERATOR,
+                source: this.getSourceLocation(node.iterator)
+            });
+            this.push(start);
+            this.push({
+                op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                source: this.getSourceLocation(node.iterator),
+                goto: end
+            });
+            for (const item of node.body) {
+                yield this.processNode(item);
+            }
+            this.push({
+                op: instruction_1.OpCode.GOTO_A,
+                source: this.getSourceLocation(node.iterator),
+                goto: start
+            });
+            this.push(end);
+        });
+    }
+    processEnvarExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.push({
+                op: instruction_1.OpCode.PUSH,
+                source: this.getSourceLocation(node),
+                value: new string_1.CustomString(node.name)
+            });
+            this.push({
+                op: instruction_1.OpCode.GET_ENVAR,
+                source: this.getSourceLocation(node)
+            });
+        });
+    }
+    createImport(node, path, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.target.push(path);
+                this.pushContext();
+                const childNodes = this.parse(code);
+                this.push({
+                    op: instruction_1.OpCode.GET_LOCALS,
+                    source: this.getInternalLocation()
+                });
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getInternalLocation(),
+                    value: new string_1.CustomString('module')
+                });
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getInternalLocation(),
+                    value: new string_1.CustomString('exports')
+                });
+                this.push({
+                    op: instruction_1.OpCode.CONSTRUCT_MAP,
+                    source: this.getInternalLocation(),
+                    length: 0
+                });
+                this.push({
+                    op: instruction_1.OpCode.CONSTRUCT_MAP,
+                    source: this.getInternalLocation(),
+                    length: 1
+                });
+                this.push({
+                    op: instruction_1.OpCode.ASSIGN,
+                    source: this.getInternalLocation(),
+                });
+                yield this.processNode(childNodes);
+                this.push({
+                    op: instruction_1.OpCode.GET_VARIABLE,
+                    source: this.getInternalLocation(),
+                    property: new string_1.CustomString('module')
+                });
+                this.push({
+                    op: instruction_1.OpCode.PUSH,
+                    source: this.getInternalLocation(),
+                    value: new string_1.CustomString('exports')
+                });
+                this.push({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: this.getInternalLocation(),
+                });
+                const context = this.popContext();
+                this.target.pop();
+                this.imports.set(path, context.code);
+            }
+            catch (err) {
+                if (err instanceof error_1.PrepareError) {
+                    throw err;
+                }
+                throw new error_1.PrepareError(err.message, {
+                    target: path,
+                    range: new miniscript_core_1.ASTRange(node.start, node.end)
+                }, err);
+            }
+        });
+    }
+    processImportExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTarget = this.target.peek();
+            const importTarget = yield this.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
+            if (this.target.includes(importTarget)) {
+                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.start.line}. Using noop instead to prevent overflow.`);
+                return;
+            }
+            if (!this.imports.has(importTarget)) {
+                const code = yield this.handler.resourceHandler.get(importTarget);
+                if (code == null) {
+                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    throw new error_1.PrepareError(`Cannot find import "${currentTarget}"`, {
+                        target: currentTarget,
+                        range
+                    });
+                }
+                yield this.createImport(node, importTarget, code);
+            }
+            this.push({
+                op: instruction_1.OpCode.GET_LOCALS,
+                source: this.getSourceLocation(node)
+            });
+            this.push({
+                op: instruction_1.OpCode.PUSH,
+                source: this.getSourceLocation(node),
+                value: new string_1.CustomString(node.name.name),
+            });
+            this.push({
+                op: instruction_1.OpCode.IMPORT,
+                source: this.getSourceLocation(node),
+                path: importTarget
+            });
+            this.push({
+                op: instruction_1.OpCode.ASSIGN,
+                source: this.getSourceLocation(node)
+            });
+        });
+    }
+    processIncludeExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTarget = this.target.peek();
+            const importTarget = yield this.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
+            if (this.target.includes(importTarget)) {
+                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.start.line}. Using noop instead to prevent overflow.`);
+                return;
+            }
+            const code = yield this.handler.resourceHandler.get(importTarget);
+            if (code == null) {
+                const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                throw new error_1.PrepareError(`Cannot find import "${currentTarget}"`, {
+                    target: currentTarget,
+                    range
+                });
+            }
+            try {
+                this.target.push(importTarget);
+                const childNodes = this.parse(code);
+                yield this.processNode(childNodes);
+                this.target.pop();
+            }
+            catch (err) {
+                if (err instanceof error_1.PrepareError) {
+                    throw err;
+                }
+                throw new error_1.PrepareError(err.message, {
+                    target: importTarget,
+                    range: new miniscript_core_1.ASTRange(node.start, node.end)
+                }, err);
+            }
+        });
+    }
+    processDebuggerExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.push({
+                op: instruction_1.OpCode.BREAKPOINT_ENABLE,
+                source: this.getSourceLocation(node)
+            });
+            this.push({
+                op: instruction_1.OpCode.BREAKPOINT,
+                source: this.getSourceLocation(node)
+            });
+        });
+    }
+}
+exports.BytecodeGenerator = BytecodeGenerator;