mevento 1.9.6 → 1.9.8

package/fesm2020/mevento.mjs

@@ -1,6 +1,6 @@
 function error(token, expected) {
     const text = `Invalid token ${token.type}[${token.value}] at ${token.line}, ${token.col} ${expected ? `: expecting ${expected} token` : ''}\n`;
-    throw (text);
+    throw Error(text);
 }
 function isNum(value) {
     return typeof value === 'number';
@@ -12,10 +12,10 @@ function isString(value) {
     return typeof value === 'string';
 }
 function _boolValue(test) {
-    return test !== null &&
-        ((isNum(test) && test !== 0) ||
-            (isString(test) && test.length > 0) ||
-            (isBoolean(test) && test));
+    return (test === null ||
+        (isNum(test) && test === 0) ||
+        (isString(test) && test.length === 0) ||
+        (isBoolean(test) && !test)) ? false : true;
 }
 ;
 function hashCode(str) {
@@ -78,6 +78,8 @@ TokenType.in = 40;
 TokenType.TILL = 41;
 TokenType.BREAK = 42;
 TokenType.CONTINUE = 43;
+TokenType.nullity = 44;
+TokenType.RETURN = 45;
 class Token {
     constructor(type, value, line = 1, col = 1) {
         this.type = type;
@@ -117,6 +119,8 @@ Chars.less = "<".charCodeAt(0);
 Chars.and = "&".charCodeAt(0);
 Chars.pipe = "|".charCodeAt(0);
 Chars.colon = ":".charCodeAt(0);
+Chars.questionMark = "?".charCodeAt(0);
+Chars.shebang = "#".charCodeAt(0);
 class LexerDictionary {
     constructor(lang, keywords) {
         this.keywords = {};
@@ -175,10 +179,10 @@ class Lexer {
         this._col++;
     }
     _pick() {
-        if (this._position >= this._source.length) {
+        if (this._position + 1 >= this._source.length) {
             return -1;
         }
-        return this._source[this._position].charCodeAt(0);
+        return this._source[this._position + 1].charCodeAt(0);
     }
     _isId(code) {
         if (code < 48) {
@@ -340,6 +344,22 @@ class Lexer {
         }
         return new Token(TokenType.stringConst, ret, lastL, lastC);
     }
+    _skipLineComment() {
+        while (!this._isLineEnd(this._currentChar) === true) {
+            this._advance();
+        }
+    }
+    _skipComment() {
+        while (this._currentChar !== -1) {
+            if (this._currentChar === Chars.star && this._pick() === Chars.shebang) {
+                // end of block comment
+                this._advance();
+                this._advance();
+                break;
+            }
+            this._advance();
+        }
+    }
     // f=SUBMIT_FORM(xxx);
     // r = CALL_API(API_ID, f);
     // DISPLAY("MSG #r")
@@ -358,6 +378,18 @@ class Lexer {
                 this._skipWhiteSpace();
                 continue;
             }
+            if (this._currentChar == Chars.shebang) {
+                this._advance();
+                if (this._currentChar === Chars.star) {
+                    // mutli block comment
+                    this._advance();
+                    this._skipComment();
+                }
+                else {
+                    this._skipLineComment();
+                }
+                continue;
+            }
             if (this._isDigit(this._currentChar)) {
                 return this._number();
             }
@@ -462,6 +494,11 @@ class Lexer {
                 this._advance();
                 return new Token(TokenType.or, '||', lastL, lastC);
             }
+            if (this._currentChar === Chars.questionMark && this._pick() === Chars.questionMark) {
+                this._advance();
+                this._advance();
+                return new Token(TokenType.nullity, '??', lastL, lastC);
+            }
             if (this._currentChar === Chars.quote || this._currentChar === Chars.squote) {
                 const startChar = this._currentChar;
                 this._advance();
@@ -489,6 +526,7 @@ Lexer._defaultLanguage = new LexerDictionary("en", {
     "in": "in",
     "break": "break",
     "continue": "continue",
+    "return": "return",
 });
 Lexer.languages = [
     Lexer._defaultLanguage,
@@ -507,6 +545,7 @@ Lexer.languages = [
         "dans": "in",
         "couper": "break",
         "continuer": "continue",
+        "returner": "return",
     }),
     new LexerDictionary("bm", {
         "nii": "if",
@@ -523,6 +562,7 @@ Lexer.languages = [
         "kono": "in",
         "tike": "break",
         "ipan": "continue",
+        "segin": "return",
     }),
 ];
 Lexer.RESERVED = {
@@ -540,6 +580,7 @@ Lexer.RESERVED = {
     "in": Token.from(TokenType.in, "in"),
     "break": Token.from(TokenType.BREAK, "break"),
     "continue": Token.from(TokenType.CONTINUE, "continue"),
+    "return": Token.from(TokenType.RETURN, "return"),
 };
 /**
  * Parser
@@ -746,6 +787,12 @@ class BreakAST extends AST {
         super(line, col);
     }
 }
+class ReturnAST extends AST {
+    constructor(value, line, col) {
+        super(line, col);
+        this.value = value;
+    }
+}
 class ContinueAST extends AST {
     constructor(line, col) {
         super(line, col);
@@ -785,6 +832,14 @@ class Parser {
         this._eat(TokenType.id);
         return node;
     }
+    _return() {
+        const token = this.currentToken;
+        let value = undefined;
+        if (!this._expect(TokenType.eol) && !this._expect(TokenType.semi)) {
+            value = this._expression();
+        }
+        return new ReturnAST(value, token?.line, token?.col);
+    }
     _factor() {
         const token = this.currentToken;
         switch (token.type) {
@@ -829,7 +884,7 @@ class Parser {
     _expression() {
         let node = this._term();
         node = this._tryBinaryExpression(0, node);
-        while ([TokenType.and, TokenType.or].includes(this.currentToken.type)) {
+        while ([TokenType.and, TokenType.or, TokenType.nullity].includes(this.currentToken.type)) {
             const token = this.currentToken;
             this._eat(token.type);
             node = new LogicalExpressionAST(node, token, this._expression());
@@ -884,6 +939,7 @@ class Parser {
         if (this.currentToken?.type != TokenType.rbrace) {
             this._eatEOL();
             properties.push(this._property());
+            this._eatEOL();
         }
         while (this.currentToken?.type === TokenType.comma) {
             this._eat(TokenType.comma);
@@ -945,6 +1001,7 @@ class Parser {
         this._eatEOL();
         // if (expect(Lexer.TokenType.RPAREN)) return emptyList()
         let expr = this._expression();
+        this._eatEOL();
         const result = [expr];
         while (this.currentToken?.type === TokenType.comma) {
             this._eat(TokenType.comma);
@@ -954,6 +1011,7 @@ class Parser {
             }
             expr = this._expression();
             result.push(expr);
+            this._eatEOL();
         }
         return result;
     }
@@ -1141,6 +1199,9 @@ class Parser {
             case TokenType.CONTINUE:
                 this._eat(TokenType.CONTINUE);
                 return new ContinueAST(this.currentToken?.line, this.currentToken?.col);
+            case TokenType.RETURN:
+                this._eat(TokenType.RETURN);
+                return this._return();
             case TokenType.semi:
                 this._eatSemi();
                 return this._statement();
@@ -1215,6 +1276,12 @@ class BreakBranch extends LoopControl {
 }
 class ContinueBranch extends LoopControl {
 }
+class ReturnBranch {
+    constructor(value) {
+        this.value = value;
+    }
+}
+;
 // AST Wallker
 class ANodeVisitor {
     constructor() {
@@ -1248,6 +1315,7 @@ class NodeVisitor extends ANodeVisitor {
         this.registerVisitor(ForOfStatement, this.visitForOfStatement);
         this.registerVisitor(BreakAST, this.visitBreakAST);
         this.registerVisitor(ContinueAST, this.visitContinueAST);
+        this.registerVisitor(ReturnAST, this.visitReturnAST);
     }
     visit(node) {
         try {
@@ -1332,6 +1400,9 @@ class MEvento extends NodeVisitor {
         let last;
         for (const n of list) {
             last = this.visit(n);
+            if (last instanceof ReturnBranch) {
+                return last.value;
+            }
         }
         return last;
     }
@@ -1344,6 +1415,9 @@ class MEvento extends NodeVisitor {
             if (last instanceof LoopControl) {
                 break;
             }
+            if (last instanceof ReturnBranch) {
+                break;
+            }
         }
         this.popScope();
         return last;
@@ -1487,6 +1561,12 @@ class MEvento extends NodeVisitor {
     visitLogicalExpressionAST(node) {
         const leftNode = node.left;
         let test = this.visit(leftNode);
+        if (node.operator.type === TokenType.nullity) {
+            if (test != null) {
+                return test;
+            }
+            return this.visit(node.right);
+        }
         const testBoolValue = _boolValue(test);
         if (node.operator.type === TokenType.and) {
             if (!testBoolValue) {
@@ -1496,12 +1576,11 @@ class MEvento extends NodeVisitor {
         }
         if (node.operator.type === TokenType.or) {
             if (testBoolValue) {
-                return test;
+                return true;
             }
-            test = this.visit(node.right);
-            return test;
+            return _boolValue(this.visit(node.right));
         }
-        return false;
+        return null;
     }
     visitIndexAccessorAST(node) {
         const ownerNode = node.owner;
@@ -1551,6 +1630,10 @@ class MEvento extends NodeVisitor {
             if (ret instanceof ContinueBranch) {
                 continue;
             }
+            if (ret instanceof ReturnBranch) {
+                this.popScope();
+                return ret;
+            }
             retainer?.push(ret);
         }
         return retainer ?? null;
@@ -1594,6 +1677,10 @@ class MEvento extends NodeVisitor {
                 update();
                 continue;
             }
+            if (ret instanceof ReturnBranch) {
+                this.popScope();
+                return ret;
+            }
             retainer?.push(ret);
             // update
             update();
@@ -1617,6 +1704,10 @@ class MEvento extends NodeVisitor {
             if (ret instanceof ContinueBranch) {
                 continue;
             }
+            if (ret instanceof ReturnBranch) {
+                this.popScope();
+                return ret;
+            }
             retainer?.push(ret);
         }
         this.popScope();
@@ -1625,6 +1716,9 @@ class MEvento extends NodeVisitor {
     visitContinueAST(node) {
         return new ContinueBranch();
     }
+    visitReturnAST(node) {
+        return new ReturnBranch(node.value != null ? this.visit(node.value) : null);
+    }
     _declareForIdentifier(node, value) {
         if (node instanceof TupleExpression) {
             if (!Array.isArray(value)) {
@@ -1711,6 +1805,9 @@ class MEventoAsync extends MEvento {
         let last;
         for (const n of list) {
             last = await this.visit(n);
+            if (last instanceof ReturnBranch) {
+                return last.value;
+            }
         }
         return last;
     }
@@ -1723,6 +1820,9 @@ class MEventoAsync extends MEvento {
             if (last instanceof LoopControl) {
                 break;
             }
+            if (last instanceof ReturnBranch) {
+                break;
+            }
         }
         this.popScope();
         return last;
@@ -1866,6 +1966,12 @@ class MEventoAsync extends MEvento {
     async visitLogicalExpressionAST(node) {
         const leftNode = node.left;
         let test = await this.visit(leftNode);
+        if (node.operator.type === TokenType.nullity) {
+            if (test != null) {
+                return test;
+            }
+            return await this.visit(node.right);
+        }
         const testBoolValue = _boolValue(test);
         if (node.operator.type === TokenType.and) {
             if (!testBoolValue) {
@@ -1875,10 +1981,9 @@ class MEventoAsync extends MEvento {
         }
         if (node.operator.type === TokenType.or) {
             if (testBoolValue) {
-                return test;
+                return true;
             }
-            test = await this.visit(node.right);
-            return test;
+            return _boolValue(await this.visit(node.right));
         }
         return false;
     }
@@ -1927,6 +2032,10 @@ class MEventoAsync extends MEvento {
             if (ret instanceof ContinueBranch) {
                 continue;
             }
+            if (ret instanceof ReturnBranch) {
+                this.popScope();
+                return ret;
+            }
             retainer?.push(ret);
         }
         return retainer;
@@ -1970,6 +2079,10 @@ class MEventoAsync extends MEvento {
                 await update();
                 continue;
             }
+            if (ret instanceof ReturnBranch) {
+                this.popScope();
+                return ret;
+            }
             retainer?.push(ret);
             // update
             await update();
@@ -1993,11 +2106,18 @@ class MEventoAsync extends MEvento {
             if (ret instanceof ContinueBranch) {
                 continue;
             }
+            if (ret instanceof ReturnBranch) {
+                this.popScope();
+                return ret;
+            }
             retainer?.push(ret);
         }
         this.popScope();
         return retainer;
     }
+    async visitReturnAST(node) {
+        return new ReturnBranch(node.value != null ? await this.visit(node.value) : null);
+    }
     async resolveArgumentsAsync(args) {
         return await Promise.all(args.map(async (it) => {
             return await this.visit(it);
@@ -2037,5 +2157,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, MEventScope, 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, ReturnAST, ReturnBranch, RootAST, Token, TokenType, TupleExpression, UnaryExpressionAST, WhileLoopStatement };
 //# sourceMappingURL=mevento.mjs.map