greybel-interpreter 0.1.5 → 0.1.9

package/dist/context.d.ts

@@ -39,6 +39,9 @@ export declare class Debugger {
     interact(operationContext: OperationContext, item: Operation | Expression): void;
     run(code: string): Promise<void>;
 }
+export interface OperationContextProcessState {
+    exit: boolean;
+}
 export interface OperationContextOptions {
     isProtected?: boolean;
     type?: string;
@@ -46,6 +49,7 @@ export interface OperationContextOptions {
     previous?: OperationContext;
     debugger?: Debugger;
     cps?: CPS;
+    processState?: OperationContextProcessState;
 }
 export declare class OperationContext {
     debugger: Debugger;
@@ -56,6 +60,7 @@ export declare class OperationContext {
     isProtected: boolean;
     memory: Map<string, any>;
     cps: CPS | null;
+    processState: OperationContextProcessState;
     constructor(options: OperationContextOptions);
     valueOf(): Map<string, any>;
     extend(map: Map<string, any>): OperationContext;

package/dist/context.js

@@ -312,6 +312,9 @@ var OperationContext = /** @class */ (function () {
         me.memory = new Map();
         me.debugger = options.debugger || new Debugger();
         me.cps = options.cps;
+        me.processState = options.processState || {
+            exit: false
+        };
     }
     OperationContext.prototype.valueOf = function () {
         return this.scope.valueOf();
@@ -381,7 +384,8 @@ var OperationContext = /** @class */ (function () {
             type: type,
             state: state,
             debugger: me.debugger,
-            cps: me.cps
+            cps: me.cps,
+            processState: me.processState
         });
         if (me.type === ContextType.FUNCTION || me.type === ContextType.GLOBAL) {
             opc.scope.refs.set('locals', opc.scope);

package/dist/custom-types/list.js

@@ -195,7 +195,7 @@ var CustomList = /** @class */ (function (_super) {
                         }
                     }
                     else if (path.length === 1 && CustomList.intrinsics.has(currentValue)) {
-                        return [2 /*return*/, CustomList.intrinsics.get(currentValue)];
+                        return [2 /*return*/, CustomList.intrinsics.get(currentValue).bind(null, me)];
                     }
                     else {
                         throw new Error("Cannot get path ".concat(path.join('.')));
@@ -228,7 +228,7 @@ var CustomList = /** @class */ (function (_super) {
                     }
                     else if (path.length === 1 && CustomList.intrinsics.has(current)) {
                         return [2 /*return*/, {
-                                origin: CustomList.intrinsics.get(current),
+                                origin: CustomList.intrinsics.get(current).bind(null, me),
                                 context: me
                             }];
                     }

package/dist/custom-types/map.js

@@ -180,7 +180,7 @@ var CustomMap = /** @class */ (function (_super) {
                         }
                     }
                     else if (path.length === 1 && CustomMap.intrinsics.has(currentValue)) {
-                        return [2 /*return*/, CustomMap.intrinsics.get(currentValue)];
+                        return [2 /*return*/, CustomMap.intrinsics.get(currentValue).bind(null, me)];
                     }
                     else {
                         throw new Error("Cannot get path ".concat(path.join('.')));
@@ -212,7 +212,7 @@ var CustomMap = /** @class */ (function (_super) {
                     }
                     else if (path.length === 1 && CustomMap.intrinsics.has(current)) {
                         return [2 /*return*/, {
-                                origin: CustomMap.intrinsics.get(current),
+                                origin: CustomMap.intrinsics.get(current).bind(null, me),
                                 context: me
                             }];
                     }

package/dist/custom-types/string.js

@@ -120,7 +120,7 @@ var CustomString = /** @class */ (function (_super) {
         return me.value.length === 0 ? null : me.value;
     };
     CustomString.prototype.toString = function () {
-        return "\"".concat(this.value.toString(), "\"");
+        return this.value;
     };
     CustomString.prototype.fork = function () {
         return new CustomString(this.value);

package/dist/expressions/call.js

@@ -123,48 +123,50 @@ var CallExpression = /** @class */ (function (_super) {
         var opc = operationContext.fork(context_1.ContextType.CALL, context_1.ContextState.TEMPORARY);
         var evaluate = function (node) {
             return __awaiter(this, void 0, void 0, function () {
-                var args, pathExpr, callable_1, callable, _a;
-                var _b, _c, _d;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+                var args, pathExpr, callable_1, _a, callable, _b;
+                var _c, _d, _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
                         case 0:
                             if (node instanceof expression_1.Expression) {
                                 return [2 /*return*/, node.get(opc)];
                             }
                             return [4 /*yield*/, node.resolveArgs(operationContext)];
                         case 1:
-                            args = _e.sent();
+                            args = _f.sent();
                             return [4 /*yield*/, node.path.get(opc, me.expr)];
                         case 2:
-                            pathExpr = _e.sent();
+                            pathExpr = _f.sent();
                             operationContext.debugger.debug('CallExpression', 'pathExpr', pathExpr);
-                            if (!pathExpr.handle) return [3 /*break*/, 5];
-                            if (!(0, typer_1.isCustomMap)(pathExpr.handle)) return [3 /*break*/, 4];
+                            if (!pathExpr.handle) return [3 /*break*/, 8];
+                            if (!(0, typer_1.isCustomMap)(pathExpr.handle)) return [3 /*break*/, 7];
                             return [4 /*yield*/, pathExpr.handle.getCallable(pathExpr.path)];
                         case 3:
-                            callable_1 = _e.sent();
-                            if (callable_1.origin instanceof operation_1.Operation) {
-                                opc.setMemory('args', args);
-                                return [2 /*return*/, callable_1.origin.run(opc)];
-                            }
-                            else if (callable_1.origin instanceof Function) {
-                                return [2 /*return*/, (_b = callable_1.origin).call.apply(_b, __spreadArray([pathExpr.handle], __read(args), false))];
-                            }
-                            operationContext.debugger.raise('Unexpected handle call', me, callable_1);
-                            _e.label = 4;
-                        case 4: return [2 /*return*/, (0, typer_1.cast)((_c = pathExpr.handle).callMethod.apply(_c, __spreadArray([pathExpr.path], __read(args), false)))];
-                        case 5: return [4 /*yield*/, opc.getCallable(pathExpr.path)];
+                            callable_1 = _f.sent();
+                            if (!(callable_1.origin instanceof operation_1.Operation)) return [3 /*break*/, 4];
+                            opc.setMemory('args', args);
+                            return [2 /*return*/, callable_1.origin.run(opc)];
+                        case 4:
+                            if (!(callable_1.origin instanceof Function)) return [3 /*break*/, 6];
+                            _a = typer_1.cast;
+                            return [4 /*yield*/, (_c = callable_1.origin).call.apply(_c, __spreadArray([pathExpr.handle], __read(args), false))];
+                        case 5: return [2 /*return*/, _a.apply(void 0, [_f.sent()])];
                         case 6:
-                            callable = _e.sent();
+                            operationContext.debugger.raise('Unexpected handle call', me, callable_1);
+                            _f.label = 7;
+                        case 7: return [2 /*return*/, (0, typer_1.cast)((_d = pathExpr.handle).callMethod.apply(_d, __spreadArray([pathExpr.path], __read(args), false)))];
+                        case 8: return [4 /*yield*/, opc.getCallable(pathExpr.path)];
+                        case 9:
+                            callable = _f.sent();
                             opc.setMemory('args', args);
-                            if (!(callable.origin instanceof operation_1.Operation)) return [3 /*break*/, 7];
+                            if (!(callable.origin instanceof operation_1.Operation)) return [3 /*break*/, 10];
                             return [2 /*return*/, callable.origin.run(opc)];
-                        case 7:
-                            if (!(callable.origin instanceof Function)) return [3 /*break*/, 9];
-                            _a = typer_1.cast;
-                            return [4 /*yield*/, (_d = callable.origin).call.apply(_d, __spreadArray([callable.context], __read(args), false))];
-                        case 8: return [2 /*return*/, _a.apply(void 0, [_e.sent()])];
-                        case 9: return [2 /*return*/, (0, typer_1.cast)(callable.origin)];
+                        case 10:
+                            if (!(callable.origin instanceof Function)) return [3 /*break*/, 12];
+                            _b = typer_1.cast;
+                            return [4 /*yield*/, (_e = callable.origin).call.apply(_e, __spreadArray([callable.context], __read(args), false))];
+                        case 11: return [2 /*return*/, _b.apply(void 0, [_f.sent()])];
+                        case 12: return [2 /*return*/, (0, typer_1.cast)(callable.origin)];
                     }
                 });
             });

package/dist/expressions/path.js

@@ -134,9 +134,9 @@ var PathExpression = /** @class */ (function (_super) {
     }
     PathExpression.prototype.get = function (operationContext, parentExpr) {
         return __awaiter(this, void 0, void 0, function () {
-            var me, evaluate, resultExpr, context, value_1, value, callable, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var me, evaluate, resultExpr, context, value_1, _a, value, callable, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         me = this;
                         evaluate = function (node) {
@@ -265,7 +265,7 @@ var PathExpression = /** @class */ (function (_super) {
                         operationContext.debugger.debug('PathExpression', 'get', 'expr', me.expr);
                         return [4 /*yield*/, evaluate(me.expr)];
                     case 1:
-                        resultExpr = _b.sent();
+                        resultExpr = _c.sent();
                         if (!!parentExpr) return [3 /*break*/, 14];
                         if (!resultExpr.handle) return [3 /*break*/, 8];
                         if (!(resultExpr.path.length === 0)) return [3 /*break*/, 2];
@@ -275,30 +275,31 @@ var PathExpression = /** @class */ (function (_super) {
                         context = resultExpr.handle;
                         return [4 /*yield*/, context.get(resultExpr.path)];
                     case 3:
-                        value_1 = _b.sent();
+                        value_1 = _c.sent();
                         if (!(value_1 instanceof operation_1.Operation)) return [3 /*break*/, 4];
                         return [2 /*return*/, value_1.run(operationContext)];
                     case 4:
                         if (!(value_1 instanceof Function)) return [3 /*break*/, 6];
+                        _a = typer_1.cast;
                         return [4 /*yield*/, value_1.call(context)];
-                    case 5: return [2 /*return*/, _b.sent()];
+                    case 5: return [2 /*return*/, _a.apply(void 0, [_c.sent()])];
                     case 6: return [2 /*return*/, value_1];
                     case 7: return [2 /*return*/, (0, typer_1.cast)(resultExpr.handle.callMethod(resultExpr.path))];
                     case 8: return [4 /*yield*/, operationContext.get(resultExpr.path)];
                     case 9:
-                        value = _b.sent();
+                        value = _c.sent();
                         if (!(value instanceof Function)) return [3 /*break*/, 12];
                         return [4 /*yield*/, operationContext.getCallable(resultExpr.path)];
                     case 10:
-                        callable = _b.sent();
-                        _a = typer_1.cast;
+                        callable = _c.sent();
+                        _b = typer_1.cast;
                         return [4 /*yield*/, callable.origin.call(callable.context)];
-                    case 11: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+                    case 11: return [2 /*return*/, _b.apply(void 0, [_c.sent()])];
                     case 12:
                         if (value instanceof operation_1.Operation) {
                             return [2 /*return*/, value.run(operationContext)];
                         }
-                        _b.label = 13;
+                        _c.label = 13;
                     case 13: return [2 /*return*/, value];
                     case 14: return [2 /*return*/, resultExpr];
                 }

package/dist/interpreter.d.ts

@@ -1,4 +1,4 @@
-import { Debugger } from './context';
+import { OperationContext, Debugger } from './context';
 import { ResourceHandler } from './resource';
 export interface InterpreterOptions {
     target?: string;
@@ -15,6 +15,8 @@ export default class Interpreter {
     params: any[];
     resourceHandler: ResourceHandler;
     debugger: Debugger;
+    context: OperationContext | null;
     constructor(options: InterpreterOptions);
     digest(): Promise<any>;
+    exit(): void;
 }

package/dist/interpreter.js

@@ -17,6 +17,7 @@ var Interpreter = /** @class */ (function () {
         me.debugger = options.debugger || new context_1.Debugger();
         me.api = options.api || new Map();
         me.params = options.params || [];
+        me.context = null;
         if (options.target) {
             me.target = options.target;
             me.code = me.resourceHandler.get(options.target);
@@ -44,12 +45,20 @@ var Interpreter = /** @class */ (function () {
         });
         mainContext.extend(me.api);
         mainContext.scope.refs.set('params', (0, typer_1.cast)(me.params));
+        me.context = mainContext;
         return topOperation.run(mainContext)
             .catch(function (err) {
             console.error(err);
             throw err;
         });
     };
+    Interpreter.prototype.exit = function () {
+        var me = this;
+        if (me.context == null) {
+            throw new Error('Unexpected exit signal.');
+        }
+        me.context.processState.exit = true;
+    };
     return Interpreter;
 }());
 exports.default = Interpreter;

package/dist/operations/body.js

@@ -117,7 +117,7 @@ var BodyOperation = /** @class */ (function (_super) {
                         _d.sent();
                         _d.label = 8;
                     case 8:
-                        if (isEOL())
+                        if (isEOL() || operationContext.processState.exit)
                             return [3 /*break*/, 10];
                         _d.label = 9;
                     case 9:

package/package.json

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