mlogjs 0.4.9 → 0.4.10

package/dist/Compiler.d.ts

@@ -1,6 +1,6 @@
 import { CompilerError } from "./CompilerError";
 import { es, IScope, IValue, TEOutput, THandler, TValueInstructions } from "./types";
-declare type THandlerMap = {
+type THandlerMap = {
     [k in es.Node["type"]]?: THandler<IValue | null>;
 };
 export interface CompilerOptions {

package/dist/CompilerError.d.ts

@@ -12,7 +12,7 @@ export interface ParsingError extends Error {
         column: number;
     };
 }
-declare type CompilerErrorSource = es.Node | es.SourceLocation | {
+type CompilerErrorSource = es.Node | es.SourceLocation | {
     line: number;
     column: number;
 };

package/dist/Scope.d.ts

@@ -7,12 +7,14 @@ export declare class Scope implements IScope {
     ntemp: number;
     name: string;
     inst: IInstruction[];
+    operationCache: Record<string, IValue>;
+    cacheDependencies: Record<string, string[]>;
     data: Record<string, IValue | null>;
     break: AddressResolver;
     continue: AddressResolver;
     function: IFunctionValue;
     label?: string;
-    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
+    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[], operationCache?: Record<string, IValue>, cacheDependencies?: Record<string, string[]>);
     copy(): IScope;
     createScope(): IScope;
     createFunction(name: string, stacked?: boolean): IScope;
@@ -22,4 +24,7 @@ export declare class Scope implements IScope {
     hardSet<T extends IValue>(name: string, value: T): T;
     make(identifier: string, name: string): SenseableValue;
     makeTempName(): string;
+    addCachedOperation(op: string, result: IValue, left: IValue, right?: IValue | undefined): void;
+    getCachedOperation(op: string, left: IValue, right?: IValue | undefined): IValue | undefined;
+    clearDependentCache(value: IValue): void;
 }

package/dist/index.cjs

@@ -167,7 +167,19 @@ const unaryOperators = [
 ];
 const updateOperators = ["++", "--"];
 const singleOperators = [...unaryOperators, ...updateOperators];
-const operators = [...leftRightOperators, ...singleOperators];
+const operators = [...leftRightOperators, ...singleOperators];
+const orderIndependentOperators = [
+    "!=",
+    "!==",
+    "&&",
+    "&",
+    "*",
+    "+",
+    "==",
+    "===",
+    "|",
+    "||",
+];
 
 class VoidValue {
     constructor() {
@@ -198,18 +210,18 @@ for (const key of operators) {
 }
 
 class InstructionBase {
-    constructor(...args) {
-        this.intent = EInstIntent.none;
-        this.alwaysRuns = true;
-        this._hidden = false;
-        this.args = args;
-    }
     get hidden() {
         return this._hidden;
     }
     set hidden(value) {
         this._hidden = value;
     }
+    constructor(...args) {
+        this.intent = EInstIntent.none;
+        this.alwaysRuns = true;
+        this._hidden = false;
+        this.args = args;
+    }
     resolve(_i) { }
     toString() {
         return this.args.filter(arg => arg).join(" ");
@@ -427,14 +439,14 @@ class EndInstruction extends InstructionBase {
 }
 
 class AddressResolver extends InstructionBase {
-    constructor(...bonds) {
-        super();
-        this.bonds = bonds;
-    }
     get hidden() {
         return true;
     }
     set hidden(value) { }
+    constructor(...bonds) {
+        super();
+        this.bonds = bonds;
+    }
     resolve(i) {
         for (const literal of this.bonds)
             literal.data = i;
@@ -646,6 +658,7 @@ class LiteralValue extends BaseValue {
         super();
         this.mutability = EMutability.constant;
         this.data = data;
+        this.name = this.toString();
     }
     eval(_scope) {
         return [this, []];
@@ -984,16 +997,18 @@ class LazyValue extends VoidValue {
 }
 
 class Scope {
-    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = []) {
+    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = [], operationCache = {}, cacheDependencies = {}) {
         this.parent = parent;
         this.stacked = stacked;
         this.ntemp = ntemp;
         this.name = name;
         this.inst = inst;
+        this.operationCache = operationCache;
+        this.cacheDependencies = cacheDependencies;
         this.data = values;
     }
     copy() {
-        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst);
+        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst, { ...this.operationCache }, { ...this.cacheDependencies });
         scope.break = this.break;
         scope.continue = this.continue;
         scope.function = this.function;
@@ -1002,6 +1017,8 @@ class Scope {
     createScope() {
         const scope = this.copy();
         scope.data = {};
+        scope.operationCache = {};
+        scope.cacheDependencies = {};
         scope.parent = this;
         return scope;
     }
@@ -1047,6 +1064,46 @@ class Scope {
         this.ntemp++;
         return result;
     }
+    addCachedOperation(op, result, left, right) {
+        if (!left.name || !result.name || (right && !right.name))
+            return;
+        const id = formatCacheId(op, left, right);
+        this.operationCache[id] = result;
+        this.clearDependentCache(result);
+        addCacheDependency(this, left.name, id);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (right)
+            addCacheDependency(this, right.name, id);
+        addCacheDependency(this, result.name, id);
+    }
+    getCachedOperation(op, left, right) {
+        const id = formatCacheId(op, left, right);
+        const result = this.operationCache[id];
+        if (result)
+            return result;
+        if (this.parent)
+            return this.parent.getCachedOperation(op, left, right);
+    }
+    clearDependentCache(value) {
+        if (!value.name)
+            return;
+        const dependents = this.cacheDependencies[value.name];
+        if (dependents) {
+            for (const id of dependents) {
+                delete this.operationCache[id];
+            }
+        }
+        if (this.parent)
+            this.parent.clearDependentCache(value);
+    }
+}
+function formatCacheId(op, left, right) {
+    if (right)
+        return `{${op}}{${left.name}}{${right.name}}`;
+    return `{${op}}{${left.name}}`;
+}
+function addCacheDependency(scope, name, id) {
+    (scope.cacheDependencies[name] ??= []).push(id);
 }
 
 const Program = (c, scope, node) => {
@@ -1222,7 +1279,21 @@ const BooleanLiteral = (_c, scope, node) => [new LiteralValue(+node.value), []];
 const LRExpression = (c, scope, node, out) => {
     const [left, leftInst] = c.handleEval(scope, node.left);
     const [right, rightInst] = c.handleEval(scope, node.right);
+    if (!(left instanceof LiteralValue) || !(right instanceof LiteralValue)) {
+        const cachedResult = scope.getCachedOperation(node.operator, left, right);
+        if (cachedResult)
+            return [cachedResult, [...leftInst, ...rightInst]];
+        // because a * b is the same as b * a
+        if (orderIndependentOperators.includes(node.operator)) {
+            const cachedResult = scope.getCachedOperation(node.operator, right, left);
+            if (cachedResult)
+                return [cachedResult, [...leftInst, ...rightInst]];
+        }
+    }
     const [op, opInst] = left[node.operator](scope, right, out);
+    if (!(op instanceof LiteralValue)) {
+        scope.addCachedOperation(node.operator, op, left, right);
+    }
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const BinaryExpression = LRExpression;
@@ -1244,18 +1315,26 @@ const AssignmentExpression = (c, scope, node) => {
         ];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
+    if (left)
+        scope.clearDependentCache(left);
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const UnaryExpression = (c, scope, { argument, operator }, out) => {
     const [arg, argInst] = c.handleEval(scope, argument);
+    const cachedResult = scope.getCachedOperation(operator, arg);
+    if (cachedResult)
+        return [cachedResult, argInst];
     const operatorId = operator == "+" || operator == "-" ? `u${operator}` : operator;
     if (operatorId === "throw")
         throw new CompilerError("throw operator is not supported");
     const [op, opInst] = arg[operatorId](scope, out);
+    scope.addCachedOperation(operator, op, arg);
     return [op, [...argInst, ...opInst]];
 };
 const UpdateExpression = (c, scope, { argument, operator, prefix }, out) => {
     const [arg, argInst] = c.handle(scope, argument);
+    if (arg)
+        scope.clearDependentCache(arg);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = arg[operator](scope, prefix, out);
     return [op, [...argInst, ...opInst]];
@@ -1358,9 +1437,12 @@ const IfStatement = (c, scope, node) => {
         return [null, inst];
     }
     const endIfAddr = new LiteralValue(null);
-    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1], new AddressResolver(endIfAddr));
-    const endElseAddr = new LiteralValue(null);
-    if (node.alternate) {
+    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1]);
+    if (!node.alternate) {
+        inst.push(new AddressResolver(endIfAddr));
+    }
+    else {
+        const endElseAddr = new LiteralValue(null);
         inst.push(new JumpInstruction(endElseAddr, EJumpKind.Always), new AddressResolver(endIfAddr), ...withAlwaysRuns(c.handle(scope, node.alternate), false)[1], new AddressResolver(endElseAddr));
     }
     return [null, inst];
@@ -2064,6 +2146,7 @@ const mathOperations = {
     sqrt: a => Math.sqrt(a),
     rand: null,
 };
+const orderIndependentOperations = ["max", "min", "len"];
 function createMacroMathOperations() {
     const macroMathOperations = {
         PI: new StoreValue("@pi", EMutability.constant),
@@ -2080,7 +2163,17 @@ function createMacroMathOperations() {
                         throw new CompilerError("Cannot do math operation with non-numerical literals.");
                     return [new LiteralValue(fn(a.num, b.num)), []];
                 }
+                const cachedResult = scope.getCachedOperation(key, a, b);
+                if (cachedResult)
+                    return [cachedResult, []];
+                // max, min and len do not change if the arguments change in order
+                if (orderIndependentOperations.includes(key)) {
+                    const cachedResult = scope.getCachedOperation(key, b, a);
+                    if (cachedResult)
+                        return [cachedResult, []];
+                }
                 const temp = StoreValue.from(scope, out);
+                scope.addCachedOperation(key, temp, a, b);
                 return [temp, [new OperationInstruction(key, temp, a, b)]];
             }
             if (fn && a instanceof LiteralValue) {
@@ -2088,8 +2181,14 @@ function createMacroMathOperations() {
                     throw new CompilerError("Cannot do math operation with non-numerical literal.");
                 return [new LiteralValue(fn(a.num)), []];
             }
+            const cachedResult = scope.getCachedOperation(key, a);
+            if (cachedResult)
+                return [cachedResult, []];
             const temp = StoreValue.from(scope, out);
-            return [temp, [new OperationInstruction(key, temp, a, b)]];
+            // ensures that operations like `rand` are not cached
+            if (mathOperations[key])
+                scope.addCachedOperation(key, temp, a);
+            return [temp, [new OperationInstruction(key, temp, a, null)]];
         });
     }
     return macroMathOperations;