Made execution context cancellable

ppaska · ppaska · commit 8d9839820141 · 2022-06-11T18:52:57.000+01:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.1.7",
+  "version": "2.1.8",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",
diff --git a/src/evaluator/evaluator.ts b/src/evaluator/evaluator.ts
@@ -23,7 +23,13 @@ export class Evaluator {
             );
         }
 
-        for (const node of ast.body) {
+        for(let i = 0; i < ast.body.length; i++) {
+            const node = ast.body[i];
+            if(blockContext.cancel) { 
+                const loc = node.loc || [];
+                return `Cancelled. ${blockContext.moduleName}: ${loc[0]}, ${loc[1]}`; 
+            }
+            
             if (node.type === 'comment') { continue; }
             if (node.type === 'import') {
                 // we can't use it here, because loader has to be promise
diff --git a/src/evaluator/evaluatorAsync.ts b/src/evaluator/evaluatorAsync.ts
@@ -52,7 +52,13 @@ export class EvaluatorAsync {
             newScope.set(funcDef.funcAst.name, invoker);
         }
 
-        for (const node of ast.body) {
+        for(let i = 0; i < ast.body.length; i++) {
+            const node = ast.body[i];
+            if(blockContext.cancel){ 
+                const loc = node.loc || [];
+                return `Cancelled. ${blockContext.moduleName}: ${loc[0]}, ${loc[1]}`; 
+            }
+
             if (node.type === 'comment') { continue; }
             if (node.type === 'import') {
                 const importNode = node as ImportNode;
diff --git a/src/evaluator/scope.ts b/src/evaluator/scope.ts
@@ -6,6 +6,7 @@ export interface BlockContext {
     breakCalled?: boolean;
     continueCalled?: boolean;
     returnObject?: any;
+    cancel?: boolean;
 }
 
 export function cloneContext(context: BlockContext): BlockContext {
diff --git a/src/initialScope.ts b/src/initialScope.ts
@@ -2,7 +2,7 @@ import { parseDatetimeOrNull } from "./common/utils";
 
 export const INITIAL_SCOPE = {
     jsPython(): string {
-        return [`JSPython v2.1.7`, "(c) 2021 FalconSoft Ltd. All rights reserved."].join('\n')
+        return [`JSPython v2.1.8`, "(c) 2022 FalconSoft Ltd. All rights reserved."].join('\n')
     },
     dateTime: (str: number | string | any = null) => parseDatetimeOrNull(str) || new Date(),
     range: range,
diff --git a/src/interpreter.ts b/src/interpreter.ts
@@ -82,14 +82,19 @@ export class Interpreter {
     }
 
     async evalAsync(codeOrAst: string | AstBlock, scope: Record<string, unknown> = {}
-        , entryFunctionName: string = '', moduleName: string = 'main.jspy'): Promise<unknown> {
+        , entryFunctionName: string = '', moduleName: string = 'main.jspy'
+        , ctxInitialized?: (ctx: BlockContext) => void): Promise<unknown> {
         const ast = (typeof codeOrAst === 'string') ? this.parse(codeOrAst as string, moduleName) : codeOrAst as AstBlock;
         const evaluator = new EvaluatorAsync();
         const blockContext = {
             moduleName: moduleName,
             blockScope: new Scope(scope)
         } as BlockContext;
 
+        if(typeof ctxInitialized === 'function') {
+            ctxInitialized(blockContext);
+        }
+
         blockContext.blockScope.set('printExecutionContext', () => console.log(blockContext.blockScope.getScope()));
         blockContext.blockScope.set('getExecutionContext', () => blockContext.blockScope.getScope());
         this._lastExecutionContext = blockContext.blockScope.getScope();
@@ -126,7 +131,7 @@ export class Interpreter {
      * Compatibility method (with v1). !
      */
     async evaluate(script: string, context: object = {}, entryFunctionName: string = ''
-        , moduleName: string = 'main.jspy'): Promise<any> {
+        , moduleName: string = 'main.jspy', ctxInitialized?: (ctx: BlockContext) => void): Promise<any> {
         if (!script || !script.length) { return null; }
         const ast = this.parse(script, moduleName);
 
@@ -138,7 +143,7 @@ export class Interpreter {
             ...context
         } as Record<string, unknown>;
 
-        return await this.evalAsync(ast, globalScope, entryFunctionName, moduleName);
+        return await this.evalAsync(ast, globalScope, entryFunctionName, moduleName, ctxInitialized);
     }
 
     registerPackagesLoader(loader: PackageLoader): Interpreter {

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "jspython-interpreter",`
`3`		`- "version": "2.1.7",`
	`3`	`+ "version": "2.1.8",`
`4`	`4`	`"description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",`
`5`	`5`	`"keywords": [`
`6`	`6`	`"python",`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ export interface BlockContext {`
`6`	`6`	`breakCalled?: boolean;`
`7`	`7`	`continueCalled?: boolean;`
`8`	`8`	`returnObject?: any;`
	`9`	`+ cancel?: boolean;`
`9`	`10`	`}`
`10`	`11`
`11`	`12`	`export function cloneContext(context: BlockContext): BlockContext {`