mevento 1.0.0 → 1.2.0

package/fesm2020/mevento.mjs

@@ -26,9 +26,7 @@ function hashCode(str) {
         return hash;
     for (i = 0; i < str.length; i++) {
         chr = str.charCodeAt(i);
-        // tslint:disable-next-line:no-bitwise
         hash = ((hash << 5) - hash) + chr;
-        // tslint:disable-next-line:no-bitwise
         hash |= 0; // Convert to 32bit integer
     }
     return hash;
@@ -71,6 +69,14 @@ TokenType.mult = 31;
 TokenType.mod = 32;
 TokenType.invalid = 33;
 TokenType.colon = 34;
+TokenType.WHILE_TILL = 35;
+TokenType.FOR_LOOP = 36;
+TokenType.up = 37;
+TokenType.down = 38;
+TokenType.with = 39;
+TokenType.in = 40;
+TokenType.TILL = 41;
+TokenType.BREAK = 42;
 class Token {
     constructor(type, value, line = 1, col = 1) {
         this.type = type;
@@ -474,15 +480,31 @@ Lexer._defaultLanguage = new LexerDictionary("en", {
     "true": "true",
     "false": "false",
     "null": "null",
+    "while": "while",
+    "for": "for",
+    "with": "with",
+    "up": "up",
+    "down": "down",
+    "till": "till",
+    "in": "in",
+    "break": "break",
 });
 Lexer.languages = [
     Lexer._defaultLanguage,
     new LexerDictionary("fr", {
         "si": "if",
         "sinon": "else",
-        "vrai": "else",
+        "vrai": "true",
         "faux": "false",
         "nul": "null",
+        "tanque": "while",
+        "pour": "for",
+        "avec": "with",
+        "mon": "up",
+        "desc": "down",
+        "jusqua": "till",
+        "dans": "in",
+        "couper": "break",
     }),
     new LexerDictionary("bm", {
         "nii": "if",
@@ -490,6 +512,14 @@ Lexer.languages = [
         "tien": "true",
         "galon": "false",
         "gansan": "null",
+        "foo": "while",
+        "seginka": "for",
+        "niin": "with",
+        "kay": "up",
+        "kaj": "down",
+        "kata": "till",
+        "kono": "in",
+        "tike": "break",
     }),
 ];
 Lexer.RESERVED = {
@@ -498,6 +528,14 @@ Lexer.RESERVED = {
     "true": Token.from(TokenType.TRUE, true),
     "false": Token.from(TokenType.FALSE, false),
     "null": Token.from(TokenType.NULL, null),
+    "for": Token.from(TokenType.FOR_LOOP, "for"),
+    "while": Token.from(TokenType.WHILE_TILL, "while"),
+    "with": Token.from(TokenType.with, "with"),
+    "up": Token.from(TokenType.up, "up"),
+    "down": Token.from(TokenType.down, "down"),
+    "till": Token.from(TokenType.TILL, "till"),
+    "in": Token.from(TokenType.in, "in"),
+    "break": Token.from(TokenType.BREAK, "break"),
 };
 /**
  * Parser
@@ -612,7 +650,7 @@ class IfStatementAST extends AST {
         this.alternate = alternate;
     }
     toString() {
-        return `if ${this.test} ${this.consequent} ${this.alternate !== null ? `else ${this.alternate} ` : ''}`;
+        return `if ${this.test} ${this.consequent} ${this.alternate ? `else ${this.alternate} ` : ''}`;
     }
 }
 class LogicalExpressionAST extends AST {
@@ -663,6 +701,47 @@ class ObjectProperty extends AST {
         this.key = key;
     }
 }
+class WhileLoopStatement extends AST {
+    constructor(test, body, startToken, endToken, retain = false) {
+        super(startToken?.line, startToken?.col);
+        this.retain = false;
+        this.test = test;
+        this.body = body;
+        this.retain = retain;
+    }
+}
+class ForLoopStatement extends AST {
+    constructor(init, test, update, direction, body, startToken, endToken, retain = false) {
+        super(startToken?.line, startToken?.col);
+        this.init = init;
+        this.test = test;
+        this.update = update;
+        this.direction = direction;
+        this.body = body;
+        this.retain = retain;
+    }
+}
+class ForOfStatement extends AST {
+    constructor(identifier, collection, body, startToken, endToken, retain = false) {
+        super(startToken?.line, startToken?.col);
+        this.identifier = identifier;
+        this.collection = collection;
+        this.body = body;
+        this.retain = retain;
+    }
+}
+class TupleExpression extends AST {
+    constructor(first, second) {
+        super(first.line, first.col);
+        this.first = first;
+        this.second = second;
+    }
+}
+class BreakAST extends AST {
+    constructor(line, col) {
+        super(line, col);
+    }
+}
 class Parser {
     constructor(lexer) {
         this.currentToken = lexer.nextToken();
@@ -905,6 +984,8 @@ class Parser {
                 break;
             }
             body.push(this._statement());
+            if (this._expect(TokenType.rbrace))
+                break;
             if (this.currentToken.type !== TokenType.eol &&
                 this.currentToken.type !== TokenType.semi &&
                 this.currentToken.type !== TokenType.eof) {
@@ -916,7 +997,8 @@ class Parser {
             // endBlock
             this._eat(TokenType.rbrace);
         }
-        return new BlockStatementAST(body, this.currentToken);
+        const ret = new BlockStatementAST(body, this.currentToken);
+        return ret;
     }
     _ifStatement() {
         this._eat(TokenType.IF);
@@ -952,8 +1034,94 @@ class Parser {
         }
         return new IfStatementAST(test, consequent, alternate);
     }
+    _whileLoop() {
+        const token = this.currentToken;
+        this._eat(TokenType.WHILE_TILL);
+        const test = this._expression();
+        const body = this.currentToken.type == TokenType.lbrace ? this._blockStatement() : this._expression();
+        return new WhileLoopStatement(test, body, token, this.currentToken);
+    }
+    _forOfIdentifier() {
+        let node;
+        switch (this.currentToken.type) {
+            case TokenType.lparen: {
+                // probable tuple
+                this._eat(TokenType.lparen);
+                const first = this._variable();
+                this._eat(TokenType.comma);
+                const second = this._variable();
+                this._eat(TokenType.rparen);
+                return new TupleExpression(first, second);
+            }
+            // TokenType.LBRACE -> objectPattern()
+            // TokenType.LBRACKET -> arrayPattern()
+            default:
+                return this._variable();
+        }
+    }
+    /**
+     * # ForLoopStatement with step
+     * (seginka|for) a=0 (foo|to) 10 (kay|kaj) niin 2 { # for a = 0; a<10; a+=2
+     *
+     * }
+     * (seginka|for) mali kono a
+     */
+    _forLoop() {
+        const startToken = this.currentToken;
+        this._eat(TokenType.FOR_LOOP);
+        let forOf = [TokenType.lparen].includes(this.currentToken.type);
+        let node;
+        if (forOf) {
+            node = this._forOfIdentifier();
+        }
+        else {
+            const expr = this._expression();
+            if (!(expr instanceof AssignmentExpressionAST)) {
+                forOf = true;
+            }
+            node = expr;
+        }
+        if (!forOf && node instanceof AssignmentExpressionAST) {
+            // normal for
+            this._eat(TokenType.TILL);
+            const test = this._expression();
+            let direction;
+            if (this.currentToken.type === TokenType.up || this.currentToken.type === TokenType.down) {
+                const t = this.currentToken;
+                this._eat(t.type);
+                direction = t;
+            }
+            else {
+                direction = new Token(TokenType.up, "up");
+            }
+            let update;
+            if (this._expect(TokenType.with)) {
+                this._eat(TokenType.with);
+                const expr = this._expression();
+                update = expr;
+            }
+            else {
+                update = new LiteralAST(new Token(TokenType.numberConst, 1, this.currentToken.line, this.currentToken.col), "1");
+            }
+            const body = (this.currentToken.type == TokenType.lbrace) ? this._blockStatement() : this._expression();
+            node = new ForLoopStatement(node, test, update, direction, body, startToken, this.currentToken);
+        }
+        else if (forOf) {
+            this._eat(TokenType.in);
+            const collection = this._expression();
+            const body = (this.currentToken.type == TokenType.lbrace) ? this._blockStatement() : this._expression();
+            node = new ForOfStatement(node, collection, body, startToken, this.currentToken);
+        }
+        else {
+            error(this.currentToken);
+        }
+        return node;
+    }
     _statement() {
         switch (this.currentToken.type) {
+            case TokenType.BREAK:
+                this._eat(TokenType.BREAK);
+                return new BreakAST(this.currentToken?.line, this.currentToken?.col);
             case TokenType.semi:
                 this._eatSemi();
                 return this._statement();
@@ -962,6 +1130,10 @@ class Parser {
                 return this._statement();
             case TokenType.IF:
                 return this._ifStatement();
+            case TokenType.WHILE_TILL:
+                return this._whileLoop();
+            case TokenType.FOR_LOOP:
+                return this._forLoop();
             default:
                 return this._statementExpression();
         }
@@ -969,32 +1141,31 @@ class Parser {
     _expect(type) {
         return this.currentToken?.type === type;
     }
-    _statements() {
-        this._eatEOL();
+    _definition() {
+        this._eatSemiOrEOL();
         if (this._expect(TokenType.eof)) {
             return [];
         }
         const results = [this._statement()];
-        while ((this.currentToken.type === TokenType.eol ||
-            this.currentToken.type === TokenType.semi)) {
+        while (true) {
             this._eatSemiOrEOL();
             if (this.currentToken.type === TokenType.eof) {
                 this._eat(TokenType.eof);
                 break;
             }
             results.push(this._statement());
-            if (this.currentToken.type !== TokenType.eol &&
-                this.currentToken.type !== TokenType.semi &&
-                this.currentToken.type !== TokenType.eof) {
-                error(this.currentToken);
-            }
+            // if (this.currentToken!.type !== TokenType.eol &&
+            //     this.currentToken!.type !== TokenType.semi &&
+            //     this.currentToken!.type !== TokenType.eof) {
+            //     error(this.currentToken!);
+            // }
         }
         return results;
     }
     _root() {
         const source = this.lexer.source;
         const name = "<module>";
-        const list = this._statements();
+        const list = this._definition();
         return new RootAST(list, name, source);
     }
     parse() {
@@ -1014,6 +1185,8 @@ Parser._binopPrecdences = {
     [TokenType.div]: 40,
     [TokenType.mod]: 40,
 };
+class BreakBranch {
+}
 // AST Wallker
 class ANodeVisitor {
     constructor() {
@@ -1035,6 +1208,7 @@ class AsyncNodeVisitor extends ANodeVisitor {
 }
 class NodeVisitor extends ANodeVisitor {
     visit(node) {
+        // console.log('node::', node);
         const methodName = `visit${node.constructor.name}`;
         // const fn = Object.getPrototypeOf(this)[methodName];
         const fn = this._nodesVisitors[methodName];
@@ -1045,6 +1219,7 @@ class MEvento extends NodeVisitor {
     constructor() {
         super();
         this._memory = {};
+        this.debug = false;
         this._functionsRegistry = {};
         this.registerVisitor(RootAST, this.visitRootAST);
         this.registerVisitor(BlockStatementAST, this.visitBlockStatementAST);
@@ -1061,8 +1236,17 @@ class MEvento extends NodeVisitor {
         this.registerVisitor(ObjectProperty, this.visitObjectProperty);
         this.registerVisitor(ObjectExpression, this.visitObjectExpression);
         this.registerVisitor(ArrayExpression, this.visitArrayExpression);
+        this.registerVisitor(WhileLoopStatement, this.visitWhileLoopStatement);
+        this.registerVisitor(ForLoopStatement, this.visitForLoopStatement);
+        this.registerVisitor(ForOfStatement, this.visitForOfStatement);
+        this.registerVisitor(BreakAST, this.visitBreakAST);
         this._functionsRegistry = { ...MEvento._globalFunctionsRegistry };
     }
+    log(message) {
+        if (this.debug) {
+            console.log(message);
+        }
+    }
     visitRootAST(node) {
         const list = node.body;
         let last;
@@ -1219,7 +1403,7 @@ class MEvento extends NodeVisitor {
         if (testBoolValue) {
             return this.visit(node.consequent);
         }
-        if (node.alternate !== null) {
+        if (node.alternate) {
             return this.visit(node.alternate);
         }
         return null;
@@ -1267,6 +1451,85 @@ class MEvento extends NodeVisitor {
         const args = this.resolveArguments(node.elements);
         return args;
     }
+    visitBreakAST(node) {
+        return new BreakBranch();
+    }
+    visitWhileLoopStatement(node) {
+        this.log(`WhileLoopStatement ${node.test} ${node.body}`);
+        const retainer = node.retain ? [] : undefined;
+        while (_boolValue(this.visit(node.test))) {
+            const ret = this.visit(node.body);
+            if (ret instanceof BreakBranch) {
+                break;
+            }
+            retainer?.push(ret);
+        }
+        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");
+        const initialValue = this.visit(node.init.init);
+        this._memory[loopIdentifier.value] = initialValue;
+        retainer?.push(initialValue);
+        const test = () => {
+            const ret = this.visit(node.test);
+            if (isNum(ret)) {
+                const tmp = this._memory[loopIdentifier.value];
+                return node.direction.type === TokenType.up ? ret >= tmp : ret <= tmp;
+            }
+            return _boolValue(ret);
+        };
+        while (test()) {
+            const ret = this.visit(node.body);
+            if (ret instanceof BreakBranch) {
+                break;
+            }
+            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);
+            }
+        }
+        return retainer || null;
+    }
+    visitForOfStatement(node) {
+        const collection = this.visit(node.collection);
+        if (!Array.isArray(collection)) {
+            throw Error("Can iterate non array object");
+        }
+        const retainer = node.retain ? [] : undefined;
+        for (const it of collection) {
+            this._declareForIdentifier(node.identifier, it);
+            const ret = this.visit(node.body);
+            if (ret instanceof BreakBranch) {
+                break;
+            }
+            retainer?.push(ret);
+        }
+        return retainer || null;
+    }
+    _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._memory[node.value] = value;
+        null;
+    }
     resolveArguments(args) {
         return args.map((it) => {
             return this.visit(it);
@@ -1476,7 +1739,7 @@ class MEventoAsync extends MEvento {
         if (testBoolValue) {
             return await this.visit(node.consequent);
         }
-        if (node.alternate !== null) {
+        if (node.alternate) {
             return await this.visit(node.alternate);
         }
         return null;
@@ -1524,6 +1787,70 @@ class MEventoAsync extends MEvento {
         const args = await this.resolveArgumentsAsync(node.elements);
         return args;
     }
+    async visitWhileLoopStatement(node) {
+        this.log(`WhileLoopStatement ${node.test} ${node.body}`);
+        const retainer = node.retain ? [] : undefined;
+        while (_boolValue(this.visit(node.test))) {
+            const ret = await this.visit(node.body);
+            if (ret instanceof BreakBranch) {
+                break;
+            }
+            retainer?.push(ret);
+        }
+        return retainer;
+    }
+    async visitForLoopStatement(node) {
+        const retainer = node.retain ? [] : undefined;
+        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;
+        retainer?.push(initialValue);
+        const test = () => {
+            const ret = this.visit(node.test);
+            if (isNum(ret)) {
+                const tmp = this._memory[loopIdentifier.value];
+                return node.direction.type === TokenType.up ? ret >= tmp : ret <= tmp;
+            }
+            return _boolValue(ret);
+        };
+        while (test()) {
+            const ret = await this.visit(node.body);
+            if (ret instanceof BreakBranch) {
+                break;
+            }
+            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);
+            }
+        }
+        return retainer;
+    }
+    async visitForOfStatement(node) {
+        const collection = this.visit(node.collection);
+        if (!Array.isArray(collection)) {
+            throw Error("Can iterate non array object");
+        }
+        const retainer = node.retain ? [] : undefined;
+        for (const it of collection) {
+            this._declareForIdentifier(node.identifier, it);
+            const ret = await this.visit(node.body);
+            if (ret instanceof BreakBranch) {
+                break;
+            }
+            retainer?.push(ret);
+        }
+        return retainer;
+    }
     async resolveArgumentsAsync(args) {
         return await Promise.all(args.map(async (it) => {
             return await this.visit(it);
@@ -1545,9 +1872,6 @@ class MEventoAsync extends MEvento {
         return await mevento.visit(module);
     }
     static newInstance() {
-        // const lexer = Lexer(source);
-        // const parser = Parser(lexer);
-        // const module = parser.parse();
         return new MEventoAsync();
     }
     clone() {