pure-dango 1.8.0

package/src/core/compiler.ts

@@ -0,0 +1,1269 @@
+import {runtimeErrors} from "../runtime/errors";
+import {errorTemplate} from "../runtime/stdlib";
+
+type Bytecode = Array<any>;
+type LoopInfo =
+{
+    start             : number,
+    continueTarget    : number | null,
+    end               : number | null,
+    breakPositions    : number[],
+    continuePositions : number[]
+}
+type TypeMap = Map<string, (node : any, bytecode : Bytecode, keepValue : boolean) => void>;
+
+function storeArgument(argument : any, bytecode : Bytecode) : void
+{
+    if (argument.type === "VariableReference") 
+        bytecode.push(operators.STORE, argument.value);
+    else if (argument.type === "MemberExpression")
+    {
+        parseObject(argument.object, bytecode, true);
+        bytecode.push(operators.PUSH, argument.property);
+        bytecode.push(operators.ARRSET);
+    }
+    else if (argument.type === "ArrayAccess")
+    {
+        parseObject(argument.object, bytecode, true);
+        parseObject(argument.index, bytecode, true);
+        bytecode.push(operators.ARRSET);
+    }
+    else 
+        throw new Error(`Invalid assignment target: "${argument.type}" at line ${argument.line}:${argument.column}`);
+}
+
+function handleDecrementAndIncrementOperator(node : any, type : number, bytecode : Bytecode, keepValue : boolean) : void
+{
+    parseObject(node.argument, bytecode, true);
+    bytecode.push(operators.PUSH, 1);
+    bytecode.push(type);
+    storeArgument(node.argument, bytecode);   // update variable
+
+    if (keepValue) 
+        parseObject(node.argument, bytecode, true) // return the updated if keepValue is true
+}
+
+function simpleUnary(node : any, bytecode : Bytecode, operator : number, keepValue : boolean) : void
+{
+    parseObject(node.argument, bytecode, true);
+    bytecode.push(operator);
+
+    if (!keepValue) 
+        bytecode.push(operators.POP);
+}
+
+function parseObject(node : any, bytecode : Bytecode = [], keepValue : boolean = false) : Bytecode
+{
+    const typeFunction = typeMap.get(node?.type);
+
+    if (!typeFunction)
+        errorTemplate(`parseObject`, `unknown node type "${node?.type}" with value ${node?.value} at line ${node?.row}:${node?.column}`);
+
+    typeFunction(node, bytecode, keepValue);
+    return bytecode;
+}
+
+function loopStatementHandler(statementName : string, bytecode : Bytecode, child : string) : void
+{
+    if (loopStack.length < 1) 
+    {
+        if (statementName === "break") 
+            throw new runtimeErrors.BreakError();
+        if (statementName === "continue") 
+            throw new runtimeErrors.ContinueError();
+    }
+    const currentLoop = loopStack[loopStack.length - 1];
+    
+    if (child === "start")
+    {
+        const continuePosition = bytecode.length;
+        bytecode.push(operators.JMP, 0);
+
+        if (!currentLoop.continuePositions) currentLoop.continuePositions = [];
+
+        currentLoop.continuePositions.push(continuePosition);
+    }
+    
+    else
+    {
+        const breakPosition = bytecode.length;
+        bytecode.push(operators.JMP, 0);
+       
+        if (!currentLoop.breakPositions) currentLoop.breakPositions = [];
+
+        currentLoop.breakPositions.push(breakPosition);
+    }
+}
+
+// Object.freeze makes this impossible to edit
+const operators : Record<string, number> = Object.freeze({
+    PUSH:       1,    // pushes a value on a stack
+    LOAD:       2,    // loads a variable
+    STORE:      3,    // stores a value in a variable
+    ALLOC:      4,    // makes a new variable
+    ADD:        5,    // short for addition
+    SUB:        6,    // short for subtract
+    MUL:        7,    // short for multiply
+    DIV:        8,    // short for divide
+    MOD:        9,    // short for modulo
+    CALL:       10,   // calls a function
+    NEG:        11,   // short for negative
+    NOT:        12, 
+    BITNOT:     13,   // flips all bits (~x = -(x+1))
+    JMP:        14,   // jumps
+    JZ:         15,   // jump if zero
+    EQ:         16,   // ==
+    NE:         17,   // !=
+    GT:         18,   // >
+    LT:         19,   // <
+    GTE:        20,   // >=
+    LTE:        21,   // <=
+    POP:        22,   // pops one item from the stack
+    PUSHSCP:    23,   // short for push scope
+    POPSCP:     24,   // short for pop scope
+    RETURN:     25,   // doesn't do anything
+    EXEC:       26,   // runs the stack.pop()'s code
+    MKFUNC:     27,   // stamps closure
+    MKARR:      28,   // creates an array from n items on the stack
+    ARRGET:     29,   // array index get
+    ARRSET:     30,   // array index set
+    MKOBJ:      31,   // creates an object from n items on the stack
+    MKCLASS:    32,   // creates a class object
+    MKINST:     33,   // creates an instance (new classname())
+    SETLINE:    34,   // this GENUINELY doesn't need a comment but: sets the row and column
+    SETFILE:    35,   // sets the current file name
+    SPREAD:     36,   // spreaded arguments
+    CALLMETHOD: 37,   
+    TRY:        38,   // start try block
+    ENDTRY:     39,   // end try-catch
+    OBJKEYS:    40,   // pops object, pushes Object.keys() as plain array
+    ARRLEN:     41,   // pops array, pushes its .length
+    ALLOCCONST: 42,   // allocates a variable as a constant
+    TYPECHECK:  43,   // checks the type of stack top, use: TYPECHECK variableName typeName
+    AND:        44,   // &
+    OR:         45,   // |
+    XOR:        46,   // ^
+    SHL:        47,   // <<
+    SHR:        48,   // >>
+    USHR:       49,   // >>>
+})
+
+const binaryOperators : Record<string, number> = Object.freeze({
+    "+":    operators.ADD,
+    "-":    operators.SUB,
+    "*":    operators.MUL,
+    "/":    operators.DIV,
+    "%":    operators.MOD,
+
+    "==":   operators.EQ,
+    "!=":   operators.NE,
+    ">":    operators.GT,
+    "<":    operators.LT,
+    ">=":   operators.GTE,
+    "<=":   operators.LTE,
+
+    "&":    operators.AND,
+    "|":    operators.OR,
+    "^":    operators.XOR,
+    "<<":   operators.SHL,
+    ">>":   operators.SHR,
+    ">>>":  operators.USHR,
+});
+
+const unaryOperators : Map<string, (node : any, bytecode : Bytecode, keepValue : boolean) => void> = new Map([
+    ["++", (node : any, bytecode : Bytecode, keepValue : boolean) =>   handleDecrementAndIncrementOperator(node, operators.ADD, bytecode, keepValue)], 
+    ["--", (node : any, bytecode : Bytecode, keepValue : boolean) =>   handleDecrementAndIncrementOperator(node, operators.SUB, bytecode, keepValue)], 
+
+    ["!", (node : any, bytecode : Bytecode, keepValue : boolean) =>    simpleUnary(node, bytecode, operators.NOT, keepValue)],
+    ["~", (node : any, bytecode : Bytecode, keepValue : boolean) =>    simpleUnary(node, bytecode, operators.BITNOT, keepValue)],
+    
+    ["-u", (node : any, bytecode : Bytecode, keepValue : boolean) =>   simpleUnary(node, bytecode, operators.NEG, keepValue)],
+    ["+u", (node : any, bytecode : Bytecode, keepValue : boolean) =>   parseObject(node.argument, bytecode, keepValue)],
+]);
+
+const loopStack : LoopInfo[] = [];
+
+let tempCounter = 0;
+function getTempName() : string
+{
+    return `__$temp${tempCounter++}`;
+}
+
+const typeMap : TypeMap = new Map([
+    ["Program", 
+        (node : any, bytecode : Bytecode) : void =>
+            node.body.forEach(
+                (n : any, i : number) =>
+                    parseObject(n, bytecode, i === node.body.length - 1)
+            )
+    ],
+
+    ["Literal",           (node : any, bytecode : Bytecode) : void => {bytecode.push(operators.PUSH, node.value)}],
+    ["StringLiteral",     (node : any, bytecode : Bytecode) : void => {bytecode.push(operators.PUSH, node.value)}],
+    ["VariableReference", 
+        (node : any, bytecode : Bytecode) : void => 
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0); 
+            bytecode.push(operators.LOAD, node.value)
+        }
+    ],
+
+    ["ArrayLiteral", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            node.elements.forEach((element : any) => parseObject(element, bytecode, true));
+            bytecode.push(operators.MKARR, node.elements.length);
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+    ["ObjectLiteral", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            for (const property of node.properties)
+            {
+                bytecode.push(operators.PUSH, property.key);
+                parseObject(property.value, bytecode, true);
+            }
+            bytecode.push(operators.MKOBJ, node.properties.length);
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["ClassDeclaration", 
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            const methods : Record<string, any> = {};
+
+            for (const method of node.methods)
+            {
+                const methodBytecode : Bytecode = [];
+                (method.body ?? []).forEach((n : any) => parseObject(n, methodBytecode));
+                methodBytecode.push(operators.PUSH, null);
+                methodBytecode.push(operators.RETURN);
+
+                const parameters = method.parameters.map
+                (
+                    (parameter: any) => 
+                    (
+                        {
+                            name           : parameter.name,
+                            rest           : parameter.rest,
+                            default        : parameter.default ? parseObject(parameter.default, [], true) : null,
+                            typeAnnotation : parameter.typeAnnotation ?? null
+                        }
+                    )
+                );
+
+                methods[method.name] = 
+                {
+                    name: method.name,
+                    bytecode: methodBytecode,
+                    parameters,
+                    ast: method
+                }
+            }
+
+            bytecode.push(operators.ALLOC, node.name);
+            bytecode.push(operators.PUSH,
+                {
+                    name : node.name,
+                    superclass : node.superclass,
+                    methods
+                }
+            );       
+
+            bytecode.push(operators.MKCLASS);
+            bytecode.push(operators.STORE, node.name);
+        }
+    ],
+
+    ["ClassInstantiation",
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            const len = bytecode.length;
+            node.args.forEach((argument : any) => parseObject(argument, bytecode, true));
+            bytecode.push(operators.MKINST, node.className, node.args.length);
+            
+            if (!keepValue) 
+                bytecode.push(operators.POP);
+        }
+    ],
+
+    ["ArrayAccess", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.object, bytecode, true);
+            parseObject(node.index, bytecode, true);
+            bytecode.push(operators.ARRGET);
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["MemberExpression", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.object, bytecode, true);
+            bytecode.push(operators.PUSH, node.property);
+            bytecode.push(operators.ARRGET);
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["BinaryExpression", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            parseObject(node.left, bytecode, true);
+            parseObject(node.right, bytecode, true);
+
+            const operator : number = binaryOperators[node.operator];
+
+            if (!operator) 
+                errorTemplate(`BinaryExpression`, `Unknown operator "${node.operator}"`);
+
+            bytecode.push(operator);
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["LogicalExpression", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            parseObject(node.left, bytecode, true);
+
+            if (node.operator === "&&")
+            {
+                const jumpToFalse : number = bytecode.length;
+                bytecode.push(operators.JZ, 0);
+
+                parseObject(node.right, bytecode, true);
+                
+                const jumpToEnd : number = bytecode.length;
+                bytecode.push(operators.JMP, 0);
+                
+                const falseLabel : number = bytecode.length;
+                bytecode[jumpToFalse + 1] = falseLabel;
+                bytecode.push(operators.PUSH, 0);
+                
+                const end : number = bytecode.length;
+                bytecode[jumpToEnd + 1] = end;
+            }
+
+            else if (node.operator === "??")
+            {
+                const tempName = `__nullish_${tempCounter++}__`;
+                bytecode.push(operators.ALLOC, tempName);
+                bytecode.push(operators.STORE, tempName);
+                bytecode.push(operators.LOAD,  tempName);
+
+                const jumpIfNull : number = bytecode.length;
+                bytecode.push(operators.JZ, 0); // if null/undefined, go to right
+
+                bytecode.push(operators.LOAD, tempName);
+                const jumpToEnd : number = bytecode.length;
+                bytecode.push(operators.JMP, 0);
+
+                const rightLabel : number = bytecode.length;
+                bytecode[jumpIfNull + 1] = rightLabel;
+                parseObject(node.right, bytecode, true);
+
+                const end : number = bytecode.length;
+                bytecode[jumpToEnd + 1] = end;
+            }
+
+            else
+            {
+                const jumpIfFalse : number = bytecode.length;
+                bytecode.push(operators.JZ, 0);
+
+                bytecode.push(operators.PUSH, 1);
+                
+                const jumpToEnd : number = bytecode.length;
+                bytecode.push(operators.JMP, 0);
+                
+                const falseLabel : number = bytecode.length;
+                bytecode[jumpIfFalse + 1] = falseLabel;
+                parseObject(node.right, bytecode, true);
+                
+                const end : number = bytecode.length;
+                bytecode[jumpToEnd + 1] = end;
+            }
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["ContinueStatement", (node : any, bytecode : Bytecode) : void => loopStatementHandler("continue", bytecode, "start")],
+    ["BreakStatement", (node : any, bytecode : Bytecode)    : void => loopStatementHandler("break", bytecode, "end")],
+
+    ["NewDeclaration", (node : any, bytecode : Bytecode) : number => bytecode.push(operators.ALLOC, node.name)],
+
+    ["NewAssignment", 
+        (node : any, bytecode) =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            if (node.constant)
+            {
+                parseObject(node.value, bytecode, true);
+
+                if (node.typeAnnotation)
+                    bytecode.push(operators.TYPECHECK, node.name, node.typeAnnotation);
+
+                bytecode.push(operators.ALLOCCONST, node.name);
+            }
+            else
+            {
+                bytecode.push(operators.ALLOC, node.name);
+                if (node.value !== null) 
+                    parseObject(node.value, bytecode, true);
+
+                if (node.typeAnnotation)
+                    bytecode.push(operators.TYPECHECK, node.name, node.typeAnnotation);
+
+                bytecode.push(operators.STORE, node.name);
+            }
+        }
+    ],
+
+    ["ArrayDestructure", 
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.value, bytecode, true);
+
+            // store in a hidden temp so we can reload per element
+            const temp = `__destructure_tmp_${tempCounter++}__`;
+            bytecode.push(operators.ALLOC, temp);
+            bytecode.push(operators.STORE, temp);
+
+            // alloc all target variables first (for non-const)
+            for (const name of node.names)
+            {
+                if (!node.constant)
+                    bytecode.push(operators.ALLOC, name);
+            }
+
+            for (let i = 0; i < node.names.length; i++)
+            {
+                const name = node.names[i];
+                bytecode.push(operators.LOAD, temp);
+                bytecode.push(operators.PUSH, String(i));
+                bytecode.push(operators.ARRGET);
+
+                if (node.constant)
+                    bytecode.push(operators.ALLOCCONST, name);
+                else
+                    bytecode.push(operators.STORE, name)
+            }
+
+            // clear temp to avoid stray BigInt in scope at the end of the program
+            bytecode.push(operators.PUSH, null);
+            bytecode.push(operators.STORE, temp);
+        }
+    ],
+
+    ["ObjectDestructure",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.value, bytecode, true);
+
+            const temp = `__destructure_tmp_${tempCounter++}__`;
+            bytecode.push(operators.ALLOC, temp);
+            bytecode.push(operators.STORE, temp);
+
+            for (const name of node.names)
+            {
+                if (!node.constant)
+                    bytecode.push(operators.ALLOC, name);
+            }
+
+            for (const name of node.names)
+            {
+                bytecode.push(operators.LOAD, temp);
+                bytecode.push(operators.PUSH, name); // string key
+                bytecode.push(operators.ARRGET);     // object[key]
+
+                if (node.constant)
+                    bytecode.push(operators.ALLOCCONST, name);
+                else
+                    bytecode.push(operators.STORE, name);
+            }
+
+            bytecode.push(operators.PUSH, null);
+            bytecode.push(operators.STORE, temp);
+        }
+    ],
+
+    ["Assignment", 
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.value, bytecode, true);
+            if (typeof node.name === "string") 
+            {
+                bytecode.push(operators.STORE, node.name);
+                if (keepValue) 
+                    bytecode.push(operators.LOAD, node.name);
+            }
+            else if (node.name.type === "MemberExpression")
+            {
+                parseObject(node.name.object, bytecode, true);
+                bytecode.push(operators.PUSH, node.name.property);
+                bytecode.push(operators.ARRSET);
+            }   
+            else
+            {
+                parseObject(node.name.object, bytecode, true);
+                parseObject(node.name.index, bytecode, true);
+                bytecode.push(operators.ARRSET);
+            }
+        }
+    ],
+
+    ["FunctionCall", 
+        (node : any, bytecode : Bytecode, keepValue : boolean = false) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            node.args.forEach
+            (
+                (argument : any) => 
+                {
+                    if (argument.type === "SpreadElement")
+                    {
+                        parseObject(argument.argument, bytecode, true);
+                        bytecode.push(operators.SPREAD);
+                    }
+                    else
+                        parseObject(argument, bytecode, true);
+                }
+            );
+
+            bytecode.push(operators.CALL, node.name, node.args.length);
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["UnaryExpression",
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            const operatorFunction = unaryOperators.get(node.value);
+            if (!operatorFunction) throw new Error(`Unknown unary operator: "${node.value}"`);
+            operatorFunction(node, bytecode, keepValue)
+        }
+    ],
+
+    ["PostfixUnaryExpression",
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            if (keepValue)
+            {
+                const tempName : string = getTempName();
+                bytecode.push(operators.ALLOC, tempName);                 // make the temp variable
+
+                parseObject(node.argument, bytecode, true);
+                bytecode.push(operators.STORE, tempName);                 // store the current value
+
+                parseObject(node.argument, bytecode, true);
+                bytecode.push(operators.PUSH, 1);
+                bytecode.push(node.operator === "++" ? operators.ADD : operators.SUB);
+                storeArgument(node.argument, bytecode);      // minus the variable by one
+
+                bytecode.push(operators.LOAD, tempName);                  // load the previous value if keepValue is true
+            }
+
+            else
+            {
+                parseObject(node.argument, bytecode, true);
+                bytecode.push(operators.PUSH, 1);
+                bytecode.push(node.operator === "++" ? operators.ADD : operators.SUB);
+                storeArgument(node.argument, bytecode);      // minus the variable by one
+            }
+        }
+    ],
+
+    ["IfStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {   
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.condition, bytecode, true);
+            const elseLabel : number = 0;
+            const endLabel  : number = 1;
+
+            const JZPosition : number = bytecode.length;
+            bytecode.push(operators.JZ, elseLabel);
+
+            bytecode.push(operators.PUSHSCP);                   // pushes an object to store local variables in
+            node.body.forEach((n : any) => parseObject(n, bytecode));   // parse the body which is a list
+            bytecode.push(operators.POPSCP);                    // delete the local variables 
+        
+            const JMPPosition : number = bytecode.length;
+            bytecode.push(operators.JMP, endLabel);
+
+            const elsePosition : number = bytecode.length;
+            bytecode[JZPosition + 1] = elsePosition;
+
+            if (node.else)
+            {
+                bytecode.push(operators.PUSHSCP);
+                node.else.forEach((n : any) => parseObject(n, bytecode));  // parse the else
+                bytecode.push(operators.POPSCP);
+            }
+
+            const endPosition : number = bytecode.length;
+            bytecode[JMPPosition + 1] = endPosition;
+        }
+    ],
+
+    ["TernaryExpression",
+        (node : any, bytecode : Bytecode, keepValue : boolean) : void =>
+        {
+            parseObject(node.condition, bytecode, true);
+
+            const JZPosition : number = bytecode.length;
+            bytecode.push(operators.JZ, 0);
+
+            parseObject(node.then, bytecode, true);
+
+            const JMPPosition : number = bytecode.length;
+            bytecode.push(operators.JMP, 0);
+
+            const elsePosition : number = bytecode.length;
+            bytecode[JZPosition + 1] = elsePosition;
+
+            parseObject(node.else, bytecode, true);
+
+            const endPosition : number = bytecode.length;
+            bytecode[JMPPosition + 1] = endPosition;
+
+            if (!keepValue) bytecode.push(operators.POP);
+        }
+    ],
+
+    ["ForStatement", 
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            bytecode.push(operators.PUSHSCP);
+            if (node.initial) parseObject(node.initial, bytecode);
+
+            const start : number = bytecode.length;
+            
+            const loopInfo : LoopInfo =
+            { 
+                start,
+                continueTarget: null,
+                end: null,
+                breakPositions: [],
+                continuePositions: []
+            };
+            loopStack.push(loopInfo);
+
+            if (node.condition) parseObject(node.condition, bytecode, true);
+            const jumpValueToEndPosition = bytecode.length;
+            bytecode.push(operators.JZ, 0);
+
+            bytecode.push(operators.PUSHSCP);
+            node.body.forEach((n : any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            loopInfo.continueTarget = bytecode.length; 
+
+            if (node.update) parseObject(node.update, bytecode);
+
+            bytecode.push(operators.JMP, start);
+            
+            const end : number = bytecode.length;
+            loopInfo.end = end;
+            
+            bytecode[jumpValueToEndPosition + 1] = end;
+
+            const positions : Array<{position : number, target : number | null}> =
+            [
+                ...loopInfo.breakPositions.map(position => ({
+                    position,
+                    target: end
+                })),
+
+                ...loopInfo.continuePositions.map(position => ({
+                    position,
+                    target: loopInfo.continueTarget
+                }))
+            ]
+            
+            for (const {position, target} of positions) bytecode[position + 1] = target;
+            
+            loopStack.pop();
+            bytecode.push(operators.POPSCP);
+        }
+    ],
+
+    ["ForInStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            bytecode.push(operators.PUSHSCP);
+            
+            // evaluate the object, extract its keys as a plain JS array
+            parseObject(node.right, bytecode, true);
+            bytecode.push(operators.OBJKEYS);
+            
+            // store the keys array
+            const keysVar = `__keys_${node.row}_${node.column}__`;
+            bytecode.push(operators.ALLOC, keysVar);
+            bytecode.push(operators.STORE, keysVar);
+            
+            // allocate and initialize counter
+            const counterVar = `__i_${node.row}_${node.column}__`;
+            bytecode.push(operators.ALLOC, counterVar);
+            bytecode.push(operators.PUSH, 0);
+            bytecode.push(operators.STORE, counterVar);
+            
+            // allocate the loop variable
+            bytecode.push(operators.ALLOC, node.left);
+            
+            const start : number = bytecode.length;
+            
+            const loopInfo : LoopInfo =
+            { 
+                start,
+                continueTarget: null,
+                end: null,
+                breakPositions: [],
+                continuePositions: []
+            };
+            loopStack.push(loopInfo);
+
+            // loop condition: counter < keys.length
+            bytecode.push(operators.LOAD, counterVar);
+            bytecode.push(operators.LOAD, keysVar);
+            bytecode.push(operators.ARRLEN);
+            bytecode.push(operators.LT);
+            
+            const jumpValueToEndPosition = bytecode.length;
+            bytecode.push(operators.JZ, 0);
+
+            bytecode.push(operators.PUSHSCP);
+            
+            // get current key: keys[counter]
+            bytecode.push(operators.LOAD, keysVar);
+            bytecode.push(operators.LOAD, counterVar);
+            bytecode.push(operators.ARRGET);
+            
+            // store in loop variable
+            bytecode.push(operators.STORE, node.left);
+            
+            // execute loop body
+            node.body.forEach((n : any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            loopInfo.continueTarget = bytecode.length;
+            
+            // increment counter
+            bytecode.push(operators.LOAD, counterVar);
+            bytecode.push(operators.PUSH, 1);
+            bytecode.push(operators.ADD);
+            bytecode.push(operators.STORE, counterVar);
+
+            bytecode.push(operators.JMP, start);
+            
+            const end : number = bytecode.length;
+            loopInfo.end = end;
+            
+            bytecode[jumpValueToEndPosition + 1] = end;
+
+            const positions : Array<{position : number, target : number | null}> =
+            [
+                ...loopInfo.breakPositions.map(position => ({
+                    position,
+                    target: end
+                })),
+
+                ...loopInfo.continuePositions.map(position => ({
+                    position,
+                    target: loopInfo.continueTarget
+                }))
+            ]
+            
+            for (const {position, target} of positions) bytecode[position + 1] = target;
+            
+            loopStack.pop();
+            bytecode.push(operators.POPSCP);
+        }
+    ],
+
+    ["ForOfStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+            
+            // parse iterable (array)
+            bytecode.push(operators.PUSHSCP);
+            parseObject(node.right, bytecode, true);
+            
+            // alloc and store the array in a temporary variable
+            const arrayVariable = `__array_${node.row}_${node.column}_`;
+            bytecode.push(operators.ALLOC, arrayVariable);
+            bytecode.push(operators.STORE, arrayVariable);
+
+            // alloc and initialize counter
+            const counterVariable = `__i_${node.row}_${node.column}__`;
+            bytecode.push(operators.ALLOC, counterVariable);
+            bytecode.push(operators.PUSH, 0);
+            bytecode.push(operators.STORE, counterVariable);
+
+            // alloc the loop variable(s)
+            if (Array.isArray(node.left))
+            {
+                for (const name of node.left)
+                    bytecode.push(operators.ALLOC, name);
+            }
+            else
+                bytecode.push(operators.ALLOC, node.left);
+
+            const start : number = bytecode.length;
+
+            const loopInfo : LoopInfo =
+            {
+                start,
+                end : null,
+
+                continueTarget : null,
+
+                breakPositions    : [],
+                continuePositions : []
+            }
+            loopStack.push(loopInfo);
+
+            bytecode.push(operators.LOAD, counterVariable);
+            bytecode.push(operators.LOAD, arrayVariable);
+            bytecode.push(operators.ARRLEN);
+            bytecode.push(operators.LT);
+
+            const jumpValueToEndPosition = bytecode.length;
+            bytecode.push(operators.JZ, 0);
+
+            bytecode.push(operators.PUSHSCP);
+
+            // get current value (array[counter])
+            bytecode.push(operators.LOAD, arrayVariable);
+            bytecode.push(operators.LOAD, counterVariable);
+            bytecode.push(operators.ARRGET);
+
+            // store in loop variable
+            if (Array.isArray(node.left))
+            {
+                const elementVar = `__elem_${node.row}_${node.column}__`;
+                bytecode.push(operators.ALLOC, elementVar);
+                bytecode.push(operators.STORE, elementVar);
+
+                for (let i = 0; i < node.left.length; i++)
+                {
+                    bytecode.push(operators.LOAD, elementVar);
+                    bytecode.push(operators.PUSH, String(i));
+                    bytecode.push(operators.ARRGET);
+                    bytecode.push(operators.STORE, node.left[i]);
+                }
+            }
+            else
+                bytecode.push(operators.STORE, node.left);
+
+            // execute loop body
+            node.body.forEach((n : any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            loopInfo.continueTarget = bytecode.length;
+            
+            // increment counter
+            bytecode.push(operators.LOAD, counterVariable);
+            bytecode.push(operators.PUSH, 1);
+            bytecode.push(operators.ADD);
+            bytecode.push(operators.STORE, counterVariable);
+
+            bytecode.push(operators.JMP, start);
+            
+            const end : number = bytecode.length;
+            loopInfo.end = end;
+            
+            bytecode[jumpValueToEndPosition + 1] = end;
+
+            const positions : Array<{position : number, target : number | null}> =
+            [
+                ...loopInfo.breakPositions.map(position => ({
+                    position,
+                    target: end
+                })),
+
+                ...loopInfo.continuePositions.map(position => ({
+                    position,
+                    target: loopInfo.continueTarget
+                }))
+            ]
+            
+            for (const {position, target} of positions) 
+                bytecode[position + 1] = target;
+            
+            loopStack.pop();
+            bytecode.push(operators.POPSCP);
+        }
+    ],
+
+    ["WhileStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            const start : number = bytecode.length;
+            
+            const loopInfo : LoopInfo = { 
+                start,
+                continueTarget: start,
+                end: null,
+                breakPositions: [],
+                continuePositions: []
+            };
+            loopStack.push(loopInfo);
+
+            parseObject(node.condition, bytecode, true);   // keepValue has to be true to push the condition result on the stack for JZ to read
+            
+            const jumpValueToEndPosition : number = bytecode.length;
+            bytecode.push(operators.JZ, 0);
+
+            bytecode.push(operators.PUSHSCP);
+            node.body.forEach((n : any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            bytecode.push(operators.JMP, start);
+            
+            const end : number = bytecode.length;
+            loopInfo.end = end;
+            
+            bytecode[jumpValueToEndPosition + 1] = end;
+            
+            const positions : Array<{position : number, target : number | null}> =
+            [
+                ...loopInfo.breakPositions.map(position => ({
+                    position,
+                    target: end
+                })),
+
+                ...loopInfo.continuePositions.map(position => ({
+                    position,
+                    target: loopInfo.continueTarget
+                }))
+            ]
+            
+            for (const {position, target} of positions) bytecode[position + 1] = target;
+            
+            loopStack.pop();
+        }
+    ],
+
+    ["DoWhileStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            const start : number = bytecode.length;
+
+            const loopInfo : LoopInfo =
+            {
+                start,
+                continueTarget: null,
+                end: null,
+                breakPositions: [],
+                continuePositions: []
+            };
+            loopStack.push(loopInfo);
+
+            bytecode.push(operators.PUSHSCP);
+            node.body.forEach((n : any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            loopInfo.continueTarget = bytecode.length;
+
+            parseObject(node.condition, bytecode, true);
+            const jumpToEndPosition : number = bytecode.length;
+            bytecode.push(operators.JZ, 0);       // jump to end if condition is falsy
+            bytecode.push(operators.JMP, start);
+
+            const end : number = bytecode.length;
+            loopInfo.end = end;
+            bytecode[jumpToEndPosition + 1] = end;
+
+            const positions : Array<{position : number, target : number | null}> =
+            [
+                ...loopInfo.breakPositions.map(position => ({
+                    position,
+                    target: end
+                })),
+
+                ...loopInfo.continuePositions.map(position => ({
+                    position,
+                    target: loopInfo.continueTarget
+                }))
+            ]
+
+            for (const {position, target} of positions) bytecode[position + 1] = target;
+
+            loopStack.pop();
+        }
+    ],
+
+    ["TryStatement", 
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            const tryStartPosition = bytecode.length;
+            bytecode.push(operators.TRY, 0, 0); // [TRY, catchPosition, finallyPosition]
+
+            // parse try body
+            bytecode.push(operators.PUSHSCP);
+            node.tryBlock.forEach((n: any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            // jump past catch block if no error occurred
+            const skipCatchPosition = bytecode.length;
+            bytecode.push(operators.JMP, 0);
+
+            // catch block
+            const catchPosition = bytecode.length;
+            bytecode[tryStartPosition + 1] = catchPosition;
+
+            bytecode.push(operators.PUSHSCP);
+            bytecode.push(operators.ALLOC, node.errorVariable);
+            bytecode.push(operators.STORE, node.errorVariable);
+
+            node.catchBlock.forEach((n: any) => parseObject(n, bytecode));
+            bytecode.push(operators.POPSCP);
+
+            // end of catch block
+            const afterCatchPosition = bytecode.length;
+            bytecode[skipCatchPosition + 1] = afterCatchPosition;
+
+            if (node.finallyBlock)
+            {
+                const finallyPosition = bytecode.length;
+                bytecode[tryStartPosition + 2] = finallyPosition;
+
+                bytecode.push(operators.PUSHSCP);
+                node.finallyBlock.forEach((n: any) => parseObject(n, bytecode));
+                bytecode.push(operators.POPSCP);
+            }
+
+            bytecode.push(operators.ENDTRY);
+        }
+    ],
+
+    ["FunctionDeclaration",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+            
+            const newBytecode : Bytecode = [];
+        
+            (node.body ?? []).forEach((n : any) => parseObject(n, newBytecode));
+
+            // make sure the function returns smth
+            newBytecode.push(operators.PUSH, null);
+            newBytecode.push(operators.RETURN);
+
+            bytecode.push(operators.ALLOC, node.name);
+
+            const parameters = node.parameters.map
+            (
+                (parameter: any) => (
+                    {
+                        name           : parameter.name,
+                        rest           : parameter.rest,
+                        default        : parameter.default ? parseObject(parameter.default, [], true) : null,
+                        typeAnnotation : parameter.typeAnnotation ?? null
+                    }
+                )
+            );
+
+            const functionObject =
+            {
+                bytecode   : newBytecode,
+                parameters,
+                returnType : node.returnType ?? null,
+                ast        : node
+            };
+
+            bytecode.push(operators.PUSH, functionObject);
+            bytecode.push(operators.MKFUNC);
+            bytecode.push(operators.STORE, node.name);
+        }
+    ],
+
+    ["MethodCall",
+        (node : any, bytecode : Bytecode, keepValue : boolean) =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.object, bytecode, true);
+            bytecode.push(operators.PUSH, node.property);
+            
+            node.args.forEach
+            (
+                (argument : any) => 
+                {
+                    if (argument.type === "SpreadElement")
+                    {
+                        parseObject(argument.argument, bytecode, true);
+                        bytecode.push(operators.SPREAD);
+                    }
+                    else
+                        parseObject(argument, bytecode, true);
+                }
+            );
+
+            bytecode.push(operators.CALLMETHOD, node.args.length);
+
+            if (!keepValue) 
+                bytecode.push(operators.POP);
+        }
+    ],
+
+    ["FunctionExpression",
+        (node : any, bytecode : Bytecode, keepValue : boolean = true) : void =>
+        {
+            const newBytecode : Bytecode = [];
+
+            (node.body ?? []).forEach((n : any) => parseObject(n, newBytecode));
+
+            newBytecode.push(operators.PUSH, null);
+            newBytecode.push(operators.RETURN);
+
+            const parameters = node.parameters.map
+            (
+                (parameter: any) => (
+                    {
+                        name           : parameter.name,
+                        rest           : parameter.rest,
+                        default        : parameter.default ? parseObject(parameter.default, [], true) : null,
+                        typeAnnotation : parameter.typeAnnotation ?? null
+                    }
+                )
+            );
+
+            const functionObject =
+            {
+                bytecode   : newBytecode,
+                parameters,
+                returnType : node.returnType ?? null,
+                ast        : node
+            }
+
+            bytecode.push(operators.PUSH, functionObject);
+            bytecode.push(operators.MKFUNC);
+            if (node.name) 
+                bytecode.push(operators.STORE, node.name);
+
+            if (!keepValue) 
+                bytecode.push(operators.POP);
+        }
+    ],
+
+    ["SwitchStatement", 
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            parseObject(node.discriminant, bytecode, true);
+            const temp = `__switch_temp_${tempCounter++}`;
+            bytecode.push(operators.ALLOC, temp);
+            bytecode.push(operators.STORE, temp);
+
+            const endJumps : number[] = [];
+
+            for (let i = 0; i < node.cases.length; i++)
+            {
+                const switchCase = node.cases[i];
+
+                bytecode.push(operators.LOAD, temp);
+                parseObject(switchCase.test, bytecode, true);
+                bytecode.push(operators.EQ);
+
+                const nextCaseJump = bytecode.length;
+                bytecode.push(operators.JZ, 0);
+
+                // execute consequent
+                bytecode.push(operators.PUSHSCP);
+                switchCase.consequent.forEach((statement : any) => parseObject(statement, bytecode));
+                bytecode.push(operators.POPSCP);
+
+                const endJump = bytecode.length;
+                bytecode.push(operators.JMP, 0);
+                endJumps.push(endJump);
+
+                // set next case position
+                bytecode[nextCaseJump + 1] = bytecode.length;
+            }
+
+            if (node.defaultCase)
+            {
+                bytecode.push(operators.PUSHSCP);
+                node.defaultCase.consequent.forEach((statement : any) => parseObject(statement, bytecode));
+                bytecode.push(operators.POPSCP);
+            }
+
+            // set all end jumps to point here
+            const endPosition = bytecode.length;
+            endJumps.forEach(position => {
+                bytecode[position + 1] = endPosition;
+            });
+        }
+    ],
+
+    ["ReturnStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+
+            if (node.argument) 
+                parseObject(node.argument, bytecode, true);
+            bytecode.push(operators.RETURN);
+        }
+    ],
+
+    ["ImportStatement",
+        (node : any, bytecode : Bytecode) : void =>
+        {
+            bytecode.push(operators.SETLINE, node.row ?? 0, node.column ?? 0);
+            bytecode.push(operators.PUSH, node.path);
+            bytecode.push(operators.EXEC);
+        }
+    ],
+]);
+
+export function buildBytecode(ast : any, filename : string = "<anonymous>")
+{
+    tempCounter = 0;
+    const bytecode : Bytecode = [];
+
+    bytecode.push(operators.SETFILE, filename);
+
+    if (ast?.body?.length > 0)
+        parseObject(ast, bytecode);
+
+    //console.dir(bytecode, {depth: null, colors: true});
+    return bytecode;
+}