mevento 1.4.0 → 1.9.0

package/fesm2015/mevento.mjs

@@ -79,6 +79,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;
@@ -145,6 +146,7 @@ class Lexer {
         return this._source;
     }
     _resolveLanguage() {
+        var _a;
         let token = this.nextToken();
         if (token.type === TokenType.less) {
             // language setting
@@ -153,7 +155,7 @@ class Lexer {
                 error(token);
             }
             const lang = idToken.value.toString();
-            this._language = Lexer.languages.find((element) => element.lang === lang) || Lexer._defaultLanguage;
+            this._language = (_a = Lexer.languages.find((element) => element.lang === lang)) !== null && _a !== void 0 ? _a : Lexer._defaultLanguage;
             token = this.nextToken();
             if (token.type !== TokenType.great) {
                 error(token);
@@ -218,6 +220,7 @@ class Lexer {
         return false;
     }
     _id() {
+        var _a, _b;
         let ret = "";
         const lastC = this._col;
         const lastP = this._position;
@@ -227,9 +230,9 @@ class Lexer {
             this._advance();
         }
         const translatedId = this._language
-            ? (this._language.keywords[ret]) || ret
+            ? (_a = (this._language.keywords[ret])) !== null && _a !== void 0 ? _a : ret
             : ret;
-        return Lexer.RESERVED[translatedId] || new Token(TokenType.id, ret, line, lastC);
+        return (_b = Lexer.RESERVED[translatedId]) !== null && _b !== void 0 ? _b : new Token(TokenType.id, ret, line, lastC);
     }
     _isLineEnd(c) {
         return c === 10 ||
@@ -490,6 +493,7 @@ Lexer._defaultLanguage = new LexerDictionary("en", {
     "till": "till",
     "in": "in",
     "break": "break",
+    "continue": "continue",
 });
 Lexer.languages = [
     Lexer._defaultLanguage,
@@ -502,11 +506,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",
@@ -522,6 +527,7 @@ Lexer.languages = [
         "kata": "till",
         "kono": "in",
         "tike": "break",
+        "ipan": "continue",
     }),
 ];
 Lexer.RESERVED = {
@@ -538,6 +544,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
@@ -744,6 +751,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();
@@ -986,8 +998,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);
@@ -1051,7 +1062,6 @@ class Parser {
         return new WhileLoopStatement(test, body, token, this.currentToken);
     }
     _forOfIdentifier() {
-        let node;
         switch (this.currentToken.type) {
             case TokenType.lparen: {
                 // probable tuple
@@ -1127,11 +1137,14 @@ class Parser {
         return node;
     }
     _statement() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         switch (this.currentToken.type) {
             case TokenType.BREAK:
                 this._eat(TokenType.BREAK);
                 return new BreakAST((_a = this.currentToken) === null || _a === void 0 ? void 0 : _a.line, (_b = this.currentToken) === null || _b === void 0 ? void 0 : _b.col);
+            case TokenType.CONTINUE:
+                this._eat(TokenType.CONTINUE);
+                return new ContinueAST((_c = this.currentToken) === null || _c === void 0 ? void 0 : _c.line, (_d = this.currentToken) === null || _d === void 0 ? void 0 : _d.col);
             case TokenType.semi:
                 this._eatSemi();
                 return this._statement();
@@ -1164,7 +1177,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) {
@@ -1196,7 +1214,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 {
@@ -1231,6 +1253,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}`;
@@ -1248,14 +1271,61 @@ 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 = Object.assign({}, MEvento._globalFunctionsRegistry);
     }
+    resolve(name) {
+        var _a, _b;
+        return (_b = (_a = this.currentScrope) === null || _a === void 0 ? void 0 : _a.resolve(name)) !== null && _b !== void 0 ? _b : null;
+    }
+    changeVariable(name, value) {
+        var _a;
+        if ((_a = this.currentScrope) === null || _a === void 0 ? void 0 : _a.change(name, value)) {
+            return value;
+        }
+        else
+            return null;
+    }
+    pushScope(name) {
+        const scope = new MEventScope(name, {}, this.currentScrope);
+        this.currentScrope = scope;
+    }
+    popScope() {
+        var _a;
+        this.currentScrope = (_a = this.currentScrope) === null || _a === void 0 ? void 0 : _a.parent;
+    }
     log(message) {
         if (this.debug) {
             console.log(message);
@@ -1272,14 +1342,20 @@ 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) {
+        var _a, _b;
         const id = node.value;
-        return this._memory[id];
+        return (_b = (_a = this.currentScrope) === null || _a === void 0 ? void 0 : _a.resolve(id)) !== null && _b !== void 0 ? _b : null;
     }
     visitLiteralAST(node) {
         const value = node.value;
@@ -1297,7 +1373,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;
     }
@@ -1467,45 +1543,59 @@ class MEvento extends NodeVisitor {
             if (ret instanceof BreakBranch) {
                 break;
             }
+            if (ret instanceof ContinueBranch) {
+                continue;
+            }
             retainer === null || retainer === void 0 ? void 0 : retainer.push(ret);
         }
-        return retainer || null;
+        return retainer !== null && retainer !== void 0 ? 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 === null || retainer === void 0 ? void 0 : 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 === null || retainer === void 0 ? void 0 : 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 && retainer !== void 0 ? retainer : null;
     }
     visitForOfStatement(node) {
         const collection = this.visit(node.collection);
@@ -1513,27 +1603,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 === null || retainer === void 0 ? void 0 : retainer.push(ret);
         }
-        return retainer || null;
+        this.popScope();
+        return retainer !== null && retainer !== void 0 ? 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) => {
@@ -1582,12 +1678,12 @@ class MEvento extends NodeVisitor {
     clone() {
         var ret = new MEvento();
         ret._functionsRegistry = Object.assign({}, this._functionsRegistry);
-        ret._memory = Object.assign({}, this._memory);
+        ret.rootScope.memory = Object.assign({}, 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;
@@ -1614,16 +1710,21 @@ class MEventoAsync extends MEvento {
         return __awaiter(this, void 0, void 0, function* () {
             const list = node.body;
             let last;
+            this.pushScope("Block");
             for (const n of list) {
                 last = yield this.visit(n);
+                if (last instanceof LoopControl) {
+                    break;
+                }
             }
+            this.popScope();
             return last;
         });
     }
     visitIdentifierAST(node) {
         return __awaiter(this, void 0, void 0, function* () {
             const id = node.value;
-            return this._memory[id];
+            return this.resolve(id);
         });
     }
     visitLiteralAST(node) {
@@ -1645,7 +1746,7 @@ class MEventoAsync extends MEvento {
             }
             else if (id instanceof IdentifierAST) {
                 value = yield this.visit(init);
-                this._memory[id.value] = value;
+                this.changeVariable(id.value, value);
             }
             return value;
         });
@@ -1743,6 +1844,9 @@ class MEventoAsync extends MEvento {
             const arg = node.argument;
             const op = node.operation;
             const argValue = yield 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`);
             }
@@ -1826,11 +1930,14 @@ class MEventoAsync extends MEvento {
         return __awaiter(this, void 0, void 0, function* () {
             this.log(`WhileLoopStatement ${node.test} ${node.body}`);
             const retainer = node.retain ? [] : undefined;
-            while (_boolValue(this.visit(node.test))) {
+            while (_boolValue(yield this.visit(node.test))) {
                 const ret = yield this.visit(node.body);
                 if (ret instanceof BreakBranch) {
                     break;
                 }
+                if (ret instanceof ContinueBranch) {
+                    continue;
+                }
                 retainer === null || retainer === void 0 ? void 0 : retainer.push(ret);
             }
             return retainer;
@@ -1842,53 +1949,68 @@ 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 = yield this.visit(node.init.init);
+            this.changeVariable(loopIdentifier.value, initialValue);
             retainer === null || retainer === void 0 ? void 0 : retainer.push(initialValue);
-            const test = () => {
-                const ret = this.visit(node.test);
+            const test = () => __awaiter(this, void 0, void 0, function* () {
+                const ret = yield 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 = () => __awaiter(this, void 0, void 0, function* () {
+                const updateValue = yield 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 (yield test()) {
                 const ret = yield this.visit(node.body);
                 if (ret instanceof BreakBranch) {
                     break;
                 }
+                if (ret instanceof ContinueBranch) {
+                    yield update();
+                    continue;
+                }
                 retainer === null || retainer === void 0 ? void 0 : 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);
-                }
+                yield update();
             }
-            return retainer;
+            this.popScope();
+            return retainer !== null && retainer !== void 0 ? retainer : null;
         });
     }
     visitForOfStatement(node) {
         return __awaiter(this, void 0, void 0, function* () {
-            const collection = this.visit(node.collection);
+            const collection = yield 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 = yield this.visit(node.body);
                 if (ret instanceof BreakBranch) {
                     break;
                 }
+                if (ret instanceof ContinueBranch) {
+                    continue;
+                }
                 retainer === null || retainer === void 0 ? void 0 : retainer.push(ret);
             }
+            this.popScope();
             return retainer;
         });
     }
@@ -1924,7 +2046,7 @@ class MEventoAsync extends MEvento {
     clone() {
         var ret = new MEventoAsync();
         ret._functionsRegistry = Object.assign({}, this._functionsRegistry);
-        ret._memory = Object.assign({}, this._memory);
+        ret.rootScope.memory = Object.assign({}, this.rootScope.memory);
         return ret;
     }
 }
@@ -1937,5 +2059,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