@minduscript/compiler 1.0.0

package/.npmignore

@@ -0,0 +1,2 @@
+.tsbuildinfo
+*.map

package/dist/asm/gen-asm.d.ts

@@ -0,0 +1,2 @@
+import type { IRNode } from '../ir/ir';
+export declare const genASM: (ir: IRNode[]) => string;

package/dist/asm/gen-asm.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genASM = void 0;
+const parser_1 = require("@minduscript/parser");
+const ir_1 = require("../ir/ir");
+const transformValue = (value) => {
+    if (!value.isLiteral) {
+        return value.name;
+    }
+    if (value.value === false) {
+        return 'false';
+    }
+    if (!value.value) {
+        return 'null';
+    }
+    return value.value.toString();
+};
+const transformRadarCondition = (condition) => {
+    switch (condition) {
+        case parser_1.RadarCondition.ANY:
+            return 'any';
+        case parser_1.RadarCondition.ENEMY:
+            return 'enemy';
+        case parser_1.RadarCondition.ALLY:
+            return 'ally';
+        case parser_1.RadarCondition.PLAYER:
+            return 'player';
+        case parser_1.RadarCondition.ATTACKER:
+            return 'attacker';
+        case parser_1.RadarCondition.FLYING:
+            return 'flying';
+        case parser_1.RadarCondition.BOSS:
+            return 'boss';
+        default:
+            return 'ground';
+    }
+};
+const transformRadarSortConfig = (config) => {
+    switch (config) {
+        case parser_1.RadarSortConfig.DISTANCE:
+            return 'distance';
+        case parser_1.RadarSortConfig.HEALTH:
+            return 'health';
+        case parser_1.RadarSortConfig.SHIELD:
+            return 'shield';
+        case parser_1.RadarSortConfig.ARMOR:
+            return 'armor';
+        default:
+            return 'maxHealth';
+    }
+};
+const transformNormalNode = (node) => {
+    switch (node.type) {
+        case ir_1.IRNodeType.READ: {
+            return `read ${node.output} ${transformValue(node.memoryName)} ${transformValue(node.memoryIndex)}`;
+        }
+        case ir_1.IRNodeType.WRITE: {
+            return `write ${transformValue(node.value)} ${transformValue(node.memoryName)} ${transformValue(node.memoryIndex)}`;
+        }
+        case ir_1.IRNodeType.DRAW_CLEAR: {
+            return `draw clear ${transformValue(node.r)} ${transformValue(node.g)} ${transformValue(node.b)}`;
+        }
+        case ir_1.IRNodeType.DRAW_COLOR: {
+            return `draw color ${transformValue(node.r)} ${transformValue(node.g)} ${transformValue(node.b)} ${transformValue(node.a)}`;
+        }
+        case ir_1.IRNodeType.DRAW_COL: {
+            return `draw col ${transformValue(node.color)}`;
+        }
+        case ir_1.IRNodeType.DRAW_STROKE: {
+            return `draw stroke ${transformValue(node.width)}`;
+        }
+        case ir_1.IRNodeType.DRAW_LINE: {
+            return `draw line ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.x2)} ${transformValue(node.y2)}`;
+        }
+        case ir_1.IRNodeType.DRAW_RECT: {
+            return `draw rect ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.width)} ${transformValue(node.height)}`;
+        }
+        case ir_1.IRNodeType.DRAW_LINE_RECT: {
+            return `draw lineRect ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.width)} ${transformValue(node.height)}`;
+        }
+        case ir_1.IRNodeType.DRAW_POLY: {
+            return `draw poly ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.sides)} ${transformValue(node.radius)} ${transformValue(node.rotation)}`;
+        }
+        case ir_1.IRNodeType.DRAW_LINE_POLY: {
+            return `draw linePoly ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.sides)} ${transformValue(node.radius)} ${transformValue(node.rotation)}`;
+        }
+        case ir_1.IRNodeType.DRAW_TRIANGLE: {
+            return `draw triangle ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.x2)} ${transformValue(node.y2)} ${transformValue(node.x3)} ${transformValue(node.y3)}`;
+        }
+        case ir_1.IRNodeType.DRAW_IMAGE: {
+            return `draw image ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.image)} ${transformValue(node.size)} ${transformValue(node.rotation)}`;
+        }
+        case ir_1.IRNodeType.PRINT: {
+            return `print ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.DRAW_FLUSH: {
+            return `drawflush ${transformValue(node.target)}`;
+        }
+        case ir_1.IRNodeType.PRINT_FLUSH: {
+            return `printflush ${transformValue(node.target)}`;
+        }
+        case ir_1.IRNodeType.GET_LINK: {
+            return `getLink ${node.result} ${transformValue(node.id)}`;
+        }
+        case ir_1.IRNodeType.SET_ENABLED: {
+            return `control enabled ${transformValue(node.building)} ${transformValue(node.enabled)}`;
+        }
+        case ir_1.IRNodeType.SET_SHOOT: {
+            return `control shoot ${transformValue(node.building)} ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.shoot)}`;
+        }
+        case ir_1.IRNodeType.SET_SHOOT_P: {
+            return `control shootp ${transformValue(node.building)} ${transformValue(node.unit)} ${transformValue(node.shoot)}`;
+        }
+        case ir_1.IRNodeType.SET_CONFIG: {
+            return `control config ${transformValue(node.building)} ${transformValue(node.config)}`;
+        }
+        case ir_1.IRNodeType.SET_COLOR: {
+            return `control color ${transformValue(node.building)} ${transformValue(node.color)}`;
+        }
+        case ir_1.IRNodeType.RADAR: {
+            return `radar ${transformRadarCondition(node.condition1)} ${transformRadarCondition(node.condition2)} ${transformRadarCondition(node.condition3)} ${transformRadarSortConfig(node.sort)} ${transformValue(node.building)} ${transformValue(node.order)} ${node.result}`;
+        }
+        case ir_1.IRNodeType.SENSOR: {
+            return `sensor ${node.result} ${transformValue(node.building)} ${transformValue(node.target)}`;
+        }
+        case ir_1.IRNodeType.ASSIGN: {
+            return `set ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.ADD: {
+            return `op add ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.SUB: {
+            return `op sub ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.MUL: {
+            return `op mul ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.DIV: {
+            return `op div ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.IDIV: {
+            return `op idiv ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.MOD: {
+            return `op mod ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.POW: {
+            return `op pow ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.EQ: {
+            return `op equal ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.NE: {
+            return `op notEqual ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.AND: {
+            return `op land ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.LESS: {
+            return `op lessThan ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.LE: {
+            return `op lessThanEq ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.GREATER: {
+            return `op greaterThan ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.GE: {
+            return `op greaterThanEq ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.STRICT_EQ: {
+            return `op strictEqual ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.SHL: {
+            return `op shl ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.SHR: {
+            return `op shr ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.BITOR: {
+            return `op or ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.BITAND: {
+            return `op and ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.XOR: {
+            return `op xor ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.FLIP: {
+            return `op not ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.MAX: {
+            return `op max ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.MIN: {
+            return `op min ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.ANGLE: {
+            return `op angle ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.ANGLE_DIFF: {
+            return `op angleDiff ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.LEN: {
+            return `op len ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.NOISE: {
+            return `op noise ${node.target} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+        case ir_1.IRNodeType.ABS: {
+            return `op abs ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.LOG: {
+            return `op log ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.LOG10: {
+            return `op log10 ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.FLOOR: {
+            return `op floor ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.CEIL: {
+            return `op ceil ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.SQRT: {
+            return `op sqrt ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.RAND: {
+            return `op rand ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.SIN: {
+            return `op sin ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.COS: {
+            return `op cos ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.TAN: {
+            return `op tan ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.ASIN: {
+            return `op asin ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.ACOS: {
+            return `op acos ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.ATAN: {
+            return `op atan ${node.target} ${transformValue(node.value)}`;
+        }
+        case ir_1.IRNodeType.PACK_COLOR: {
+            return `packcolor ${node.result} ${transformValue(node.r)} ${transformValue(node.g)} ${transformValue(node.b)} ${transformValue(node.a)}`;
+        }
+        case ir_1.IRNodeType.WAIT: {
+            return `wait ${transformValue(node.time)}`;
+        }
+        case ir_1.IRNodeType.CPU_STOP: {
+            return 'stop';
+        }
+        case ir_1.IRNodeType.UNIT_BIND: {
+            return `ubind ${node.unit}`;
+        }
+        case ir_1.IRNodeType.IDLE: {
+            return 'ucontrol idle';
+        }
+        case ir_1.IRNodeType.STOP: {
+            return 'ucontrol stop';
+        }
+        case ir_1.IRNodeType.MOVE: {
+            return `ucontrol move ${transformValue(node.x)} ${transformValue(node.y)}`;
+        }
+        case ir_1.IRNodeType.APPROACH: {
+            return `ucontrol approach ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.distance)}`;
+        }
+        case ir_1.IRNodeType.PATH_FIND: {
+            return `ucontrol pathfind ${transformValue(node.x)} ${transformValue(node.y)}`;
+        }
+        case ir_1.IRNodeType.AUTO_PATH_FIND: {
+            return 'ucontrol autoPathfind';
+        }
+        case ir_1.IRNodeType.BOOST: {
+            return `ucontrol boost ${transformValue(node.enabled)}`;
+        }
+        case ir_1.IRNodeType.TARGET: {
+            return `ucontrol target ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.shoot)}`;
+        }
+        case ir_1.IRNodeType.TARGET_P: {
+            return `ucontrol targetp ${transformValue(node.unit)} ${transformValue(node.shoot)}`;
+        }
+        case ir_1.IRNodeType.ITEM_DROP: {
+            return `ucontrol itemDrop ${transformValue(node.building)} ${transformValue(node.amount)}`;
+        }
+        case ir_1.IRNodeType.ITEM_TAKE: {
+            return `ucontrol itemTake ${transformValue(node.building)} ${transformValue(node.item)} ${transformValue(node.amount)}`;
+        }
+        case ir_1.IRNodeType.PAY_DROP: {
+            return 'ucontrol payDrop';
+        }
+        case ir_1.IRNodeType.PAY_TAKE: {
+            return `ucontrol payTake ${transformValue(node.takeUnits)}`;
+        }
+        case ir_1.IRNodeType.PAY_ENTER: {
+            return 'ucontrol payEnter';
+        }
+        case ir_1.IRNodeType.MINE: {
+            return `ucontrol mine ${transformValue(node.x)} ${transformValue(node.y)}`;
+        }
+        case ir_1.IRNodeType.FLAG: {
+            return `ucontrol flag ${transformValue(node.flag)}`;
+        }
+        case ir_1.IRNodeType.BUILD: {
+            return `ucontrol build ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.block)} ${transformValue(node.rotation)} ${transformValue(node.config)}`;
+        }
+        case ir_1.IRNodeType.GET_BLOCK: {
+            return `ucontrol getBlock ${transformValue(node.x)} ${transformValue(node.y)} ${node.outType} ${node.building} ${node.floor}`;
+        }
+        case ir_1.IRNodeType.WITHIN: {
+            return `ucontrol within ${transformValue(node.x)} ${transformValue(node.y)} ${transformValue(node.radius)} ${node.result}`;
+        }
+        case ir_1.IRNodeType.UNBIND: {
+            return 'ucontrol unbind';
+        }
+        case ir_1.IRNodeType.UNIT_RADAR: {
+            return `uradar ${transformRadarCondition(node.condition1)} ${transformRadarCondition(node.condition2)} ${transformRadarCondition(node.condition3)} ${transformRadarSortConfig(node.sort)} 0 ${transformValue(node.order)} ${node.result}`;
+        }
+        case ir_1.IRNodeType.UNIT_LOCATE_ORE: {
+            return `ulocate ore core true ${transformValue(node.target)} ${node.outX} ${node.outY} ${node.found}`;
+        }
+        case ir_1.IRNodeType.UNIT_LOCATE_BUILDING: {
+            let group;
+            switch (node.group) {
+                case parser_1.UnitLocateBuildingGroup.CORE:
+                    group = 'core';
+                    break;
+                case parser_1.UnitLocateBuildingGroup.STORAGE:
+                    group = 'storage';
+                    break;
+                case parser_1.UnitLocateBuildingGroup.GENERATOR:
+                    group = 'generator';
+                    break;
+                case parser_1.UnitLocateBuildingGroup.TURRET:
+                    group = 'turret';
+                    break;
+                case parser_1.UnitLocateBuildingGroup.FACTORY:
+                    group = 'factory';
+                    break;
+                case parser_1.UnitLocateBuildingGroup.REPAIR:
+                    group = 'repair';
+                    break;
+                case parser_1.UnitLocateBuildingGroup.BATTERY:
+                    group = 'battery';
+                    break;
+                default:
+                    group = 'reactor';
+            }
+            return `ulocate building ${group} ${transformValue(node.enemy)} @copper ${node.outX} ${node.outY} ${node.found} ${node.building}`;
+        }
+        case ir_1.IRNodeType.UNIT_LOCATE_SPAWN: {
+            return `ulocate spawn core true @copper ${node.outX} ${node.outY} ${node.found} ${node.building}`;
+        }
+        default: {
+            return `ulocate damaged core true @copper ${node.outX} ${node.outY} ${node.found} ${node.building}`;
+        }
+    }
+};
+const transformJumpNode = (node, labelMap) => {
+    switch (node.type) {
+        case ir_1.IRNodeType.JUMP: {
+            return `jump ${labelMap[node.label]} always`;
+        }
+        default: {
+            let condition;
+            switch (node.condition) {
+                case ir_1.JumpCondition.EQ:
+                    condition = 'equal';
+                    break;
+                case ir_1.JumpCondition.NE:
+                    condition = 'notEqual';
+                    break;
+                case ir_1.JumpCondition.LESS:
+                    condition = 'lessThan';
+                    break;
+                case ir_1.JumpCondition.LE:
+                    condition = 'lessThanEq';
+                    break;
+                case ir_1.JumpCondition.GREATER:
+                    condition = 'greaterThan';
+                    break;
+                case ir_1.JumpCondition.GE:
+                    condition = 'greaterThanEq';
+                    break;
+                default:
+                    condition = 'strictEqual';
+            }
+            return `jump ${labelMap[node.label]} ${condition} ${transformValue(node.left)} ${transformValue(node.right)}`;
+        }
+    }
+};
+const genASM = (ir) => {
+    const labelMap = {};
+    let instructionLine = 0;
+    for (const node of ir) {
+        if (node.type === ir_1.IRNodeType.LABEL) {
+            labelMap[node.name] = instructionLine;
+            continue;
+        }
+        instructionLine += 1;
+    }
+    const asmLines = [];
+    for (const node of ir) {
+        if (node.type === ir_1.IRNodeType.LABEL ||
+            node.type === ir_1.IRNodeType.MACRO_CALL ||
+            node.type === ir_1.IRNodeType.MACRO_CALL_ASSIGN ||
+            node.type === ir_1.IRNodeType.BIND) {
+            continue;
+        }
+        if (node.type === ir_1.IRNodeType.JUMP || node.type === ir_1.IRNodeType.CONDITIONAL_JUMP) {
+            asmLines.push(transformJumpNode(node, labelMap));
+            continue;
+        }
+        asmLines.push(transformNormalNode(node));
+    }
+    const trailingLabels = Object.keys(labelMap).filter((name) => labelMap[name] === asmLines.length);
+    if (trailingLabels.length > 0) {
+        const nopLine = asmLines.length;
+        asmLines.push('noop');
+        for (const name of trailingLabels) {
+            labelMap[name] = nopLine;
+        }
+    }
+    return asmLines.join('\n');
+};
+exports.genASM = genASM;
+//# sourceMappingURL=gen-asm.js.map

package/dist/counter.d.ts

@@ -0,0 +1,5 @@
+export declare const counter: {
+    value: number;
+    reset(): void;
+    next(): number;
+};

package/dist/counter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.counter = void 0;
+exports.counter = {
+    value: 0,
+    reset() {
+        this.value = 0;
+    },
+    next() {
+        return ++this.value;
+    },
+};
+//# sourceMappingURL=counter.js.map

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const compile: (entryFilePath: string, projectRoot?: string) => string;

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+const gen_asm_1 = require("./asm/gen-asm");
+const build_ir_1 = require("./ir/build-ir");
+const project_1 = require("./ir/project");
+const expand_macros_1 = require("./macro/expand-macros");
+const optimizer_1 = require("./optimizer/optimizer");
+const compile = (entryFilePath, projectRoot) => {
+    const project = (0, project_1.parseProject)(entryFilePath, projectRoot);
+    const ir = (0, build_ir_1.buildIR)(project);
+    const optimized = (0, optimizer_1.optimizeIR)((0, expand_macros_1.expandMacros)(ir));
+    const asm = (0, gen_asm_1.genASM)(optimized.body);
+    return asm;
+};
+exports.compile = compile;
+//# sourceMappingURL=index.js.map

package/dist/ir/build-ir.d.ts

@@ -0,0 +1,3 @@
+import { type IRProgram } from './ir';
+import type { Project } from './project';
+export declare const buildIR: (project: Project) => IRProgram;