greybel-interpreter 3.5.0 → 4.0.0

package/dist/context.d.ts

@@ -1,109 +1,46 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { ASTBase } from 'miniscript-core';
-import { CPS } from './cps';
-import { HandlerContainer } from './handler-container';
-import { Operation } from './operations/operation';
 import { CustomValue } from './types/base';
 import { CustomMap } from './types/map';
 import { ObjectValue } from './utils/object-value';
-import { Path } from './utils/path';
 import { ContextTypeIntrinsics } from './context/types';
+import { Instruction } from './byte-compiler/instruction';
 export declare enum ContextType {
     Api = 0,
     Global = 1,
     Function = 2,
-    External = 3,
-    Loop = 4,
-    Map = 5,
-    Call = 6
-}
-export declare enum ContextState {
-    Temporary = 0,
-    Default = 1
+    Injected = 3
 }
 export declare class Scope extends CustomMap {
     private readonly context;
     constructor(context: OperationContext);
-    get(path: Path<CustomValue> | CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValue;
-}
-export declare class Debugger {
-    private breakpoint;
-    private nextStep;
-    private lastContext;
-    getLastContext(): OperationContext;
-    debug(...segments: any[]): CustomValue;
-    setBreakpoint(breakpoint: boolean): Debugger;
-    getBreakpoint(_ctx: OperationContext): boolean;
-    next(): Debugger;
-    resume(): Promise<void>;
-    interact(ctx: OperationContext, _ast: ASTBase, _op: Operation): void;
-}
-export interface ExitObserver {
-    occured: () => boolean;
-    close: () => void;
-}
-export declare class ProcessState extends EventEmitter {
-    isPending: boolean;
-    last: OperationContext;
-    private observer;
-    private observerWithExitOccurence;
-    constructor();
-    createExitObserver(): ExitObserver;
-}
-export declare class LoopState {
-    isBreak: boolean;
-    isContinue: boolean;
-}
-export declare class FunctionState {
-    value: CustomValue;
-    isReturn: boolean;
-    context: CustomValue;
-    super: CustomValue;
+    get(current: CustomValue, typeIntrinsics: ContextTypeIntrinsics): CustomValue;
 }
 export interface ContextOptions {
-    target?: string;
-    stackTrace?: Operation[];
+    code: Instruction[];
     previous?: OperationContext;
     type?: ContextType;
-    state?: ContextState;
+    self?: CustomValue;
+    super?: CustomValue;
     isProtected?: boolean;
-    injected?: boolean;
-    debugger?: Debugger;
-    handler?: HandlerContainer;
-    cps?: CPS;
-    processState?: ProcessState;
-    environmentVariables?: Map<string, string>;
-    ignoreOuter?: boolean;
-    contextTypeIntrinsics?: ContextTypeIntrinsics;
-    time?: number;
+    outer?: OperationContext;
 }
 export interface ContextForkOptions {
+    code: Instruction[];
     type: ContextType;
-    state: ContextState;
+    self?: CustomValue;
+    super?: CustomValue;
     target?: string;
-    injected?: boolean;
-    ignoreOuter?: boolean;
-    processState?: ProcessState;
+    outer?: OperationContext;
 }
 export declare class OperationContext {
-    target: string;
-    stackTrace: Operation[];
-    debugger: Debugger;
-    environmentVariables: Map<string, string>;
-    handler: HandlerContainer;
-    contextTypeIntrinsics: ContextTypeIntrinsics;
     previous: OperationContext;
     readonly type: ContextType;
-    readonly state: ContextState;
     readonly scope: Scope;
-    readonly cps: CPS;
-    readonly time: number;
-    readonly processState: ProcessState;
-    loopState: LoopState;
-    functionState: FunctionState;
     isProtected: boolean;
     injected: boolean;
+    ip: number;
+    code: Instruction[];
+    self: CustomValue | null;
+    super: CustomValue | null;
     readonly api: OperationContext;
     readonly locals: OperationContext;
     readonly outer: OperationContext;
@@ -111,15 +48,8 @@ export declare class OperationContext {
     private static readonly lookupApiType;
     private static readonly lookupGlobalsType;
     private static readonly lookupLocalsType;
-    constructor(options?: ContextOptions);
-    isIgnoredInDebugging(op: Operation): boolean;
-    step(op: Operation): Promise<CustomValue>;
-    setLastActive(ctx: OperationContext): OperationContext;
-    getLastActive(): OperationContext;
-    isPending(): boolean;
-    setPending(pending: boolean): OperationContext;
+    constructor(options: ContextOptions);
     lookupAllOfType(validate: (type: ContextType) => boolean): OperationContext[];
-    exit(): Promise<OperationContext>;
     lookupType(allowedTypes: Array<ContextType>): OperationContext;
     lookupAllScopes(): OperationContext[];
     lookupApi(): OperationContext;
@@ -127,7 +57,9 @@ export declare class OperationContext {
     lookupLocals(): OperationContext;
     lookupOuter(): OperationContext;
     extend(map: ObjectValue): OperationContext;
-    set(path: Path<CustomValue> | CustomValue, value: CustomValue): void;
-    get(path: Path<CustomValue> | CustomValue): CustomValue;
+    set(path: CustomValue, value: CustomValue): void;
+    get(path: CustomValue, contextTypeIntrinsics: ContextTypeIntrinsics): CustomValue;
+    injectContext(): void;
+    getCurrentInstruction(): Instruction;
     fork(options: ContextForkOptions): OperationContext;
 }

package/dist/context.js

@@ -1,236 +1,57 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationContext = exports.FunctionState = exports.LoopState = exports.ProcessState = exports.Debugger = exports.Scope = exports.ContextState = exports.ContextType = void 0;
-const events_1 = require("events");
-const handler_container_1 = require("./handler-container");
-const noop_1 = require("./operations/noop");
-const operation_1 = require("./operations/operation");
-const base_1 = require("./types/base");
-const default_1 = require("./types/default");
+exports.OperationContext = exports.Scope = exports.ContextType = void 0;
 const map_1 = require("./types/map");
-const path_1 = require("./utils/path");
-const set_immediate_1 = require("./utils/set-immediate");
-const uuid_1 = require("./utils/uuid");
+const string_1 = require("./types/string");
 var ContextType;
 (function (ContextType) {
     ContextType[ContextType["Api"] = 0] = "Api";
     ContextType[ContextType["Global"] = 1] = "Global";
     ContextType[ContextType["Function"] = 2] = "Function";
-    ContextType[ContextType["External"] = 3] = "External";
-    ContextType[ContextType["Loop"] = 4] = "Loop";
-    ContextType[ContextType["Map"] = 5] = "Map";
-    ContextType[ContextType["Call"] = 6] = "Call";
+    ContextType[ContextType["Injected"] = 3] = "Injected";
 })(ContextType = exports.ContextType || (exports.ContextType = {}));
-var ContextState;
-(function (ContextState) {
-    ContextState[ContextState["Temporary"] = 0] = "Temporary";
-    ContextState[ContextState["Default"] = 1] = "Default";
-})(ContextState = exports.ContextState || (exports.ContextState = {}));
 class Scope extends map_1.CustomMap {
     constructor(context) {
         super();
         this.context = context;
     }
-    get(path, typeIntrinsics) {
+    get(current, typeIntrinsics) {
         var _a, _b, _c, _d;
-        if (path instanceof base_1.CustomValue) {
-            return this.get(new path_1.Path([path]), typeIntrinsics);
+        if (this.has(current)) {
+            return super.get(current, typeIntrinsics);
         }
-        if (path.count() === 0) {
-            return this;
-        }
-        const traversalPath = path.clone();
-        const current = traversalPath.next();
-        if (this.has(path)) {
-            return super.get(path, typeIntrinsics);
+        else if ((_a = this.context.outer) === null || _a === void 0 ? void 0 : _a.scope.has(current)) {
+            return this.context.outer.scope.get(current, typeIntrinsics);
         }
-        else if ((_a = this.context.outer) === null || _a === void 0 ? void 0 : _a.scope.has(path)) {
-            return this.context.outer.scope.get(path, typeIntrinsics);
+        else if ((_b = this.context.globals) === null || _b === void 0 ? void 0 : _b.scope.has(current)) {
+            return this.context.globals.scope.get(current, typeIntrinsics);
         }
-        else if ((_b = this.context.globals) === null || _b === void 0 ? void 0 : _b.scope.has(path)) {
-            return this.context.globals.scope.get(path, typeIntrinsics);
-        }
-        else if ((_c = this.context.api) === null || _c === void 0 ? void 0 : _c.scope.has(path)) {
-            return this.context.api.scope.get(path, typeIntrinsics);
+        else if ((_c = this.context.api) === null || _c === void 0 ? void 0 : _c.scope.has(current)) {
+            return this.context.api.scope.get(current, typeIntrinsics);
         }
         const intrinsics = (_d = typeIntrinsics.map) !== null && _d !== void 0 ? _d : map_1.CustomMap.getIntrinsics();
-        if (traversalPath.count() === 0 && intrinsics.has(current)) {
+        if (intrinsics.has(current)) {
             return intrinsics.get(current);
         }
-        throw new Error(`Unknown path ${path.toString()}.`);
+        throw new Error(`Unknown path ${current.toString()}.`);
     }
 }
 exports.Scope = Scope;
-class Debugger {
-    constructor() {
-        this.breakpoint = false;
-        this.nextStep = false;
-        /* eslint-disable no-use-before-define */
-        this.lastContext = null;
-    }
-    getLastContext() {
-        return this.lastContext;
-    }
-    debug(...segments) {
-        console.debug(...segments);
-        return default_1.DefaultType.Void;
-    }
-    setBreakpoint(breakpoint) {
-        this.breakpoint = breakpoint;
-        return this;
-    }
-    getBreakpoint(_ctx) {
-        return this.breakpoint;
-    }
-    next() {
-        this.nextStep = true;
-        return this;
-    }
-    resume() {
-        if (!this.breakpoint) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            const check = () => {
-                if (!this.breakpoint) {
-                    resolve();
-                }
-                else if (this.nextStep) {
-                    this.nextStep = false;
-                    resolve();
-                }
-                else {
-                    (0, set_immediate_1.setImmediate)(check);
-                }
-            };
-            check();
-        });
-    }
-    interact(ctx, _ast, _op) {
-        const me = this;
-        console.warn('Debugger is not setup.');
-        console.info(ctx);
-        me.breakpoint = false;
-    }
-}
-exports.Debugger = Debugger;
-class ProcessState extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.isPending = false;
-        /* eslint-disable no-use-before-define */
-        this.last = null;
-        this.observer = new Set();
-        this.observerWithExitOccurence = new Set();
-        this.once('exit', () => {
-            this.observerWithExitOccurence = new Set(this.observer);
-        });
-    }
-    createExitObserver() {
-        const id = (0, uuid_1.uuid)();
-        this.observer.add(id);
-        return {
-            occured: () => this.observerWithExitOccurence.has(id),
-            close: () => this.observer.delete(id)
-        };
-    }
-}
-exports.ProcessState = ProcessState;
-class LoopState {
-    constructor() {
-        this.isBreak = false;
-        this.isContinue = false;
-    }
-}
-exports.LoopState = LoopState;
-class FunctionState {
-    constructor() {
-        this.value = default_1.DefaultType.Void;
-        this.isReturn = false;
-        this.context = null;
-        this.super = null;
-    }
-}
-exports.FunctionState = FunctionState;
 class OperationContext {
-    constructor(options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-        this.target = (_a = options.target) !== null && _a !== void 0 ? _a : 'unknown';
-        this.stackTrace = (_b = options.stackTrace) !== null && _b !== void 0 ? _b : [];
-        this.time = (_c = options.time) !== null && _c !== void 0 ? _c : Date.now();
-        this.previous = (_d = options.previous) !== null && _d !== void 0 ? _d : null;
-        this.type = (_e = options.type) !== null && _e !== void 0 ? _e : ContextType.Api;
-        this.state = (_f = options.state) !== null && _f !== void 0 ? _f : ContextState.Default;
-        this.scope = new Scope(this);
-        this.isProtected = (_g = options.isProtected) !== null && _g !== void 0 ? _g : false;
-        this.injected = (_h = options.injected) !== null && _h !== void 0 ? _h : false;
-        this.debugger = (_j = options.debugger) !== null && _j !== void 0 ? _j : new Debugger();
-        this.handler = (_k = options.handler) !== null && _k !== void 0 ? _k : new handler_container_1.HandlerContainer();
-        this.contextTypeIntrinsics = (_l = options.contextTypeIntrinsics) !== null && _l !== void 0 ? _l : {
-            string: null,
-            number: null,
-            list: null,
-            map: null,
-            function: null
-        };
-        this.cps = (_m = options.cps) !== null && _m !== void 0 ? _m : null;
-        this.processState = (_o = options.processState) !== null && _o !== void 0 ? _o : new ProcessState();
-        this.environmentVariables = (_p = options.environmentVariables) !== null && _p !== void 0 ? _p : new Map();
-        this.functionState = new FunctionState();
-        this.loopState = new LoopState();
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.code = options.code;
+        this.ip = 0;
+        this.previous = (_a = options.previous) !== null && _a !== void 0 ? _a : null;
+        this.type = (_b = options.type) !== null && _b !== void 0 ? _b : ContextType.Api;
+        this.scope = this.type === ContextType.Injected ? options.previous.scope : new Scope(this);
+        this.self = (_c = options.self) !== null && _c !== void 0 ? _c : null;
+        this.super = (_d = options.super) !== null && _d !== void 0 ? _d : null;
+        this.isProtected = (_e = options.isProtected) !== null && _e !== void 0 ? _e : false;
         this.api = this.lookupApi();
         this.globals = this.lookupGlobals();
-        this.locals = (_q = this.lookupLocals()) !== null && _q !== void 0 ? _q : this;
-        this.outer = (_r = (options.ignoreOuter ? null : this.lookupOuter())) !== null && _r !== void 0 ? _r : this.globals;
-    }
-    isIgnoredInDebugging(op) {
-        return op instanceof operation_1.OperationBlock || op instanceof noop_1.Noop;
-    }
-    step(op) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isIgnoredInDebugging(op)) {
-                return op.handle(this);
-            }
-            this.stackTrace.unshift(op);
-            if (!this.injected) {
-                this.target = (_a = op.target) !== null && _a !== void 0 ? _a : this.target;
-                this.setLastActive(this);
-                if (this.debugger.getBreakpoint(this)) {
-                    this.processState.emit('breakpoint');
-                    this.debugger.interact(this, op.item, op);
-                    yield this.debugger.resume();
-                }
-            }
-            const result = yield op.handle(this);
-            this.stackTrace.shift();
-            return result;
-        });
-    }
-    setLastActive(ctx) {
-        if (!ctx.injected) {
-            this.processState.last = ctx;
-        }
-        return this;
-    }
-    getLastActive() {
-        return this.processState.last;
-    }
-    isPending() {
-        return this.processState.isPending;
-    }
-    setPending(pending) {
-        this.processState.isPending = pending;
-        return this;
+        this.locals = (_f = this.lookupLocals()) !== null && _f !== void 0 ? _f : this;
+        this.outer = (_g = options.outer) !== null && _g !== void 0 ? _g : this.lookupOuter();
     }
     lookupAllOfType(validate) {
         const me = this;
@@ -247,23 +68,6 @@ class OperationContext {
         }
         return result;
     }
-    exit() {
-        if (this.processState.isPending) {
-            this.processState.emit('exit');
-            return new Promise((resolve) => {
-                const check = () => {
-                    if (!this.processState.isPending) {
-                        resolve(this);
-                    }
-                    else {
-                        (0, set_immediate_1.setImmediate)(check);
-                    }
-                };
-                check();
-            });
-        }
-        return Promise.reject(new Error('No running process found.'));
-    }
     lookupType(allowedTypes) {
         if (allowedTypes.includes(this.type)) {
             return this;
@@ -294,67 +98,34 @@ class OperationContext {
         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) {
-            (_a = this.previous) === null || _a === void 0 ? void 0 : _a.extend(map);
-        }
-        else {
-            this.scope.extend(map);
-        }
+        this.scope.extend(map);
         return this;
     }
     set(path, value) {
-        var _a;
-        if (path instanceof base_1.CustomValue) {
-            this.set(new path_1.Path([path]), value);
-            return;
-        }
-        if (this.state === ContextState.Temporary) {
-            (_a = this.previous) === null || _a === void 0 ? void 0 : _a.set(path, value);
-        }
-        else {
-            this.locals.scope.set(path, value);
-        }
+        this.locals.scope.set(path, value);
     }
-    get(path) {
-        var _a;
-        if (path instanceof base_1.CustomValue) {
-            return this.get(new path_1.Path([path]));
-        }
-        if (path.count() === 0) {
-            return this.scope;
-        }
-        if (this.state === ContextState.Temporary) {
-            return (_a = this.previous) === null || _a === void 0 ? void 0 : _a.get(path);
-        }
-        return this.locals.scope.get(path, this.contextTypeIntrinsics);
+    get(path, contextTypeIntrinsics) {
+        return this.locals.scope.get(path, contextTypeIntrinsics);
+    }
+    injectContext() {
+        if (this.self)
+            this.set(new string_1.CustomString('self'), this.self);
+        if (this.super)
+            this.set(new string_1.CustomString('super'), this.super);
+    }
+    getCurrentInstruction() {
+        return this.code[this.ip - 1];
     }
     fork(options) {
-        var _a, _b;
-        const newContext = new OperationContext({
-            target: (_a = options.target) !== null && _a !== void 0 ? _a : this.target,
-            stackTrace: this.stackTrace,
+        return new OperationContext({
             previous: this,
             type: options.type,
-            state: options.state,
-            ignoreOuter: options.ignoreOuter,
             isProtected: false,
-            injected: this.injected,
-            debugger: this.debugger,
-            handler: this.handler,
-            cps: this.cps,
-            processState: (_b = options.processState) !== null && _b !== void 0 ? _b : this.processState,
-            environmentVariables: this.environmentVariables,
-            contextTypeIntrinsics: this.contextTypeIntrinsics,
-            time: this.time
+            code: options.code,
+            self: options.self,
+            super: options.super,
+            outer: options.outer
         });
-        if (options.type !== ContextType.Function) {
-            if (options.type !== ContextType.Loop) {
-                newContext.loopState = this.loopState;
-            }
-            newContext.functionState = this.functionState;
-        }
-        return newContext;
     }
 }
 OperationContext.lookupApiType = [ContextType.Api];

package/dist/index.d.ts

@@ -1,39 +1,13 @@
-export { ContextForkOptions, ContextOptions, ContextState, ContextType, Debugger, FunctionState, LoopState, OperationContext, ProcessState, Scope } from './context';
-export { CPS, CPSContext, CPSVisitCallback, defaultCPSVisit } from './cps';
+export { ContextForkOptions, ContextOptions, ContextType, OperationContext, Scope } from './context';
 export { DefaultErrorHandler, ErrorHandler } from './handler/error';
 export { DefaultOutputHandler, KeyEvent, OutputHandler, PrintOptions } from './handler/output';
 export { DefaultResourceHandler, ResourceHandler } from './handler/resource';
 export { HandlerContainer } from './handler-container';
 export { Interpreter, InterpreterOptions } from './interpreter';
-export { Assign } from './operations/assign';
-export { Block, IsEOL } from './operations/block';
-export { Break } from './operations/break';
-export { Call } from './operations/call';
-export { Chunk } from './operations/chunk';
-export { Continue } from './operations/continue';
-export { DebuggerStatement } from './operations/debugger-statement';
-export { Evaluate, GenericProcessorHandler, handle, handleList, handleMap, handleNumber, handleString, ListProcessorHandler, MapProcessorHandler, NumberProcessorHandler, ProcessorHandler, ProcessorHandlerFunction, StringProcessorHandler } from './operations/evaluate';
-export { For } from './operations/for';
-export { FunctionOperation } from './operations/function';
-export { Clause, IfStatement } from './operations/if-statement';
-export { Import } from './operations/import';
-export { Include } from './operations/include';
-export { List } from './operations/list';
-export { Literal } from './operations/literal';
-export { MapOperation } from './operations/map';
-export { NegatedBinary } from './operations/negated-binary';
-export { NewInstance } from './operations/new-instance';
-export { Noop } from './operations/noop';
-export { Not } from './operations/not';
-export { CPSVisit, Operation } from './operations/operation';
-export { Reference } from './operations/reference';
-export { IdentifierSegment, IndexSegment, OperationSegment, Resolve, ResolveResult, Segment } from './operations/resolve';
-export { Return } from './operations/return';
-export { While } from './operations/while';
 export { CustomValue } from './types/base';
 export { CustomBoolean } from './types/boolean';
 export { DefaultType } from './types/default';
-export { Argument, Callback, CustomFunction } from './types/function';
+export { CustomFunctionCallback, CustomFunction } from './types/function';
 export { CustomList, CustomListIterator } from './types/list';
 export { CustomMap, CustomMapIterator } from './types/map';
 export { CustomNil } from './types/nil';
@@ -42,6 +16,8 @@ export { CustomString, CustomStringIterator } from './types/string';
 export { CustomObject, CustomValueWithIntrinsics } from './types/with-intrinsics';
 export { PrepareError, RuntimeError } from './utils/error';
 export { ObjectValue } from './utils/object-value';
-export { Path } from './utils/path';
 export { deepEqual } from './utils/deep-equal';
 export { deepHash } from './utils/deep-hash';
+export { Debugger, VM, VMOptions } from './vm';
+export { Instruction } from './byte-compiler/instruction';
+export { BytecodeGenerator, BytecodeCompileResult, BytecodeConverterOptions, BytecodeGeneratorContext } from './bytecode-generator';