mlogjs 0.4.1 → 0.4.2

package/dist/Scope.d.ts

@@ -11,6 +11,7 @@ export declare class Scope implements IScope {
     break: AddressResolver;
     continue: AddressResolver;
     function: IFunctionValue;
+    label?: string;
     constructor(values: Record<string, IValueOwner | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
     copy(): IScope;
     createScope(): IScope;

package/dist/bin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.cjs","sources":["../src/bin.ts"],"sourcesContent":[null],"names":["yargs","hideBin","path","existsSync","Compiler","readFileSync","chalk","resolve","highlight","writeFileSync","parse","join"],"mappings":"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"}

package/dist/handlers/Statements.d.ts

@@ -3,3 +3,4 @@ export declare const ExpressionStatement: THandler<IValue | null>;
 export declare const BreakStatement: THandler<null>;
 export declare const ContinueStatement: THandler<null>;
 export declare const ReturnStatement: THandler<IValue | null>;
+export declare const LabeledStatement: THandler<null>;

package/dist/index.cjs

@@ -138,7 +138,7 @@ const arithmeticAssignmentOperators = [
     "-=",
     "/=",
 ];
-const logicalAssignmentOperators = ["&&=", "||="];
+const logicalAssignmentOperators = ["&&=", "||=", "??="];
 const bitwiseAssignmentOperators = [
     "<<=",
     ">>=",
@@ -231,8 +231,22 @@ class SetInstruction extends InstructionBase {
     constructor(store, value) {
         super("set", store, value);
     }
+    get store() {
+        return this.args[1];
+    }
+    get value() {
+        return this.args[2];
+    }
     get hidden() {
-        return this._hidden || !this.args[1].owner;
+        const { store, value } = this;
+        return (this._hidden ||
+            // assignment to discarded value
+            !store.owner ||
+            // self assignment of a store
+            (!!store.owner &&
+                store instanceof StoreValue &&
+                value instanceof StoreValue &&
+                store.owner === value.owner));
     }
 }
 
@@ -341,6 +355,34 @@ class BaseValue extends VoidValue {
         const temp = new StoreValue(scope);
         return [temp, [...inst, new OperationInstruction("not", temp, that, null)]];
     }
+    // requires special handling
+    // the handler should give an object value to allow the lazy evaluation
+    "??"(scope, other) {
+        const [left, leftInst] = this.eval(scope);
+        const nullLiteral = new LiteralValue(null);
+        const endAdress = new LiteralValue(null);
+        const [nullTest] = left["=="](scope, nullLiteral);
+        if (nullTest instanceof LiteralValue) {
+            if (nullTest.data)
+                return other.eval(scope);
+            else
+                return [left, leftInst];
+        }
+        const [right, rightInst] = other.eval(scope);
+        const result = new StoreValue(scope);
+        result.ensureOwned();
+        return [
+            result,
+            [
+                ...leftInst,
+                ...result["="](scope, left)[1],
+                new JumpInstruction(endAdress, EJumpKind.NotEqual, result, nullLiteral),
+                ...rightInst,
+                ...result["="](scope, right)[1],
+                new AddressResolver(endAdress),
+            ],
+        ];
+    }
 }
 const operatorMap$1 = {
     "==": "equal",
@@ -397,6 +439,7 @@ const assignmentToBinary = {
     "<<=": "<<",
     "&&=": "&&",
     "||=": "||",
+    "??=": "??",
 };
 for (const op in assignmentToBinary) {
     BaseValue.prototype[op] = function (scope, value) {
@@ -1002,35 +1045,26 @@ const BinaryExpression = LRExpression;
 const LogicalExpression = (c, scope, node) => {
     if (node.operator !== "??")
         return LRExpression(c, scope, node);
-    const nullLiteral = new LiteralValue(null);
-    const endAdress = new LiteralValue(null);
+    const other = lazyValue({
+        eval: scope => c.handleEval(scope, node.right),
+        consume: scope => c.handleConsume(scope, node.right),
+    });
     const [left, leftInst] = c.handleEval(scope, node.left);
-    const [nullTest] = left["=="](scope, nullLiteral);
-    if (nullTest instanceof LiteralValue) {
-        if (nullTest.data)
-            return c.handleEval(scope, node.right);
-        else
-            return [left, leftInst];
-    }
-    const [right, rightInst] = c.handleEval(scope, node.right);
-    const result = new StoreValue(scope);
-    result.ensureOwned();
-    return [
-        result,
-        [
-            ...leftInst,
-            ...result["="](scope, left)[1],
-            new JumpInstruction(endAdress, EJumpKind.NotEqual, result, nullLiteral),
-            ...rightInst,
-            ...result["="](scope, right)[1],
-            new AddressResolver(endAdress),
-        ],
-    ];
+    const [result, resultInst] = left["??"](scope, other);
+    return [result, [...leftInst, ...resultInst]];
 };
 const AssignmentExpression = (c, scope, node) => {
     const [left, leftInst] = c.handle(scope, node.left);
     // doesn't need to consume because the operators already do that
-    const [right, rightInst] = c.handleEval(scope, node.right);
+    const [right, rightInst] = node.operator !== "??="
+        ? c.handleEval(scope, node.right)
+        : [
+            lazyValue({
+                eval: scope => c.handleEval(scope, node.right),
+                consume: scope => c.handleConsume(scope, node.right),
+            }),
+            [],
+        ];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
     return [op, [...leftInst, ...rightInst, ...opInst]];
@@ -1078,7 +1112,13 @@ const ConditionalExpression = (c, scope, node) => {
             new AddressResolver(endExpressionAdress),
         ],
     ];
-};
+};
+function lazyValue(options) {
+    const value = new VoidValue();
+    value.eval = options.eval;
+    value.consume = options.consume;
+    return value;
+}
 
 const Identifier = (c, scope, node) => {
     return [scope.get(node.name), []];
@@ -1087,14 +1127,18 @@ const Identifier = (c, scope, node) => {
 const ExpressionStatement = (c, scope, node) => {
     return c.handle(scope, node.expression);
 };
-const BreakStatement = (_, scope) => {
+const BreakStatement = (_, scope, node) => {
+    const label = node.label?.name;
+    const target = label ? findScopeLabel(scope, label) : scope;
     const addr = new LiteralValue(null);
-    scope.break.bind(addr);
+    target.break.bind(addr);
     return [null, [new BreakInstruction(addr)]];
 };
-const ContinueStatement = (_, scope) => {
+const ContinueStatement = (_, scope, node) => {
     const addr = new LiteralValue(null);
-    scope.continue.bind(addr);
+    const label = node.label?.name;
+    const target = label ? findScopeLabel(scope, label) : scope;
+    target.continue.bind(addr);
     return [null, [new ContinueInstruction(addr)]];
 };
 const ReturnStatement = (c, scope, node) => {
@@ -1103,7 +1147,24 @@ const ReturnStatement = (c, scope, node) => {
         : [null, []];
     const [ret, retInst] = scope.function.return(scope, arg);
     return [ret, [...argInst, ...retInst]];
-};
+};
+const LabeledStatement = (c, scope, node) => {
+    const inner = scope.createScope();
+    inner.label = node.label.name;
+    const end = new LiteralValue(null);
+    const endAdress = new AddressResolver(end).bindBreak(inner);
+    const [, bodyInst] = c.handle(inner, node.body);
+    return [null, [...bodyInst, endAdress]];
+};
+function findScopeLabel(scope, label) {
+    let current = scope;
+    while (current !== null) {
+        if (current.label === label)
+            return current;
+        current = current.parent;
+    }
+    throw new CompilerError(`Could not find label "${label}"`);
+}
 
 const IfStatement = (c, scope, node) => {
     const inst = [];
@@ -1188,25 +1249,33 @@ const SwitchStatement = (c, scope, node) => {
 const WhileStatement = (c, scope, node) => {
     const lines = [];
     const [test, testLines] = c.handleConsume(scope, node.test);
+    const childScope = scope.createScope();
     const startLoopAddr = new LiteralValue(null);
     const endLoopAddr = new LiteralValue(null);
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
-    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
+    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(childScope);
+    if (scope.label) {
+        startLoopLine.bindContinue(scope);
+    }
     if (test instanceof LiteralValue) {
         if (test.data) {
-            lines.push(startLoopLine, ...c.handle(scope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+            lines.push(startLoopLine, ...c.handle(childScope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
         }
         return [null, lines];
     }
-    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(scope, node.body), false)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(childScope, node.body), false)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
     return [null, lines];
 };
 const DoWhileStatement = (c, scope, node) => {
     const lines = [];
     const [test, testLines] = c.handleConsume(scope, node.test);
+    const childScope = scope.createScope();
     const startLoopAddr = new LiteralValue(null);
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
-    const [, bodyLines] = c.handle(scope, node.body);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
+    if (scope.label) {
+        startLoopLine.bindContinue(scope);
+    }
+    const [, bodyLines] = c.handle(childScope, node.body);
     if (test instanceof LiteralValue) {
         if (!test.data)
             return [null, [...lines, ...bodyLines]];
@@ -1224,8 +1293,8 @@ const DoWhileStatement = (c, scope, node) => {
     return [null, lines];
 };
 
-const ForStatement = (c, scope, node) => {
-    scope = scope.createScope();
+const ForStatement = (c, parentScope, node) => {
+    const scope = parentScope.createScope();
     const initInst = node.init ? c.handle(scope, node.init)[1] : [];
     const [test, testLines] = node.test
         ? c.handleConsume(scope, node.test)
@@ -1235,6 +1304,9 @@ const ForStatement = (c, scope, node) => {
     const endLoopAddr = new LiteralValue(null);
     const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
     const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    if (parentScope.label) {
+        startLoopLine.bindContinue(parentScope);
+    }
     return [
         null,
         [
@@ -1657,6 +1729,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     BreakStatement: BreakStatement,
     ContinueStatement: ContinueStatement,
     ReturnStatement: ReturnStatement,
+    LabeledStatement: LabeledStatement,
     IfStatement: IfStatement,
     SwitchStatement: SwitchStatement,
     WhileStatement: WhileStatement,
@@ -1689,7 +1762,7 @@ class MacroFunction extends VoidValue {
     constructor(fn) {
         super();
         this.macro = true;
-        this.constant = true;
+        this.mutability = EMutability.constant;
         this.fn = fn;
     }
     call(scope, args) {
@@ -1724,8 +1797,23 @@ const mathOperations = {
     sqrt: a => Math.sqrt(a),
     rand: null,
 };
-function createMacroMathOperations() {
-    const macroMathOperations = {};
+function mathConstant(scope, name) {
+    return new ValueOwner({
+        scope,
+        constant: true,
+        name,
+        value: assign(new StoreValue(scope), {
+            mutability: EMutability.constant,
+        }),
+    }).value;
+}
+function createMacroMathOperations(scope) {
+    const macroMathOperations = {
+        PI: mathConstant(scope, "@pi"),
+        E: mathConstant(scope, "@e"),
+        degToRad: mathConstant(scope, "@degToRad"),
+        radToDeg: mathConstant(scope, "@radToDeg"),
+    };
     for (const key in mathOperations) {
         const fn = mathOperations[key];
         macroMathOperations[key] = new MacroFunction((scope, a, b) => {
@@ -1750,8 +1838,8 @@ function createMacroMathOperations() {
     return macroMathOperations;
 }
 class MlogMath extends ObjectValue {
-    constructor() {
-        super(createMacroMathOperations());
+    constructor(scope) {
+        super(createMacroMathOperations(scope));
     }
 }
 // op angle result a b
@@ -2425,6 +2513,7 @@ class SetRule extends ObjectValue {
                 solarMultiplier: { args: ["multiplier"] },
                 buildSpeed: { args: ["team", "multiplier"] },
                 unitBuildSpeed: { args: ["team", "multiplier"] },
+                unitCost: { args: ["team", "multiplier"] },
                 unitDamage: { args: ["team", "multiplier"] },
                 blockHealth: { args: ["team", "multiplier"] },
                 blockDamage: { args: ["team", "multiplier"] },
@@ -2444,6 +2533,7 @@ class SetRule extends ObjectValue {
                     }
                     case "buildSpeed":
                     case "unitBuildSpeed":
+                    case "unitCost":
                     case "unitDamage":
                     case "blockHealth":
                     case "blockDamage":
@@ -2451,7 +2541,7 @@ class SetRule extends ObjectValue {
                     case "rtsMinSquad": {
                         const [team, value] = args;
                         params[1] = team;
-                        params[2] = value;
+                        params[0] = value;
                         break;
                     }
                     default:
@@ -2812,7 +2902,7 @@ function initScope(scope) {
     scope.hardSet("getVar", new GetGlobal(EMutability.mutable));
     scope.hardSet("concat", new Concat());
     scope.hardSet("asm", new Asm());
-    scope.hardSet("Math", new MlogMath());
+    scope.hardSet("Math", new MlogMath(scope));
     scope.hardSet("Memory", new MemoryBuilder());
     // commands
     scope.hardSet("draw", new Draw());
@@ -2952,7 +3042,7 @@ class Compiler {
      */
     handleMany(scope, nodes, handler) {
         const lines = [];
-        for (const node of nodes) {
+        for (const node of hoistedFunctionNodes(nodes)) {
             const [, nodeLines] = this.handle(scope, node, handler && (() => handler(node)));
             lines.push(...nodeLines);
         }
@@ -2982,6 +3072,20 @@ function hideRedundantJumps(inst) {
             current = inst[searchIndex];
         }
     }
+}
+function* hoistedFunctionNodes(nodes) {
+    // sorting is O(n long n) while this is just O(n)
+    // besides, it's better not to modify the node array
+    for (const node of nodes) {
+        if (node.type === "FunctionDeclaration") {
+            yield node;
+        }
+    }
+    for (const node of nodes) {
+        if (node.type !== "FunctionDeclaration") {
+            yield node;
+        }
+    }
 }
 
 exports.Compiler = Compiler;