greybel-interpreter 0.1.0

package/dist/cps.js

@@ -0,0 +1,438 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CPSMap = void 0;
+var greybel_core_1 = require("greybel-core");
+var assign_1 = __importDefault(require("./expressions/assign"));
+var call_1 = __importDefault(require("./expressions/call"));
+var list_1 = __importDefault(require("./expressions/list"));
+var logical_and_binary_1 = __importDefault(require("./expressions/logical-and-binary"));
+var map_1 = __importDefault(require("./expressions/map"));
+var path_1 = __importDefault(require("./expressions/path"));
+var binary_negated_expression_1 = __importDefault(require("./expressions/binary-negated-expression"));
+var argument_1 = __importDefault(require("./operations/argument"));
+var while_1 = __importDefault(require("./operations/while"));
+var for_1 = __importDefault(require("./operations/for"));
+var return_1 = __importDefault(require("./operations/return"));
+var reference_1 = __importDefault(require("./operations/reference"));
+var new_1 = __importDefault(require("./operations/new"));
+var not_1 = __importDefault(require("./operations/not"));
+var if_statement_1 = __importDefault(require("./operations/if-statement"));
+var if_1 = __importDefault(require("./operations/if"));
+var else_if_1 = __importDefault(require("./operations/else-if"));
+var else_1 = __importDefault(require("./operations/else"));
+var continue_1 = __importDefault(require("./operations/continue"));
+var break_1 = __importDefault(require("./operations/break"));
+var body_1 = __importDefault(require("./operations/body"));
+var debugger_1 = __importDefault(require("./operations/debugger"));
+var function_1 = __importDefault(require("./operations/function"));
+var boolean_1 = __importDefault(require("./custom-types/boolean"));
+var number_1 = __importDefault(require("./custom-types/number"));
+var string_1 = __importDefault(require("./custom-types/string"));
+var nil_1 = __importDefault(require("./custom-types/nil"));
+var CPSMap = function (visit, context) {
+    return {
+        'AssignmentStatement': function (item) {
+            return new assign_1.default(item, visit);
+        },
+        'MemberExpression': function (item) {
+            return new path_1.default(item, visit);
+        },
+        'FunctionDeclaration': function (item) {
+            var e_1, _a, e_2, _b;
+            var args = new argument_1.default(item.parameters);
+            var body = new body_1.default(item.body);
+            try {
+                for (var _c = __values(item.parameters), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var parameterItem = _d.value;
+                    args.stack.push(visit(parameterItem));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            try {
+                for (var _e = __values(item.body), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var bodyItem = _f.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return new function_1.default(item, {
+                args: args,
+                body: body
+            });
+        },
+        'MapConstructorExpression': function (item) {
+            return new map_1.default(item, visit);
+        },
+        'Identifier': function (item) {
+            return new path_1.default(item, visit);
+        },
+        'ReturnStatement': function (item) {
+            var arg = visit(item.argument);
+            return new return_1.default(item, {
+                arg: arg
+            });
+        },
+        'NumericLiteral': function (item) {
+            // @ts-ignore: Key is always a literal
+            return new number_1.default(item.value);
+        },
+        'WhileStatement': function (item) {
+            var e_3, _a;
+            var body = new body_1.default(item.body);
+            var condition = visit(item.condition);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return new while_1.default(item, {
+                body: body,
+                condition: condition
+            });
+        },
+        'StringLiteral': function (item) {
+            // @ts-ignore: Key is always a literal
+            return new string_1.default(item.value);
+        },
+        'IndexExpression': function (item) {
+            return new path_1.default(item, visit);
+        },
+        'FeatureEnvarExpression': function (_item) {
+            throw new Error('Not supported');
+        },
+        'IfShortcutStatement': function (item) {
+            var e_4, _a;
+            var op = new if_statement_1.default(item);
+            try {
+                for (var _b = __values(item.clauses), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var clausesItem = _c.value;
+                    op.clauses.push(visit(clausesItem));
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            return op;
+        },
+        'IfShortcutClause': function (item) {
+            var e_5, _a;
+            var body = new body_1.default(item.body);
+            var condition = visit(item.condition);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            return new if_1.default(item, {
+                condition: condition,
+                body: body
+            });
+        },
+        'ElseifShortcutClause': function (item) {
+            var e_6, _a;
+            var body = new body_1.default(item.body);
+            var condition = visit(item.condition);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return new else_if_1.default(item, {
+                body: body,
+                condition: condition
+            });
+        },
+        'ElseShortcutClause': function (item) {
+            var e_7, _a;
+            var body = new body_1.default(item.body);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            return new else_1.default(item, {
+                body: body
+            });
+        },
+        'NilLiteral': function (item) {
+            return new nil_1.default();
+        },
+        'ForGenericStatement': function (item) {
+            var e_8, _a;
+            var body = new body_1.default(item.body);
+            var variable = visit(item.variable);
+            var iterator = visit(item.iterator);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            return new for_1.default(item, {
+                body: body,
+                variable: variable,
+                iterator: iterator
+            });
+        },
+        'IfStatement': function (item) {
+            var e_9, _a;
+            var op = new if_statement_1.default(item);
+            try {
+                for (var _b = __values(item.clauses), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var clausesItem = _c.value;
+                    op.clauses.push(visit(clausesItem));
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            return op;
+        },
+        'IfClause': function (item) {
+            var e_10, _a;
+            var body = new body_1.default(item.body);
+            var condition = visit(item.condition);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            return new if_1.default(item, {
+                body: body,
+                condition: condition
+            });
+        },
+        'ElseifClause': function (item) {
+            var e_11, _a;
+            var body = new body_1.default(item.body);
+            var condition = visit(item.condition);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+            return new else_if_1.default(item, {
+                body: body,
+                condition: condition
+            });
+        },
+        'ElseClause': function (item) {
+            var e_12, _a;
+            var body = new body_1.default(item.body);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    body.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+            return new else_1.default(item, {
+                body: body
+            });
+        },
+        'NegationExpression': function (item) {
+            var arg = visit(item.argument);
+            return new not_1.default(item, { arg: arg });
+        },
+        'ContinueStatement': function (item) {
+            return new continue_1.default(item);
+        },
+        'BreakStatement': function (item) {
+            return new break_1.default(item);
+        },
+        'CallExpression': function (item) {
+            return new call_1.default(item, visit);
+        },
+        'CallStatement': function (item) {
+            return new call_1.default(item, visit);
+        },
+        'FeatureImportExpression': function (_item) {
+            throw new Error('Not supported');
+        },
+        'FeatureIncludeExpression': function (_item) {
+            throw new Error('Not supported');
+        },
+        'ImportCodeExpression': function (item) {
+            var resourceHandler = context.resourceHandler;
+            var target = resourceHandler.getTargetRelativeTo(context.target, 
+            // @ts-ignore: FileSystemDirectory is always a string
+            item.fileSystemDirectory.value);
+            var code = context.resourceHandler.get(target);
+            var parser = new greybel_core_1.Parser(code);
+            var chunk = parser.parseChunk();
+            return visit(chunk);
+        },
+        'FeatureDebuggerExpression': function (item) {
+            return new debugger_1.default(item);
+        },
+        'ListConstructorExpression': function (item) {
+            return new list_1.default(item, visit);
+        },
+        'BooleanLiteral': function (item) {
+            // @ts-ignore: Key is always a literal
+            return new boolean_1.default(item.value);
+        },
+        'EmptyExpression': function (item) { },
+        'BinaryExpression': function (item) {
+            return new logical_and_binary_1.default(item, visit);
+        },
+        'BinaryNegatedExpression': function (item) {
+            return new binary_negated_expression_1.default(item, visit);
+        },
+        'LogicalExpression': function (item) {
+            return new logical_and_binary_1.default(item, visit);
+        },
+        'UnaryExpression': function (item) {
+            var arg = visit(item.argument);
+            var op;
+            if ('@' === item.operator) {
+                op = new reference_1.default(item, { arg: arg });
+            }
+            else if ('new' === item.operator) {
+                op = new new_1.default(item, { arg: arg });
+            }
+            else {
+                throw new Error('Unknown unary expression.');
+            }
+            return op;
+        },
+        'Chunk': function (item) {
+            var e_13, _a;
+            var op = new body_1.default(item.body);
+            try {
+                for (var _b = __values(item.body), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bodyItem = _c.value;
+                    op.stack.push(visit(bodyItem));
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+            return op;
+        }
+    };
+};
+exports.CPSMap = CPSMap;
+var CPS = /** @class */ (function () {
+    function CPS(context) {
+        var me = this;
+        me.cpsMap = (0, exports.CPSMap)(me.visit.bind(me), context);
+    }
+    CPS.prototype.visit = function (o) {
+        var me = this;
+        if (o == null)
+            return '';
+        if (o.type == null) {
+            console.error('Error ast type:', o);
+            throw new Error('Unexpected as type');
+        }
+        var fn = me.cpsMap[o.type];
+        if (fn == null) {
+            console.error('Error ast:', o);
+            throw new Error('Type does not exist ' + o.type);
+        }
+        var result = fn.call(me, o);
+        return result;
+    };
+    return CPS;
+}());
+exports.default = CPS;

package/dist/custom-types/boolean.d.ts

@@ -0,0 +1,10 @@
+import { CustomLiteralType } from '../types/custom-type';
+export default class CustomBoolean extends CustomLiteralType {
+    static intrinsics: Map<string, Function>;
+    value: boolean;
+    constructor(value: boolean);
+    getType(): string;
+    valueOf(): boolean;
+    toString(): string;
+    fork(): CustomBoolean;
+}

package/dist/custom-types/boolean.js

@@ -0,0 +1,41 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var custom_type_1 = require("../types/custom-type");
+var CustomBoolean = /** @class */ (function (_super) {
+    __extends(CustomBoolean, _super);
+    function CustomBoolean(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    CustomBoolean.prototype.getType = function () {
+        return 'boolean';
+    };
+    CustomBoolean.prototype.valueOf = function () {
+        return this.value;
+    };
+    CustomBoolean.prototype.toString = function () {
+        return this.value.toString();
+    };
+    CustomBoolean.prototype.fork = function () {
+        return new CustomBoolean(this.value);
+    };
+    CustomBoolean.intrinsics = new Map();
+    return CustomBoolean;
+}(custom_type_1.CustomLiteralType));
+exports.default = CustomBoolean;

package/dist/custom-types/list.d.ts

@@ -0,0 +1,25 @@
+import { CustomLiteralType, CustomObjectType, Callable } from '../types/custom-type';
+export declare class CustomListIterator implements Iterator<any> {
+    value: any[];
+    index: number;
+    constructor(value: any);
+    next(): IteratorResult<any>;
+}
+export default class CustomList extends CustomObjectType {
+    static intrinsics: Map<string, Function>;
+    value: any[];
+    static isNumber(value: string): boolean;
+    constructor(value: any[]);
+    [Symbol.iterator](): CustomListIterator;
+    concat(list: CustomList): CustomList;
+    slice: (a: CustomLiteralType, b: CustomLiteralType) => CustomList;
+    toIndex(value: string): number;
+    set(path: any[], value: any): Promise<void>;
+    get(path: any[]): Promise<any>;
+    getCallable(path: any[]): Promise<Callable>;
+    callMethod(method: string[], ...args: any[]): any;
+    getType(): string;
+    valueOf(): CustomList | null;
+    toString(): string;
+    fork(): CustomList;
+}