@lewin671/python-vm 0.1.0

package/dist/vm/expressions.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = evaluateExpression;
+exports.evaluateExpressionString = evaluateExpressionString;
+exports.executeExpressionInline = executeExpressionInline;
+exports.applyFormatSpec = applyFormatSpec;
+exports.splitFormatSpec = splitFormatSpec;
+exports.applyWidth = applyWidth;
+exports.contains = contains;
+const types_1 = require("../types");
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const runtime_types_1 = require("./runtime-types");
+const value_utils_1 = require("./value-utils");
+function evaluateExpression(node, scope) {
+    switch (node.type) {
+        case types_1.ASTNodeType.NUMBER_LITERAL: {
+            const raw = node.value;
+            if (typeof raw === 'number')
+                return raw;
+            if (typeof raw === 'string' && raw.endsWith('j')) {
+                const imag = parseFloat(raw.slice(0, -1));
+                return { __complex__: true, re: 0, im: imag };
+            }
+            if (raw.includes('.'))
+                return new Number(parseFloat(raw));
+            const big = BigInt(raw);
+            const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+            const minSafe = BigInt(Number.MIN_SAFE_INTEGER);
+            if (big > maxSafe || big < minSafe)
+                return big;
+            return Number(raw);
+        }
+        case types_1.ASTNodeType.STRING_LITERAL: {
+            const { value, isFString } = (0, value_utils_1.parseStringToken)(node.value);
+            if (isFString) {
+                return value.replace(/\{([^}]+)\}/g, (_m, expr) => {
+                    const { rawExpr, rawSpec } = this.splitFormatSpec(expr);
+                    const inner = this.evaluateExpressionString(rawExpr.trim(), scope);
+                    const formatted = this.applyFormatSpec(inner, rawSpec ? rawSpec.trim() : '');
+                    return formatted;
+                });
+            }
+            return value;
+        }
+        case types_1.ASTNodeType.BOOLEAN_LITERAL:
+            return node.value;
+        case types_1.ASTNodeType.NONE_LITERAL:
+            return null;
+        case types_1.ASTNodeType.IDENTIFIER:
+            return scope.get(node.name);
+        case types_1.ASTNodeType.LIST_LITERAL:
+            return node.elements.map((el) => this.evaluateExpression(el, scope));
+        case types_1.ASTNodeType.LIST_COMP: {
+            const result = [];
+            const compScope = new runtime_types_1.Scope(scope);
+            this.evaluateComprehension(node.comprehension, compScope, () => {
+                result.push(this.evaluateExpression(node.expression, compScope));
+            });
+            return result;
+        }
+        case types_1.ASTNodeType.TUPLE_LITERAL: {
+            const arr = node.elements.map((el) => this.evaluateExpression(el, scope));
+            arr.__tuple__ = true;
+            return arr;
+        }
+        case types_1.ASTNodeType.SET_COMP: {
+            const result = new Set();
+            const compScope = new runtime_types_1.Scope(scope);
+            this.evaluateComprehension(node.comprehension, compScope, () => {
+                result.add(this.evaluateExpression(node.expression, compScope));
+            });
+            return result;
+        }
+        case types_1.ASTNodeType.SET_LITERAL:
+            return new Set(node.elements.map((el) => this.evaluateExpression(el, scope)));
+        case types_1.ASTNodeType.DICT_LITERAL: {
+            const map = new runtime_types_1.PyDict();
+            for (const entry of node.entries) {
+                map.set(this.evaluateExpression(entry.key, scope), this.evaluateExpression(entry.value, scope));
+            }
+            return map;
+        }
+        case types_1.ASTNodeType.DICT_COMP: {
+            const map = new runtime_types_1.PyDict();
+            const compScope = new runtime_types_1.Scope(scope);
+            this.evaluateComprehension(node.comprehension, compScope, () => {
+                map.set(this.evaluateExpression(node.key, compScope), this.evaluateExpression(node.value, compScope));
+            });
+            return map;
+        }
+        case types_1.ASTNodeType.GENERATOR_EXPR: {
+            const self = this;
+            const compScope = new runtime_types_1.Scope(scope);
+            const iterator = function* () {
+                yield* self.generateComprehension(node.comprehension, compScope, () => self.evaluateExpression(node.expression, compScope));
+            };
+            return new runtime_types_1.PyGenerator(iterator());
+        }
+        case types_1.ASTNodeType.BINARY_OPERATION: {
+            const left = this.evaluateExpression(node.left, scope);
+            const right = this.evaluateExpression(node.right, scope);
+            return this.applyBinary(node.operator, left, right);
+        }
+        case types_1.ASTNodeType.UNARY_OPERATION: {
+            const operand = this.evaluateExpression(node.operand, scope);
+            switch (node.operator) {
+                case 'not':
+                    return !this.isTruthy(operand, scope);
+                case '+':
+                    return typeof operand === 'bigint' ? operand : +operand;
+                case '-':
+                    if ((0, value_utils_1.isIntObject)(operand)) {
+                        const boxed = new Number(-operand.valueOf());
+                        boxed.__int__ = true;
+                        return boxed;
+                    }
+                    if ((0, value_utils_1.isFloatObject)(operand))
+                        return new Number(-operand.valueOf());
+                    return -operand;
+                case '~':
+                    return ~operand;
+                default:
+                    throw new runtime_types_1.PyException('TypeError', `unsupported unary operator ${node.operator}`);
+            }
+        }
+        case types_1.ASTNodeType.BOOL_OPERATION: {
+            if (node.operator === 'and') {
+                const left = this.evaluateExpression(node.values[0], scope);
+                return this.isTruthy(left, scope) ? this.evaluateExpression(node.values[1], scope) : left;
+            }
+            const left = this.evaluateExpression(node.values[0], scope);
+            return this.isTruthy(left, scope) ? left : this.evaluateExpression(node.values[1], scope);
+        }
+        case types_1.ASTNodeType.COMPARE: {
+            let left = this.evaluateExpression(node.left, scope);
+            for (let i = 0; i < node.ops.length; i++) {
+                const op = node.ops[i];
+                const right = this.evaluateExpression(node.comparators[i], scope);
+                let result = false;
+                switch (op) {
+                    case '==':
+                        result = (0, value_utils_1.numericEquals)(left, right);
+                        break;
+                    case '!=':
+                        result = !(0, value_utils_1.numericEquals)(left, right);
+                        break;
+                    case '<': {
+                        const numeric = (0, value_utils_1.numericCompare)(left, right);
+                        if (numeric) {
+                            if (numeric.kind === 'float') {
+                                result =
+                                    !Number.isNaN(numeric.left) && !Number.isNaN(numeric.right) && numeric.left < numeric.right;
+                            }
+                            else {
+                                result = numeric.left < numeric.right;
+                            }
+                        }
+                        else {
+                            result = left < right;
+                        }
+                        break;
+                    }
+                    case '>': {
+                        const numeric = (0, value_utils_1.numericCompare)(left, right);
+                        if (numeric) {
+                            if (numeric.kind === 'float') {
+                                result =
+                                    !Number.isNaN(numeric.left) && !Number.isNaN(numeric.right) && numeric.left > numeric.right;
+                            }
+                            else {
+                                result = numeric.left > numeric.right;
+                            }
+                        }
+                        else {
+                            result = left > right;
+                        }
+                        break;
+                    }
+                    case '<=': {
+                        const numeric = (0, value_utils_1.numericCompare)(left, right);
+                        if (numeric) {
+                            if (numeric.kind === 'float') {
+                                result =
+                                    !Number.isNaN(numeric.left) && !Number.isNaN(numeric.right) && numeric.left <= numeric.right;
+                            }
+                            else {
+                                result = numeric.left <= numeric.right;
+                            }
+                        }
+                        else {
+                            result = left <= right;
+                        }
+                        break;
+                    }
+                    case '>=': {
+                        const numeric = (0, value_utils_1.numericCompare)(left, right);
+                        if (numeric) {
+                            if (numeric.kind === 'float') {
+                                result =
+                                    !Number.isNaN(numeric.left) && !Number.isNaN(numeric.right) && numeric.left >= numeric.right;
+                            }
+                            else {
+                                result = numeric.left >= numeric.right;
+                            }
+                        }
+                        else {
+                            result = left >= right;
+                        }
+                        break;
+                    }
+                    case 'in':
+                        result = this.contains(right, left);
+                        break;
+                    case 'not in':
+                        result = !this.contains(right, left);
+                        break;
+                    case 'is':
+                        result = left === right;
+                        break;
+                    case 'is not':
+                        result = left !== right;
+                        break;
+                    default:
+                        throw new runtime_types_1.PyException('TypeError', `unsupported comparison ${op}`);
+                }
+                if (!result)
+                    return false;
+                left = right;
+            }
+            return true;
+        }
+        case types_1.ASTNodeType.CALL: {
+            const callee = this.evaluateExpression(node.callee, scope);
+            const positional = [];
+            const kwargs = {};
+            for (const arg of node.args) {
+                if (arg.type === 'KeywordArg') {
+                    kwargs[arg.name] = this.evaluateExpression(arg.value, scope);
+                }
+                else if (arg.type === 'StarArg') {
+                    const value = this.evaluateExpression(arg.value, scope);
+                    positional.push(...(Array.isArray(value) ? value : Array.from(value)));
+                }
+                else if (arg.type === 'KwArg') {
+                    const value = this.evaluateExpression(arg.value, scope);
+                    Object.assign(kwargs, value);
+                }
+                else {
+                    positional.push(this.evaluateExpression(arg, scope));
+                }
+            }
+            return this.callFunction(callee, positional, scope, kwargs);
+        }
+        case types_1.ASTNodeType.ATTRIBUTE: {
+            const obj = this.evaluateExpression(node.object, scope);
+            return this.getAttribute(obj, node.name, scope);
+        }
+        case types_1.ASTNodeType.SUBSCRIPT: {
+            const obj = this.evaluateExpression(node.object, scope);
+            if (node.index && node.index.type === types_1.ASTNodeType.SLICE) {
+                const slice = {
+                    type: types_1.ASTNodeType.SLICE,
+                    start: node.index.start ? this.evaluateExpression(node.index.start, scope) : null,
+                    end: node.index.end ? this.evaluateExpression(node.index.end, scope) : null,
+                    step: node.index.step ? this.evaluateExpression(node.index.step, scope) : null,
+                };
+                return this.getSubscript(obj, slice);
+            }
+            const index = this.evaluateExpression(node.index, scope);
+            return this.getSubscript(obj, index);
+        }
+        case types_1.ASTNodeType.IF_EXPRESSION: {
+            const test = this.evaluateExpression(node.test, scope);
+            return this.isTruthy(test, scope)
+                ? this.evaluateExpression(node.consequent, scope)
+                : this.evaluateExpression(node.alternate, scope);
+        }
+        case types_1.ASTNodeType.LAMBDA: {
+            return new runtime_types_1.PyFunction('<lambda>', node.params.map((p) => ({ type: 'Param', name: p })), [
+                {
+                    type: types_1.ASTNodeType.RETURN_STATEMENT,
+                    value: node.body,
+                },
+            ], scope, false);
+        }
+        default:
+            throw new Error(`Unsupported expression type: ${node.type}`);
+    }
+}
+function evaluateExpressionString(expr, scope) {
+    const wrapped = `__f = ${expr}\n`;
+    const tokens = new lexer_1.Lexer(wrapped).tokenize();
+    const ast = new parser_1.Parser(tokens).parse();
+    const assignment = ast.body[0];
+    if (!assignment || assignment.type !== types_1.ASTNodeType.ASSIGNMENT) {
+        return this.executeExpressionInline(expr, scope);
+    }
+    return this.evaluateExpression(assignment.value, scope);
+}
+function executeExpressionInline(expr, scope) {
+    const tokens = expr.trim().split(/\s+/);
+    if (tokens.length === 1 && scope.values.has(tokens[0])) {
+        return scope.get(tokens[0]);
+    }
+    return expr;
+}
+function applyFormatSpec(value, spec) {
+    if (!spec)
+        return (0, value_utils_1.pyStr)(value);
+    if (spec.endsWith('%')) {
+        const digits = spec.includes('.') ? parseInt(spec.split('.')[1], 10) : 0;
+        const num = (0, value_utils_1.isNumericLike)(value) ? (0, value_utils_1.toNumber)(value) : parseFloat(value);
+        return (num * 100).toFixed(digits) + '%';
+    }
+    if (spec.includes('.')) {
+        const parts = spec.split('.');
+        const width = parts[0];
+        const precision = parseInt(parts[1].replace(/[^\d]/g, ''), 10);
+        const num = (0, value_utils_1.isNumericLike)(value) ? (0, value_utils_1.toNumber)(value) : parseFloat(value);
+        const formatted = num.toFixed(precision);
+        return this.applyWidth(formatted, width);
+    }
+    if (spec === 'd')
+        return typeof value === 'bigint' ? value.toString() : String(parseInt(value, 10));
+    if (spec === 'b')
+        return typeof value === 'bigint' ? value.toString(2) : Number(value).toString(2);
+    if (spec === 'x')
+        return typeof value === 'bigint' ? value.toString(16) : Number(value).toString(16);
+    if (spec === 'o')
+        return typeof value === 'bigint' ? value.toString(8) : Number(value).toString(8);
+    return this.applyWidth(String(value), spec);
+}
+function splitFormatSpec(expr) {
+    let depth = 0;
+    for (let i = 0; i < expr.length; i++) {
+        const ch = expr[i];
+        if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        if (ch === ')' || ch === ']' || ch === '}')
+            depth = Math.max(0, depth - 1);
+        if (ch === ':' && depth === 0) {
+            return { rawExpr: expr.slice(0, i), rawSpec: expr.slice(i + 1) };
+        }
+    }
+    return { rawExpr: expr, rawSpec: '' };
+}
+function applyWidth(text, spec) {
+    const match = spec.match(/([<^>])?(\d+)/);
+    if (!match)
+        return text;
+    const align = match[1] || '>';
+    const width = parseInt(match[2], 10);
+    if (text.length >= width)
+        return text;
+    const padding = width - text.length;
+    if (align === '<')
+        return text + ' '.repeat(padding);
+    if (align === '^') {
+        const left = Math.floor(padding / 2);
+        const right = padding - left;
+        return ' '.repeat(left) + text + ' '.repeat(right);
+    }
+    return ' '.repeat(padding) + text;
+}
+function contains(container, value) {
+    if (Array.isArray(container)) {
+        if ((0, value_utils_1.isNumericLike)(value)) {
+            return container.some((item) => (0, value_utils_1.isNumericLike)(item) && (0, value_utils_1.numericEquals)(item, value));
+        }
+        return container.includes(value);
+    }
+    if (typeof container === 'string')
+        return container.includes(value);
+    if (container instanceof Set) {
+        if (container.has(value))
+            return true;
+        if ((0, value_utils_1.isNumericLike)(value)) {
+            for (const item of container.values()) {
+                if ((0, value_utils_1.isNumericLike)(item) && (0, value_utils_1.numericEquals)(item, value))
+                    return true;
+            }
+        }
+        return false;
+    }
+    if (container instanceof runtime_types_1.PyDict)
+        return container.has(value);
+    return false;
+}
+//# sourceMappingURL=expressions.js.map

package/dist/vm/imports.d.ts

@@ -0,0 +1,7 @@
+import type { VirtualMachine } from './vm';
+import { Scope } from './runtime-types';
+export declare function importModule(this: VirtualMachine, name: string, scope: Scope): any;
+export declare function createAsyncioModule(this: VirtualMachine, scope: Scope): any;
+export declare function loadModuleFromFile(this: VirtualMachine, name: string, scope: Scope): any;
+export declare function resolveModulePath(this: VirtualMachine, name: string): string | null;
+//# sourceMappingURL=imports.d.ts.map

package/dist/vm/imports.js

@@ -0,0 +1,99 @@
+"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.importModule = importModule;
+exports.createAsyncioModule = createAsyncioModule;
+exports.loadModuleFromFile = loadModuleFromFile;
+exports.resolveModulePath = resolveModulePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const runtime_types_1 = require("./runtime-types");
+function importModule(name, scope) {
+    if (this.moduleCache.has(name)) {
+        return this.moduleCache.get(name);
+    }
+    let module;
+    if (name === 'asyncio') {
+        module = this.createAsyncioModule(scope);
+    }
+    else {
+        module = this.loadModuleFromFile(name, scope);
+    }
+    this.moduleCache.set(name, module);
+    return module;
+}
+function createAsyncioModule(scope) {
+    return {
+        __name__: 'asyncio',
+        run: (value) => {
+            if (value instanceof runtime_types_1.PyFunction) {
+                return this.callFunction(value, [], scope);
+            }
+            if (value instanceof runtime_types_1.PyGenerator) {
+                return value.next();
+            }
+            return value;
+        }
+    };
+}
+function loadModuleFromFile(name, scope) {
+    const modulePath = this.resolveModulePath(name);
+    if (!modulePath) {
+        throw new runtime_types_1.PyException('ImportError', `No module named '${name}'`);
+    }
+    const code = fs.readFileSync(modulePath, 'utf-8');
+    const lexer = new lexer_1.Lexer(code);
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens);
+    const ast = parser.parse();
+    const moduleScope = new runtime_types_1.Scope(scope.root());
+    moduleScope.set('__name__', name);
+    this.executeBlock(ast.body, moduleScope);
+    return { __name__: name, __moduleScope__: moduleScope };
+}
+function resolveModulePath(name) {
+    for (const basePath of this.moduleSearchPaths) {
+        const directPath = path.join(basePath, `${name}.py`);
+        if (fs.existsSync(directPath))
+            return directPath;
+        const initPath = path.join(basePath, name, '__init__.py');
+        if (fs.existsSync(initPath))
+            return initPath;
+    }
+    return null;
+}
+//# sourceMappingURL=imports.js.map

package/dist/vm/index.d.ts

@@ -0,0 +1,3 @@
+export { VirtualMachine } from './vm';
+export * from './runtime-types';
+//# sourceMappingURL=index.d.ts.map

package/dist/vm/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualMachine = void 0;
+var vm_1 = require("./vm");
+Object.defineProperty(exports, "VirtualMachine", { enumerable: true, get: function () { return vm_1.VirtualMachine; } });
+__exportStar(require("./runtime-types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/vm/operations.d.ts

@@ -0,0 +1,16 @@
+import type { VirtualMachine } from './vm';
+import { PyClass, Scope } from './runtime-types';
+export declare function applyBinary(this: VirtualMachine, op: string, left: any, right: any): any;
+export declare function formatPercent(this: VirtualMachine, format: string, value: any): string;
+export declare function getSubscript(this: VirtualMachine, obj: any, index: any): any;
+export declare function computeSliceBounds(this: VirtualMachine, length: number, start: any, end: any, step: any): {
+    start: number;
+    end: number;
+    step: number;
+};
+export declare function computeSliceIndices(this: VirtualMachine, length: number, start: any, end: any, step: any): number[];
+export declare function normalizeSliceStep(step: any): number;
+export declare function getAttribute(this: VirtualMachine, obj: any, name: string, scope: Scope): any;
+export declare function setAttribute(this: VirtualMachine, obj: any, name: string, value: any): void;
+export declare function findClassAttribute(klass: PyClass, name: string): any;
+//# sourceMappingURL=operations.d.ts.map