@lewin671/python-vm 0.1.0

package/dist/vm/execution.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+exports.executeBlock = executeBlock;
+exports.iterableToArray = iterableToArray;
+exports.matchValueEquals = matchValueEquals;
+exports.matchPattern = matchPattern;
+exports.applyBindings = applyBindings;
+exports.executeBlockGenerator = executeBlockGenerator;
+exports.executeStatementGenerator = executeStatementGenerator;
+const types_1 = require("../types");
+const runtime_types_1 = require("./runtime-types");
+const runtime_types_2 = require("./runtime-types");
+function execute(bytecode) {
+    if (!bytecode.ast) {
+        throw new Error('Bytecode missing AST');
+    }
+    const globalScope = new runtime_types_1.Scope();
+    this.installBuiltins(globalScope);
+    return this.executeBlock(bytecode.ast.body, globalScope);
+}
+function executeBlock(body, scope) {
+    let lastValue = null;
+    for (const stmt of body) {
+        lastValue = this.executeStatement(stmt, scope);
+    }
+    return lastValue;
+}
+function iterableToArray(iterable) {
+    if (iterable instanceof runtime_types_2.PyDict)
+        return Array.from(iterable.keys());
+    if (iterable instanceof Set)
+        return Array.from(iterable.values());
+    if (Array.isArray(iterable))
+        return iterable;
+    if (iterable && typeof iterable[Symbol.iterator] === 'function')
+        return Array.from(iterable);
+    throw new Error('Object is not iterable');
+}
+function matchValueEquals(left, right) {
+    if (Array.isArray(left) && Array.isArray(right)) {
+        if (left.length !== right.length)
+            return false;
+        for (let i = 0; i < left.length; i++) {
+            if (!matchValueEquals(left[i], right[i]))
+                return false;
+        }
+        return true;
+    }
+    if (left instanceof Map && right instanceof Map) {
+        if (left.size !== right.size)
+            return false;
+        for (const [k, v] of left.entries()) {
+            if (!right.has(k) || !matchValueEquals(v, right.get(k)))
+                return false;
+        }
+        return true;
+    }
+    return left === right;
+}
+function matchPattern(node, value, scope) {
+    switch (node.type) {
+        case types_1.ASTNodeType.MATCH_PATTERN_VALUE:
+            return { matched: matchValueEquals(value, this.evaluateExpression(node.value, scope)), bindings: new Map() };
+        case types_1.ASTNodeType.MATCH_PATTERN_WILDCARD:
+            return { matched: true, bindings: new Map() };
+        case types_1.ASTNodeType.MATCH_PATTERN_CAPTURE:
+            return { matched: true, bindings: new Map([[node.name, value]]) };
+        case types_1.ASTNodeType.MATCH_PATTERN_OR: {
+            for (const pattern of node.patterns || []) {
+                const result = this.matchPattern(pattern, value, scope);
+                if (result.matched)
+                    return result;
+            }
+            return { matched: false, bindings: new Map() };
+        }
+        case types_1.ASTNodeType.MATCH_PATTERN_SEQUENCE: {
+            const elements = node.elements || node.patterns;
+            if (!Array.isArray(value) || !elements || elements.length !== value.length) {
+                return { matched: false, bindings: new Map() };
+            }
+            const bindings = new Map();
+            for (let i = 0; i < elements.length; i++) {
+                const result = this.matchPattern(elements[i], value[i], scope);
+                if (!result.matched)
+                    return { matched: false, bindings: new Map() };
+                for (const [k, v] of result.bindings.entries())
+                    bindings.set(k, v);
+            }
+            return { matched: true, bindings };
+        }
+        case 'MatchValue':
+            return { matched: matchValueEquals(value, node.value), bindings: new Map() };
+        case 'MatchSingleton':
+            return { matched: value === node.value, bindings: new Map() };
+        case 'MatchSequence': {
+            if (!Array.isArray(value))
+                return { matched: false, bindings: new Map() };
+            if (!node.patterns || node.patterns.length !== value.length)
+                return { matched: false, bindings: new Map() };
+            const bindings = new Map();
+            for (let i = 0; i < node.patterns.length; i++) {
+                const result = this.matchPattern(node.patterns[i], value[i], scope);
+                if (!result.matched)
+                    return { matched: false, bindings: new Map() };
+                for (const [k, v] of result.bindings.entries())
+                    bindings.set(k, v);
+            }
+            return { matched: true, bindings };
+        }
+        case 'MatchMapping': {
+            if (!(value instanceof runtime_types_2.PyDict))
+                return { matched: false, bindings: new Map() };
+            const bindings = new Map();
+            for (const { key, pattern } of node.keys) {
+                if (!value.has(key))
+                    return { matched: false, bindings: new Map() };
+                const result = this.matchPattern(pattern, value.get(key), scope);
+                if (!result.matched)
+                    return { matched: false, bindings: new Map() };
+                for (const [k, v] of result.bindings.entries())
+                    bindings.set(k, v);
+            }
+            return { matched: true, bindings };
+        }
+        case 'MatchAs':
+            return {
+                matched: true,
+                bindings: node.name ? new Map([[node.name, value]]) : new Map(),
+            };
+        case 'MatchClass': {
+            if (!value || !value.klass || value.klass.name !== node.className)
+                return { matched: false, bindings: new Map() };
+            const bindings = new Map();
+            for (let i = 0; i < node.patterns.length; i++) {
+                const attrName = node.kwd_attrs[i] || node.patterns[i].name;
+                const attrValue = value.attributes.get(attrName);
+                const result = this.matchPattern(node.patterns[i], attrValue, scope);
+                if (!result.matched)
+                    return { matched: false, bindings: new Map() };
+                for (const [k, v] of result.bindings.entries())
+                    bindings.set(k, v);
+            }
+            return { matched: true, bindings };
+        }
+        default:
+            return { matched: false, bindings: new Map() };
+    }
+}
+function applyBindings(bindings, scope) {
+    for (const [name, value] of bindings.entries()) {
+        scope.set(name, value);
+    }
+}
+function* executeBlockGenerator(body, scope) {
+    for (const stmt of body) {
+        yield* this.executeStatementGenerator(stmt, scope);
+    }
+    return null;
+}
+function* executeStatementGenerator(node, scope) {
+    switch (node.type) {
+        case types_1.ASTNodeType.EXPRESSION_STATEMENT: {
+            if (this.expressionHasYield(node.expression)) {
+                yield* this.evaluateExpressionGenerator(node.expression, scope);
+                return null;
+            }
+            this.evaluateExpression(node.expression, scope);
+            return null;
+        }
+        case types_1.ASTNodeType.ASSIGNMENT: {
+            const value = this.expressionHasYield(node.value)
+                ? yield* this.evaluateExpressionGenerator(node.value, scope)
+                : this.evaluateExpression(node.value, scope);
+            for (const target of node.targets) {
+                this.assignTarget(target, value, scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.IF_STATEMENT: {
+            const test = this.expressionHasYield(node.test)
+                ? yield* this.evaluateExpressionGenerator(node.test, scope)
+                : this.evaluateExpression(node.test, scope);
+            if (this.isTruthy(test, scope)) {
+                yield* this.executeBlockGenerator(node.body, scope);
+                return null;
+            }
+            for (const branch of node.elifs) {
+                const branchTest = this.expressionHasYield(branch.test)
+                    ? yield* this.evaluateExpressionGenerator(branch.test, scope)
+                    : this.evaluateExpression(branch.test, scope);
+                if (this.isTruthy(branchTest, scope)) {
+                    yield* this.executeBlockGenerator(branch.body, scope);
+                    return null;
+                }
+            }
+            if (node.orelse?.length) {
+                yield* this.executeBlockGenerator(node.orelse, scope);
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.WHILE_STATEMENT: {
+            while (true) {
+                const test = this.expressionHasYield(node.test)
+                    ? yield* this.evaluateExpressionGenerator(node.test, scope)
+                    : this.evaluateExpression(node.test, scope);
+                if (!this.isTruthy(test, scope))
+                    break;
+                try {
+                    yield* this.executeBlockGenerator(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.expressionHasYield(node.iter)
+                ? yield* this.evaluateExpressionGenerator(node.iter, scope)
+                : this.evaluateExpression(node.iter, scope);
+            const items = this.iterableToArray(iterable);
+            for (const item of items) {
+                this.assignTarget(node.target, item, scope);
+                try {
+                    yield* this.executeBlockGenerator(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.expressionHasYield(node.subject)
+                ? yield* this.evaluateExpressionGenerator(node.subject, scope)
+                : 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);
+                    const guardValue = this.expressionHasYield(matchCase.guard)
+                        ? yield* this.evaluateExpressionGenerator(matchCase.guard, guardScope)
+                        : this.evaluateExpression(matchCase.guard, guardScope);
+                    if (!this.isTruthy(guardValue, scope))
+                        continue;
+                }
+                this.applyBindings(result.bindings, scope);
+                yield* this.executeBlockGenerator(matchCase.body, scope);
+                return null;
+            }
+            return null;
+        }
+        case types_1.ASTNodeType.RETURN_STATEMENT: {
+            const value = node.value
+                ? (this.expressionHasYield(node.value)
+                    ? yield* this.evaluateExpressionGenerator(node.value, scope)
+                    : this.evaluateExpression(node.value, scope))
+                : null;
+            throw new runtime_types_1.ReturnSignal(value);
+        }
+        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;
+        default:
+            return this.executeStatement(node, scope);
+    }
+}
+//# sourceMappingURL=execution.js.map

package/dist/vm/expression-generator.d.ts

@@ -0,0 +1,3 @@
+import type { VirtualMachine } from './vm';
+export declare function evaluateExpressionGenerator(this: VirtualMachine, node: any, scope: any): Generator<any, any, any>;
+//# sourceMappingURL=expression-generator.d.ts.map

package/dist/vm/expression-generator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpressionGenerator = evaluateExpressionGenerator;
+const types_1 = require("../types");
+function* evaluateExpressionGenerator(node, scope) {
+    switch (node.type) {
+        case types_1.ASTNodeType.YIELD: {
+            const value = node.value ? yield* this.evaluateExpressionGenerator(node.value, scope) : null;
+            const sent = yield value;
+            return sent;
+        }
+        case types_1.ASTNodeType.BINARY_OPERATION: {
+            const left = yield* this.evaluateExpressionGenerator(node.left, scope);
+            const right = yield* this.evaluateExpressionGenerator(node.right, scope);
+            return this.applyBinary(node.operator, left, right);
+        }
+        case types_1.ASTNodeType.UNARY_OPERATION: {
+            const operand = yield* this.evaluateExpressionGenerator(node.operand, scope);
+            return this.evaluateExpression({ ...node, operand }, scope);
+        }
+        case types_1.ASTNodeType.COMPARE: {
+            const left = yield* this.evaluateExpressionGenerator(node.left, scope);
+            const comparators = [];
+            for (const comp of node.comparators) {
+                comparators.push(yield* this.evaluateExpressionGenerator(comp, scope));
+            }
+            return this.evaluateExpression({ ...node, left, comparators }, scope);
+        }
+        case types_1.ASTNodeType.CALL: {
+            const callee = yield* this.evaluateExpressionGenerator(node.callee, scope);
+            const positional = [];
+            const kwargs = {};
+            for (const arg of node.args) {
+                if (arg.type === 'KeywordArg') {
+                    kwargs[arg.name] = yield* this.evaluateExpressionGenerator(arg.value, scope);
+                }
+                else if (arg.type === 'StarArg') {
+                    const value = yield* this.evaluateExpressionGenerator(arg.value, scope);
+                    positional.push(...(Array.isArray(value) ? value : Array.from(value)));
+                }
+                else if (arg.type === 'KwArg') {
+                    const value = yield* this.evaluateExpressionGenerator(arg.value, scope);
+                    Object.assign(kwargs, value);
+                }
+                else {
+                    positional.push(yield* this.evaluateExpressionGenerator(arg, scope));
+                }
+            }
+            return this.callFunction(callee, positional, scope, kwargs);
+        }
+        case types_1.ASTNodeType.ATTRIBUTE: {
+            const obj = yield* this.evaluateExpressionGenerator(node.object, scope);
+            return this.getAttribute(obj, node.name, scope);
+        }
+        case types_1.ASTNodeType.SUBSCRIPT: {
+            const obj = yield* this.evaluateExpressionGenerator(node.object, scope);
+            const index = yield* this.evaluateExpressionGenerator(node.index, scope);
+            return this.getSubscript(obj, index);
+        }
+        case types_1.ASTNodeType.IF_EXPRESSION: {
+            const test = yield* this.evaluateExpressionGenerator(node.test, scope);
+            return this.isTruthy(test, scope)
+                ? yield* this.evaluateExpressionGenerator(node.consequent, scope)
+                : yield* this.evaluateExpressionGenerator(node.alternate, scope);
+        }
+        default:
+            return this.evaluateExpression(node, scope);
+    }
+}
+//# sourceMappingURL=expression-generator.js.map

package/dist/vm/expressions.d.ts

@@ -0,0 +1,13 @@
+import type { VirtualMachine } from './vm';
+import { Scope } from './runtime-types';
+export declare function evaluateExpression(this: VirtualMachine, node: any, scope: Scope): any;
+export declare function evaluateExpressionString(this: VirtualMachine, expr: string, scope: Scope): any;
+export declare function executeExpressionInline(this: VirtualMachine, expr: string, scope: Scope): any;
+export declare function applyFormatSpec(this: VirtualMachine, value: any, spec: string): string;
+export declare function splitFormatSpec(expr: string): {
+    rawExpr: string;
+    rawSpec: string;
+};
+export declare function applyWidth(text: string, spec: string): string;
+export declare function contains(this: VirtualMachine, container: any, value: any): boolean;
+//# sourceMappingURL=expressions.d.ts.map