mevento 2.0.5 → 2.1.0

package/fesm2020/mevento.mjs

@@ -178,6 +178,15 @@ class Lexer {
         this._currentChar = this._source[this._position].charCodeAt(0);
         this._col++;
     }
+    _jump(n) {
+        this._position += n;
+        if (this._position >= this._source.length) {
+            this._currentChar = -1;
+            return;
+        }
+        this._currentChar = this._source[this._position].charCodeAt(0);
+        this._col += n;
+    }
     _pick() {
         if (this._position + 1 >= this._source.length) {
             return -1;
@@ -311,28 +320,62 @@ class Lexer {
         const lastL = this._line;
         while (this._currentChar !== -1) {
             const next = String.fromCharCode(this._pick());
-            if (this._currentChar === Chars.backslash) {
-                // scape char
-                if ([
-                    startChar,
-                    '\\',
-                    '0',
-                    'a',
-                    'b',
-                    'e',
-                    'f',
-                    'n',
-                    'r',
-                    't',
-                    'u',
-                    'U',
-                    'v',
-                    'x'
-                ].includes(next)) {
-                    lastChar = this._currentChar;
-                    this._advance();
-                    continue;
+            if (this._currentChar == Chars.backslash) {
+                switch (next) {
+                    case '\\':
+                        ret += "\\";
+                        break;
+                    case '0':
+                        ret += "\0";
+                        break;
+                    case 'a':
+                        ret += "\a";
+                        break;
+                    case 'b':
+                        ret += "\b";
+                        break;
+                    case 'f':
+                        ret += "\f";
+                        break;
+                    case 'n':
+                        ret += "\n";
+                        break;
+                    case 'r':
+                        ret += "\r";
+                        break;
+                    case 't':
+                        ret += "\t";
+                        break;
+                    case 'u':
+                        ret += String.fromCharCode(Number.parseInt(this._source.substring(this._position + 2, this._position + 6), 16));
+                        this._jump(4);
+                        // consume 4 unicode chars
+                        break;
+                    case 'v':
+                        ret += "\v";
+                        break;
+                    case 'x':
+                        ret += String.fromCharCode(Number.parseInt(this._source.substring(this._position + 2, this._position + 4), 16));
+                        this._jump(2);
+                        break;
+                    default:
+                        {
+                            if (String.fromCharCode(startChar) == next) {
+                                ret += String.fromCharCode(startChar);
+                            }
+                            else {
+                                this._advance();
+                                lastChar = this._currentChar;
+                                ret += String.fromCharCode(this._currentChar);
+                                this._advance();
+                                continue;
+                            }
+                        }
                 }
+                // scape char
+                this._jump(2);
+                lastChar = this._currentChar;
+                continue;
             }
             if (this._currentChar === startChar && lastChar !== Chars.backslash) {
                 // end
@@ -798,8 +841,33 @@ class ContinueAST extends AST {
         super(line, col);
     }
 }
+class ListQueue {
+    constructor(capacity = Infinity) {
+        this.capacity = capacity;
+        this.storage = [];
+    }
+    push(item) {
+        if (this.size() === this.capacity) {
+            throw Error("Stack has reached max capacity, you cannot add more items");
+        }
+        this.storage.push(item);
+    }
+    pop() {
+        return this.storage.pop();
+    }
+    peek() {
+        return this.storage[this.size() - 1];
+    }
+    size() {
+        return this.storage.length;
+    }
+    get isEmpty() {
+        return this.storage.length === 0;
+    }
+}
 class Parser {
     constructor(lexer) {
+        this._loopTrack = new ListQueue();
         this.currentToken = lexer.nextToken();
         this.lexer = lexer;
     }
@@ -873,10 +941,32 @@ class Parser {
                 return this._objectExpression();
             case TokenType.IF:
                 return this._ifStatement();
+            case TokenType.WHILE_TILL:
+                return this._whileLoop(true);
+            case TokenType.FOR_LOOP:
+                return this._forLoop(true);
+            case TokenType.BREAK:
+                return this._breakExpression();
+            case TokenType.CONTINUE:
+                return this._continueExpression();
             default:
                 return this._variable();
         }
     }
+    _breakExpression() {
+        if (this._loopTrack.isEmpty) {
+            error(this.currentToken);
+        }
+        this._eat(TokenType.BREAK);
+        return new BreakAST(this.currentToken?.line, this.currentToken?.col);
+    }
+    _continueExpression() {
+        if (this._loopTrack.isEmpty) {
+            error(this.currentToken);
+        }
+        this._eat(TokenType.CONTINUE);
+        return new ContinueAST(this.currentToken?.line, this.currentToken?.col);
+    }
     _term() {
         let node = this._factor();
         node = this._tryParsingFunctionCall(node);
@@ -1111,12 +1201,20 @@ class Parser {
         }
         return new IfStatementAST(test, consequent, alternate);
     }
-    _whileLoop() {
+    _pushLoop() {
+        this._loopTrack.push(true);
+    }
+    _popLoop() {
+        this._loopTrack.pop();
+    }
+    _whileLoop(retain = false) {
         const token = this.currentToken;
         this._eat(TokenType.WHILE_TILL);
+        this._pushLoop();
         const test = this._expression();
         const body = this.currentToken.type === TokenType.lbrace ? this._blockStatement() : this._expression();
-        return new WhileLoopStatement(test, body, token, this.currentToken);
+        this._popLoop();
+        return new WhileLoopStatement(test, body, token, this.currentToken, retain);
     }
     _forOfIdentifier() {
         switch (this.currentToken.type) {
@@ -1142,9 +1240,10 @@ class Parser {
      * }
      * (seginka|for) mali kono a
      */
-    _forLoop() {
+    _forLoop(retain = false) {
         const startToken = this.currentToken;
         this._eat(TokenType.FOR_LOOP);
+        this._pushLoop();
         let forOf = [TokenType.lparen].includes(this.currentToken.type);
         let node;
         if (forOf) {
@@ -1180,13 +1279,15 @@ class Parser {
                 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);
+            node = new ForLoopStatement(node, test, update, direction, body, startToken, this.currentToken, retain);
+            this._popLoop();
         }
         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);
+            node = new ForOfStatement(node, collection, body, startToken, this.currentToken, retain);
+            this._popLoop();
         }
         else {
             error(this.currentToken);
@@ -1196,11 +1297,9 @@ class Parser {
     _statement() {
         switch (this.currentToken.type) {
             case TokenType.BREAK:
-                this._eat(TokenType.BREAK);
-                return new BreakAST(this.currentToken?.line, this.currentToken?.col);
+                return this._breakExpression();
             case TokenType.CONTINUE:
-                this._eat(TokenType.CONTINUE);
-                return new ContinueAST(this.currentToken?.line, this.currentToken?.col);
+                return this._continueExpression();
             case TokenType.RETURN:
                 this._eat(TokenType.RETURN);
                 return this._return();
@@ -1477,17 +1576,17 @@ class MEvento extends NodeVisitor {
                 if (isNum(lValue) && isNum(rValue)) {
                     return lValue - rValue;
                 }
-                if (isString(lValue) && isNum(rValue)) {
-                    return lValue * rValue;
-                }
-                if (isNum(lValue) && isString(rValue)) {
-                    return rValue * lValue;
-                }
                 throw new Error(`Operation ${op.value} not allowed no num value`);
             case TokenType.mult:
                 if (isNum(lValue) && isNum(rValue)) {
                     return lValue * rValue;
                 }
+                if (isString(lValue) && isNum(rValue)) {
+                    return lValue.repeat(rValue);
+                }
+                if (isNum(lValue) && isString(rValue)) {
+                    return rValue.repeat(lValue);
+                }
                 throw new Error(`Operation ${op.value} not allowed no num value`);
             case TokenType.div:
                 if (isNum(lValue) && isNum(rValue)) {
@@ -1648,7 +1747,7 @@ class MEvento extends NodeVisitor {
         this.pushScope("ForLoopStatement");
         const initialValue = this.visit(node.init.init);
         this.changeVariable(loopIdentifier.value, initialValue);
-        retainer?.push(initialValue);
+        // retainer?.push(initialValue)
         const test = () => {
             const ret = this.visit(node.test);
             if (isNum(ret)) {
@@ -1889,10 +1988,10 @@ class MEventoAsync extends MEvento {
                     return lValue - rValue;
                 }
                 if (isString(lValue) && isNum(rValue)) {
-                    return lValue * rValue;
+                    return lValue.repeat(rValue);
                 }
                 if (isNum(lValue) && isString(rValue)) {
-                    return rValue * lValue;
+                    return rValue.repeat(lValue);
                 }
                 throw new Error(`Operation ${op.value} not allowed no num value`);
             case TokenType.mult:
@@ -2056,7 +2155,7 @@ class MEventoAsync extends MEvento {
         this.pushScope("ForLoopStatement");
         const initialValue = await this.visit(node.init.init);
         this.changeVariable(loopIdentifier.value, initialValue);
-        retainer?.push(initialValue);
+        // retainer?.push(initialValue)
         const test = async () => {
             const ret = await this.visit(node.test);
             if (isNum(ret)) {