mevento 1.4.0 → 1.9.0

package/fesm2020/mevento.mjs

@@ -77,6 +77,7 @@ TokenType.with = 39;
 TokenType.in = 40;
 TokenType.TILL = 41;
 TokenType.BREAK = 42;
+TokenType.CONTINUE = 43;
 class Token {
     constructor(type, value, line = 1, col = 1) {
         this.type = type;
@@ -151,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);
@@ -225,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 ||
@@ -488,6 +489,7 @@ Lexer._defaultLanguage = new LexerDictionary("en", {
     "till": "till",
     "in": "in",
     "break": "break",
+    "continue": "continue",
 });
 Lexer.languages = [
     Lexer._defaultLanguage,
@@ -500,11 +502,12 @@ Lexer.languages = [
         "tanque": "while",
         "pour": "for",
         "avec": "with",
-        "mon": "up",
+        "mont": "up",
         "desc": "down",
         "jusqua": "till",
         "dans": "in",
         "couper": "break",
+        "continuer": "continue",
     }),
     new LexerDictionary("bm", {
         "nii": "if",
@@ -520,6 +523,7 @@ Lexer.languages = [
         "kata": "till",
         "kono": "in",
         "tike": "break",
+        "ipan": "continue",
     }),
 ];
 Lexer.RESERVED = {
@@ -536,6 +540,7 @@ Lexer.RESERVED = {
     "till": Token.from(TokenType.TILL, "till"),
     "in": Token.from(TokenType.in, "in"),
     "break": Token.from(TokenType.BREAK, "break"),
+    "continue": Token.from(TokenType.CONTINUE, "continue"),
 };
 /**
  * Parser
@@ -742,6 +747,11 @@ class BreakAST extends AST {
         super(line, col);
     }
 }
+class ContinueAST extends AST {
+    constructor(line, col) {
+        super(line, col);
+    }
+}
 class Parser {
     constructor(lexer) {
         this.currentToken = lexer.nextToken();
@@ -976,8 +986,7 @@ class Parser {
         }
         // const body = _statements();
         const body = [this._statement()];
-        while (this.currentToken.type === TokenType.eol ||
-            this.currentToken.type === TokenType.semi) {
+        while (true) {
             this._eatSemiOrEOL();
             if (this.currentToken.type === TokenType.rbrace || this.currentToken.type === TokenType.eof) {
                 // _eat(this.currentToken!.type);
@@ -1041,7 +1050,6 @@ class Parser {
         return new WhileLoopStatement(test, body, token, this.currentToken);
     }
     _forOfIdentifier() {
-        let node;
         switch (this.currentToken.type) {
             case TokenType.lparen: {
                 // probable tuple
@@ -1121,6 +1129,9 @@ class Parser {
             case TokenType.BREAK:
                 this._eat(TokenType.BREAK);
                 return new BreakAST(this.currentToken?.line, this.currentToken?.col);
+            case TokenType.CONTINUE:
+                this._eat(TokenType.CONTINUE);
+                return new ContinueAST(this.currentToken?.line, this.currentToken?.col);
             case TokenType.semi:
                 this._eatSemi();
                 return this._statement();
@@ -1152,7 +1163,12 @@ class Parser {
                 this._eat(TokenType.eof);
                 break;
             }
-            results.push(this._statement());
+            if (this.currentToken.type === TokenType.lbrace) {
+                results.push(this._blockStatement());
+            }
+            else {
+                results.push(this._statement());
+            }
             // if (this.currentToken!.type !== TokenType.eol &&
             //     this.currentToken!.type !== TokenType.semi &&
             //     this.currentToken!.type !== TokenType.eof) {
@@ -1184,7 +1200,11 @@ Parser._binopPrecdences = {
     [TokenType.div]: 40,
     [TokenType.mod]: 40,
 };
-class BreakBranch {
+class LoopControl {
+}
+class BreakBranch extends LoopControl {
+}
+class ContinueBranch extends LoopControl {
 }
 // AST Wallker
 class ANodeVisitor {
@@ -1219,6 +1239,7 @@ class NodeVisitor extends ANodeVisitor {
         this.registerVisitor(ForLoopStatement, this.visitForLoopStatement);
         this.registerVisitor(ForOfStatement, this.visitForOfStatement);
         this.registerVisitor(BreakAST, this.visitBreakAST);
+        this.registerVisitor(ContinueAST, this.visitContinueAST);
     }
     visit(node) {
         const methodName = `visit${node.constructor.name}`;
@@ -1236,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);
@@ -1260,14 +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) {
+                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;
@@ -1285,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;
     }
@@ -1455,45 +1525,59 @@ class MEvento extends NodeVisitor {
             if (ret instanceof BreakBranch) {
                 break;
             }
+            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 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);
@@ -1501,27 +1585,33 @@ 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 ContinueBranch) {
+                continue;
+            }
             retainer?.push(ret);
         }
-        return retainer || null;
+        this.popScope();
+        return retainer ?? null;
+    }
+    visitContinueAST(node) {
+        return new ContinueBranch();
     }
     _declareForIdentifier(node, value) {
         if (node instanceof TupleExpression) {
             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) => {
@@ -1570,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;
@@ -1599,14 +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) {
+                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;
@@ -1624,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;
     }
@@ -1714,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`);
         }
@@ -1783,11 +1881,14 @@ 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 ContinueBranch) {
+                continue;
+            }
             retainer?.push(ret);
         }
         return retainer;
@@ -1797,51 +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 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 ContinueBranch) {
+                continue;
+            }
             retainer?.push(ret);
         }
+        this.popScope();
         return retainer;
     }
     async resolveArgumentsAsync(args) {
@@ -1870,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;
     }
 }
@@ -1883,5 +1999,5 @@ class MEventoAsync extends MEvento {
  * Generated bundle index. Do not edit.
  */
 
-export { AST, ArrayExpression, AssignmentExpressionAST, BinaryExpressionAST, BlockStatementAST, BreakAST, BreakBranch, CallExpressionAST, ExpressionStatementAST, ForLoopStatement, ForOfStatement, IdentifierAST, IfStatementAST, IndexAccessorAST, LexerDictionary, LiteralAST, LogicalExpressionAST, 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