mlogjs 0.2.0 → 0.2.1

package/build/values/BaseValue.js

@@ -1,112 +1,112 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseValue = void 0;
-const instructions_1 = require("../instructions");
-const operators_1 = require("../operators");
-const _1 = require(".");
-class BaseValue extends _1.VoidValue {
-    "u-"(scope) {
-        const [that, inst] = this.eval(scope);
-        const temp = new _1.TempValue(scope);
-        return [
-            temp,
-            [
-                ...inst,
-                new instructions_1.OperationInstruction("sub", temp, new _1.LiteralValue(scope, 0), that),
-            ],
-        ];
-    }
-}
-exports.BaseValue = BaseValue;
-const operatorMap = {
-    "==": "equal",
-    "===": "strictEqual",
-    "!=": "notEqual",
-    "!==": "notEqual",
-    "<": "lessThan",
-    ">": "greaterThan",
-    "<=": "lessThanEq",
-    ">=": "greaterThanEq",
-    "+": "add",
-    "-": "sub",
-    "*": "mul",
-    "/": "div",
-    "%": "mod",
-    "**": "pow",
-    "|": "or",
-    "&": "and",
-    "^": "xor",
-    ">>": "shr",
-    ">>>": "shr",
-    "<<": "shl",
-    "&&": "land",
-    "||": "or",
-};
-for (const key in operatorMap) {
-    const kind = operatorMap[key];
-    BaseValue.prototype[key] = function (scope, value) {
-        const [left, leftInst] = this.eval(scope);
-        const [right, rightInst] = value.eval(scope);
-        const temp = new _1.TempValue(scope);
-        return [
-            temp,
-            [
-                ...leftInst,
-                ...rightInst,
-                new instructions_1.OperationInstruction(kind, temp, left, right),
-            ],
-        ];
-    };
-}
-const unaryOperatorMap = {
-    "!": "not",
-    "~": "flip",
-};
-for (const key in unaryOperatorMap) {
-    const name = unaryOperatorMap[key];
-    BaseValue.prototype[key] = function (scope) {
-        const [that, inst] = this.eval(scope);
-        const temp = new _1.TempValue(scope);
-        return [temp, [...inst, new instructions_1.OperationInstruction(name, temp, that)]];
-    };
-}
-const assignmentToBinary = {
-    "+=": "+",
-    "-=": "-",
-    "*=": "*",
-    "/=": "/",
-    "%=": "%",
-    "**=": "**",
-    "|=": "|",
-    "&=": "&",
-    "^=": "^",
-    ">>=": ">>",
-    ">>>=": ">>>",
-    "<<=": "<<",
-    "&&=": "&&",
-    "||=": "||",
-};
-for (const op in assignmentToBinary) {
-    BaseValue.prototype[op] = function (scope, value) {
-        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value);
-        const [retValue, retInst] = this["="](scope, opValue);
-        return [retValue, [...opInst, ...retInst]];
-    };
-}
-for (const key of operators_1.updateOperators) {
-    BaseValue.prototype[key] = function (scope, prefix) {
-        let [ret, inst] = this.eval(scope);
-        if (!prefix) {
-            const temp = new _1.TempValue(scope);
-            const [tempValue, tempInst] = temp["="](scope, ret);
-            ret = tempValue;
-            inst.push(...tempInst);
-        }
-        const kind = key === "++" ? "+=" : "-=";
-        return [
-            ret,
-            [...inst, ...this[kind](scope, new _1.LiteralValue(scope, 1))[1]],
-        ];
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseValue = void 0;
+const instructions_1 = require("../instructions");
+const operators_1 = require("../operators");
+const _1 = require(".");
+class BaseValue extends _1.VoidValue {
+    "u-"(scope) {
+        const [that, inst] = this.eval(scope);
+        const temp = new _1.TempValue(scope);
+        return [
+            temp,
+            [
+                ...inst,
+                new instructions_1.OperationInstruction("sub", temp, new _1.LiteralValue(scope, 0), that),
+            ],
+        ];
+    }
+}
+exports.BaseValue = BaseValue;
+const operatorMap = {
+    "==": "equal",
+    "===": "strictEqual",
+    "!=": "notEqual",
+    "!==": "notEqual",
+    "<": "lessThan",
+    ">": "greaterThan",
+    "<=": "lessThanEq",
+    ">=": "greaterThanEq",
+    "+": "add",
+    "-": "sub",
+    "*": "mul",
+    "/": "div",
+    "%": "mod",
+    "**": "pow",
+    "|": "or",
+    "&": "and",
+    "^": "xor",
+    ">>": "shr",
+    ">>>": "shr",
+    "<<": "shl",
+    "&&": "land",
+    "||": "or",
+};
+for (const key in operatorMap) {
+    const kind = operatorMap[key];
+    BaseValue.prototype[key] = function (scope, value) {
+        const [left, leftInst] = this.eval(scope);
+        const [right, rightInst] = value.eval(scope);
+        const temp = new _1.TempValue(scope);
+        return [
+            temp,
+            [
+                ...leftInst,
+                ...rightInst,
+                new instructions_1.OperationInstruction(kind, temp, left, right),
+            ],
+        ];
+    };
+}
+const unaryOperatorMap = {
+    "!": "not",
+    "~": "flip",
+};
+for (const key in unaryOperatorMap) {
+    const name = unaryOperatorMap[key];
+    BaseValue.prototype[key] = function (scope) {
+        const [that, inst] = this.eval(scope);
+        const temp = new _1.TempValue(scope);
+        return [temp, [...inst, new instructions_1.OperationInstruction(name, temp, that)]];
+    };
+}
+const assignmentToBinary = {
+    "+=": "+",
+    "-=": "-",
+    "*=": "*",
+    "/=": "/",
+    "%=": "%",
+    "**=": "**",
+    "|=": "|",
+    "&=": "&",
+    "^=": "^",
+    ">>=": ">>",
+    ">>>=": ">>>",
+    "<<=": "<<",
+    "&&=": "&&",
+    "||=": "||",
+};
+for (const op in assignmentToBinary) {
+    BaseValue.prototype[op] = function (scope, value) {
+        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value);
+        const [retValue, retInst] = this["="](scope, opValue);
+        return [retValue, [...opInst, ...retInst]];
+    };
+}
+for (const key of operators_1.updateOperators) {
+    BaseValue.prototype[key] = function (scope, prefix) {
+        let [ret, inst] = this.eval(scope);
+        if (!prefix) {
+            const temp = new _1.TempValue(scope);
+            const [tempValue, tempInst] = temp["="](scope, ret);
+            ret = tempValue;
+            inst.push(...tempInst);
+        }
+        const kind = key === "++" ? "+=" : "-=";
+        return [
+            ret,
+            [...inst, ...this[kind](scope, new _1.LiteralValue(scope, 1))[1]],
+        ];
+    };
+}
 //# sourceMappingURL=BaseValue.js.map

package/build/values/FunctionValue.d.ts

@@ -1,34 +1,34 @@
-import { Compiler } from "../Compiler";
-import { es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
-import { StoreValue } from "./StoreValue";
-import { VoidValue } from "./VoidValue";
-export declare class FunctionValue extends VoidValue implements IFunctionValue {
-    constant: boolean;
-    macro: boolean;
-    private paramStores;
-    private paramNames;
-    private inst;
-    private addr;
-    private temp;
-    private ret;
-    private inline;
-    private tryingInline;
-    private body;
-    private name;
-    private c;
-    private callSize;
-    private inlineTemp;
-    private inlineEnd;
-    private bundled;
-    private createValues;
-    typeof(scope: IScope): TValueInstructions;
-    private createInst;
-    constructor(scope: IScope, name: string, paramNames: string[], paramStores: StoreValue[], body: es.BlockStatement, c: Compiler);
-    private normalReturn;
-    private normalCall;
-    private inlineReturn;
-    private inlineCall;
-    call(scope: IScope, args: IValue[]): TValueInstructions;
-    return(scope: IScope, arg: IValue): TValueInstructions;
-    eval(scope: IScope): TValueInstructions;
-}
+import { Compiler } from "../Compiler";
+import { es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
+import { StoreValue } from "./StoreValue";
+import { VoidValue } from "./VoidValue";
+export declare class FunctionValue extends VoidValue implements IFunctionValue {
+    constant: boolean;
+    macro: boolean;
+    private paramStores;
+    private paramNames;
+    private inst;
+    private addr;
+    private temp;
+    private ret;
+    private inline;
+    private tryingInline;
+    private body;
+    private name;
+    private c;
+    private callSize;
+    private inlineTemp;
+    private inlineEnd;
+    private bundled;
+    private createValues;
+    typeof(scope: IScope): TValueInstructions;
+    private createInst;
+    constructor(scope: IScope, name: string, paramNames: string[], paramStores: StoreValue[], body: es.BlockStatement, c: Compiler);
+    private normalReturn;
+    private normalCall;
+    private inlineReturn;
+    private inlineCall;
+    call(scope: IScope, args: IValue[]): TValueInstructions;
+    return(scope: IScope, arg: IValue): TValueInstructions;
+    eval(scope: IScope): TValueInstructions;
+}

package/build/values/FunctionValue.js

@@ -1,104 +1,104 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionValue = void 0;
-const instructions_1 = require("../instructions");
-const LiteralValue_1 = require("./LiteralValue");
-const StoreValue_1 = require("./StoreValue");
-const TempValue_1 = require("./TempValue");
-const VoidValue_1 = require("./VoidValue");
-class FunctionValue extends VoidValue_1.VoidValue {
-    constructor(scope, name, paramNames, paramStores, body, c) {
-        super(scope);
-        this.constant = true;
-        this.macro = true;
-        this.bundled = false;
-        this.name = name;
-        this.paramNames = paramNames;
-        this.paramStores = paramStores;
-        this.body = body;
-        this.c = c;
-        this.callSize = paramStores.length + 2;
-        scope.function = this;
-        this.createValues();
-        this.createInst();
-    }
-    createValues() {
-        this.addr = new LiteralValue_1.LiteralValue(this.scope, null);
-        this.temp = new StoreValue_1.StoreValue(this.scope, "f" + this.name);
-        this.ret = new StoreValue_1.StoreValue(this.scope, "r" + this.name);
-    }
-    typeof(scope) {
-        return [new LiteralValue_1.LiteralValue(scope, "function"), []];
-    }
-    createInst() {
-        this.inst = [
-            new instructions_1.AddressResolver(this.addr),
-            ...this.c.handle(this.scope, this.body)[1],
-        ];
-        this.inst.push(new instructions_1.SetCounterInstruction(this.ret));
-    }
-    normalReturn(scope, arg) {
-        const argInst = arg ? this.temp["="](scope, arg)[1] : [];
-        return [null, [...argInst, new instructions_1.SetCounterInstruction(this.ret)]];
-    }
-    normalCall(scope, args) {
-        if (!this.bundled)
-            this.scope.inst.push(...this.inst);
-        this.bundled = true;
-        const callAddressLiteral = new LiteralValue_1.LiteralValue(scope, null);
-        const inst = this.paramStores
-            .map((param, i) => param["="](scope, args[i])[1])
-            .reduce((s, c) => s.concat(c), [])
-            .concat(...this.ret["="](scope, callAddressLiteral)[1], new instructions_1.JumpInstruction(this.addr, instructions_1.EJumpKind.Always), new instructions_1.AddressResolver(callAddressLiteral));
-        return [this.temp, inst];
-    }
-    inlineReturn(scope, arg) {
-        const argInst = arg ? this.inlineTemp["="](scope, arg)[1] : [];
-        return [null, [...argInst, new instructions_1.ReturnInstruction(this.inlineEnd)]];
-    }
-    inlineCall(scope, args) {
-        // create return value
-        this.inlineTemp = new TempValue_1.TempValue(scope);
-        this.inlineEnd = new LiteralValue_1.LiteralValue(scope, null);
-        // make a copy of the function scope
-        const fnScope = this.scope.copy();
-        // hard set variables within the function scope
-        this.paramNames.forEach((name, i) => fnScope.hardSet(name, args[i]));
-        this.tryingInline = true;
-        let inst = this.c.handle(fnScope, this.body)[1];
-        this.tryingInline = false;
-        // removing useless instruction
-        // get the last instructions
-        // const [jump] = inst.slice(-1);
-        // if (jump instanceof JumpInstruction) {
-        // 	// remove useless jump
-        // 	if (jump.args[1] === this.inlineEnd) inst.pop();
-        // }
-        inst.push(new instructions_1.AddressResolver(this.inlineEnd));
-        // return the function value
-        return [this.inlineTemp, inst];
-    }
-    call(scope, args) {
-        if (args.length !== this.paramStores.length)
-            throw new Error("Cannot call: argument count not matching.");
-        const inlineCall = this.inlineCall(scope, args);
-        const inlineSize = inlineCall[1].filter(i => !i.hidden).length;
-        if (this.inline || inlineSize <= this.callSize)
-            return inlineCall;
-        return this.normalCall(scope, args);
-    }
-    return(scope, arg) {
-        if (arg && arg.macro) {
-            this.inline = true;
-            return [null, []];
-        }
-        if (this.inline || this.tryingInline)
-            return this.inlineReturn(scope, arg);
-        return this.normalReturn(scope, arg);
-    }
-    eval(scope) {
-        return [this, []];
-    }
-}
-exports.FunctionValue = FunctionValue;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionValue = void 0;
+const instructions_1 = require("../instructions");
+const LiteralValue_1 = require("./LiteralValue");
+const StoreValue_1 = require("./StoreValue");
+const TempValue_1 = require("./TempValue");
+const VoidValue_1 = require("./VoidValue");
+class FunctionValue extends VoidValue_1.VoidValue {
+    constructor(scope, name, paramNames, paramStores, body, c) {
+        super(scope);
+        this.constant = true;
+        this.macro = true;
+        this.bundled = false;
+        this.name = name;
+        this.paramNames = paramNames;
+        this.paramStores = paramStores;
+        this.body = body;
+        this.c = c;
+        this.callSize = paramStores.length + 2;
+        scope.function = this;
+        this.createValues();
+        this.createInst();
+    }
+    createValues() {
+        this.addr = new LiteralValue_1.LiteralValue(this.scope, null);
+        this.temp = new StoreValue_1.StoreValue(this.scope, "f" + this.name);
+        this.ret = new StoreValue_1.StoreValue(this.scope, "r" + this.name);
+    }
+    typeof(scope) {
+        return [new LiteralValue_1.LiteralValue(scope, "function"), []];
+    }
+    createInst() {
+        this.inst = [
+            new instructions_1.AddressResolver(this.addr),
+            ...this.c.handle(this.scope, this.body)[1],
+        ];
+        this.inst.push(new instructions_1.SetCounterInstruction(this.ret));
+    }
+    normalReturn(scope, arg) {
+        const argInst = arg ? this.temp["="](scope, arg)[1] : [];
+        return [null, [...argInst, new instructions_1.SetCounterInstruction(this.ret)]];
+    }
+    normalCall(scope, args) {
+        if (!this.bundled)
+            this.scope.inst.push(...this.inst);
+        this.bundled = true;
+        const callAddressLiteral = new LiteralValue_1.LiteralValue(scope, null);
+        const inst = this.paramStores
+            .map((param, i) => param["="](scope, args[i])[1])
+            .reduce((s, c) => s.concat(c), [])
+            .concat(...this.ret["="](scope, callAddressLiteral)[1], new instructions_1.JumpInstruction(this.addr, instructions_1.EJumpKind.Always), new instructions_1.AddressResolver(callAddressLiteral));
+        return [this.temp, inst];
+    }
+    inlineReturn(scope, arg) {
+        const argInst = arg ? this.inlineTemp["="](scope, arg)[1] : [];
+        return [null, [...argInst, new instructions_1.ReturnInstruction(this.inlineEnd)]];
+    }
+    inlineCall(scope, args) {
+        // create return value
+        this.inlineTemp = new TempValue_1.TempValue(scope);
+        this.inlineEnd = new LiteralValue_1.LiteralValue(scope, null);
+        // make a copy of the function scope
+        const fnScope = this.scope.copy();
+        // hard set variables within the function scope
+        this.paramNames.forEach((name, i) => fnScope.hardSet(name, args[i]));
+        this.tryingInline = true;
+        let inst = this.c.handle(fnScope, this.body)[1];
+        this.tryingInline = false;
+        // removing useless instruction
+        // get the last instructions
+        // const [jump] = inst.slice(-1);
+        // if (jump instanceof JumpInstruction) {
+        // 	// remove useless jump
+        // 	if (jump.args[1] === this.inlineEnd) inst.pop();
+        // }
+        inst.push(new instructions_1.AddressResolver(this.inlineEnd));
+        // return the function value
+        return [this.inlineTemp, inst];
+    }
+    call(scope, args) {
+        if (args.length !== this.paramStores.length)
+            throw new Error("Cannot call: argument count not matching.");
+        const inlineCall = this.inlineCall(scope, args);
+        const inlineSize = inlineCall[1].filter(i => !i.hidden).length;
+        if (this.inline || inlineSize <= this.callSize)
+            return inlineCall;
+        return this.normalCall(scope, args);
+    }
+    return(scope, arg) {
+        if (arg && arg.macro) {
+            this.inline = true;
+            return [null, []];
+        }
+        if (this.inline || this.tryingInline)
+            return this.inlineReturn(scope, arg);
+        return this.normalReturn(scope, arg);
+    }
+    eval(scope) {
+        return [this, []];
+    }
+}
+exports.FunctionValue = FunctionValue;
 //# sourceMappingURL=FunctionValue.js.map

package/build/values/LiteralValue.d.ts

@@ -1,12 +1,12 @@
-import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue } from "../types";
-import { BaseValue } from ".";
-export declare class LiteralValue extends BaseValue implements IBindableValue {
-    data: TLiteral;
-    constant: boolean;
-    constructor(scope: IScope, data: TLiteral);
-    eval(scope: IScope): TValueInstructions;
-    toString(): string;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    get num(): number;
-    typeof(scope: IScope): TValueInstructions;
-}
+import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue } from "../types";
+import { BaseValue } from ".";
+export declare class LiteralValue extends BaseValue implements IBindableValue {
+    data: TLiteral;
+    constant: boolean;
+    constructor(scope: IScope, data: TLiteral);
+    eval(scope: IScope): TValueInstructions;
+    toString(): string;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    get num(): number;
+    typeof(scope: IScope): TValueInstructions;
+}