mevento 1.8.0 → 1.9.0

package/fesm2020/mevento.mjs

@@ -152,7 +152,7 @@ class Lexer {
                 error(token);
             }
             const lang = idToken.value.toString();
-            this._language = Lexer.languages.find((element) => element.lang === lang) || Lexer._defaultLanguage;
+            this._language = Lexer.languages.find((element) => element.lang === lang) ?? Lexer._defaultLanguage;
             token = this.nextToken();
             if (token.type !== TokenType.great) {
                 error(token);
@@ -226,9 +226,9 @@ class Lexer {
             this._advance();
         }
         const translatedId = this._language
-            ? (this._language.keywords[ret]) || ret
+            ? (this._language.keywords[ret]) ?? ret
             : ret;
-        return Lexer.RESERVED[translatedId] || new Token(TokenType.id, ret, line, lastC);
+        return Lexer.RESERVED[translatedId] ?? new Token(TokenType.id, ret, line, lastC);
     }
     _isLineEnd(c) {
         return c === 10 ||
@@ -1257,14 +1257,58 @@ class NodeVisitor extends ANodeVisitor {
         else { }
     }
 }
+class MEventScope {
+    constructor(name, memory, parent) {
+        this.memory = {};
+        this.name = name;
+        this.memory = memory;
+        this.parent = parent;
+    }
+    resolve(key) {
+        return Object.keys(this.memory).includes(key) ? this.memory[key] : (this.parent ? this.parent.resolve(key) : null);
+    }
+    change(key, value, declare = true) {
+        if (Object.keys(this.memory).includes(key)) {
+            // change here
+            this.memory[key] = value;
+            return true;
+        }
+        if (this.parent && this.parent.change(key, value, false)) {
+            return true;
+        }
+        if (!declare) {
+            return false;
+        }
+        this.memory[key] = value;
+        return true;
+    }
+}
 class MEvento extends NodeVisitor {
     constructor() {
         super();
-        this._memory = {};
+        this.rootScope = new MEventScope("Program", {});
+        this.currentScrope = this.rootScope;
         this.debug = false;
         this._functionsRegistry = {};
         this._functionsRegistry = { ...MEvento._globalFunctionsRegistry };
     }
+    resolve(name) {
+        return this.currentScrope?.resolve(name) ?? null;
+    }
+    changeVariable(name, value) {
+        if (this.currentScrope?.change(name, value)) {
+            return value;
+        }
+        else
+            return null;
+    }
+    pushScope(name) {
+        const scope = new MEventScope(name, {}, this.currentScrope);
+        this.currentScrope = scope;
+    }
+    popScope() {
+        this.currentScrope = this.currentScrope?.parent;
+    }
     log(message) {
         if (this.debug) {
             console.log(message);
@@ -1281,17 +1325,19 @@ class MEvento extends NodeVisitor {
     visitBlockStatementAST(node) {
         const list = node.body;
         let last;
+        this.pushScope("Block");
         for (const n of list) {
             last = this.visit(n);
             if (last instanceof LoopControl) {
-                return last;
+                break;
             }
         }
+        this.popScope();
         return last;
     }
     visitIdentifierAST(node) {
         const id = node.value;
-        return this._memory[id];
+        return this.currentScrope?.resolve(id) ?? null;
     }
     visitLiteralAST(node) {
         const value = node.value;
@@ -1309,7 +1355,7 @@ class MEvento extends NodeVisitor {
         }
         else if (id instanceof IdentifierAST) {
             value = this.visit(init);
-            this._memory[id.value] = value;
+            this.changeVariable(id.value, value);
         }
         return value;
     }
@@ -1479,51 +1525,59 @@ class MEvento extends NodeVisitor {
             if (ret instanceof BreakBranch) {
                 break;
             }
-            if (ret instanceof ContinueAST) {
+            if (ret instanceof ContinueBranch) {
                 continue;
             }
             retainer?.push(ret);
         }
-        return retainer || null;
+        return retainer ?? null;
     }
     visitForLoopStatement(node) {
         const retainer = node.retain ? [] : undefined;
         const loopIdentifier = node.init.identifier;
         if (!(loopIdentifier instanceof IdentifierAST))
             throw new Error("Unexpected identifer found");
+        this.pushScope("ForLoopStatement");
         const initialValue = this.visit(node.init.init);
-        this._memory[loopIdentifier.value] = initialValue;
+        this.changeVariable(loopIdentifier.value, initialValue);
         retainer?.push(initialValue);
         const test = () => {
             const ret = this.visit(node.test);
             if (isNum(ret)) {
-                const tmp = this._memory[loopIdentifier.value];
+                const tmp = this.resolve(loopIdentifier.value);
                 return node.direction.type === TokenType.up ? ret >= tmp : ret <= tmp;
             }
             return _boolValue(ret);
         };
+        const update = () => {
+            const updateValue = this.visit(node.update);
+            if (isNum(updateValue)) {
+                // auto handle
+                const tmp = this.resolve(loopIdentifier.value);
+                if (!isNum(tmp))
+                    throw Error("Cant update value");
+                this.changeVariable(loopIdentifier.value, node.direction.type === TokenType.up ? tmp + updateValue : tmp - updateValue);
+                // console.log('Update loop from ' + tmp + ' to ' + this.resolve(loopIdentifier.value))
+            }
+            else {
+                throw Error("Update value cant be non number");
+            }
+        };
         while (test()) {
             const ret = this.visit(node.body);
             if (ret instanceof BreakBranch) {
                 break;
             }
-            if (ret instanceof ContinueAST) {
+            if (ret instanceof ContinueBranch) {
+                update();
                 continue;
             }
             retainer?.push(ret);
             // update
-            if (node.update instanceof LiteralAST && isNum(node.update.value)) {
-                // auto handle
-                const tmp = this._memory[loopIdentifier.value];
-                if (!isNum(tmp))
-                    throw Error("Can update value");
-                this._memory[loopIdentifier.value] = node.direction.type === TokenType.up ? tmp + node.update.value : tmp - node.update.value;
-            }
-            else {
-                this.visit(node.update);
-            }
+            update();
         }
-        return retainer || null;
+        this.popScope();
+        return retainer ?? null;
     }
     visitForOfStatement(node) {
         const collection = this.visit(node.collection);
@@ -1531,18 +1585,20 @@ class MEvento extends NodeVisitor {
             throw Error("Can iterate non array object");
         }
         const retainer = node.retain ? [] : undefined;
+        this.pushScope("ForOfStatement");
         for (const it of collection) {
             this._declareForIdentifier(node.identifier, it);
             const ret = this.visit(node.body);
             if (ret instanceof BreakBranch) {
                 break;
             }
-            if (ret instanceof ContinueAST) {
+            if (ret instanceof ContinueBranch) {
                 continue;
             }
             retainer?.push(ret);
         }
-        return retainer || null;
+        this.popScope();
+        return retainer ?? null;
     }
     visitContinueAST(node) {
         return new ContinueBranch();
@@ -1552,12 +1608,10 @@ class MEvento extends NodeVisitor {
             if (!Array.isArray(value)) {
                 throw Error("Unable to make a tuple from non Array element");
             }
-            this._memory[node.first.value] = value[0];
-            this._memory[node.second.value] = value[1];
-            null;
+            this.changeVariable(node.first.value, value[0]);
+            this.changeVariable(node.second.value, value[1]);
         }
-        this._memory[node.value] = value;
-        null;
+        this.changeVariable(node.value, value);
     }
     resolveArguments(args) {
         return args.map((it) => {
@@ -1606,12 +1660,12 @@ class MEvento extends NodeVisitor {
     clone() {
         var ret = new MEvento();
         ret._functionsRegistry = { ...this._functionsRegistry };
-        ret._memory = { ...this._memory };
+        ret.rootScope.memory = { ...this.rootScope.memory };
         return ret;
     }
     newAsyncInstance() {
         const asyncIns = MEventoAsync.newInstance();
-        asyncIns._memory = this._memory;
+        asyncIns.rootScope.memory = this.rootScope.memory;
         /// ????
         asyncIns._functionsRegistry = this._functionsRegistry;
         return asyncIns;
@@ -1635,17 +1689,19 @@ class MEventoAsync extends MEvento {
     async visitBlockStatementAST(node) {
         const list = node.body;
         let last;
+        this.pushScope("Block");
         for (const n of list) {
             last = await this.visit(n);
             if (last instanceof LoopControl) {
-                return last;
+                break;
             }
         }
+        this.popScope();
         return last;
     }
     async visitIdentifierAST(node) {
         const id = node.value;
-        return this._memory[id];
+        return this.resolve(id);
     }
     async visitLiteralAST(node) {
         const value = node.value;
@@ -1663,7 +1719,7 @@ class MEventoAsync extends MEvento {
         }
         else if (id instanceof IdentifierAST) {
             value = await this.visit(init);
-            this._memory[id.value] = value;
+            this.changeVariable(id.value, value);
         }
         return value;
     }
@@ -1753,6 +1809,9 @@ class MEventoAsync extends MEvento {
         const arg = node.argument;
         const op = node.operation;
         const argValue = await this.visit(arg);
+        if (op.type === TokenType.not) {
+            return _boolValue(argValue) === false;
+        }
         if (isNum(argValue)) {
             throw new Error(`Operation ${op.value} not allowed no num value`);
         }
@@ -1822,12 +1881,12 @@ class MEventoAsync extends MEvento {
     async visitWhileLoopStatement(node) {
         this.log(`WhileLoopStatement ${node.test} ${node.body}`);
         const retainer = node.retain ? [] : undefined;
-        while (_boolValue(this.visit(node.test))) {
+        while (_boolValue(await this.visit(node.test))) {
             const ret = await this.visit(node.body);
             if (ret instanceof BreakBranch) {
                 break;
             }
-            if (ret instanceof ContinueAST) {
+            if (ret instanceof ContinueBranch) {
                 continue;
             }
             retainer?.push(ret);
@@ -1839,57 +1898,66 @@ class MEventoAsync extends MEvento {
         const loopIdentifier = node.init.identifier;
         if (!(loopIdentifier instanceof IdentifierAST))
             throw new Error("Unexpected identifer found");
-        const initialValue = this.visit(node.init.init);
-        this._memory[loopIdentifier.value] = initialValue;
+        this.pushScope("ForLoopStatement");
+        const initialValue = await this.visit(node.init.init);
+        this.changeVariable(loopIdentifier.value, initialValue);
         retainer?.push(initialValue);
-        const test = () => {
-            const ret = this.visit(node.test);
+        const test = async () => {
+            const ret = await this.visit(node.test);
             if (isNum(ret)) {
-                const tmp = this._memory[loopIdentifier.value];
+                const tmp = this.resolve(loopIdentifier.value);
                 return node.direction.type === TokenType.up ? ret >= tmp : ret <= tmp;
             }
             return _boolValue(ret);
         };
-        while (test()) {
+        const update = async () => {
+            const updateValue = await this.visit(node.update);
+            if (isNum(updateValue)) {
+                // auto handle
+                const tmp = this.resolve(loopIdentifier.value);
+                if (!isNum(tmp))
+                    throw Error("Cant update value");
+                this.changeVariable(loopIdentifier.value, node.direction.type === TokenType.up ? tmp + updateValue : tmp - updateValue);
+            }
+            else {
+                throw Error("Update value cant be non number");
+            }
+        };
+        while (await test()) {
             const ret = await this.visit(node.body);
             if (ret instanceof BreakBranch) {
                 break;
             }
-            if (ret instanceof ContinueAST) {
+            if (ret instanceof ContinueBranch) {
+                await update();
                 continue;
             }
             retainer?.push(ret);
             // update
-            if (node.update instanceof LiteralAST && isNum(node.update.value)) {
-                // auto handle
-                const tmp = this._memory[loopIdentifier.value];
-                if (!isNum(tmp))
-                    throw Error("Can update value");
-                this._memory[loopIdentifier.value] = node.direction.type === TokenType.up ? tmp + node.update.value : tmp - node.update.value;
-            }
-            else {
-                this.visit(node.update);
-            }
+            await update();
         }
-        return retainer;
+        this.popScope();
+        return retainer ?? null;
     }
     async visitForOfStatement(node) {
-        const collection = this.visit(node.collection);
+        const collection = await this.visit(node.collection);
         if (!Array.isArray(collection)) {
             throw Error("Can iterate non array object");
         }
         const retainer = node.retain ? [] : undefined;
+        this.pushScope("ForOfStatement");
         for (const it of collection) {
             this._declareForIdentifier(node.identifier, it);
             const ret = await this.visit(node.body);
             if (ret instanceof BreakBranch) {
                 break;
             }
-            if (ret instanceof ContinueAST) {
+            if (ret instanceof ContinueBranch) {
                 continue;
             }
             retainer?.push(ret);
         }
+        this.popScope();
         return retainer;
     }
     async resolveArgumentsAsync(args) {
@@ -1918,7 +1986,7 @@ class MEventoAsync extends MEvento {
     clone() {
         var ret = new MEventoAsync();
         ret._functionsRegistry = { ...this._functionsRegistry };
-        ret._memory = { ...this._memory };
+        ret.rootScope.memory = { ...this.rootScope.memory };
         return ret;
     }
 }
@@ -1931,5 +1999,5 @@ class MEventoAsync extends MEvento {
  * Generated bundle index. Do not edit.
  */
 
-export { AST, ArrayExpression, AssignmentExpressionAST, BinaryExpressionAST, BlockStatementAST, BreakAST, BreakBranch, CallExpressionAST, ContinueAST, ContinueBranch, ExpressionStatementAST, ForLoopStatement, ForOfStatement, IdentifierAST, IfStatementAST, IndexAccessorAST, LexerDictionary, LiteralAST, LogicalExpressionAST, LoopControl, MEvento, MEventoAsync, NodeVisitor, ObjectExpression, ObjectProperty, RootAST, Token, TokenType, TupleExpression, UnaryExpressionAST, WhileLoopStatement };
+export { AST, ArrayExpression, AssignmentExpressionAST, BinaryExpressionAST, BlockStatementAST, BreakAST, BreakBranch, CallExpressionAST, ContinueAST, ContinueBranch, ExpressionStatementAST, ForLoopStatement, ForOfStatement, IdentifierAST, IfStatementAST, IndexAccessorAST, LexerDictionary, LiteralAST, LogicalExpressionAST, LoopControl, MEventScope, MEvento, MEventoAsync, NodeVisitor, ObjectExpression, ObjectProperty, RootAST, Token, TokenType, TupleExpression, UnaryExpressionAST, WhileLoopStatement };
 //# sourceMappingURL=mevento.mjs.map