null coelsing and simple for loop

Author: ppaska

index.html

@@ -29,12 +29,12 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-x = 1
-
-if x == 3:
-  x = 5
-else:
-  x = 10
+      sum = 0
+      
+      for item in [1,2,3]:
+        sum = sum + item
+      
+      sum
 
     </div>
     <button onclick="tokenize()">Tokenize</button>
@@ -94,10 +94,10 @@ <h4>JSPython development console</h4>
       try {
         const scope = {
           Math,
-          print: (p1, p2) => {return p1;},
+          print: (p1, p2) => { return p1; },
           x: 10,
           o: {
-            f1: (x,y) => {return {x, y};},
+            f1: (x, y) => { return { x, y }; },
             v1: 55,
             sub1: {
               subValue: 88

src/common/ast-types.ts

@@ -9,7 +9,8 @@ export abstract class AstNode {
             | 'getSingleVar' | 'setSingleVar' | 'dotObjectAccess' | 'bracketObjectAccess'
             | 'funcCall' | 'funcDef' | 'arrowFuncDef'
             | 'createObject' | 'createArray'
-            | 'if' | 'while' | 'tryCatch'
+            | 'if' | 'for' | 'tryCatch'
+            | 'return' | 'continue' | 'break'
     ) { }
 }
 
@@ -31,6 +32,24 @@ export class ConstNode extends AstNode {
     }
 }
 
+export class ReturnNode extends AstNode {
+    constructor(public returnValue: AstNode) {
+        super('return');
+    }
+}
+
+export class ContinueNode extends AstNode {
+    constructor() {
+        super('continue');
+    }
+}
+
+export class BreakNode extends AstNode {
+    constructor() {
+        super('break');
+    }
+}
+
 export class SetSingleVarNode extends AstNode {
     public name: string;
     constructor(token: Token) {
@@ -63,6 +82,12 @@ export class IfNode extends AstNode {
     }
 }
 
+export class ForNode extends AstNode {
+    constructor(public sourceArray: AstNode, public itemVarName: string, public body: AstNode[]) {
+        super('for');
+    }
+}
+
 export class GetSingleVarNode extends AstNode {
     name: string;
     nullCoelsing: boolean | undefined = undefined;
@@ -98,7 +123,6 @@ export class CreateArrayNode extends AstNode {
     }
 }
 
-
 export class BracketObjectAccessNode extends AstNode {
     constructor(
         public propertyName: string,

src/evaluator/evaluator.ts

@@ -1,7 +1,7 @@
 import {
     ArrowFuncDefNode,
     AssignNode, AstBlock, AstNode, BinOpNode, BracketObjectAccessNode, ConstNode, CreateArrayNode,
-    CreateObjectNode, DotObjectAccessNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode, IfNode, OperationFuncs, Primitive, SetSingleVarNode
+    CreateObjectNode, DotObjectAccessNode, ForNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode, IfNode, OperationFuncs, Primitive, SetSingleVarNode
 } from '../common';
 import { Scope } from './scope';
 
@@ -97,6 +97,20 @@ export class Evaluator {
             return;
         }
 
+        if (node.type === 'for') {
+            const forNode = node as ForNode;
+            const newScope = scope;
+
+            const array = this.evalNode(forNode.sourceArray, newScope) as unknown[] | string;
+
+            for(let item of array){
+                newScope.set(forNode.itemVarName, item);
+                this.evalBlock({ body: forNode.body } as AstBlock, newScope);
+            }
+            return;
+        }
+
+
         if (node.type === "const") {
             return (node as ConstNode).value;
         }
@@ -185,15 +199,20 @@ export class Evaluator {
 
             let startObject = this.evalNode(dotObject.nestedProps[0], scope) as any;
             for (let i = 1; i < dotObject.nestedProps.length; i++) {
+                const nestedProp = dotObject.nestedProps[i];
+
+                if((dotObject.nestedProps[i - 1] as any).nullCoelsing && !startObject) {
+                    startObject = {};
+                }
 
-                if (dotObject.nestedProps[i].type === 'getSingleVar') {
-                    startObject = startObject[(dotObject.nestedProps[i] as SetSingleVarNode).name] as unknown;
-                } else if (dotObject.nestedProps[i].type === 'bracketObjectAccess') {
-                    const node = dotObject.nestedProps[i] as BracketObjectAccessNode;
+                if (nestedProp.type === 'getSingleVar') {
+                    startObject = startObject[(nestedProp as SetSingleVarNode).name] as unknown;
+                } else if (nestedProp.type === 'bracketObjectAccess') {
+                    const node = nestedProp as BracketObjectAccessNode;
                     startObject = startObject[node.propertyName] as unknown;
                     startObject = startObject[this.evalNode(node.bracketBody, scope) as string] as unknown;
-                } else if (dotObject.nestedProps[i].type === 'funcCall') {
-                    const funcCallNode = dotObject.nestedProps[i] as FunctionCallNode;
+                } else if (nestedProp.type === 'funcCall') {
+                    const funcCallNode = nestedProp as FunctionCallNode;
                     const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;
                     const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, scope)) || []
 
@@ -204,7 +223,8 @@ export class Evaluator {
                 }
             }
 
-            return startObject;
+            // no undefined values, make it rather null
+            return (startObject === undefined)? null : startObject;
         }
 
         if (node.type === 'createObject') {

src/interpreter.spec.ts

@@ -209,7 +209,7 @@ describe('Interpreter', () => {
 
 
   it('if condition', () => {
-    const script = (p) => `
+    const script = (p: ) => `
     x = 1
     if x == ${p}:
       x = 5
@@ -221,5 +221,24 @@ describe('Interpreter', () => {
     expect(e.evaluate(script(2))).toBe(10);
   });
 
+  it('if condition', () => {
+    const script = `
+    x = {o1: {ov: 55}}
+    x.o1.ov1?.someProp or 32
+    `; 
+    expect(e.evaluate(script)).toBe(32);
+    expect(e.evaluate("x={}\nx?.p1?.ff")).toBe(null);
+  });
+
+  it('simple for', () => {
+    const script = `
+    sum = 0
+    for item in [1,2,3]:
+      sum = sum + item
+    sum
+      `; 
+    expect(e.evaluate(script)).toBe(6);
+  });
+
 
 });

src/parser/parser.ts

@@ -2,7 +2,7 @@ import {
     BinOpNode, ConstNode, AstBlock, Token, ParserOptions, AstNode, Operators, AssignNode, TokenTypes,
     GetSingleVarNode, FunctionCallNode, getTokenType, getTokenValue, isTokenTypeLiteral, getStartLine,
     getStartColumn, getEndColumn, getEndLine, findOperators, splitTokens, DotObjectAccessNode, BracketObjectAccessNode,
-    findTokenValueIndex, FunctionDefNode, CreateObjectNode, ObjectPropertyInfo, CreateArrayNode, ArrowFuncDefNode, ExpressionOperators, IfNode
+    findTokenValueIndex, FunctionDefNode, CreateObjectNode, ObjectPropertyInfo, CreateArrayNode, ArrowFuncDefNode, ExpressionOperators, IfNode, ForNode
 } from '../common';
 
 export class InstructionLine {
@@ -111,6 +111,20 @@ export class Parser {
 
                 ast.body.push(new IfNode(conditionNode, ifBody, elseBody))
 
+            } else if (getTokenValue(instruction.tokens[0]) === 'for') {
+
+                const endDefOfDef = findTokenValueIndex(instruction.tokens, v => v === ':');
+
+                if (endDefOfDef === -1) {
+                    throw (`Can't find : for if`)
+                }
+
+                const itemVarName = getTokenValue(instruction.tokens[1]) as string;
+                const sourceArray = this.createExpressionNode(instruction.tokens.slice(3, endDefOfDef))
+                const forBody = getBody(instruction.tokens, endDefOfDef + 1);
+
+                ast.body.push(new ForNode(sourceArray, itemVarName, forBody))
+
             } else if (assignTokens.length > 1) {
                 const target = this.createExpressionNode(assignTokens[0]);
                 const source = this.createExpressionNode(assignTokens[1]);