@quenk/potoo 4.0.7 → 4.0.11

package/lib/actor/system/vm/registry.ts

@@ -1,223 +0,0 @@
-import { Maybe } from '@quenk/noni/lib/data/maybe';
-
-import { PTObject } from './object';
-import {
-    PTString,
-    PTValue,
-    TYPE_LIST,
-    TYPE_MASK,
-    TYPE_OBJECT,
-    TYPE_STRING
-} from './type';
-
-/**
- * RegistryType indicates the type of the registry.
- */
-export enum RegistryType {
-    string = TYPE_STRING,
-    object = TYPE_OBJECT
-}
-
-/**
- * RefCount is a number indicating how many Frames are aware of an object.
- *
- * A zero value indicates the object is dead and can be removed from the
- * registry.
- */
-export type RefCount = number;
-
-/**
- * RegistryAddress is the address of an object in the registry.
- */
-export type RegistryAddress = number;
-
-/**
- * RegistrySet is a container for all the registries used by the VM.
- */
-export class RegistrySet {
-    constructor(
-        public strings = new Registry<PTString>(RegistryType.string),
-        public objects = new Registry<PTObject>(RegistryType.object)
-    ) {}
-
-    /**
-     * isRegistryAddress tests whether a number is a valid registry address.
-     *
-     * This does not test whether the address can be dereferenced.
-     */
-    isRegistryAddress(addr: number): boolean {
-        let type = addr & TYPE_MASK;
-        return (
-            type === TYPE_STRING || type === TYPE_OBJECT || type === TYPE_LIST
-        );
-    }
-
-    /**
-     * addString to the registry.
-     */
-    addString(value: PTString): RegistryAddress {
-        return this.strings.add(value);
-    }
-
-    /**
-     * addObject to the registry.
-     */
-    addObject(value: PTObject): RegistryAddress {
-        return this.objects.add(value);
-    }
-
-    /**
-     * getString returns a string from the registry given its address.
-     */
-    getString(addr: RegistryAddress): Maybe<PTString> {
-        return this.strings.get(addr);
-    }
-
-    /**
-     * getObject returns an object from the registry given its address.
-     */
-    getObject(addr: RegistryAddress): Maybe<PTObject> {
-        return this.objects.get(addr);
-    }
-
-    /**
-     * increment the ref count for a registry address.
-     */
-    increment(addr: RegistryAddress): void {
-        switch (addr & TYPE_MASK) {
-            case TYPE_STRING:
-                this.strings.increment(addr);
-                break;
-            case TYPE_OBJECT:
-            case TYPE_LIST:
-                this.objects.increment(addr);
-                break;
-        }
-    }
-
-    /**
-     * decrement the ref count for a registry address.
-     */
-    decrement(addr: RegistryAddress): void {
-        switch (addr & TYPE_MASK) {
-            case TYPE_STRING:
-                this.strings.decrement(addr);
-                break;
-            case TYPE_OBJECT:
-            case TYPE_LIST:
-                this.objects.decrement(addr);
-                break;
-        }
-    }
-
-    /**
-     * deref an object from the registry.
-     *
-     * This attempts to retrieve an object from the relevant registry given its
-     * address.
-     */
-    deref(addr: RegistryAddress): Maybe<PTValue> {
-        switch (addr & TYPE_MASK) {
-            case TYPE_STRING:
-                return this.strings.get(addr);
-            case TYPE_OBJECT:
-            case TYPE_LIST:
-                return this.objects.get(addr);
-            default:
-                return Maybe.nothing();
-        }
-    }
-
-    /**
-     * flush all the internal registries.
-     */
-    flush(): void {
-        this.strings.flush();
-        this.objects.flush();
-    }
-}
-
-/**
- * Registry serves as a container for objects used by the VM.
- *
- * This interface allows for a naive reference counting system for objects
- * created by the VM and foreign objects the VM is aware of. It does not yet
- * take cyclical references into account.
- *
- * The tracking here is needed so that we know when an object can be removed
- * from the container and allow the JS engine's own garbage collection to get
- * rid of it.
- *
- * Each instance handles one specific type of data indicated by the "type"
- * parameter. This value is used when generating the address of the object that
- * can be used for its retrieval.
- */
-export class Registry<T> {
-    constructor(
-        public type: RegistryType,
-        public values: Map<RegistryAddress, T> = new Map(),
-        public refCounts: Map<RegistryAddress, RefCount> = new Map(),
-        public deadValues: RegistryAddress[] = []
-    ) {}
-
-    /**
-     * add an object to the registry.
-     *
-     * Each time an object is added to the registry we initialize its counter
-     * to 0. The idea is for the VM opcodes to increment/decrement this value
-     * as needed.
-     */
-    add(value: T): RegistryAddress {
-        let addr = (this.values.size + 1) | this.type;
-        this.values.set(addr, value);
-        this.refCounts.set(addr, 0);
-        return addr;
-    }
-
-    /**
-     * get an object from the registry.
-     */
-    get(addr: RegistryAddress): Maybe<T> {
-        return Maybe.fromNullable(this.values.get(addr));
-    }
-
-    /**
-     * increment the ref count for an object.
-     *
-     * This should be done anytime an object is used in a new Frame.
-     */
-    increment(addr: RegistryAddress): void {
-        if (this.values.has(addr))
-            this.refCounts.set(addr, (this.refCounts.get(addr) || 0) + 1);
-    }
-
-    /**
-     * decrement the ref count for an object.
-     *
-     * This should be done whenever a frame that "knows" about the object is
-     * popped off the stack. When the ref count reaches 0, the object is
-     * considered dead and will be marked for removal.
-     */
-    decrement(addr: RegistryAddress): void {
-        if (!this.values.has(addr)) return;
-        let oldCount = this.refCounts.get(addr) || 0;
-        let newCount = oldCount <= 0 ? 0 : oldCount - 1;
-        this.refCounts.set(addr, newCount);
-        if (newCount === 0) this.deadValues.push(addr);
-    }
-
-    /**
-     * flush all dead objects from the registry.
-     *
-     * When called, this method will remove all objects marked as dead from the
-     * registry. Determining the right time to call this method is left up to the
-     * VM.
-     */
-    flush(): void {
-        this.deadValues.forEach(addr => {
-            this.values.delete(addr);
-            this.refCounts.delete(addr);
-        });
-        this.deadValues = [];
-    }
-}

package/lib/actor/system/vm/runtime/error.ts

@@ -1,248 +0,0 @@
-import { Err } from '@quenk/noni/lib/control/err';
-
-import { Address, ADDRESS_RESTRICTED } from '../../../address';
-import { TypeInfo } from '../script/info';
-import { DATA_MAX_SAFE_UINT32 } from '../frame';
-import { Thread } from '../thread';
-
-/**
- * ErrorClass
- */
-export class ErrorClass {
-    constructor(public message: string) {}
-
-    stack?: string;
-}
-
-/**
- * InvalidIdError indicates an id used in a template is invalid.
- */
-export class InvalidIdErr extends ErrorClass {
-    constructor(public id: string) {
-        super(
-            `The id "${id} must not contain` +
-                `${ADDRESS_RESTRICTED} or be an empty string!`
-        );
-    }
-}
-
-/**
- * UnknownParentAddressErr indicates the parent address used for
- * spawning an actor does not exist.
- */
-export class UnknownParentAddressErr extends ErrorClass {
-    constructor(public address: Address) {
-        super(`The parent address "${address}" is not part of the system!`);
-    }
-}
-
-/**
- * DuplicateAddressErr indicates the address of a freshly spawned
- * actor is already in use.
- */
-export class DuplicateAddressErr extends ErrorClass {
-    constructor(public address: Address) {
-        super(`Duplicate address "${address}" detected!`);
-    }
-}
-
-/**
- * NullTemplatePointerErr occurs when a reference to a template
- * does not exist in the templates table.
- */
-export class NullTemplatePointerErr extends ErrorClass {
-    constructor(public index: number) {
-        super(`The index "${index}" does not exist in the Template table!`);
-    }
-}
-
-export class NullFunctionPointerErr extends ErrorClass {
-    constructor(public index: number) {
-        super(`The index "${index}" does not exist in the function table!`);
-    }
-}
-
-/**
- * JumpOutOfBoundsErr
- */
-export class JumpOutOfBoundsErr extends ErrorClass {
-    constructor(public location: number, public size: number) {
-        super(`Cannot jump to location "${location}"! Max location: ${size}!`);
-    }
-}
-
-/**
- * NullPointerErr
- */
-export class NullPointerErr extends ErrorClass {
-    constructor(public data: number) {
-        super(`Value: [${data.toString(16)}]`);
-    }
-}
-
-/**
- * UnexpectedDataType
- */
-export class UnexpectedDataType extends ErrorClass {
-    constructor(public expected: number, public got: number) {
-        super(
-            `Expected: ${expected.toString(16)}, ` +
-                `Received: ${got.toString(16)}`
-        );
-    }
-}
-
-/**
- * IllegalStopErr
- */
-export class IllegalStopErr extends ErrorClass {
-    constructor(public parent: string, public child: string) {
-        super(`The actor at address "${parent}" can not kill "${child}"!`);
-    }
-}
-
-/**
- * NoReceiverErr
- */
-export class NoReceiverErr extends ErrorClass {
-    constructor(public actor: string) {
-        super(`Actor ${actor} tried to read a message without a receiver!`);
-    }
-}
-
-/**
- * NoMailboxErr
- */
-export class NoMailboxErr extends ErrorClass {
-    constructor(public actor: string) {
-        super(`Actor ${actor} has no mailbox!`);
-    }
-}
-
-/**
- * EmptyMailboxErr
- */
-export class EmptyMailboxErr extends ErrorClass {
-    constructor() {
-        super('Mailbox empty.');
-    }
-}
-
-/**
- * UnknownAddressErr
- */
-export class UnknownAddressErr extends ErrorClass {
-    constructor(public actor: string) {
-        super(`The system has no actor for address "${actor}"!`);
-    }
-}
-
-/**
- * MissingSymbolErr
- */
-export class MissingSymbolErr extends ErrorClass {
-    constructor(public index: number) {
-        super(`Cannot locate symbol at index 0x${index.toString(16)}`);
-    }
-}
-
-/**
- * IntegerOverflowErr
- */
-export class IntegerOverflowErr extends ErrorClass {
-    constructor() {
-        super(`DATA_MAX_SAFE_UINT32=${DATA_MAX_SAFE_UINT32}`);
-    }
-}
-
-/**
- * StackEmptyErr
- */
-export class StackEmptyErr extends ErrorClass {
-    constructor() {
-        super('Stack is empty.');
-    }
-}
-
-/**
- * InvalidPropertyIndex
- */
-export class InvalidPropertyIndex extends ErrorClass {
-    constructor(public cons: TypeInfo, public idx: number) {
-        super(`Constructor: ${cons.name}, index: ${idx}`);
-    }
-}
-
-/**
- * MissingInfoErr
- */
-export class MissingInfoErr extends ErrorClass {
-    constructor(public idx: number) {
-        super(`No info object index: ${idx}!`);
-    }
-}
-
-/**
- * InvalidConstructorErr
- */
-export class InvalidConstructorErr extends ErrorClass {
-    constructor(public name: string) {
-        super(`Named object "${name}" cannot be used as a constructor!`);
-    }
-}
-
-/**
- * InvalidFunctionErr
- */
-export class InvalidFunctionErr extends ErrorClass {
-    constructor(public name: string) {
-        super(`Named object "${name}" cannot be used as a function!`);
-    }
-}
-
-/**
- * UnknownInstanceErr
- */
-export class UnknownInstanceErr extends ErrorClass {
-    constructor(public instance: object) {
-        super(
-            'The instance provided with constructor "' +
-                (instance ? instance.constructor.name || instance : instance) +
-                '" is not in the system!'
-        );
-    }
-}
-
-/**
- * UnknownFuncErr
- */
-export class UnknownFunErr extends ErrorClass {
-    constructor(public name: string) {
-        super(`The function '${name}' does not exist and cannot be executed!`);
-    }
-}
-
-/**
- * InvalidThreadErr
- */
-export class InvalidThreadErr extends ErrorClass {
-    constructor(public thread: Thread) {
-        super('Thread is no longer part of the system or is invalid!');
-    }
-}
-
-/**
- * ActorTerminatedErr
- *
- * Note: This signals that an actor has been removed involuntarily due to an
- * unhandled error.
- */
-export class ActorTerminatedErr extends Error {
-    constructor(
-        public actor: Address,
-        public origin: Address,
-        public originalError: Err
-    ) {
-        super('ActorTerminated');
-    }
-}

package/lib/actor/system/vm/runtime.ts

@@ -1,31 +0,0 @@
-import { Api } from '../../api';
-import { Actor } from '../..';
-import { VM } from '.';
-
-/**
- * Runtime is the interface used by the outside world (JS) to execute code
- * in the VM.
- */
-export interface Runtime extends Actor, Api {
-    /**
-     * vm the Runtime belongs to.
-     */
-    vm: VM;
-
-    /**
-     * isValid indicates whether the Runtime is still valid.
-     *
-     * A Runtime is invalid if it has encountered an error or is no longer
-     * part of the system.
-     */
-    isValid(): boolean;
-
-    /**
-     * watch an asynchronous task, feeding any errors into the VM's
-     * error handling machinery.
-     *
-     * This method exists to allow async operations to trigger the error
-     * handling machinery built into the VM.
-     */
-    watch<T>(task: () => Promise<T>): Promise<void>;
-}

package/lib/actor/system/vm/scheduler.ts

@@ -1,108 +0,0 @@
-import { SharedThread, ThreadState } from './thread/shared';
-
-export const ERR_THREAD_DEQUEUED = 'ERR_THREAD_DEQUEUED';
-
-/**
- * PendingTask tuple type.
- */
-export type PendingTask = [SharedThread, (err?: Error) => void];
-
-export class Task {
-    constructor(
-        public thread: SharedThread,
-        public abort: (err: Error) => void,
-        public exec: () => Promise<void>
-    ) {}
-}
-
-/**
- * Scheduler provides a mechanism for cooperative execution between Thread
- * instances within the VM.
- *
- * Each Thread enqueues a Task to be executed each time it has work to do.
- * The Scheduler.run() method will execute each of these tasks in a round-robin
- * fashion until the queue is empty or no Threads are in the IDLE state.
- *
- * In prior versions, Threads executed code at will which made it possible
- * for a single actor's state to be mutated while a previous tasks still executed
- * (when an actor sends a  message to itself for example).
- *
- * This led to errors and bugs that were hard to track down. By using scheduling
- * execution we ensure threads do not preempt themselves.
- */
-export class Scheduler {
-    constructor(public queue: Task[] = [], public isRunning = false) {}
-
-    /**
-     * postTask a Task for future execution.
-     * @param task    - The Task to post.
-     * @param preempt - If true, the task will be executed before any other
-     *                  tasks in the queue belonging to the Thread.
-     */
-    postTask(task: Task, preempt = false) {
-        if (preempt) {
-            let idx = this.queue.findIndex(
-                ({ thread }) => thread === task.thread
-            );
-            if (idx != -1) {
-                this.queue.splice(idx, 0, task);
-            } else {
-                this.queue.push(task);
-            }
-        } else {
-            this.queue.push(task);
-        }
-
-        this.run();
-    }
-
-    /**
-     * removeTasks for a Thread.
-     *
-     * The Tasks will be terminated with an ERR_THREAD_DEQUEUED error.
-     */
-    removeTasks(thread: SharedThread) {
-        this.queue = this.queue.filter(task => {
-            if (task.thread != thread) return true;
-            // TODO: dispatch event? callback into thread?
-            task.abort(new Error(ERR_THREAD_DEQUEUED));
-        });
-    }
-
-    /**
-     * run queued pending tasks for idle threads.
-     *
-     * This method only executes if the scheduler is not already running. It
-     * does not wait for tasks to be completed before moving on to the next
-     * however once a thread is not in the idle state no other tasks will
-     * be executed for it.
-     */
-    run() {
-        if (this.isRunning) return;
-
-        this.isRunning = true;
-
-        let idx;
-        while (
-            (idx = this.queue.findIndex(
-                task => task.thread.state === ThreadState.IDLE
-            )) !== -1
-        ) {
-            let task = this.queue.splice(idx, 1)[0];
-
-            task.thread.state = ThreadState.RUNNING;
-
-            // TODO: disatch event
-            task.exec()
-                .then(() => {
-                    if (task.thread.state === ThreadState.RUNNING)
-                        task.thread.state = ThreadState.IDLE;
-                })
-                .catch(err => {
-                    task.abort(err);
-                });
-        }
-
-        this.isRunning = false;
-    }
-}

package/lib/actor/system/vm/script/index.ts

@@ -1,64 +0,0 @@
-import { Either, left, right } from '@quenk/noni/lib/data/either';
-import { Err } from '@quenk/noni/lib/control/error';
-
-import { MissingInfoErr } from '../runtime/error';
-import { PTNumber, PTString } from '../type';
-import { Instruction } from '../op';
-import { Info } from './info';
-
-export const CONSTANTS_INDEX_NUMBER = 0;
-export const CONSTANTS_INDEX_STRING = 1;
-
-/**
- * Constants is a tuple of immutable values available to a
- * Script at runtime.
- */
-export type Constants = [PTNumber[], PTString[]];
-
-/**
- * Script contains the code and supporting information of an actor used by
- * the VM for code execution.
- */
-export interface Script {
-    /**
-     * name of the Script.
-     * This is an absolute path or an id for dynamically generated scripts.
-     */
-    name: string;
-
-    /**
-     * constants pool for the actor where certain references are resolved from.
-     */
-    constants: Constants;
-
-    /**
-     * info is a table of various named structures within the script source.
-     */
-    info: Info[];
-
-    /**
-     * code is the actual instructions the VM will execute.
-     */
-    code: Instruction[];
-}
-
-/**
- * PScript provides a constructor for creating Scripts.
- */
-export class PScript implements Script {
-    constructor(
-        public name: string,
-        public constants: Constants = [[], []],
-        public info: Info[] = [],
-        public code: Instruction[] = []
-    ) {}
-}
-
-/**
- * getInfo retrivies an Info object from the info section.
- */
-export const getInfo = (s: Script, idx: number): Either<Err, Info> => {
-    if (s.info[idx] == null) return left(new MissingInfoErr(idx));
-
-    return right(s.info[idx]);
-};