greybel-interpreter 4.5.13 → 4.6.0

package/dist/bytecode-generator/statement.js

@@ -0,0 +1,825 @@
+"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.BytecodeStatementGenerator = void 0;
+const greybel_core_1 = require("greybel-core");
+const miniscript_core_1 = require("miniscript-core");
+const default_1 = require("../types/default");
+const number_1 = require("../types/number");
+const string_1 = require("../types/string");
+const error_1 = require("../utils/error");
+const expression_1 = require("./expression");
+const instruction_1 = require("./instruction");
+const keywords_1 = require("./keywords");
+const module_1 = require("./module");
+const utils_1 = require("./utils");
+class BytecodeStatementGenerator {
+    constructor(context, parseCodeFunction) {
+        this.context = context;
+        this.exprGenerator = new expression_1.BytecodeExpressionGenerator(this.context, parseCodeFunction, this);
+        this.parseCode = parseCodeFunction;
+    }
+    process(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            if (this.context.isDebugMode()) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.BREAKPOINT,
+                    source: mod.getSourceLocation(node)
+                });
+            }
+            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:
+                    return;
+                case miniscript_core_1.ASTType.Identifier:
+                    yield this.processIdentifier(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.process(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:
+                    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.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);
+                    return;
+                case miniscript_core_1.ASTType.ListConstructorExpression:
+                    yield this.processListConstructorExpression(node);
+                    return;
+                case miniscript_core_1.ASTType.FunctionDeclaration:
+                    return;
+                case miniscript_core_1.ASTType.WhileStatement:
+                    yield this.processWhileStatement(node);
+                    return;
+                case miniscript_core_1.ASTType.ParenthesisExpression:
+                    yield this.process(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.process(node.expression);
+                    return;
+                case miniscript_core_1.ASTType.CallExpression:
+                    yield this.processCallExpression(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:
+                    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.context.target.peek(),
+                        range
+                    });
+                }
+            }
+        });
+    }
+    processMemberExpression(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const base = (0, utils_1.unwrap)(node.base);
+            if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(node.identifier),
+                    value: new string_1.CustomString(node.identifier.name)
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
+                    source: mod.getSourceLocation(node.identifier),
+                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference),
+                    command: true
+                });
+            }
+            else {
+                yield this.exprGenerator.process(base);
+                yield this.processIdentifier(node.identifier, {
+                    isDescending: true,
+                    isReference: !!(context === null || context === void 0 ? void 0 : context.isReference)
+                });
+            }
+        });
+    }
+    processIndexExpression(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const base = (0, utils_1.unwrap)(node.base);
+            if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                yield this.exprGenerator.process(node.index);
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_SUPER_PROPERTY,
+                    source: mod.getSourceLocation(node.index, node.type),
+                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference),
+                    command: true
+                });
+            }
+            else {
+                yield this.exprGenerator.process(base);
+                yield this.exprGenerator.process(node.index);
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: mod.getSourceLocation(node.index, node.type),
+                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference),
+                    command: true
+                });
+            }
+        });
+    }
+    processIdentifier(node, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            if (!(context === null || context === void 0 ? void 0 : context.isDescending)) {
+                switch (node.name) {
+                    case keywords_1.RuntimeKeyword.Self:
+                    case keywords_1.RuntimeKeyword.Super:
+                    case keywords_1.RuntimeKeyword.Outer:
+                    case keywords_1.RuntimeKeyword.Locals:
+                    case keywords_1.RuntimeKeyword.Globals: {
+                        return;
+                    }
+                    default: {
+                        mod.pushCode({
+                            op: instruction_1.OpCode.GET_VARIABLE,
+                            source: mod.getSourceLocation(node),
+                            property: new string_1.CustomString(node.name),
+                            invoke: !(context === null || context === void 0 ? void 0 : context.isReference),
+                            command: true
+                        });
+                    }
+                }
+            }
+            else {
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(node),
+                    value: new string_1.CustomString(node.name)
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: mod.getSourceLocation(node),
+                    invoke: !(context === null || context === void 0 ? void 0 : context.isReference),
+                    command: true
+                });
+            }
+        });
+    }
+    processAssignmentStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            let variable = (0, utils_1.unwrap)(node.variable);
+            if (variable instanceof miniscript_core_1.ASTUnaryExpression) {
+                variable = (0, utils_1.unwrap)(variable.argument);
+            }
+            if (variable instanceof miniscript_core_1.ASTMemberExpression) {
+                yield this.exprGenerator.process(variable.base);
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(variable.identifier),
+                    value: new string_1.CustomString(variable.identifier.name)
+                });
+            }
+            else if (variable instanceof miniscript_core_1.ASTIndexExpression) {
+                yield this.exprGenerator.process(variable.base);
+                yield this.exprGenerator.process(variable.index);
+            }
+            else if (variable instanceof miniscript_core_1.ASTIdentifier) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_LOCALS,
+                    source: mod.getSourceLocation(variable)
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(variable),
+                    value: new string_1.CustomString(variable.name)
+                });
+            }
+            else {
+                yield this.exprGenerator.process(variable);
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(variable),
+                    value: default_1.DefaultType.Void
+                });
+            }
+            yield this.exprGenerator.process(node.init, { includeOuter: true });
+            mod.pushCode({
+                op: instruction_1.OpCode.ASSIGN,
+                source: mod.getSourceLocation(node)
+            });
+        });
+    }
+    processEvaluationExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const skip = {
+                op: instruction_1.OpCode.NOOP,
+                source: mod.getSourceLocation(node)
+            };
+            yield this.exprGenerator.process(node.left);
+            if (node.operator === miniscript_core_1.Operator.And) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                    source: mod.getSourceLocation(node),
+                    goto: skip
+                });
+            }
+            else if (node.operator === miniscript_core_1.Operator.Or) {
+                mod.pushCode({
+                    op: instruction_1.OpCode.GOTO_A_IF_TRUE,
+                    source: mod.getSourceLocation(node),
+                    goto: skip
+                });
+            }
+            yield this.process(node.right);
+            switch (node.operator) {
+                case miniscript_core_1.Operator.And:
+                case miniscript_core_1.Operator.Or: {
+                    mod.pushCode(skip);
+                    break;
+                }
+                case miniscript_core_1.Operator.Isa:
+                case miniscript_core_1.Operator.Equal:
+                case miniscript_core_1.Operator.NotEqual:
+                case miniscript_core_1.Operator.LessThan:
+                case miniscript_core_1.Operator.LessThanOrEqual:
+                case miniscript_core_1.Operator.GreaterThan:
+                case miniscript_core_1.Operator.GreaterThanOrEqual:
+                case miniscript_core_1.Operator.Plus:
+                case miniscript_core_1.Operator.Minus:
+                case miniscript_core_1.Operator.Asterik:
+                case miniscript_core_1.Operator.Slash:
+                case miniscript_core_1.Operator.Modulo:
+                case miniscript_core_1.Operator.Power:
+                case greybel_core_1.Operator.BitwiseAnd:
+                case greybel_core_1.Operator.BitwiseOr:
+                case greybel_core_1.Operator.LeftShift:
+                case greybel_core_1.Operator.RightShift:
+                case greybel_core_1.Operator.UnsignedRightShift: {
+                    break;
+                }
+                default:
+                    throw new Error(`Unexpected evaluation expression operator. ("${node.operator}")`);
+            }
+        });
+    }
+    processReturn(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            if (mod.isGlobalScope()) {
+                if (node.argument) {
+                    yield this.process(node.argument);
+                }
+                return;
+            }
+            if (node.argument) {
+                yield this.exprGenerator.process(node.argument);
+            }
+            else {
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getSourceLocation(node),
+                    value: default_1.DefaultType.Void
+                });
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.RETURN,
+                source: mod.getSourceLocation(node)
+            });
+        });
+    }
+    processBreak(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const jumpPoint = mod.getJumpPoint();
+            if (jumpPoint === null)
+                return;
+            const end = jumpPoint[1];
+            mod.pushCode({
+                op: instruction_1.OpCode.GOTO_A,
+                source: mod.getSourceLocation(node),
+                goto: end
+            });
+        });
+    }
+    processContinue(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const jumpPoint = mod.getJumpPoint();
+            if (jumpPoint === null)
+                return;
+            const start = jumpPoint[0];
+            mod.pushCode({
+                op: instruction_1.OpCode.GOTO_A,
+                source: mod.getSourceLocation(node),
+                goto: start
+            });
+        });
+    }
+    processMapConstructorExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            for (const field of node.fields) {
+                yield this.exprGenerator.process(field.key);
+                yield this.exprGenerator.process(field.value);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.CONSTRUCT_MAP,
+                source: mod.getSourceLocation(node),
+                length: node.fields.length,
+                command: true
+            });
+        });
+    }
+    processListConstructorExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            for (const field of node.fields) {
+                yield this.exprGenerator.process(field.value);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.CONSTRUCT_LIST,
+                source: mod.getSourceLocation(node),
+                length: node.fields.length,
+                command: true
+            });
+        });
+    }
+    processWhileStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const start = {
+                op: instruction_1.OpCode.NOOP,
+                source: mod.getSourceLocation(node.condition)
+            };
+            const end = {
+                op: instruction_1.OpCode.NOOP,
+                source: mod.getSourceLocation(node)
+            };
+            mod.pushCode(start);
+            yield this.exprGenerator.process(node.condition);
+            mod.pushCode({
+                op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                source: mod.getSourceLocation(node.condition),
+                goto: end
+            });
+            mod.pushJumppoint(start, end);
+            for (const item of node.body) {
+                yield this.process(item);
+            }
+            mod.popJumppoint();
+            mod.pushCode({
+                op: instruction_1.OpCode.GOTO_A,
+                source: mod.getSourceLocation(node.condition),
+                goto: start
+            });
+            mod.pushCode(end);
+        });
+    }
+    processUnaryExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const arg = (0, utils_1.unwrap)(node.argument);
+            switch (node.operator) {
+                case miniscript_core_1.Operator.Reference:
+                    if (arg instanceof miniscript_core_1.ASTMemberExpression) {
+                        yield this.processMemberExpression(arg, { isReference: true });
+                    }
+                    else if (arg instanceof miniscript_core_1.ASTIndexExpression) {
+                        yield this.processIndexExpression(arg, { isReference: true });
+                    }
+                    else if (arg instanceof miniscript_core_1.ASTIdentifier) {
+                        yield this.processIdentifier(arg, {
+                            isDescending: false,
+                            isReference: true
+                        });
+                    }
+                    else {
+                        yield this.process(arg);
+                    }
+                    return;
+                case miniscript_core_1.Operator.Not: {
+                    yield this.exprGenerator.process(arg);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.FALSIFY,
+                        source: mod.getSourceLocation(node),
+                        command: true
+                    });
+                    return;
+                }
+                case miniscript_core_1.Operator.Minus: {
+                    yield this.exprGenerator.process(arg);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.NEGATE,
+                        source: mod.getSourceLocation(node),
+                        command: true
+                    });
+                    return;
+                }
+                case miniscript_core_1.Operator.New: {
+                    yield this.exprGenerator.process(arg);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.NEW,
+                        source: mod.getSourceLocation(node),
+                        command: true
+                    });
+                }
+            }
+        });
+    }
+    processCallExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const pushArgs = () => __awaiter(this, void 0, void 0, function* () {
+                for (const arg of node.arguments) {
+                    yield this.exprGenerator.process(arg);
+                }
+            });
+            const left = (0, utils_1.unwrap)(node.base);
+            if (left instanceof miniscript_core_1.ASTMemberExpression) {
+                const base = (0, utils_1.unwrap)(left.base);
+                if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(left.identifier),
+                        value: new string_1.CustomString(left.identifier.name)
+                    });
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
+                        source: mod.getSourceLocation(node.base, node.type),
+                        length: node.arguments.length,
+                        command: true
+                    });
+                }
+                else {
+                    yield this.exprGenerator.process(base);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.PUSH,
+                        source: mod.getSourceLocation(left.identifier),
+                        value: new string_1.CustomString(left.identifier.name)
+                    });
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
+                        source: mod.getSourceLocation(left.identifier, node.type),
+                        length: node.arguments.length,
+                        command: true
+                    });
+                }
+            }
+            else if (left instanceof miniscript_core_1.ASTIndexExpression) {
+                const base = (0, utils_1.unwrap)(left.base);
+                if (base instanceof miniscript_core_1.ASTIdentifier && base.name === keywords_1.RuntimeKeyword.Super) {
+                    yield this.exprGenerator.process(left.index);
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_SUPER_PROPERTY,
+                        source: mod.getSourceLocation(left.index, node.type),
+                        length: node.arguments.length,
+                        command: true
+                    });
+                }
+                else {
+                    yield this.exprGenerator.process(base);
+                    yield this.exprGenerator.process(left.index);
+                    yield pushArgs();
+                    mod.pushCode({
+                        op: instruction_1.OpCode.CALL_WITH_CONTEXT,
+                        source: mod.getSourceLocation(left.index, node.type),
+                        length: node.arguments.length,
+                        command: true
+                    });
+                }
+            }
+            else if (left instanceof miniscript_core_1.ASTIdentifier) {
+                yield this.exprGenerator.processIdentifier(left, {
+                    isDescending: false,
+                    isReference: true
+                });
+                yield pushArgs();
+                mod.pushCode({
+                    op: instruction_1.OpCode.CALL,
+                    source: mod.getSourceLocation(left, node.type),
+                    length: node.arguments.length,
+                    command: true
+                });
+            }
+            else {
+                yield this.exprGenerator.process(left);
+                yield pushArgs();
+                mod.pushCode({
+                    op: instruction_1.OpCode.CALL,
+                    source: mod.getSourceLocation(left, node.type),
+                    length: node.arguments.length,
+                    command: true
+                });
+            }
+        });
+    }
+    processIfStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const end = {
+                op: instruction_1.OpCode.NOOP,
+                source: mod.getSourceLocation(node)
+            };
+            for (const clause of node.clauses) {
+                if (clause instanceof miniscript_core_1.ASTIfClause) {
+                    const next = {
+                        op: instruction_1.OpCode.NOOP,
+                        source: mod.getSourceLocation(clause)
+                    };
+                    yield this.exprGenerator.process(clause.condition);
+                    mod.pushCode({
+                        op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                        source: mod.getSourceLocation(node),
+                        goto: next
+                    });
+                    for (const item of clause.body) {
+                        yield this.process(item);
+                    }
+                    mod.pushCode({
+                        op: instruction_1.OpCode.GOTO_A,
+                        source: mod.getSourceLocation(node),
+                        goto: end
+                    });
+                    mod.pushCode(next);
+                }
+                else if (clause instanceof miniscript_core_1.ASTElseClause) {
+                    for (const item of clause.body) {
+                        yield this.process(item);
+                    }
+                }
+            }
+            mod.pushCode(end);
+        });
+    }
+    processForGenericStatement(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mod = this.context.module.peek();
+            const variable = node.variable;
+            const idxVariable = new string_1.CustomString(`__${variable.name}_idx`);
+            const start = {
+                op: instruction_1.OpCode.NEXT,
+                source: mod.getSourceLocation(node.iterator),
+                idxVariable,
+                variable: new string_1.CustomString(variable.name)
+            };
+            const end = {
+                op: instruction_1.OpCode.POP_ITERATOR,
+                source: mod.getSourceLocation(node.iterator)
+            };
+            mod.pushJumppoint(start, end);
+            mod.pushCode({
+                op: instruction_1.OpCode.GET_LOCALS,
+                source: mod.getSourceLocation(node)
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH,
+                source: mod.getSourceLocation(node),
+                value: idxVariable
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH,
+                source: mod.getSourceLocation(node),
+                value: new number_1.CustomNumber(-1)
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.ASSIGN,
+                source: mod.getSourceLocation(node)
+            });
+            yield this.exprGenerator.process(node.iterator);
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH_ITERATOR,
+                source: mod.getSourceLocation(node.iterator)
+            });
+            mod.pushCode(start);
+            mod.pushCode({
+                op: instruction_1.OpCode.GOTO_A_IF_FALSE,
+                source: mod.getSourceLocation(node.iterator),
+                goto: end
+            });
+            for (const item of node.body) {
+                yield this.process(item);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.GOTO_A,
+                source: mod.getSourceLocation(node.iterator),
+                goto: start
+            });
+            mod.pushCode(end);
+            mod.popJumppoint();
+        });
+    }
+    createImport(node, path, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const mod = new module_1.Module(path);
+                this.context.target.push(path);
+                this.context.module.push(mod);
+                const childNodes = this.parseCode(code);
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_LOCALS,
+                    source: mod.getInternalLocation()
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getInternalLocation(),
+                    value: new string_1.CustomString('module')
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getInternalLocation(),
+                    value: new string_1.CustomString('exports')
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.CONSTRUCT_MAP,
+                    source: mod.getInternalLocation(),
+                    length: 0
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.CONSTRUCT_MAP,
+                    source: mod.getInternalLocation(),
+                    length: 1
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.ASSIGN,
+                    source: mod.getInternalLocation()
+                });
+                yield this.process(childNodes);
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_VARIABLE,
+                    source: mod.getInternalLocation(),
+                    property: new string_1.CustomString('module')
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.PUSH,
+                    source: mod.getInternalLocation(),
+                    value: new string_1.CustomString('exports')
+                });
+                mod.pushCode({
+                    op: instruction_1.OpCode.GET_PROPERTY,
+                    source: mod.getInternalLocation()
+                });
+                this.context.module.pop();
+                this.context.target.pop();
+                this.context.imports.set(path, mod.getCode());
+            }
+            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 mod = this.context.module.peek();
+            const currentTarget = this.context.target.peek();
+            const importTarget = yield this.context.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
+            if (this.context.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.context.imports.has(importTarget)) {
+                const code = yield this.context.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);
+            }
+            mod.pushCode({
+                op: instruction_1.OpCode.GET_LOCALS,
+                source: mod.getSourceLocation(node)
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.PUSH,
+                source: mod.getSourceLocation(node),
+                value: new string_1.CustomString(node.name.name)
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.IMPORT,
+                source: mod.getSourceLocation(node),
+                path: importTarget
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.ASSIGN,
+                source: mod.getSourceLocation(node)
+            });
+        });
+    }
+    processIncludeExpression(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTarget = this.context.target.peek();
+            const importTarget = yield this.context.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
+            if (this.context.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.context.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.context.target.push(importTarget);
+                const childNodes = this.parseCode(code);
+                yield this.process(childNodes);
+                this.context.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* () {
+            const mod = this.context.module.peek();
+            mod.pushCode({
+                op: instruction_1.OpCode.BREAKPOINT_ENABLE,
+                source: mod.getSourceLocation(node)
+            });
+            mod.pushCode({
+                op: instruction_1.OpCode.BREAKPOINT,
+                source: mod.getSourceLocation(node)
+            });
+        });
+    }
+}
+exports.BytecodeStatementGenerator = BytecodeStatementGenerator;