added functions defs/calls as well as arrow funcs

Author: ppaska

index.html

@@ -29,8 +29,15 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-x = { obj1: 2 + 4 }
-x
+arr = [1,2,3]
+arr.map(n =>
+  n = n * 2
+  {
+    t1: n * 2,
+    t2: n * 3
+  }
+)
+
     </div>
     <button onclick="tokenize()">Tokenize</button>
     <button onclick="parse()">Parse</button>
@@ -68,11 +75,11 @@ <h4>JSPython development console</h4>
       }
     }
 
-    async function parse() {
+    function parse() {
 
       const scripts = editor.getValue();
       try {
-        const result = await jsPython()
+        const result = jsPython()
           .parse(scripts);
 
         const data = typeof result === 'object' ? JSON.stringify(result, null, '\t') : result;
@@ -83,7 +90,7 @@ <h4>JSPython development console</h4>
       }
     }
 
-    async function runInterpreter() {
+    function runInterpreter() {
 
       const scripts = editor.getValue();
       try {
@@ -99,7 +106,7 @@ <h4>JSPython development console</h4>
             }
           }
         };
-        const result = await jsPython()
+        const result = jsPython()
           .evaluate(scripts, scope);
 
         const data = typeof result === 'object' ? JSON.stringify(result, null, '\t') : String(result);

src/common/ast-types.ts

@@ -7,7 +7,7 @@ export abstract class AstNode {
         public type:
             'assign' | 'binOp' | 'const'
             | 'getSingleVar' | 'setSingleVar' | 'dotObjectAccess' | 'bracketObjectAccess'
-            | 'funcCall' | 'funcDef'
+            | 'funcCall' | 'funcDef' | 'arrowFuncDef'
             | 'createObject' | 'createArray'
             | 'if' | 'while' | 'tryCatch'
     ) { }
@@ -51,6 +51,12 @@ export class FunctionDefNode extends AstNode {
     }
 }
 
+export class ArrowFuncDefNode extends AstNode {
+    constructor(public params: string[], public body: AstNode[]    ) {
+        super('arrowFuncDef');
+    }
+}
+
 export class GetSingleVarNode extends AstNode {
     name: string;
     nullCoelsing: boolean | undefined = undefined;
@@ -105,8 +111,9 @@ export class BinOpNode extends AstNode {
     }
 }
 
-export interface Ast {
+export interface AstBlock {
     name: string;
+    type: 'module' | 'func' | 'if' | 'for' | 'trycatch'
     funcs: FunctionDefNode[];
     body: AstNode[];
 }

src/common/token-types.ts

@@ -101,13 +101,18 @@ export function findTokenValueIndexes(tokens: Token[], predicate: (value: TokenV
     const opIndexes: number[] = [];
 
     for (let i = 0; i < tokens.length; i++) {
-        if (getTokenValue(tokens[i]) === '(') {
+        const tValue = getTokenValue(tokens[i]);
+        const tType = getTokenType(tokens[i]);
+
+        if (tType === TokenTypes.LiteralString) { continue; }
+
+        if (tValue === '(') {
             i = skipInnerBrackets(tokens, i, '(', ')');
-        } else if (getTokenValue(tokens[i]) === '[') {
+        } else if (tValue === '[') {
             i = skipInnerBrackets(tokens, i, '[', ']');
-        } else if (getTokenValue(tokens[i]) === '{') {
+        } else if (tValue === '{') {
             i = skipInnerBrackets(tokens, i, '{', '}');
-        } else if (predicate(getTokenValue(tokens[i]))) {
+        } else if (predicate(tValue)) {
             opIndexes.push(i);
         }
     }

src/evaluator/evaluator.ts

@@ -1,6 +1,7 @@
-import { 
-    AssignNode, Ast, AstNode, BinOpNode, BracketObjectAccessNode, ConstNode, CreateArrayNode, 
-    CreateObjectNode, DotObjectAccessNode, FunctionCallNode, GetSingleVarNode, SetSingleVarNode 
+import {
+    ArrowFuncDefNode,
+    AssignNode, AstBlock, AstNode, BinOpNode, BracketObjectAccessNode, ConstNode, CreateArrayNode,
+    CreateObjectNode, DotObjectAccessNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode, SetSingleVarNode
 } from '../common';
 import { Scope } from './scope';
 
@@ -14,26 +15,44 @@ const OperationFuncs: Record<string, (l: Primitive, r: Primitive) => Primitive>
 
 export class Evaluator {
 
-    registerFunction(funcName: string, fn: () => unknown): Evaluator {
-        throw new Error('Not implemented yet!')
-    }
 
-    registerInstance(instanceName: string, instance: Record<string, unknown>): Evaluator {
-        throw new Error('Not implemented yet!')
-    }
+    evalBlock(ast: AstBlock, scope: Scope): unknown {
+        let lastResult = null;
 
-    assignObject(obj: Record<string, unknown>): Evaluator {
-        throw new Error('Not implemented yet!')
-    }
+        for (let node of ast?.funcs || []) {
+            const funcDef = node as FunctionDefNode;
 
-    eval(ast: Ast, scope: Scope): Promise<unknown> {
-        let lastResult = null;
+            const ast = {
+                name: '',
+                type: 'func',
+                funcs: [],
+                body: funcDef.body
+            } as AstBlock;
+
+            // a child scope needs to be created here
+            const newScope = scope;
+
+            scope.set(funcDef.name, (...args: unknown[]): unknown => {
+
+                // set parameters into new scope, based incomming arguments
+                for (let i = 0; i < args?.length || 0; i++) {
+                    if (i >= funcDef.params.length) {
+                        break;
+                        // throw new Error('Too much parameters provided');
+                    }
+                    newScope.set(funcDef.params[i], args[i]);
+                }
+                return this.evalBlock(ast, newScope);
+            }
+            );
+
+        }
 
         for (const node of ast.body) {
             lastResult = this.evalNode(node, scope);
         }
 
-        return Promise.resolve(lastResult);
+        return lastResult;
     }
 
     private invokeFunction(func: (...args: unknown[]) => unknown, fps: unknown[]): unknown {
@@ -89,6 +108,32 @@ export class Evaluator {
             return OperationFuncs[binOpNode.op](left as Primitive, right as Primitive);
         }
 
+        if(node.type === "arrowFuncDef") {
+            const arrowFuncDef = node as ArrowFuncDefNode;
+
+            const newScope = scope;
+            const ast = {
+                name: '',
+                type: 'func',
+                funcs: [],
+                body: arrowFuncDef.body
+            } as AstBlock;
+
+            const arrowFuncHandler = (...args: unknown[]): unknown => {
+                // set parameters into new scope, based incomming arguments
+                for (let i = 0; i < args?.length || 0; i++) {
+                    if (i >= arrowFuncDef.params.length) {
+                        break;
+                        // throw new Error('Too much parameters provided');
+                    }
+                    newScope.set(arrowFuncDef.params[i], args[i]);
+                }
+                return this.evalBlock(ast, newScope);              
+            }
+
+            return arrowFuncHandler;
+        }
+
         if (node.type === "funcCall") {
             const funcCallNode = node as FunctionCallNode;
             const func = scope.get(funcCallNode.name) as (...args: unknown[]) => unknown;
@@ -148,7 +193,7 @@ export class Evaluator {
                     const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;
                     const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, scope)) || []
 
-                    startObject = this.invokeFunction(func, pms);
+                    startObject = this.invokeFunction(func.bind(startObject), pms);
 
                 } else {
                     throw Error("Can't resolve dotObjectAccess node")