@lewin671/python-vm 0.1.0

package/dist/vm/runtime-types.js

@@ -0,0 +1,290 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PyFile = exports.PyDict = exports.PyGenerator = exports.PyInstance = exports.PyClass = exports.PyFunction = exports.Scope = exports.PyException = exports.ContinueSignal = exports.BreakSignal = exports.ReturnSignal = void 0;
+const fs = __importStar(require("fs"));
+class ReturnSignal {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.ReturnSignal = ReturnSignal;
+class BreakSignal {
+}
+exports.BreakSignal = BreakSignal;
+class ContinueSignal {
+}
+exports.ContinueSignal = ContinueSignal;
+class PyException extends Error {
+    constructor(pyType, message, pyValue) {
+        super(message || pyType);
+        this.pyType = pyType;
+        this.pyValue = pyValue;
+    }
+}
+exports.PyException = PyException;
+class Scope {
+    constructor(parent = null) {
+        this.values = new Map();
+        this.globals = new Set();
+        this.nonlocals = new Set();
+        this.parent = parent;
+    }
+    get(name) {
+        if (this.values.has(name)) {
+            return this.values.get(name);
+        }
+        if (this.parent) {
+            return this.parent.get(name);
+        }
+        throw new PyException('NameError', `name '${name}' is not defined`);
+    }
+    set(name, value) {
+        if (this.globals.has(name) && this.parent) {
+            this.root().values.set(name, value);
+            return;
+        }
+        if (this.nonlocals.has(name) && this.parent) {
+            const scope = this.parent.findScopeWith(name);
+            if (!scope) {
+                throw new PyException('NameError', `no binding for nonlocal '${name}' found`);
+            }
+            scope.values.set(name, value);
+            return;
+        }
+        this.values.set(name, value);
+    }
+    root() {
+        let scope = this;
+        while (scope.parent) {
+            scope = scope.parent;
+        }
+        return scope;
+    }
+    findScopeWith(name) {
+        let scope = this;
+        while (scope) {
+            if (scope.values.has(name))
+                return scope;
+            scope = scope.parent;
+        }
+        return null;
+    }
+}
+exports.Scope = Scope;
+class PyFunction {
+    constructor(name, params, body, closure, isGenerator) {
+        this.name = name;
+        this.params = params;
+        this.body = body;
+        this.closure = closure;
+        this.isGenerator = isGenerator;
+    }
+}
+exports.PyFunction = PyFunction;
+class PyClass {
+    constructor(name, bases, attributes, isException = false) {
+        this.name = name;
+        this.bases = bases;
+        this.attributes = attributes;
+        this.isException = isException;
+    }
+}
+exports.PyClass = PyClass;
+class PyInstance {
+    constructor(klass) {
+        this.klass = klass;
+        this.attributes = new Map();
+    }
+}
+exports.PyInstance = PyInstance;
+class PyGenerator {
+    constructor(iterator) {
+        this.iterator = iterator;
+    }
+    next(value) {
+        const result = this.iterator.next(value === undefined ? null : value);
+        if (result.done) {
+            throw new PyException('StopIteration', 'StopIteration');
+        }
+        return result.value;
+    }
+    send(value) {
+        const result = this.iterator.next(value === undefined ? null : value);
+        if (result.done) {
+            throw new PyException('StopIteration', 'StopIteration');
+        }
+        return result.value;
+    }
+    [Symbol.iterator]() {
+        return this.iterator;
+    }
+}
+exports.PyGenerator = PyGenerator;
+class PyDict {
+    constructor() {
+        this.primitiveStore = new Map();
+        this.objectStore = new Map();
+    }
+    get size() {
+        return this.primitiveStore.size + this.objectStore.size;
+    }
+    set(key, value) {
+        const info = this.keyInfo(key);
+        const existing = info.store.get(info.id);
+        if (existing) {
+            existing.value = value;
+            return this;
+        }
+        info.store.set(info.id, { key, value });
+        return this;
+    }
+    get(key) {
+        const info = this.keyInfo(key);
+        const entry = info.store.get(info.id);
+        return entry ? entry.value : undefined;
+    }
+    has(key) {
+        const info = this.keyInfo(key);
+        return info.store.has(info.id);
+    }
+    delete(key) {
+        const info = this.keyInfo(key);
+        return info.store.delete(info.id);
+    }
+    *entries() {
+        for (const entry of this.primitiveStore.values()) {
+            yield [entry.key, entry.value];
+        }
+        for (const entry of this.objectStore.values()) {
+            yield [entry.key, entry.value];
+        }
+    }
+    *keys() {
+        for (const entry of this.primitiveStore.values()) {
+            yield entry.key;
+        }
+        for (const entry of this.objectStore.values()) {
+            yield entry.key;
+        }
+    }
+    *values() {
+        for (const entry of this.primitiveStore.values()) {
+            yield entry.value;
+        }
+        for (const entry of this.objectStore.values()) {
+            yield entry.value;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    keyInfo(key) {
+        const numeric = this.normalizeNumericKey(key);
+        if (numeric !== null) {
+            return { store: this.primitiveStore, id: `n:${String(numeric)}` };
+        }
+        if (typeof key === 'string') {
+            return { store: this.primitiveStore, id: `s:${key}` };
+        }
+        if (key === null) {
+            return { store: this.primitiveStore, id: 'none' };
+        }
+        if (key === undefined) {
+            return { store: this.primitiveStore, id: 'undefined' };
+        }
+        return { store: this.objectStore, id: key };
+    }
+    normalizeNumericKey(key) {
+        if (typeof key === 'boolean')
+            return key ? 1 : 0;
+        if (typeof key === 'bigint')
+            return key;
+        if (typeof key === 'number')
+            return key;
+        if (key instanceof Number)
+            return key.valueOf();
+        return null;
+    }
+}
+exports.PyDict = PyDict;
+class PyFile {
+    constructor(path, mode) {
+        this.path = path;
+        this.mode = mode;
+        this.handle = null;
+    }
+    open() {
+        if (this.handle !== null)
+            return;
+        if (this.mode.includes('w')) {
+            this.handle = fs.openSync(this.path, 'w');
+        }
+        else if (this.mode.includes('r')) {
+            this.handle = fs.openSync(this.path, 'r');
+        }
+        else {
+            this.handle = fs.openSync(this.path, 'r');
+        }
+    }
+    write(data) {
+        this.open();
+        if (this.handle === null)
+            return;
+        fs.writeSync(this.handle, data);
+    }
+    read() {
+        if (this.mode.includes('r')) {
+            return fs.readFileSync(this.path, 'utf8');
+        }
+        return '';
+    }
+    close() {
+        if (this.handle !== null) {
+            fs.closeSync(this.handle);
+            this.handle = null;
+        }
+    }
+    __enter__() {
+        this.open();
+        return this;
+    }
+    __exit__() {
+        this.close();
+        return false;
+    }
+}
+exports.PyFile = PyFile;
+//# sourceMappingURL=runtime-types.js.map

package/dist/vm/statements.d.ts

@@ -0,0 +1,7 @@
+import type { VirtualMachine } from './vm';
+import { Scope } from './runtime-types';
+export declare function executeStatement(this: VirtualMachine, node: any, scope: Scope): any;
+export declare function assignTarget(this: VirtualMachine, target: any, value: any, scope: Scope): void;
+export declare function toIterableArray(this: VirtualMachine, value: any): any[];
+export declare function deleteTarget(this: VirtualMachine, target: any, scope: Scope): void;
+//# sourceMappingURL=statements.d.ts.map

package/dist/vm/statements.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeStatement = executeStatement;
+exports.assignTarget = assignTarget;
+exports.toIterableArray = toIterableArray;
+exports.deleteTarget = deleteTarget;
+const types_1 = require("../types");
+const runtime_types_1 = require("./runtime-types");
+const runtime_types_2 = require("./runtime-types");
+function executeStatement(node, scope) {
+    switch (node.type) {
+        case types_1.ASTNodeType.EXPRESSION_STATEMENT:
+            return this.evaluateExpression(node.expression, scope);
+        case types_1.ASTNodeType.IMPORT_STATEMENT: {
+            for (const entry of node.names) {
+                const module = this.importModule(entry.name, scope);
+                const bindingName = entry.alias || entry.name.split('.')[0];
+                scope.set(bindingName, module);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.ASSIGNMENT: {
+            const value = this.evaluateExpression(node.value, scope);
+            for (const target of node.targets) {
+                this.assignTarget(target, value, scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.AUG_ASSIGNMENT: {
+            const current = this.evaluateExpression(node.target, scope);
+            const value = this.evaluateExpression(node.value, scope);
+            const result = this.applyBinary(node.operator.slice(0, -1), current, value);
+            this.assignTarget(node.target, result, scope);
+            return null;
+        }
+        case types_1.ASTNodeType.IF_STATEMENT: {
+            if (this.isTruthy(this.evaluateExpression(node.test, scope), scope)) {
+                return this.executeBlock(node.body, scope);
+            }
+            for (const branch of node.elifs) {
+                if (this.isTruthy(this.evaluateExpression(branch.test, scope), scope)) {
+                    return this.executeBlock(branch.body, scope);
+                }
+            }
+            if (node.orelse?.length) {
+                return this.executeBlock(node.orelse, scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.WHILE_STATEMENT: {
+            while (this.isTruthy(this.evaluateExpression(node.test, scope), scope)) {
+                try {
+                    this.executeBlock(node.body, scope);
+                }
+                catch (err) {
+                    if (err instanceof runtime_types_1.BreakSignal)
+                        break;
+                    if (err instanceof runtime_types_1.ContinueSignal)
+                        continue;
+                    throw err;
+                }
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.FOR_STATEMENT: {
+            const iterable = this.evaluateExpression(node.iter, scope);
+            const items = this.iterableToArray(iterable);
+            for (const item of items) {
+                this.assignTarget(node.target, item, scope);
+                try {
+                    this.executeBlock(node.body, scope);
+                }
+                catch (err) {
+                    if (err instanceof runtime_types_1.BreakSignal)
+                        break;
+                    if (err instanceof runtime_types_1.ContinueSignal)
+                        continue;
+                    throw err;
+                }
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.MATCH_STATEMENT: {
+            const subject = this.evaluateExpression(node.subject, scope);
+            for (const matchCase of node.cases) {
+                const result = this.matchPattern(matchCase.pattern, subject, scope);
+                if (!result.matched)
+                    continue;
+                if (matchCase.guard) {
+                    const guardScope = new runtime_types_1.Scope(scope);
+                    this.applyBindings(result.bindings, guardScope);
+                    if (!this.isTruthy(this.evaluateExpression(matchCase.guard, guardScope), guardScope))
+                        continue;
+                }
+                this.applyBindings(result.bindings, scope);
+                return this.executeBlock(matchCase.body, scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.FUNCTION_DEF: {
+            const params = (node.params || []).map((param) => {
+                if (param.type === 'Param' && param.defaultValue) {
+                    return { ...param, defaultEvaluated: this.evaluateExpression(param.defaultValue, scope) };
+                }
+                return param;
+            });
+            const fn = new runtime_types_1.PyFunction(node.name, params, node.body, scope, this.containsYield(node.body));
+            scope.set(node.name, fn);
+            if (node.decorators && node.decorators.length > 0) {
+                let decorated = fn;
+                for (const decorator of node.decorators.reverse()) {
+                    const decFn = this.evaluateExpression(decorator, scope);
+                    decorated = this.callFunction(decFn, [decorated], scope);
+                }
+                scope.set(node.name, decorated);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.CLASS_DEF: {
+            const bases = node.bases?.map((b) => this.evaluateExpression(b, scope)) || [];
+            const classScope = new runtime_types_1.Scope(scope);
+            this.executeBlock(node.body, classScope);
+            const attributes = new Map(classScope.values.entries());
+            const isException = bases.some((b) => b instanceof runtime_types_1.PyClass && b.isException);
+            const klass = new runtime_types_1.PyClass(node.name, bases, attributes, isException);
+            scope.set(node.name, klass);
+            if (node.decorators && node.decorators.length > 0) {
+                let decorated = klass;
+                for (const decorator of node.decorators.reverse()) {
+                    const decFn = this.evaluateExpression(decorator, scope);
+                    decorated = this.callFunction(decFn, [decorated], scope);
+                }
+                scope.set(node.name, decorated);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.RETURN_STATEMENT:
+            throw new runtime_types_1.ReturnSignal(node.value ? this.evaluateExpression(node.value, scope) : null);
+        case types_1.ASTNodeType.BREAK_STATEMENT:
+            throw new runtime_types_1.BreakSignal();
+        case types_1.ASTNodeType.CONTINUE_STATEMENT:
+            throw new runtime_types_1.ContinueSignal();
+        case types_1.ASTNodeType.PASS_STATEMENT:
+            return null;
+        case types_1.ASTNodeType.ASSERT_STATEMENT: {
+            const test = this.evaluateExpression(node.test, scope);
+            if (!this.isTruthy(test, scope)) {
+                const message = node.message ? this.evaluateExpression(node.message, scope) : 'Assertion failed';
+                throw new runtime_types_1.PyException('AssertionError', String(message));
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.RAISE_STATEMENT: {
+            const exc = node.exception ? this.evaluateExpression(node.exception, scope) : null;
+            if (exc instanceof runtime_types_1.PyException)
+                throw exc;
+            if (exc instanceof runtime_types_1.PyInstance && exc.klass.isException) {
+                const message = exc.attributes.get('message');
+                throw new runtime_types_1.PyException(exc.klass.name, message ? String(message) : exc.klass.name, exc);
+            }
+            if (exc instanceof runtime_types_1.PyClass && exc.isException) {
+                throw new runtime_types_1.PyException(exc.name, exc.name);
+            }
+            throw new runtime_types_1.PyException('Exception', exc ? String(exc) : 'Exception');
+        }
+        case types_1.ASTNodeType.TRY_STATEMENT: {
+            try {
+                this.executeBlock(node.body, scope);
+            }
+            catch (err) {
+                let handled = false;
+                for (const handler of node.handlers) {
+                    if (!handler.exceptionType) {
+                        handled = true;
+                    }
+                    else if (err instanceof runtime_types_1.PyException) {
+                        const expected = this.evaluateExpression(handler.exceptionType, scope);
+                        if (expected instanceof runtime_types_1.PyClass && expected.isException && err.pyType === expected.name) {
+                            handled = true;
+                        }
+                        else if (expected instanceof runtime_types_1.PyInstance && expected.klass.isException && err.pyType === expected.klass.name) {
+                            handled = true;
+                        }
+                    }
+                    if (handled) {
+                        if (handler.name) {
+                            scope.set(handler.name, err instanceof runtime_types_1.PyException ? err : new runtime_types_1.PyException('Exception', String(err)));
+                        }
+                        this.executeBlock(handler.body, scope);
+                        break;
+                    }
+                }
+                if (!handled)
+                    throw err;
+            }
+            finally {
+                if (node.finalbody?.length) {
+                    this.executeBlock(node.finalbody, scope);
+                }
+            }
+            if (node.orelse?.length) {
+                this.executeBlock(node.orelse, scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.WITH_STATEMENT: {
+            for (const item of node.items) {
+                const ctx = this.evaluateExpression(item.context, scope);
+                const enter = this.getAttribute(ctx, '__enter__', scope);
+                const exit = this.getAttribute(ctx, '__exit__', scope);
+                const value = this.callFunction(enter, [], scope);
+                if (item.target) {
+                    this.assignTarget(item.target, value, scope);
+                }
+                try {
+                    this.executeBlock(node.body, scope);
+                }
+                catch (err) {
+                    this.callFunction(exit, [err], scope);
+                    throw err;
+                }
+                this.callFunction(exit, [null, null, null], scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.GLOBAL_STATEMENT:
+            for (const name of node.names)
+                scope.globals.add(name);
+            return null;
+        case types_1.ASTNodeType.NONLOCAL_STATEMENT:
+            for (const name of node.names)
+                scope.nonlocals.add(name);
+            return null;
+        case types_1.ASTNodeType.DELETE_STATEMENT:
+            this.deleteTarget(node.target, scope);
+            return null;
+        default:
+            throw new Error(`Unsupported statement type: ${node.type}`);
+    }
+}
+function assignTarget(target, value, scope) {
+    if (target.type === types_1.ASTNodeType.IDENTIFIER) {
+        scope.set(target.name, value);
+        return;
+    }
+    if (target.type === types_1.ASTNodeType.ATTRIBUTE) {
+        const obj = this.evaluateExpression(target.object, scope);
+        this.setAttribute(obj, target.name, value);
+        return;
+    }
+    if (target.type === types_1.ASTNodeType.SUBSCRIPT) {
+        const obj = this.evaluateExpression(target.object, scope);
+        let index;
+        if (target.index && target.index.type === types_1.ASTNodeType.SLICE) {
+            index = {
+                type: types_1.ASTNodeType.SLICE,
+                start: target.index.start ? this.evaluateExpression(target.index.start, scope) : null,
+                end: target.index.end ? this.evaluateExpression(target.index.end, scope) : null,
+                step: target.index.step ? this.evaluateExpression(target.index.step, scope) : null
+            };
+        }
+        else {
+            index = this.evaluateExpression(target.index, scope);
+        }
+        if (Array.isArray(obj)) {
+            if (index && index.type === types_1.ASTNodeType.SLICE) {
+                const start = index.start !== null ? index.start : null;
+                const end = index.end !== null ? index.end : null;
+                const step = index.step !== null ? index.step : null;
+                const stepValue = step !== null && step !== undefined ? step : 1;
+                const values = this.toIterableArray(value);
+                if (stepValue === 1) {
+                    const bounds = this.computeSliceBounds(obj.length, start, end, stepValue);
+                    obj.splice(bounds.start, bounds.end - bounds.start, ...values);
+                }
+                else {
+                    const indices = this.computeSliceIndices(obj.length, start, end, stepValue);
+                    if (values.length !== indices.length) {
+                        throw new runtime_types_1.PyException('ValueError', `attempt to assign sequence of size ${values.length} to extended slice of size ${indices.length}`);
+                    }
+                    for (let i = 0; i < indices.length; i++) {
+                        obj[indices[i]] = values[i];
+                    }
+                }
+            }
+            else {
+                obj[index] = value;
+            }
+            return;
+        }
+        if (obj instanceof runtime_types_2.PyDict) {
+            obj.set(index, value);
+            return;
+        }
+        throw new runtime_types_1.PyException('TypeError', 'unsupported subscript assignment');
+    }
+    if (target.type === types_1.ASTNodeType.TUPLE_LITERAL || target.type === types_1.ASTNodeType.LIST_LITERAL) {
+        const elements = target.elements;
+        const unpackValue = this.toIterableArray(value);
+        const starIndex = elements.findIndex((el) => el.type === types_1.ASTNodeType.STARRED);
+        if (starIndex === -1) {
+            for (let i = 0; i < elements.length; i++) {
+                this.assignTarget(elements[i], unpackValue[i], scope);
+            }
+            return;
+        }
+        const prefixCount = starIndex;
+        const suffixCount = elements.length - starIndex - 1;
+        if (unpackValue.length < prefixCount + suffixCount) {
+            throw new runtime_types_1.PyException('ValueError', 'not enough values to unpack');
+        }
+        for (let i = 0; i < prefixCount; i++) {
+            this.assignTarget(elements[i], unpackValue[i], scope);
+        }
+        const starTarget = elements[starIndex];
+        const middle = unpackValue.slice(prefixCount, unpackValue.length - suffixCount);
+        this.assignTarget(starTarget.target, middle, scope);
+        for (let i = 0; i < suffixCount; i++) {
+            const valueIndex = unpackValue.length - suffixCount + i;
+            const elementIndex = starIndex + 1 + i;
+            this.assignTarget(elements[elementIndex], unpackValue[valueIndex], scope);
+        }
+        return;
+    }
+    throw new runtime_types_1.PyException('TypeError', 'invalid assignment target');
+}
+function toIterableArray(value) {
+    if (Array.isArray(value))
+        return value;
+    if (value && typeof value[Symbol.iterator] === 'function') {
+        return Array.from(value);
+    }
+    throw new runtime_types_1.PyException('TypeError', 'cannot unpack non-iterable');
+}
+function deleteTarget(target, scope) {
+    if (target.type === types_1.ASTNodeType.SUBSCRIPT) {
+        const obj = this.evaluateExpression(target.object, scope);
+        let index;
+        if (target.index && target.index.type === types_1.ASTNodeType.SLICE) {
+            index = {
+                type: types_1.ASTNodeType.SLICE,
+                start: target.index.start ? this.evaluateExpression(target.index.start, scope) : null,
+                end: target.index.end ? this.evaluateExpression(target.index.end, scope) : null,
+                step: target.index.step ? this.evaluateExpression(target.index.step, scope) : null
+            };
+        }
+        else {
+            index = this.evaluateExpression(target.index, scope);
+        }
+        if (Array.isArray(obj)) {
+            if (index && index.type === types_1.ASTNodeType.SLICE) {
+                const start = index.start !== null ? index.start : null;
+                const end = index.end !== null ? index.end : null;
+                const step = index.step !== null ? index.step : null;
+                const stepValue = step !== null && step !== undefined ? step : 1;
+                if (stepValue === 1) {
+                    const bounds = this.computeSliceBounds(obj.length, start, end, stepValue);
+                    obj.splice(bounds.start, bounds.end - bounds.start);
+                }
+                else {
+                    const indices = this.computeSliceIndices(obj.length, start, end, stepValue);
+                    indices.sort((a, b) => b - a);
+                    for (const idx of indices) {
+                        obj.splice(idx, 1);
+                    }
+                }
+            }
+            else {
+                obj.splice(index, 1);
+            }
+            return;
+        }
+        if (obj instanceof runtime_types_2.PyDict) {
+            obj.delete(index);
+            return;
+        }
+        throw new runtime_types_1.PyException('TypeError', 'unsupported delete target');
+    }
+    throw new runtime_types_1.PyException('TypeError', 'unsupported delete target');
+}
+//# sourceMappingURL=statements.js.map

package/dist/vm/truthy.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualMachine } from './vm';
+import { Scope } from './runtime-types';
+export declare function isTruthy(this: VirtualMachine, value: any, scope: Scope): boolean;
+//# sourceMappingURL=truthy.d.ts.map