@minduscript/compiler 1.0.0

package/dist/ir/build-ir.js

@@ -0,0 +1,1057 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIR = void 0;
+const parser_1 = require("@minduscript/parser");
+const counter_1 = require("../counter");
+const gather_macros_1 = require("./gather-macros");
+const ir_1 = require("./ir");
+const lexer_1 = require("@minduscript/lexer");
+const getVarName = (context, variable) => {
+    let current = context;
+    while (current) {
+        if (variable in current.varNameMap) {
+            return current.varNameMap[variable];
+        }
+        current = current.parent;
+    }
+    return variable;
+};
+const buildIdentifier = (name) => ({
+    isLiteral: false,
+    isMindustry: name.startsWith('@'),
+    name,
+});
+const buildLiteral = (value) => ({
+    isLiteral: true,
+    value,
+});
+const buildDeclaredIdentifier = (context, identifier) => {
+    if (context.parent) {
+        const newName = `$${counter_1.counter.next()}`;
+        context.varNameMap[identifier] = newName;
+        return newName;
+    }
+    else {
+        return identifier;
+    }
+};
+const buildOutputIdentifier = (context, identifier) => {
+    if (identifier.isMindustry) {
+        return identifier.value;
+    }
+    if (identifier.identifierType != parser_1.IdentifierType.SIMPLE && context.parent) {
+        context.varNameMap[identifier.value] = `$${counter_1.counter.next()}`;
+        return context.varNameMap[identifier.value];
+    }
+    return getVarName(context, identifier.value);
+};
+const expandExpression = (macroNameMap, context, expression, ir) => {
+    const visit = (node) => {
+        switch (node.type) {
+            case parser_1.NodeType.UNARY_OP_EXPRESSION: {
+                const childName = visit(node.child);
+                const newName = `$${counter_1.counter.next()}`;
+                switch (node.opType) {
+                    case lexer_1.TokenType.NOT:
+                        ir.push({
+                            type: ir_1.IRNodeType.EQ,
+                            target: newName,
+                            left: buildIdentifier(childName),
+                            right: buildLiteral(0),
+                        });
+                        break;
+                    default:
+                        ir.push({
+                            type: ir_1.IRNodeType.FLIP,
+                            target: newName,
+                            value: buildIdentifier(childName),
+                        });
+                }
+                return newName;
+            }
+            case parser_1.NodeType.BINARY_OP_EXPRESSION: {
+                const lChildName = visit(node.lChild);
+                const rChildName = visit(node.rChild);
+                const newName = `$${counter_1.counter.next()}`;
+                if (node.opType == lexer_1.TokenType.OR) {
+                    const tempName1 = `$${counter_1.counter.next()}`;
+                    const tempName2 = `$${counter_1.counter.next()}`;
+                    ir.push({
+                        type: ir_1.IRNodeType.NE,
+                        target: tempName1,
+                        left: buildIdentifier(lChildName),
+                        right: buildLiteral(0),
+                    });
+                    ir.push({
+                        type: ir_1.IRNodeType.NE,
+                        target: tempName2,
+                        left: buildIdentifier(rChildName),
+                        right: buildLiteral(0),
+                    });
+                    ir.push({
+                        type: ir_1.IRNodeType.BITOR,
+                        target: newName,
+                        left: buildIdentifier(tempName1),
+                        right: buildIdentifier(tempName2),
+                    });
+                }
+                else {
+                    const temp = {
+                        type: undefined,
+                        target: newName,
+                        left: buildIdentifier(lChildName),
+                        right: buildIdentifier(rChildName),
+                    };
+                    switch (node.opType) {
+                        case lexer_1.TokenType.AND:
+                            temp.type = ir_1.IRNodeType.AND;
+                            break;
+                        case lexer_1.TokenType.EQ:
+                            temp.type = ir_1.IRNodeType.EQ;
+                            break;
+                        case lexer_1.TokenType.NE:
+                            temp.type = ir_1.IRNodeType.NE;
+                            break;
+                        case lexer_1.TokenType.LESS:
+                            temp.type = ir_1.IRNodeType.LESS;
+                            break;
+                        case lexer_1.TokenType.LE:
+                            temp.type = ir_1.IRNodeType.LE;
+                            break;
+                        case lexer_1.TokenType.GREATER:
+                            temp.type = ir_1.IRNodeType.GREATER;
+                            break;
+                        case lexer_1.TokenType.GE:
+                            temp.type = ir_1.IRNodeType.GE;
+                            break;
+                        case lexer_1.TokenType.STRICT_EQ:
+                            temp.type = ir_1.IRNodeType.STRICT_EQ;
+                            break;
+                        case lexer_1.TokenType.BITOR:
+                            temp.type = ir_1.IRNodeType.BITOR;
+                            break;
+                        case lexer_1.TokenType.XOR:
+                            temp.type = ir_1.IRNodeType.XOR;
+                            break;
+                        case lexer_1.TokenType.BITAND:
+                            temp.type = ir_1.IRNodeType.BITAND;
+                            break;
+                        case lexer_1.TokenType.SHL:
+                            temp.type = ir_1.IRNodeType.SHL;
+                            break;
+                        case lexer_1.TokenType.SHR:
+                            temp.type = ir_1.IRNodeType.SHR;
+                            break;
+                        case lexer_1.TokenType.ADD:
+                            temp.type = ir_1.IRNodeType.ADD;
+                            break;
+                        case lexer_1.TokenType.SUB:
+                            temp.type = ir_1.IRNodeType.SUB;
+                            break;
+                        case lexer_1.TokenType.MUL:
+                            temp.type = ir_1.IRNodeType.MUL;
+                            break;
+                        case lexer_1.TokenType.DIV:
+                            temp.type = ir_1.IRNodeType.DIV;
+                            break;
+                        case lexer_1.TokenType.IDIV:
+                            temp.type = ir_1.IRNodeType.IDIV;
+                            break;
+                        case lexer_1.TokenType.MOD:
+                            temp.type = ir_1.IRNodeType.MOD;
+                            break;
+                        default:
+                            temp.type = ir_1.IRNodeType.POW;
+                    }
+                    ir.push(temp);
+                }
+                return newName;
+            }
+            case parser_1.NodeType.FUNCTION_CALL_EXPRESSION: {
+                const argCount = node.args.length;
+                if (argCount == 1) {
+                    const argName = visit(node.args[0]);
+                    const newName = `$${counter_1.counter.next()}`;
+                    const temp = {
+                        type: undefined,
+                        target: newName,
+                        value: buildIdentifier(argName),
+                    };
+                    switch (node.function) {
+                        case lexer_1.TokenType.ABS:
+                            temp.type = ir_1.IRNodeType.ABS;
+                            break;
+                        case lexer_1.TokenType.LOG:
+                            temp.type = ir_1.IRNodeType.LOG;
+                            break;
+                        case lexer_1.TokenType.LOG10:
+                            temp.type = ir_1.IRNodeType.LOG10;
+                            break;
+                        case lexer_1.TokenType.FLOOR:
+                            temp.type = ir_1.IRNodeType.FLOOR;
+                            break;
+                        case lexer_1.TokenType.CEIL:
+                            temp.type = ir_1.IRNodeType.CEIL;
+                            break;
+                        case lexer_1.TokenType.SQRT:
+                            temp.type = ir_1.IRNodeType.SQRT;
+                            break;
+                        case lexer_1.TokenType.RAND:
+                            temp.type = ir_1.IRNodeType.RAND;
+                            break;
+                        case lexer_1.TokenType.SIN:
+                            temp.type = ir_1.IRNodeType.SIN;
+                            break;
+                        case lexer_1.TokenType.COS:
+                            temp.type = ir_1.IRNodeType.COS;
+                            break;
+                        case lexer_1.TokenType.TAN:
+                            temp.type = ir_1.IRNodeType.TAN;
+                            break;
+                        case lexer_1.TokenType.ASIN:
+                            temp.type = ir_1.IRNodeType.ASIN;
+                            break;
+                        case lexer_1.TokenType.ACOS:
+                            temp.type = ir_1.IRNodeType.ACOS;
+                            break;
+                        default:
+                            temp.type = ir_1.IRNodeType.ATAN;
+                    }
+                    ir.push(temp);
+                    return newName;
+                }
+                else {
+                    const leftArgName = visit(node.args[0]);
+                    const rightArgName = visit(node.args[1]);
+                    const newName = `$${counter_1.counter.next()}`;
+                    const temp = {
+                        type: undefined,
+                        target: newName,
+                        left: buildIdentifier(leftArgName),
+                        right: buildIdentifier(rightArgName),
+                    };
+                    switch (node.function) {
+                        case lexer_1.TokenType.MAX:
+                            temp.type = ir_1.IRNodeType.MAX;
+                            break;
+                        case lexer_1.TokenType.MIN:
+                            temp.type = ir_1.IRNodeType.MIN;
+                            break;
+                        case lexer_1.TokenType.ANGLE:
+                            temp.type = ir_1.IRNodeType.ANGLE;
+                            break;
+                        case lexer_1.TokenType.ANGLE_DIFF:
+                            temp.type = ir_1.IRNodeType.ANGLE_DIFF;
+                            break;
+                        case lexer_1.TokenType.LEN:
+                            temp.type = ir_1.IRNodeType.LEN;
+                            break;
+                        default:
+                            temp.type = ir_1.IRNodeType.NOISE;
+                    }
+                    ir.push(temp);
+                    return newName;
+                }
+            }
+            case parser_1.NodeType.MACRO_CALL_EXPRESSION: {
+                const inputNames = [];
+                for (const arg of node.inputArgs) {
+                    inputNames.push(visit(arg));
+                }
+                const macroName = macroNameMap[context.filePath][node.name];
+                const name = macroName.name;
+                if (context.macroDependencies) {
+                    context.macroDependencies.add(name);
+                }
+                const newName = `$${counter_1.counter.next()}`;
+                ir.push({
+                    type: ir_1.IRNodeType.MACRO_CALL_ASSIGN,
+                    name,
+                    returnTarget: newName,
+                    inputArgs: inputNames.map((n) => buildIdentifier(n)),
+                    outputArgs: node.outputArgs.map((n) => buildOutputIdentifier(context, n)),
+                });
+                return newName;
+            }
+            case parser_1.NodeType.LITERAL_EXPRESSION: {
+                const newName = `$${counter_1.counter.next()}`;
+                ir.push({
+                    type: ir_1.IRNodeType.ASSIGN,
+                    target: newName,
+                    value: buildLiteral(node.value),
+                });
+                return newName;
+            }
+            default: {
+                if (node.isMindustry) {
+                    return node.value;
+                }
+                return getVarName(context, node.value);
+            }
+        }
+    };
+    return visit(expression.child);
+};
+const buildStatement = (macroNameMap, context, statement) => {
+    const result = [];
+    switch (statement.statementType) {
+        case parser_1.StatementType.EMPTY:
+            break;
+        case parser_1.StatementType.VARIABLE_DEFINE: {
+            result.push({
+                type: ir_1.IRNodeType.ASSIGN,
+                target: buildDeclaredIdentifier(context, statement.variableName),
+                value: buildIdentifier(expandExpression(macroNameMap, context, statement.expression, result)),
+            });
+            break;
+        }
+        case parser_1.StatementType.ASSIGN: {
+            result.push({
+                type: ir_1.IRNodeType.ASSIGN,
+                target: getVarName(context, statement.variableName),
+                value: buildIdentifier(expandExpression(macroNameMap, context, statement.expression, result)),
+            });
+            break;
+        }
+        case parser_1.StatementType.CONTROL: {
+            switch (statement.controlType) {
+                case parser_1.ControlType.READ: {
+                    result.push({
+                        type: ir_1.IRNodeType.READ,
+                        output: buildOutputIdentifier(context, statement.output),
+                        memoryName: buildIdentifier(expandExpression(macroNameMap, context, statement.memoryName, result)),
+                        memoryIndex: buildIdentifier(expandExpression(macroNameMap, context, statement.memoryIndex, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.WRITE: {
+                    result.push({
+                        type: ir_1.IRNodeType.WRITE,
+                        value: buildIdentifier(expandExpression(macroNameMap, context, statement.value, result)),
+                        memoryName: buildIdentifier(expandExpression(macroNameMap, context, statement.memoryName, result)),
+                        memoryIndex: buildIdentifier(expandExpression(macroNameMap, context, statement.memoryIndex, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_CLEAR: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_CLEAR,
+                        r: buildIdentifier(expandExpression(macroNameMap, context, statement.r, result)),
+                        g: buildIdentifier(expandExpression(macroNameMap, context, statement.g, result)),
+                        b: buildIdentifier(expandExpression(macroNameMap, context, statement.b, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_COLOR: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_COLOR,
+                        r: buildIdentifier(expandExpression(macroNameMap, context, statement.r, result)),
+                        g: buildIdentifier(expandExpression(macroNameMap, context, statement.g, result)),
+                        b: buildIdentifier(expandExpression(macroNameMap, context, statement.b, result)),
+                        a: buildIdentifier(expandExpression(macroNameMap, context, statement.a, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_COL: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_COL,
+                        color: buildIdentifier(expandExpression(macroNameMap, context, statement.color, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_STROKE: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_STROKE,
+                        width: buildIdentifier(expandExpression(macroNameMap, context, statement.width, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_LINE: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_LINE,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        x2: buildIdentifier(expandExpression(macroNameMap, context, statement.x2, result)),
+                        y2: buildIdentifier(expandExpression(macroNameMap, context, statement.y2, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_RECT: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_RECT,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        width: buildIdentifier(expandExpression(macroNameMap, context, statement.width, result)),
+                        height: buildIdentifier(expandExpression(macroNameMap, context, statement.height, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_LINE_RECT: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_LINE_RECT,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        width: buildIdentifier(expandExpression(macroNameMap, context, statement.width, result)),
+                        height: buildIdentifier(expandExpression(macroNameMap, context, statement.height, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_POLY: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_POLY,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        sides: buildIdentifier(expandExpression(macroNameMap, context, statement.sides, result)),
+                        radius: buildIdentifier(expandExpression(macroNameMap, context, statement.radius, result)),
+                        rotation: buildIdentifier(expandExpression(macroNameMap, context, statement.rotation, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_LINE_POLY: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_LINE_POLY,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        sides: buildIdentifier(expandExpression(macroNameMap, context, statement.sides, result)),
+                        radius: buildIdentifier(expandExpression(macroNameMap, context, statement.radius, result)),
+                        rotation: buildIdentifier(expandExpression(macroNameMap, context, statement.rotation, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_TRIANGLE: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_TRIANGLE,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        x2: buildIdentifier(expandExpression(macroNameMap, context, statement.x2, result)),
+                        y2: buildIdentifier(expandExpression(macroNameMap, context, statement.y2, result)),
+                        x3: buildIdentifier(expandExpression(macroNameMap, context, statement.x3, result)),
+                        y3: buildIdentifier(expandExpression(macroNameMap, context, statement.y3, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_IMAGE: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_IMAGE,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        image: buildIdentifier(expandExpression(macroNameMap, context, statement.image, result)),
+                        size: buildIdentifier(expandExpression(macroNameMap, context, statement.size, result)),
+                        rotation: buildIdentifier(expandExpression(macroNameMap, context, statement.rotation, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.PRINT: {
+                    result.push({
+                        type: ir_1.IRNodeType.PRINT,
+                        value: buildIdentifier(expandExpression(macroNameMap, context, statement.value, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.DRAW_FLUSH: {
+                    result.push({
+                        type: ir_1.IRNodeType.DRAW_FLUSH,
+                        target: buildIdentifier(expandExpression(macroNameMap, context, statement.target, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.PRINT_FLUSH: {
+                    result.push({
+                        type: ir_1.IRNodeType.PRINT_FLUSH,
+                        target: buildIdentifier(expandExpression(macroNameMap, context, statement.target, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.GET_LINK: {
+                    result.push({
+                        type: ir_1.IRNodeType.GET_LINK,
+                        result: buildOutputIdentifier(context, statement.result),
+                        id: buildIdentifier(expandExpression(macroNameMap, context, statement.id, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.SET_ENABLED: {
+                    result.push({
+                        type: ir_1.IRNodeType.SET_ENABLED,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        enabled: buildIdentifier(expandExpression(macroNameMap, context, statement.value, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.SET_SHOOT: {
+                    result.push({
+                        type: ir_1.IRNodeType.SET_SHOOT,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        shoot: buildIdentifier(expandExpression(macroNameMap, context, statement.shoot, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.SET_SHOOT_P: {
+                    result.push({
+                        type: ir_1.IRNodeType.SET_SHOOT_P,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        unit: buildIdentifier(expandExpression(macroNameMap, context, statement.unit, result)),
+                        shoot: buildIdentifier(expandExpression(macroNameMap, context, statement.shoot, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.SET_CONFIG: {
+                    result.push({
+                        type: ir_1.IRNodeType.SET_CONFIG,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        config: buildIdentifier(expandExpression(macroNameMap, context, statement.config, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.SET_COLOR: {
+                    result.push({
+                        type: ir_1.IRNodeType.SET_COLOR,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        color: buildIdentifier(expandExpression(macroNameMap, context, statement.color, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.RADAR: {
+                    result.push({
+                        type: ir_1.IRNodeType.RADAR,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        condition1: statement.condition1,
+                        condition2: statement.condition2,
+                        condition3: statement.condition3,
+                        order: buildIdentifier(expandExpression(macroNameMap, context, statement.order, result)),
+                        sort: statement.sort,
+                        result: buildOutputIdentifier(context, statement.result),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.SENSOR: {
+                    result.push({
+                        type: ir_1.IRNodeType.SENSOR,
+                        target: buildIdentifier(expandExpression(macroNameMap, context, statement.target, result)),
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        result: buildOutputIdentifier(context, statement.result),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.PACK_COLOR: {
+                    result.push({
+                        type: ir_1.IRNodeType.PACK_COLOR,
+                        result: buildOutputIdentifier(context, statement.result),
+                        r: buildIdentifier(expandExpression(macroNameMap, context, statement.r, result)),
+                        g: buildIdentifier(expandExpression(macroNameMap, context, statement.g, result)),
+                        b: buildIdentifier(expandExpression(macroNameMap, context, statement.b, result)),
+                        a: buildIdentifier(expandExpression(macroNameMap, context, statement.a, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.WAIT: {
+                    result.push({
+                        type: ir_1.IRNodeType.WAIT,
+                        time: buildIdentifier(expandExpression(macroNameMap, context, statement.time, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.CPU_STOP: {
+                    result.push({ type: ir_1.IRNodeType.CPU_STOP });
+                    break;
+                }
+                case parser_1.ControlType.UNIT_BIND: {
+                    result.push({
+                        type: ir_1.IRNodeType.UNIT_BIND,
+                        unit: buildIdentifier(expandExpression(macroNameMap, context, statement.unit, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.UNIT_RADAR: {
+                    result.push({
+                        type: ir_1.IRNodeType.UNIT_RADAR,
+                        condition1: statement.condition1,
+                        condition2: statement.condition2,
+                        condition3: statement.condition3,
+                        order: buildIdentifier(expandExpression(macroNameMap, context, statement.order, result)),
+                        sort: statement.sort,
+                        result: buildOutputIdentifier(context, statement.result),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.UNIT_LOCATE: {
+                    switch (statement.category) {
+                        case parser_1.UnitLocateCategory.ORE: {
+                            result.push({
+                                type: ir_1.IRNodeType.UNIT_LOCATE_ORE,
+                                target: buildIdentifier(expandExpression(macroNameMap, context, statement.target, result)),
+                                outX: buildOutputIdentifier(context, statement.outX),
+                                outY: buildOutputIdentifier(context, statement.outY),
+                                found: buildOutputIdentifier(context, statement.found),
+                            });
+                            break;
+                        }
+                        case parser_1.UnitLocateCategory.BUILDING: {
+                            result.push({
+                                type: ir_1.IRNodeType.UNIT_LOCATE_BUILDING,
+                                group: statement.group,
+                                enemy: buildIdentifier(expandExpression(macroNameMap, context, statement.enemy, result)),
+                                outX: buildOutputIdentifier(context, statement.outX),
+                                outY: buildOutputIdentifier(context, statement.outY),
+                                found: buildOutputIdentifier(context, statement.found),
+                                building: buildOutputIdentifier(context, statement.building),
+                            });
+                            break;
+                        }
+                        case parser_1.UnitLocateCategory.SPAWN: {
+                            result.push({
+                                type: ir_1.IRNodeType.UNIT_LOCATE_SPAWN,
+                                outX: buildOutputIdentifier(context, statement.outX),
+                                outY: buildOutputIdentifier(context, statement.outY),
+                                found: buildOutputIdentifier(context, statement.found),
+                                building: buildOutputIdentifier(context, statement.building),
+                            });
+                            break;
+                        }
+                        case parser_1.UnitLocateCategory.DAMAGED: {
+                            result.push({
+                                type: ir_1.IRNodeType.UNIT_LOCATE_DAMAGED,
+                                outX: buildOutputIdentifier(context, statement.outX),
+                                outY: buildOutputIdentifier(context, statement.outY),
+                                found: buildOutputIdentifier(context, statement.found),
+                                building: buildOutputIdentifier(context, statement.building),
+                            });
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case parser_1.ControlType.IDLE: {
+                    result.push({ type: ir_1.IRNodeType.IDLE });
+                    break;
+                }
+                case parser_1.ControlType.STOP: {
+                    result.push({ type: ir_1.IRNodeType.STOP });
+                    break;
+                }
+                case parser_1.ControlType.MOVE: {
+                    result.push({
+                        type: ir_1.IRNodeType.MOVE,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.APPROACH: {
+                    result.push({
+                        type: ir_1.IRNodeType.APPROACH,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        distance: buildIdentifier(expandExpression(macroNameMap, context, statement.distance, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.PATH_FIND: {
+                    result.push({
+                        type: ir_1.IRNodeType.PATH_FIND,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.AUTO_PATH_FIND: {
+                    result.push({ type: ir_1.IRNodeType.AUTO_PATH_FIND });
+                    break;
+                }
+                case parser_1.ControlType.BOOST: {
+                    result.push({
+                        type: ir_1.IRNodeType.BOOST,
+                        enabled: buildIdentifier(expandExpression(macroNameMap, context, statement.enabled, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.TARGET: {
+                    result.push({
+                        type: ir_1.IRNodeType.TARGET,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        shoot: buildIdentifier(expandExpression(macroNameMap, context, statement.shoot, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.TARGET_P: {
+                    result.push({
+                        type: ir_1.IRNodeType.TARGET_P,
+                        unit: buildIdentifier(expandExpression(macroNameMap, context, statement.unit, result)),
+                        shoot: buildIdentifier(expandExpression(macroNameMap, context, statement.shoot, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.ITEM_DROP: {
+                    result.push({
+                        type: ir_1.IRNodeType.ITEM_DROP,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        amount: buildIdentifier(expandExpression(macroNameMap, context, statement.amount, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.ITEM_TAKE: {
+                    result.push({
+                        type: ir_1.IRNodeType.ITEM_TAKE,
+                        building: buildIdentifier(expandExpression(macroNameMap, context, statement.building, result)),
+                        item: buildIdentifier(expandExpression(macroNameMap, context, statement.item, result)),
+                        amount: buildIdentifier(expandExpression(macroNameMap, context, statement.amount, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.PAY_DROP: {
+                    result.push({ type: ir_1.IRNodeType.PAY_DROP });
+                    break;
+                }
+                case parser_1.ControlType.PAY_TAKE: {
+                    result.push({
+                        type: ir_1.IRNodeType.PAY_TAKE,
+                        takeUnits: buildIdentifier(expandExpression(macroNameMap, context, statement.takeUnits, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.PAY_ENTER: {
+                    result.push({ type: ir_1.IRNodeType.PAY_ENTER });
+                    break;
+                }
+                case parser_1.ControlType.MINE: {
+                    result.push({
+                        type: ir_1.IRNodeType.MINE,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.FLAG: {
+                    result.push({
+                        type: ir_1.IRNodeType.FLAG,
+                        flag: buildIdentifier(expandExpression(macroNameMap, context, statement.flag, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.BUILD: {
+                    result.push({
+                        type: ir_1.IRNodeType.BUILD,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        block: buildIdentifier(expandExpression(macroNameMap, context, statement.block, result)),
+                        rotation: buildIdentifier(expandExpression(macroNameMap, context, statement.rotation, result)),
+                        config: buildIdentifier(expandExpression(macroNameMap, context, statement.config, result)),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.GET_BLOCK: {
+                    result.push({
+                        type: ir_1.IRNodeType.GET_BLOCK,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        outType: buildOutputIdentifier(context, statement.outType),
+                        building: buildOutputIdentifier(context, statement.building),
+                        floor: buildOutputIdentifier(context, statement.floor),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.WITHIN: {
+                    result.push({
+                        type: ir_1.IRNodeType.WITHIN,
+                        x: buildIdentifier(expandExpression(macroNameMap, context, statement.x, result)),
+                        y: buildIdentifier(expandExpression(macroNameMap, context, statement.y, result)),
+                        radius: buildIdentifier(expandExpression(macroNameMap, context, statement.radius, result)),
+                        result: buildOutputIdentifier(context, statement.result),
+                    });
+                    break;
+                }
+                case parser_1.ControlType.UNBIND: {
+                    result.push({ type: ir_1.IRNodeType.UNBIND });
+                    break;
+                }
+            }
+            break;
+        }
+        case parser_1.StatementType.MACRO_CALL: {
+            const macroName = macroNameMap[context.filePath][statement.name];
+            const name = macroName.name;
+            if (context.macroDependencies) {
+                context.macroDependencies.add(name);
+            }
+            result.push({
+                type: ir_1.IRNodeType.MACRO_CALL,
+                name,
+                inputArgs: statement.inputArgs.map((arg) => buildIdentifier(expandExpression(macroNameMap, context, arg, result))),
+                outputArgs: statement.outputArgs.map((arg) => buildOutputIdentifier(context, arg)),
+            });
+            break;
+        }
+        case parser_1.StatementType.IF_ELSE: {
+            const elseLabel = `${counter_1.counter.next()}`;
+            const endLabel = `${counter_1.counter.next()}`;
+            const conditionName = expandExpression(macroNameMap, context, statement.condition, result);
+            result.push({
+                type: ir_1.IRNodeType.CONDITIONAL_JUMP,
+                condition: ir_1.JumpCondition.EQ,
+                left: buildIdentifier(conditionName),
+                right: buildLiteral(0),
+                label: elseLabel,
+            });
+            const newContext1 = {
+                ...context,
+                parent: context,
+                varNameMap: {},
+            };
+            result.push(...buildStatementList(macroNameMap, newContext1, statement.ifBody));
+            result.push({
+                type: ir_1.IRNodeType.JUMP,
+                label: endLabel,
+            });
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: elseLabel,
+            });
+            const newContext2 = {
+                ...context,
+                parent: context,
+                varNameMap: {},
+            };
+            result.push(...buildStatementList(macroNameMap, newContext2, statement.elseBody));
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: endLabel,
+            });
+            break;
+        }
+        case parser_1.StatementType.IF: {
+            const endLabel = `${counter_1.counter.next()}`;
+            const conditionName = expandExpression(macroNameMap, context, statement.condition, result);
+            result.push({
+                type: ir_1.IRNodeType.CONDITIONAL_JUMP,
+                condition: ir_1.JumpCondition.EQ,
+                left: buildIdentifier(conditionName),
+                right: buildLiteral(0),
+                label: endLabel,
+            });
+            const newContext = {
+                ...context,
+                parent: context,
+                varNameMap: {},
+            };
+            result.push(...buildStatementList(macroNameMap, newContext, statement.ifBody));
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: endLabel,
+            });
+            break;
+        }
+        case parser_1.StatementType.FOR: {
+            const conditionLabel = `${counter_1.counter.next()}`;
+            const incrementLabel = `${counter_1.counter.next()}`;
+            const endLabel = `${counter_1.counter.next()}`;
+            const forContext = {
+                ...context,
+                parent: context,
+                varNameMap: {},
+            };
+            result.push(...buildStatement(macroNameMap, forContext, statement.init));
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: conditionLabel,
+            });
+            const forConditionName = expandExpression(macroNameMap, forContext, statement.condition, result);
+            result.push({
+                type: ir_1.IRNodeType.CONDITIONAL_JUMP,
+                condition: ir_1.JumpCondition.EQ,
+                left: buildIdentifier(forConditionName),
+                right: buildLiteral(0),
+                label: endLabel,
+            });
+            const forBodyContext = {
+                ...forContext,
+                parent: forContext,
+                varNameMap: {},
+                breakLabel: endLabel,
+                continueLabel: incrementLabel,
+            };
+            result.push(...buildStatementList(macroNameMap, forBodyContext, statement.body));
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: incrementLabel,
+            });
+            if (statement.increment) {
+                result.push(...buildStatement(macroNameMap, forContext, statement.increment));
+            }
+            result.push({
+                type: ir_1.IRNodeType.JUMP,
+                label: conditionLabel,
+            });
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: endLabel,
+            });
+            break;
+        }
+        case parser_1.StatementType.WHILE: {
+            const conditionLabel = `${counter_1.counter.next()}`;
+            const endLabel = `${counter_1.counter.next()}`;
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: conditionLabel,
+            });
+            const conditionName = expandExpression(macroNameMap, context, statement.condition, result);
+            result.push({
+                type: ir_1.IRNodeType.CONDITIONAL_JUMP,
+                condition: ir_1.JumpCondition.EQ,
+                left: buildIdentifier(conditionName),
+                right: buildLiteral(0),
+                label: endLabel,
+            });
+            const newContext = {
+                ...context,
+                parent: context,
+                varNameMap: {},
+                breakLabel: endLabel,
+                continueLabel: conditionLabel,
+            };
+            result.push(...buildStatementList(macroNameMap, newContext, statement.body));
+            result.push({
+                type: ir_1.IRNodeType.JUMP,
+                label: conditionLabel,
+            });
+            result.push({
+                type: ir_1.IRNodeType.LABEL,
+                name: endLabel,
+            });
+            break;
+        }
+        case parser_1.StatementType.LOOP_CONTROL: {
+            if (statement.controlType == parser_1.LoopControlType.BREAK) {
+                result.push({
+                    type: ir_1.IRNodeType.JUMP,
+                    label: context.breakLabel,
+                });
+            }
+            else {
+                result.push({
+                    type: ir_1.IRNodeType.JUMP,
+                    label: context.continueLabel,
+                });
+            }
+            break;
+        }
+        case parser_1.StatementType.RETURN: {
+            const returnValueName = expandExpression(macroNameMap, context, statement.expression, result);
+            result.push({
+                type: ir_1.IRNodeType.ASSIGN,
+                target: '$return',
+                value: buildIdentifier(returnValueName),
+            });
+            result.push({
+                type: ir_1.IRNodeType.JUMP,
+                label: context.returnLabel,
+            });
+            break;
+        }
+        case parser_1.StatementType.BIND: {
+            if (context.boundVariables) {
+                context.boundVariables.add(statement.variableName);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return result;
+};
+const buildStatementList = (macroNameMap, context, statements) => {
+    const result = [];
+    for (const statement of statements) {
+        result.push(...buildStatement(macroNameMap, context, statement));
+    }
+    return result;
+};
+const buildMacro = (macroNameMap, filePath, macro) => {
+    const returnLabel = `${counter_1.counter.next()}`;
+    const context = {
+        filePath,
+        parent: {
+            filePath,
+            varNameMap: {},
+        },
+        varNameMap: {},
+        returnLabel,
+        macroDependencies: new Set(),
+    };
+    const inputParams = [];
+    for (const param of macro.inputParams) {
+        const newName = `$input_${counter_1.counter.next()}`;
+        context.varNameMap[param] = newName;
+        inputParams.push(newName);
+    }
+    const outputParams = [];
+    for (const param of macro.outputParams) {
+        const newName = `$output_${counter_1.counter.next()}`;
+        context.varNameMap[param] = newName;
+        outputParams.push(newName);
+    }
+    const ir = buildStatementList(macroNameMap, context, macro.body);
+    ir.push({
+        type: ir_1.IRNodeType.ASSIGN,
+        target: '$return',
+        value: buildLiteral(null),
+    });
+    ir.push({
+        type: ir_1.IRNodeType.LABEL,
+        name: returnLabel,
+    });
+    return {
+        name: macroNameMap[filePath][macro.name].name,
+        inputParams,
+        outputParams,
+        body: ir,
+        dependencies: context.macroDependencies,
+    };
+};
+const buildMain = (macroNameMap, filePath, mainBody, boundVariables) => {
+    const context = {
+        filePath,
+        varNameMap: {},
+        boundVariables,
+    };
+    return buildStatementList(macroNameMap, context, mainBody);
+};
+const buildIR = (project) => {
+    const macroNameMap = (0, gather_macros_1.gatherMacros)(project);
+    counter_1.counter.reset();
+    const macros = [];
+    const visitedMacros = new Set();
+    for (const filePath in macroNameMap) {
+        for (const macroName in macroNameMap[filePath]) {
+            const macroMetadata = macroNameMap[filePath][macroName];
+            const macroId = macroMetadata.name;
+            if (!visitedMacros.has(macroId)) {
+                const declarationSource = project.sources[macroMetadata.filePath];
+                if (!declarationSource) {
+                    continue;
+                }
+                const hasSameMacroId = (name) => macroNameMap[macroMetadata.filePath]?.[name]?.name === macroId;
+                let macroNode = declarationSource.macros.find((m) => hasSameMacroId(m.name));
+                if (!macroNode) {
+                    macroNode = declarationSource.internalMacros.find((m) => hasSameMacroId(m.name));
+                }
+                if (!macroNode) {
+                    continue;
+                }
+                visitedMacros.add(macroId);
+                macros.push(buildMacro(macroNameMap, macroMetadata.filePath, macroNode));
+            }
+        }
+    }
+    const boundVariables = new Set();
+    return {
+        macros,
+        boundVariables,
+        main: buildMain(macroNameMap, project.entryPath, project.sources[project.entryPath].ast.statementList, boundVariables),
+    };
+};
+exports.buildIR = buildIR;
+//# sourceMappingURL=build-ir.js.map