greybel-interpreter 2.6.0 → 2.6.2

package/dist/context.d.ts

@@ -67,12 +67,14 @@ export interface ContextOptions {
     cps?: CPS;
     processState?: ProcessState;
     environmentVariables?: Map<string, string>;
+    ignoreOuter?: boolean;
 }
 export interface ContextForkOptions {
     type: ContextType;
     state: ContextState;
     target?: string;
     injected?: boolean;
+    ignoreOuter?: boolean;
 }
 export declare class OperationContext {
     target: string;
@@ -112,6 +114,7 @@ export declare class OperationContext {
     lookupApi(): OperationContext;
     lookupGlobals(): OperationContext;
     lookupLocals(): OperationContext;
+    lookupOuter(): OperationContext;
     extend(map: ObjectValue): OperationContext;
     set(path: Path<CustomValue> | CustomValue, value: CustomValue): void;
     get(path: Path<CustomValue> | CustomValue): CustomValue;

package/dist/context.js

@@ -149,7 +149,7 @@ class FunctionState {
 exports.FunctionState = FunctionState;
 class OperationContext {
     constructor(options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         this.target = (_a = options.target) !== null && _a !== void 0 ? _a : 'unknown';
         this.stackTrace = (_b = options.stackTrace) !== null && _b !== void 0 ? _b : [];
         this.previous = (_c = options.previous) !== null && _c !== void 0 ? _c : null;
@@ -168,7 +168,7 @@ class OperationContext {
         this.api = this.lookupApi();
         this.globals = this.lookupGlobals();
         this.locals = (_o = this.lookupLocals()) !== null && _o !== void 0 ? _o : this;
-        this.outer = (_q = (_p = this.locals.previous) === null || _p === void 0 ? void 0 : _p.lookupLocals()) !== null && _q !== void 0 ? _q : null;
+        this.outer = options.ignoreOuter ? null : this.lookupOuter();
     }
     isIgnoredInDebugging(op) {
         return op instanceof operation_1.OperationBlock || op instanceof noop_1.Noop;
@@ -272,6 +272,10 @@ class OperationContext {
     lookupLocals() {
         return this.lookupType(OperationContext.lookupLocalsType);
     }
+    lookupOuter() {
+        var _a, _b;
+        return (_b = (_a = this.locals.previous) === null || _a === void 0 ? void 0 : _a.lookupLocals()) !== null && _b !== void 0 ? _b : null;
+    }
     extend(map) {
         var _a;
         if (this.state === ContextState.Temporary) {
@@ -316,6 +320,7 @@ class OperationContext {
             previous: this,
             type: options.type,
             state: options.state,
+            ignoreOuter: options.ignoreOuter,
             isProtected: false,
             injected: this.injected,
             debugger: this.debugger,

package/dist/operations/assign-self.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssignSelf = void 0;
 const default_1 = require("../types/default");
+const function_1 = require("./function");
 const operation_1 = require("./operation");
 class AssignSelf extends operation_1.Operation {
     constructor(item, target) {
@@ -25,7 +26,13 @@ class AssignSelf extends operation_1.Operation {
     }
     handle(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const rightValue = yield this.right.handle(ctx);
+            let rightValue;
+            if (this.right instanceof function_1.FunctionOperation) {
+                rightValue = yield this.right.handle(ctx, true);
+            }
+            else {
+                rightValue = yield this.right.handle(ctx);
+            }
             ctx.functionState.context = rightValue;
             return default_1.DefaultType.Void;
         });

package/dist/operations/assign.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Assign = void 0;
 const default_1 = require("../types/default");
 const create_resolve_1 = require("../utils/create-resolve");
+const function_1 = require("./function");
 const operation_1 = require("./operation");
 const resolve_1 = require("./resolve");
 class Assign extends operation_1.Operation {
@@ -33,10 +34,16 @@ class Assign extends operation_1.Operation {
             if (ctx.isExit()) {
                 return default_1.DefaultType.Void;
             }
-            const rightValue = yield this.right.handle(ctx);
             if (resolveResult.path.count() === 0) {
                 throw new Error('Resolve path cannot be empty.');
             }
+            let rightValue;
+            if (this.right instanceof function_1.FunctionOperation) {
+                rightValue = yield this.right.handle(ctx, true);
+            }
+            else {
+                rightValue = yield this.right.handle(ctx);
+            }
             if (!(resolveResult.handle instanceof resolve_1.ResolveNil)) {
                 const resultValueCtx = resolveResult.handle;
                 resultValueCtx.set(resolveResult.path, rightValue);

package/dist/operations/for.js

@@ -17,6 +17,7 @@ const string_1 = require("../types/string");
 const set_immediate_1 = require("../utils/set-immediate");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
+const FOR_BATCH_SIZE = 30;
 class For extends operation_1.OperationBlock {
     constructor(item, target) {
         super(null, target);
@@ -49,32 +50,41 @@ class For extends operation_1.OperationBlock {
                 const idxIdentifier = new string_1.CustomString(`__${identifier}_idx`);
                 const varIdentifier = new string_1.CustomString(identifier);
                 let iteratorResult = iterator.next();
-                const iteration = () => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        if (iteratorResult.done) {
-                            resolve(default_1.DefaultType.Void);
-                            return;
-                        }
-                        const current = iteratorResult.value;
-                        loopState.isContinue = false;
-                        forCtx.set(idxIdentifier, new number_1.CustomNumber(iterator.index - 1));
-                        forCtx.set(varIdentifier, current);
-                        yield this.block.handle(forCtx);
-                        if (loopState.isBreak ||
-                            forCtx.functionState.isReturn ||
-                            ctx.isExit()) {
-                            resolve(default_1.DefaultType.Void);
-                            return;
-                        }
-                        const idxValue = forCtx.get(idxIdentifier).toNumber();
-                        iterator.index += idxValue - (iterator.index - 1);
-                        iteratorResult = iterator.next();
-                        (0, set_immediate_1.setImmediate)(iteration);
+                const next = () => __awaiter(this, void 0, void 0, function* () {
+                    if (iteratorResult.done) {
+                        return false;
                     }
-                    catch (err) {
-                        reject(err);
+                    const current = iteratorResult.value;
+                    loopState.isContinue = false;
+                    forCtx.set(idxIdentifier, new number_1.CustomNumber(iterator.index - 1));
+                    forCtx.set(varIdentifier, current);
+                    yield this.block.handle(forCtx);
+                    if (loopState.isBreak ||
+                        forCtx.functionState.isReturn ||
+                        ctx.isExit()) {
+                        return false;
                     }
+                    const idxValue = forCtx.get(idxIdentifier).toNumber();
+                    iterator.index += idxValue - (iterator.index - 1);
+                    iteratorResult = iterator.next();
+                    return true;
                 });
+                const iteration = function () {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            for (let index = 0; index < FOR_BATCH_SIZE; index++) {
+                                if (!(yield next())) {
+                                    resolve(default_1.DefaultType.Void);
+                                    return;
+                                }
+                            }
+                            (0, set_immediate_1.setImmediate)(iteration);
+                        }
+                        catch (err) {
+                            reject(err);
+                        }
+                    });
+                };
                 iteration();
             });
         });

package/dist/operations/function.d.ts

@@ -15,5 +15,5 @@ export declare class FunctionOperation extends Operation {
     args: FunctionOperationArgument[];
     constructor(item: ASTFunctionStatement, target?: string);
     build(visit: CPSVisit): Promise<Operation>;
-    handle(ctx: OperationContext): Promise<CustomValue>;
+    handle(ctx: OperationContext, assignOuter?: boolean): Promise<CustomValue>;
 }

package/dist/operations/function.js

@@ -54,7 +54,7 @@ class FunctionOperation extends operation_1.Operation {
             return this;
         });
     }
-    handle(ctx) {
+    handle(ctx, assignOuter = false) {
         const func = new function_1.CustomFunction(ctx, 'anonymous', (fnCtx, self, args, next) => __awaiter(this, void 0, void 0, function* () {
             const functionState = new context_1.FunctionState();
             functionState.context = self;
@@ -73,7 +73,7 @@ class FunctionOperation extends operation_1.Operation {
             fnCtx.functionState = functionState;
             yield this.block.handle(fnCtx);
             return functionState.value;
-        }));
+        }), assignOuter);
         for (const item of this.args) {
             func.addArgument(item.name, item.op);
         }

package/dist/operations/while.js

@@ -15,6 +15,7 @@ const default_1 = require("../types/default");
 const set_immediate_1 = require("../utils/set-immediate");
 const block_1 = require("./block");
 const operation_1 = require("./operation");
+const WHILE_BATCH_SIZE = 30;
 class While extends operation_1.OperationBlock {
     constructor(item, target) {
         super(null, target);
@@ -37,27 +38,38 @@ class While extends operation_1.OperationBlock {
             const loopState = new context_1.LoopState();
             whileCtx.loopState = loopState;
             return new Promise((resolve, reject) => {
-                const iteration = () => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const conditionResult = yield whileCtx.step(this.condition);
-                        if (!conditionResult.toTruthy()) {
-                            resolve(default_1.DefaultType.Void);
-                            return;
-                        }
-                        loopState.isContinue = false;
-                        yield this.block.handle(whileCtx);
-                        if (loopState.isBreak ||
-                            whileCtx.functionState.isReturn ||
-                            ctx.isExit()) {
-                            resolve(default_1.DefaultType.Void);
-                            return;
-                        }
-                        (0, set_immediate_1.setImmediate)(iteration);
+                const next = () => __awaiter(this, void 0, void 0, function* () {
+                    const conditionResult = yield whileCtx.step(this.condition);
+                    if (!conditionResult.toTruthy()) {
+                        resolve(default_1.DefaultType.Void);
+                        return false;
                     }
-                    catch (err) {
-                        reject(err);
+                    loopState.isContinue = false;
+                    yield this.block.handle(whileCtx);
+                    if (loopState.isBreak ||
+                        whileCtx.functionState.isReturn ||
+                        ctx.isExit()) {
+                        resolve(default_1.DefaultType.Void);
+                        return false;
                     }
+                    return true;
                 });
+                const iteration = function () {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            for (let index = 0; index < WHILE_BATCH_SIZE; index++) {
+                                if (!(yield next())) {
+                                    resolve(default_1.DefaultType.Void);
+                                    return;
+                                }
+                            }
+                            (0, set_immediate_1.setImmediate)(iteration);
+                        }
+                        catch (err) {
+                            reject(err);
+                        }
+                    });
+                };
                 iteration();
             });
         });

package/dist/types/function.d.ts

@@ -21,10 +21,11 @@ export declare class CustomFunction extends CustomValue {
     readonly name: string;
     readonly value: Callback;
     readonly argumentDefs: Array<Argument>;
+    readonly assignOuter: boolean;
     static createExternalAnonymous(callback: Callback): CustomFunction;
     static createExternal(name: string, callback: Callback): CustomFunction;
     static createExternalWithSelf(name: string, callback: Callback): CustomFunction;
-    constructor(scope: OperationContext, name: string, callback: Callback);
+    constructor(scope: OperationContext, name: string, callback: Callback, assignOuter?: boolean);
     addArgument(name: string, defaultValue?: Operation | CustomValue): CustomFunction;
     fork(): CustomValue;
     getCustomType(): string;

package/dist/types/function.js

@@ -52,12 +52,13 @@ class CustomFunction extends base_1.CustomValue {
     static createExternalWithSelf(name, callback) {
         return new CustomFunction(null, name, callback).addArgument(exports.SELF_NAMESPACE);
     }
-    constructor(scope, name, callback) {
+    constructor(scope, name, callback, assignOuter = false) {
         super();
         this.scope = scope;
         this.name = name;
         this.value = callback;
         this.argumentDefs = [];
+        this.assignOuter = assignOuter;
     }
     addArgument(name, defaultValue = default_1.DefaultType.Void) {
         this.argumentDefs.push(new Argument(name, defaultValue));
@@ -112,7 +113,8 @@ class CustomFunction extends base_1.CustomValue {
             }
             const fnCtx = (_a = this.scope) === null || _a === void 0 ? void 0 : _a.fork({
                 type: context_1.ContextType.Function,
-                state: context_1.ContextState.Default
+                state: context_1.ContextState.Default,
+                ignoreOuter: !this.assignOuter
             });
             const argMap = new Map();
             const hasSelf = !(self instanceof nil_1.CustomNil);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greybel-interpreter",
-    "version": "2.6.0",
+    "version": "2.6.2",
     "description": "Interpreter",
     "main": "dist/index",
     "typings": "dist/index",