@minduscript/compiler 1.0.0

package/dist/ir/gather-macros.d.ts

@@ -0,0 +1,8 @@
+import type { Project } from './project';
+export type MacroName = {
+    name: string;
+    filePath: string;
+};
+export type MacroNameMap = Record<string, Record<string, MacroName>>;
+declare const gatherMacros: (project: Project) => MacroNameMap;
+export { gatherMacros };

package/dist/ir/gather-macros.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherMacros = void 0;
+const counter_1 = require("../counter");
+const parser_1 = require("@minduscript/parser");
+const path_1 = __importDefault(require("path"));
+const gatherMacros = (project) => {
+    counter_1.counter.reset();
+    const nameMap = {};
+    const entrySource = project.sources[project.entryPath];
+    if (!entrySource) {
+        return nameMap;
+    }
+    const ensureSourceMap = (sourcePath) => {
+        if (!nameMap[sourcePath]) {
+            nameMap[sourcePath] = {};
+        }
+        return nameMap[sourcePath];
+    };
+    const resolveSourcePath = (fromPath, importerPath) => {
+        const basePath = path_1.default.dirname(importerPath);
+        const candidate = path_1.default.isAbsolute(fromPath)
+            ? fromPath
+            : fromPath.startsWith('.')
+                ? path_1.default.resolve(basePath, fromPath)
+                : path_1.default.resolve(project.rootPath, fromPath);
+        const normalized = path_1.default.normalize(candidate);
+        const candidates = path_1.default.extname(normalized) ? [normalized] : [normalized, `${normalized}.minduscript`];
+        for (const sourcePath of candidates) {
+            if (project.sources[sourcePath]) {
+                return sourcePath;
+            }
+        }
+        return undefined;
+    };
+    const sourceContextMap = new Map();
+    const getSourceContext = (sourcePath) => {
+        const existing = sourceContextMap.get(sourcePath);
+        if (existing) {
+            return existing;
+        }
+        const source = project.sources[sourcePath];
+        const context = {
+            localMacroMap: new Map(),
+            importMacroMap: new Map(),
+        };
+        if (source) {
+            for (const statement of source.ast.statementList) {
+                if (statement.statementType !== parser_1.StatementType.MACRO_DEFINE) {
+                    continue;
+                }
+                context.localMacroMap.set(statement.name, statement);
+            }
+            for (const importStatement of source.ast.importList) {
+                const importedSourcePath = resolveSourcePath(importStatement.from, sourcePath);
+                if (!importedSourcePath) {
+                    continue;
+                }
+                context.importMacroMap.set(importStatement.asName, {
+                    sourcePath: importedSourcePath,
+                    macroName: importStatement.name,
+                });
+            }
+        }
+        sourceContextMap.set(sourcePath, context);
+        return context;
+    };
+    const resolveMacroDefinition = (sourcePath, macroName, aliasChain = []) => {
+        const nextAliasChain = [...aliasChain, { sourcePath, macroName }];
+        const sourceContext = getSourceContext(sourcePath);
+        const localMacro = sourceContext.localMacroMap.get(macroName);
+        if (localMacro) {
+            return {
+                sourcePath,
+                macroName,
+                macro: localMacro,
+                aliases: nextAliasChain,
+            };
+        }
+        const imported = sourceContext.importMacroMap.get(macroName);
+        if (!imported) {
+            return undefined;
+        }
+        return resolveMacroDefinition(imported.sourcePath, imported.macroName, nextAliasChain);
+    };
+    const collectMacroCallsFromExpressionChild = (child, output) => {
+        switch (child.type) {
+            case parser_1.NodeType.UNARY_OP_EXPRESSION:
+                collectMacroCallsFromExpressionChild(child.child, output);
+                break;
+            case parser_1.NodeType.BINARY_OP_EXPRESSION:
+                collectMacroCallsFromExpressionChild(child.lChild, output);
+                collectMacroCallsFromExpressionChild(child.rChild, output);
+                break;
+            case parser_1.NodeType.FUNCTION_CALL_EXPRESSION:
+                child.args.forEach((arg) => collectMacroCallsFromExpressionChild(arg, output));
+                break;
+            case parser_1.NodeType.MACRO_CALL_EXPRESSION:
+                output.push(child.name);
+                child.inputArgs.forEach((arg) => collectMacroCallsFromExpressionChild(arg, output));
+                break;
+            case parser_1.NodeType.LITERAL_EXPRESSION:
+            case parser_1.NodeType.IDENTIFIER_EXPRESSION:
+                break;
+            default:
+                child;
+        }
+    };
+    const collectMacroCallsFromExpression = (expression, output) => {
+        collectMacroCallsFromExpressionChild(expression.child, output);
+    };
+    const collectMacroCallsFromStatement = (statement, output) => {
+        switch (statement.statementType) {
+            case parser_1.StatementType.EMPTY:
+            case parser_1.StatementType.LOOP_CONTROL:
+            case parser_1.StatementType.BIND:
+                break;
+            case parser_1.StatementType.VARIABLE_DEFINE:
+            case parser_1.StatementType.ASSIGN:
+            case parser_1.StatementType.RETURN:
+                collectMacroCallsFromExpression(statement.expression, output);
+                break;
+            case parser_1.StatementType.CONTROL:
+                for (const value of Object.values(statement)) {
+                    if (value && typeof value === 'object' && 'type' in value && value.type === parser_1.NodeType.EXPRESSION) {
+                        collectMacroCallsFromExpression(value, output);
+                    }
+                }
+                break;
+            case parser_1.StatementType.MACRO_CALL:
+                output.push(statement.name);
+                statement.inputArgs.forEach((arg) => collectMacroCallsFromExpression(arg, output));
+                break;
+            case parser_1.StatementType.MACRO_DEFINE:
+                break;
+            case parser_1.StatementType.IF:
+                collectMacroCallsFromExpression(statement.condition, output);
+                statement.ifBody.forEach((child) => collectMacroCallsFromStatement(child, output));
+                break;
+            case parser_1.StatementType.IF_ELSE:
+                collectMacroCallsFromExpression(statement.condition, output);
+                statement.ifBody.forEach((child) => collectMacroCallsFromStatement(child, output));
+                statement.elseBody.forEach((child) => collectMacroCallsFromStatement(child, output));
+                break;
+            case parser_1.StatementType.FOR:
+                collectMacroCallsFromStatement(statement.init, output);
+                collectMacroCallsFromExpression(statement.condition, output);
+                if (statement.increment) {
+                    collectMacroCallsFromStatement(statement.increment, output);
+                }
+                statement.body.forEach((child) => collectMacroCallsFromStatement(child, output));
+                break;
+            case parser_1.StatementType.WHILE:
+                collectMacroCallsFromExpression(statement.condition, output);
+                statement.body.forEach((child) => collectMacroCallsFromStatement(child, output));
+                break;
+            default:
+                statement;
+        }
+    };
+    const visited = new Set();
+    const visiting = new Set();
+    const toMacroKey = (sourcePath, macroName) => `${sourcePath}\u0000${macroName}`;
+    const visitMacro = (sourcePath, macroName) => {
+        const resolved = resolveMacroDefinition(sourcePath, macroName);
+        if (!resolved) {
+            return;
+        }
+        const key = toMacroKey(resolved.sourcePath, resolved.macroName);
+        if (visited.has(key)) {
+            return;
+        }
+        // 递归宏调用在 parseProject 阶段已被校验，这里只做保护以避免异常输入导致死循环。
+        if (visiting.has(key)) {
+            return;
+        }
+        const existingRenamed = resolved.aliases
+            .map((alias) => nameMap[alias.sourcePath]?.[alias.macroName]?.name)
+            .find((renamed) => typeof renamed === 'string');
+        const renamed = existingRenamed ?? `${counter_1.counter.next()}`;
+        for (const alias of resolved.aliases) {
+            const sourceMap = ensureSourceMap(alias.sourcePath);
+            sourceMap[alias.macroName] = {
+                name: renamed,
+                filePath: resolved.sourcePath,
+            };
+        }
+        visiting.add(key);
+        const calledMacros = [];
+        resolved.macro.body.forEach((statement) => collectMacroCallsFromStatement(statement, calledMacros));
+        calledMacros.forEach((calledMacroName) => visitMacro(resolved.sourcePath, calledMacroName));
+        visiting.delete(key);
+        visited.add(key);
+    };
+    const entryCalls = [];
+    entrySource.ast.statementList.forEach((statement) => collectMacroCallsFromStatement(statement, entryCalls));
+    entryCalls.forEach((macroName) => visitMacro(project.entryPath, macroName));
+    return nameMap;
+};
+exports.gatherMacros = gatherMacros;
+//# sourceMappingURL=gather-macros.js.map

package/dist/ir/ir.d.ts

@@ -0,0 +1,478 @@
+import type { RadarCondition, RadarSortConfig, UnitLocateBuildingGroup } from '@minduscript/parser';
+export declare enum IRNodeType {
+    READ = 0,
+    WRITE = 1,
+    DRAW_CLEAR = 2,
+    DRAW_COLOR = 3,
+    DRAW_COL = 4,
+    DRAW_STROKE = 5,
+    DRAW_LINE = 6,
+    DRAW_RECT = 7,
+    DRAW_LINE_RECT = 8,
+    DRAW_POLY = 9,
+    DRAW_LINE_POLY = 10,
+    DRAW_TRIANGLE = 11,
+    DRAW_IMAGE = 12,
+    PRINT = 13,
+    DRAW_FLUSH = 14,
+    PRINT_FLUSH = 15,
+    GET_LINK = 16,
+    SET_ENABLED = 17,
+    SET_SHOOT = 18,
+    SET_SHOOT_P = 19,
+    SET_CONFIG = 20,
+    SET_COLOR = 21,
+    RADAR = 22,
+    SENSOR = 23,
+    PACK_COLOR = 24,
+    WAIT = 25,
+    CPU_STOP = 26,
+    UNIT_BIND = 27,
+    UNIT_RADAR = 28,
+    UNIT_LOCATE_ORE = 29,
+    UNIT_LOCATE_BUILDING = 30,
+    UNIT_LOCATE_SPAWN = 31,
+    UNIT_LOCATE_DAMAGED = 32,
+    IDLE = 33,
+    STOP = 34,
+    MOVE = 35,
+    APPROACH = 36,
+    PATH_FIND = 37,
+    AUTO_PATH_FIND = 38,
+    BOOST = 39,
+    TARGET = 40,
+    TARGET_P = 41,
+    ITEM_DROP = 42,
+    ITEM_TAKE = 43,
+    PAY_DROP = 44,
+    PAY_TAKE = 45,
+    PAY_ENTER = 46,
+    MINE = 47,
+    FLAG = 48,
+    BUILD = 49,
+    GET_BLOCK = 50,
+    WITHIN = 51,
+    UNBIND = 52,
+    ASSIGN = 53,
+    FLIP = 54,
+    AND = 55,
+    EQ = 56,
+    NE = 57,
+    LESS = 58,
+    LE = 59,
+    GREATER = 60,
+    GE = 61,
+    STRICT_EQ = 62,
+    BITOR = 63,
+    XOR = 64,
+    BITAND = 65,
+    SHL = 66,
+    SHR = 67,
+    ADD = 68,
+    SUB = 69,
+    MUL = 70,
+    DIV = 71,
+    IDIV = 72,
+    MOD = 73,
+    POW = 74,
+    MAX = 75,
+    MIN = 76,
+    ANGLE = 77,
+    ANGLE_DIFF = 78,
+    LEN = 79,
+    NOISE = 80,
+    ABS = 81,
+    LOG = 82,
+    LOG10 = 83,
+    FLOOR = 84,
+    CEIL = 85,
+    SQRT = 86,
+    RAND = 87,
+    SIN = 88,
+    COS = 89,
+    TAN = 90,
+    ASIN = 91,
+    ACOS = 92,
+    ATAN = 93,
+    LABEL = 94,
+    JUMP = 95,
+    CONDITIONAL_JUMP = 96,
+    MACRO_CALL = 97,
+    MACRO_CALL_ASSIGN = 98,
+    BIND = 99
+}
+export type Value = {
+    isLiteral: true;
+    value: number | string | boolean | null;
+} | {
+    isLiteral: false;
+    name: string;
+    isMindustry: boolean;
+};
+export type ReadNode = {
+    type: IRNodeType.READ;
+    output: string;
+    memoryName: Value;
+    memoryIndex: Value;
+};
+export type WriteNode = {
+    type: IRNodeType.WRITE;
+    value: Value;
+    memoryName: Value;
+    memoryIndex: Value;
+};
+export type DrawClearNode = {
+    type: IRNodeType.DRAW_CLEAR;
+    r: Value;
+    g: Value;
+    b: Value;
+};
+export type DrawColorNode = {
+    type: IRNodeType.DRAW_COLOR;
+    r: Value;
+    g: Value;
+    b: Value;
+    a: Value;
+};
+export type DrawColNode = {
+    type: IRNodeType.DRAW_COL;
+    color: Value;
+};
+export type DrawStrokeNode = {
+    type: IRNodeType.DRAW_STROKE;
+    width: Value;
+};
+export type DrawLineNode = {
+    type: IRNodeType.DRAW_LINE;
+    x: Value;
+    y: Value;
+    x2: Value;
+    y2: Value;
+};
+export type DrawRectNode = {
+    type: IRNodeType.DRAW_RECT;
+    x: Value;
+    y: Value;
+    width: Value;
+    height: Value;
+};
+export type DrawLineRectNode = {
+    type: IRNodeType.DRAW_LINE_RECT;
+    x: Value;
+    y: Value;
+    width: Value;
+    height: Value;
+};
+export type DrawPolyNode = {
+    type: IRNodeType.DRAW_POLY;
+    x: Value;
+    y: Value;
+    sides: Value;
+    radius: Value;
+    rotation: Value;
+};
+export type DrawLinePolyNode = {
+    type: IRNodeType.DRAW_LINE_POLY;
+    x: Value;
+    y: Value;
+    sides: Value;
+    radius: Value;
+    rotation: Value;
+};
+export type DrawTriangleNode = {
+    type: IRNodeType.DRAW_TRIANGLE;
+    x: Value;
+    y: Value;
+    x2: Value;
+    y2: Value;
+    x3: Value;
+    y3: Value;
+};
+export type DrawImageNode = {
+    type: IRNodeType.DRAW_IMAGE;
+    x: Value;
+    y: Value;
+    image: Value;
+    size: Value;
+    rotation: Value;
+};
+export type PrintNode = {
+    type: IRNodeType.PRINT;
+    value: Value;
+};
+export type DrawFlushNode = {
+    type: IRNodeType.DRAW_FLUSH;
+    target: Value;
+};
+export type PrintFlushNode = {
+    type: IRNodeType.PRINT_FLUSH;
+    target: Value;
+};
+export type GetLinkNode = {
+    type: IRNodeType.GET_LINK;
+    result: string;
+    id: Value;
+};
+export type SetEnabledNode = {
+    type: IRNodeType.SET_ENABLED;
+    building: Value;
+    enabled: Value;
+};
+export type SetShootNode = {
+    type: IRNodeType.SET_SHOOT;
+    building: Value;
+    x: Value;
+    y: Value;
+    shoot: Value;
+};
+export type SetShootPNode = {
+    type: IRNodeType.SET_SHOOT_P;
+    building: Value;
+    unit: Value;
+    shoot: Value;
+};
+export type SetConfigNode = {
+    type: IRNodeType.SET_CONFIG;
+    building: Value;
+    config: Value;
+};
+export type SetColorNode = {
+    type: IRNodeType.SET_COLOR;
+    building: Value;
+    color: Value;
+};
+export type RadarNode = {
+    type: IRNodeType.RADAR;
+    building: Value;
+    condition1: RadarCondition;
+    condition2: RadarCondition;
+    condition3: RadarCondition;
+    order: Value;
+    sort: RadarSortConfig;
+    result: string;
+};
+export type SensorNode = {
+    type: IRNodeType.SENSOR;
+    target: Value;
+    building: Value;
+    result: string;
+};
+export type PackColorNode = {
+    type: IRNodeType.PACK_COLOR;
+    result: string;
+    r: Value;
+    g: Value;
+    b: Value;
+    a: Value;
+};
+export type WaitNode = {
+    type: IRNodeType.WAIT;
+    time: Value;
+};
+export type CpuStopNode = {
+    type: IRNodeType.CPU_STOP;
+};
+export type UnitBindNode = {
+    type: IRNodeType.UNIT_BIND;
+    unit: Value;
+};
+export type UnitRadarNode = {
+    type: IRNodeType.UNIT_RADAR;
+    condition1: RadarCondition;
+    condition2: RadarCondition;
+    condition3: RadarCondition;
+    order: Value;
+    sort: RadarSortConfig;
+    result: string;
+};
+export type UnitLocateOreNode = {
+    type: IRNodeType.UNIT_LOCATE_ORE;
+    target: Value;
+    outX: string;
+    outY: string;
+    found: string;
+};
+export type UnitLocateBuildingNode = {
+    type: IRNodeType.UNIT_LOCATE_BUILDING;
+    group: UnitLocateBuildingGroup;
+    enemy: Value;
+    outX: string;
+    outY: string;
+    found: string;
+    building: string;
+};
+export type UnitLocateSpawnNode = {
+    type: IRNodeType.UNIT_LOCATE_SPAWN;
+    outX: string;
+    outY: string;
+    found: string;
+    building: string;
+};
+export type UnitLocateDamagedNode = {
+    type: IRNodeType.UNIT_LOCATE_DAMAGED;
+    outX: string;
+    outY: string;
+    found: string;
+    building: string;
+};
+export type IdleNode = {
+    type: IRNodeType.IDLE;
+};
+export type StopNode = {
+    type: IRNodeType.STOP;
+};
+export type MoveNode = {
+    type: IRNodeType.MOVE;
+    x: Value;
+    y: Value;
+};
+export type ApproachNode = {
+    type: IRNodeType.APPROACH;
+    x: Value;
+    y: Value;
+    distance: Value;
+};
+export type PathFindNode = {
+    type: IRNodeType.PATH_FIND;
+    x: Value;
+    y: Value;
+};
+export type AutoPathFindNode = {
+    type: IRNodeType.AUTO_PATH_FIND;
+};
+export type BoostNode = {
+    type: IRNodeType.BOOST;
+    enabled: Value;
+};
+export type TargetNode = {
+    type: IRNodeType.TARGET;
+    x: Value;
+    y: Value;
+    shoot: Value;
+};
+export type TargetPNode = {
+    type: IRNodeType.TARGET_P;
+    unit: Value;
+    shoot: Value;
+};
+export type ItemDropNode = {
+    type: IRNodeType.ITEM_DROP;
+    building: Value;
+    amount: Value;
+};
+export type ItemTakeNode = {
+    type: IRNodeType.ITEM_TAKE;
+    building: Value;
+    item: Value;
+    amount: Value;
+};
+export type PayDropNode = {
+    type: IRNodeType.PAY_DROP;
+};
+export type PayTakeNode = {
+    type: IRNodeType.PAY_TAKE;
+    takeUnits: Value;
+};
+export type PayEnterNode = {
+    type: IRNodeType.PAY_ENTER;
+};
+export type MineNode = {
+    type: IRNodeType.MINE;
+    x: Value;
+    y: Value;
+};
+export type FlagNode = {
+    type: IRNodeType.FLAG;
+    flag: Value;
+};
+export type BuildNode = {
+    type: IRNodeType.BUILD;
+    x: Value;
+    y: Value;
+    block: Value;
+    rotation: Value;
+    config: Value;
+};
+export type GetBlockNode = {
+    type: IRNodeType.GET_BLOCK;
+    x: Value;
+    y: Value;
+    outType: string;
+    building: string;
+    floor: string;
+};
+export type WithinNode = {
+    type: IRNodeType.WITHIN;
+    x: Value;
+    y: Value;
+    radius: Value;
+    result: string;
+};
+export type UnbindNode = {
+    type: IRNodeType.UNBIND;
+};
+export type UnaryOpNode = {
+    type: IRNodeType.ASSIGN | IRNodeType.FLIP | IRNodeType.ABS | IRNodeType.LOG | IRNodeType.LOG10 | IRNodeType.FLOOR | IRNodeType.CEIL | IRNodeType.SQRT | IRNodeType.RAND | IRNodeType.SIN | IRNodeType.COS | IRNodeType.TAN | IRNodeType.ASIN | IRNodeType.ACOS | IRNodeType.ATAN;
+    target: string;
+    value: Value;
+};
+export type BinaryOpNode = {
+    type: IRNodeType.AND | IRNodeType.EQ | IRNodeType.NE | IRNodeType.LESS | IRNodeType.LE | IRNodeType.GREATER | IRNodeType.GE | IRNodeType.STRICT_EQ | IRNodeType.BITOR | IRNodeType.XOR | IRNodeType.BITAND | IRNodeType.SHL | IRNodeType.SHR | IRNodeType.ADD | IRNodeType.SUB | IRNodeType.MUL | IRNodeType.DIV | IRNodeType.IDIV | IRNodeType.MOD | IRNodeType.POW | IRNodeType.MAX | IRNodeType.MIN | IRNodeType.ANGLE | IRNodeType.ANGLE_DIFF | IRNodeType.LEN | IRNodeType.NOISE;
+    target: string;
+    left: Value;
+    right: Value;
+};
+export type LabelNode = {
+    type: IRNodeType.LABEL;
+    name: string;
+};
+export type JumpNode = {
+    type: IRNodeType.JUMP;
+    label: string;
+};
+export declare enum JumpCondition {
+    EQ = 0,
+    NE = 1,
+    LESS = 2,
+    LE = 3,
+    GREATER = 4,
+    GE = 5,
+    STRICT_EQ = 6
+}
+export type ConditionalJumpNode = {
+    type: IRNodeType.CONDITIONAL_JUMP;
+    condition: JumpCondition;
+    left: Value;
+    right: Value;
+    label: string;
+};
+export type MacroCallNode = {
+    type: IRNodeType.MACRO_CALL;
+    name: string;
+    inputArgs: Value[];
+    outputArgs: string[];
+};
+export type MacroCallAssignNode = {
+    type: IRNodeType.MACRO_CALL_ASSIGN;
+    name: string;
+    inputArgs: Value[];
+    outputArgs: string[];
+    returnTarget: string;
+};
+export type BindNode = {
+    type: IRNodeType.BIND;
+    name: string;
+};
+export type IRNode = ReadNode | WriteNode | DrawClearNode | DrawColorNode | DrawColNode | DrawStrokeNode | DrawLineNode | DrawRectNode | DrawLineRectNode | DrawPolyNode | DrawLinePolyNode | DrawTriangleNode | DrawImageNode | PrintNode | DrawFlushNode | PrintFlushNode | GetLinkNode | SetEnabledNode | SetShootNode | SetShootPNode | SetConfigNode | SetColorNode | RadarNode | SensorNode | PackColorNode | WaitNode | CpuStopNode | UnitBindNode | UnitRadarNode | UnitLocateOreNode | UnitLocateBuildingNode | UnitLocateSpawnNode | UnitLocateDamagedNode | IdleNode | StopNode | MoveNode | ApproachNode | PathFindNode | AutoPathFindNode | BoostNode | TargetNode | TargetPNode | ItemDropNode | ItemTakeNode | PayDropNode | PayTakeNode | PayEnterNode | MineNode | FlagNode | BuildNode | GetBlockNode | WithinNode | UnbindNode | UnaryOpNode | BinaryOpNode | LabelNode | JumpNode | ConditionalJumpNode | MacroCallNode | MacroCallAssignNode | BindNode;
+export type IRMacro = {
+    name: string;
+    inputParams: string[];
+    outputParams: string[];
+    body: IRNode[];
+    dependencies: Set<string>;
+};
+export type IRProgram = {
+    macros: IRMacro[];
+    boundVariables: Set<string>;
+    main: IRNode[];
+};