@lewin671/python-vm 0.1.0

package/dist/vm/operations.js

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyBinary = applyBinary;
+exports.formatPercent = formatPercent;
+exports.getSubscript = getSubscript;
+exports.computeSliceBounds = computeSliceBounds;
+exports.computeSliceIndices = computeSliceIndices;
+exports.normalizeSliceStep = normalizeSliceStep;
+exports.getAttribute = getAttribute;
+exports.setAttribute = setAttribute;
+exports.findClassAttribute = findClassAttribute;
+const types_1 = require("../types");
+const runtime_types_1 = require("./runtime-types");
+const value_utils_1 = require("./value-utils");
+function applyBinary(op, left, right) {
+    if ((0, value_utils_1.isComplex)(left) || (0, value_utils_1.isComplex)(right)) {
+        const a = (0, value_utils_1.toComplex)(left);
+        const b = (0, value_utils_1.toComplex)(right);
+        switch (op) {
+            case '+':
+                return { __complex__: true, re: a.re + b.re, im: a.im + b.im };
+            case '-':
+                return { __complex__: true, re: a.re - b.re, im: a.im - b.im };
+            case '*':
+                return {
+                    __complex__: true,
+                    re: a.re * b.re - a.im * b.im,
+                    im: a.re * b.im + a.im * b.re,
+                };
+            default:
+                throw new runtime_types_1.PyException('TypeError', `unsupported complex operator ${op}`);
+        }
+    }
+    switch (op) {
+        case '+':
+            if (Array.isArray(left) && Array.isArray(right)) {
+                const result = [...left, ...right];
+                if (left.__tuple__ && right.__tuple__) {
+                    result.__tuple__ = true;
+                }
+                return result;
+            }
+            if ((0, value_utils_1.isFloatLike)(left) || (0, value_utils_1.isFloatLike)(right)) {
+                return new Number((0, value_utils_1.toNumber)(left) + (0, value_utils_1.toNumber)(right));
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) + (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left + right;
+        case '-':
+            if (left instanceof Set && right instanceof Set) {
+                const result = new Set(left);
+                for (const item of right.values())
+                    result.delete(item);
+                return result;
+            }
+            if ((0, value_utils_1.isFloatLike)(left) || (0, value_utils_1.isFloatLike)(right)) {
+                return new Number((0, value_utils_1.toNumber)(left) - (0, value_utils_1.toNumber)(right));
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) - (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left - right;
+        case '*':
+            if (typeof left === 'string' && (0, value_utils_1.isIntLike)(right)) {
+                const count = (0, value_utils_1.toNumber)(right);
+                if (count <= 0)
+                    return '';
+                return left.repeat(count);
+            }
+            if (typeof right === 'string' && (0, value_utils_1.isIntLike)(left)) {
+                const count = (0, value_utils_1.toNumber)(left);
+                if (count <= 0)
+                    return '';
+                return right.repeat(count);
+            }
+            if (Array.isArray(left) && (0, value_utils_1.isIntLike)(right)) {
+                const count = (0, value_utils_1.toNumber)(right);
+                if (count <= 0) {
+                    const result = [];
+                    if (left.__tuple__) {
+                        result.__tuple__ = true;
+                    }
+                    return result;
+                }
+                const result = Array(count).fill(null).flatMap(() => left);
+                if (left.__tuple__) {
+                    result.__tuple__ = true;
+                }
+                return result;
+            }
+            if ((0, value_utils_1.isFloatLike)(left) || (0, value_utils_1.isFloatLike)(right)) {
+                return new Number((0, value_utils_1.toNumber)(left) * (0, value_utils_1.toNumber)(right));
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) * (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left * right;
+        case '/':
+            if (right === 0 || right === 0n)
+                throw new runtime_types_1.PyException('ZeroDivisionError', 'division by zero');
+            return new Number((0, value_utils_1.toNumber)(left) / (0, value_utils_1.toNumber)(right));
+        case '//':
+            if (right === 0 || right === 0n)
+                throw new runtime_types_1.PyException('ZeroDivisionError', 'division by zero');
+            if ((0, value_utils_1.isFloatLike)(left) || (0, value_utils_1.isFloatLike)(right)) {
+                return new Number(Math.floor((0, value_utils_1.toNumber)(left) / (0, value_utils_1.toNumber)(right)));
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.bigIntFloorDiv)((0, value_utils_1.toBigIntValue)(left), (0, value_utils_1.toBigIntValue)(right));
+            }
+            return Math.floor(left / right);
+        case '%':
+            if (typeof left === 'string') {
+                return this.formatPercent(left, right);
+            }
+            return (0, value_utils_1.pythonModulo)(left, right);
+        case '**':
+            if ((0, value_utils_1.isIntLike)(left) && (0, value_utils_1.isIntLike)(right) && !(0, value_utils_1.isFloatLike)(left) && !(0, value_utils_1.isFloatLike)(right)) {
+                const exponentNum = (0, value_utils_1.toNumber)(right);
+                if (Number.isInteger(exponentNum) && exponentNum >= 0) {
+                    const approx = Math.pow((0, value_utils_1.toNumber)(left), exponentNum);
+                    if ((0, value_utils_1.shouldUseBigInt)(left, right) || !Number.isSafeInteger(approx)) {
+                        return (0, value_utils_1.toBigIntValue)(left) ** (0, value_utils_1.toBigIntValue)(right);
+                    }
+                }
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                const exponent = (0, value_utils_1.toBigIntValue)(right);
+                if (exponent < 0n) {
+                    return new Number(Math.pow((0, value_utils_1.toNumber)(left), (0, value_utils_1.toNumber)(right)));
+                }
+                return (0, value_utils_1.toBigIntValue)(left) ** exponent;
+            }
+            return Math.pow((0, value_utils_1.toNumber)(left), (0, value_utils_1.toNumber)(right));
+        case '&':
+            if (left instanceof Set && right instanceof Set) {
+                const result = new Set();
+                for (const item of left.values()) {
+                    if (right.has(item))
+                        result.add(item);
+                }
+                return result;
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) & (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left & right;
+        case '|':
+            if (left instanceof Set && right instanceof Set) {
+                const result = new Set(left);
+                for (const item of right.values())
+                    result.add(item);
+                return result;
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) | (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left | right;
+        case '^':
+            if (left instanceof Set && right instanceof Set) {
+                const result = new Set();
+                for (const item of left.values()) {
+                    if (!right.has(item))
+                        result.add(item);
+                }
+                for (const item of right.values()) {
+                    if (!left.has(item))
+                        result.add(item);
+                }
+                return result;
+            }
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) ^ (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left ^ right;
+        case '<<':
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) << (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left << right;
+        case '>>':
+            if ((0, value_utils_1.shouldUseBigInt)(left, right)) {
+                return (0, value_utils_1.toBigIntValue)(left) >> (0, value_utils_1.toBigIntValue)(right);
+            }
+            return left >> right;
+        default:
+            throw new runtime_types_1.PyException('TypeError', `unsupported operator ${op}`);
+    }
+}
+function formatPercent(format, value) {
+    const values = Array.isArray(value) ? value : [value];
+    let index = 0;
+    return format.replace(/%[sdfo]/g, (match) => {
+        const val = values[index++];
+        if (match === '%d')
+            return typeof val === 'bigint' ? val.toString() : String(parseInt(val, 10));
+        if (match === '%f')
+            return String(parseFloat(val));
+        return String(val);
+    });
+}
+function getSubscript(obj, index) {
+    if (index && index.type === types_1.ASTNodeType.SLICE) {
+        const start = index.start !== null && index.start !== undefined ? index.start : null;
+        const end = index.end !== null && index.end !== undefined ? index.end : null;
+        const step = index.step !== null && index.step !== undefined ? index.step : 1;
+        const indices = this.computeSliceIndices(obj.length, start, end, step);
+        const result = [];
+        for (const idx of indices)
+            result.push(obj[idx]);
+        if (typeof obj === 'string')
+            return result.join('');
+        if (Array.isArray(obj) && obj.__tuple__) {
+            result.__tuple__ = true;
+        }
+        return result;
+    }
+    if (Array.isArray(obj) || typeof obj === 'string') {
+        let idx = index;
+        if ((0, value_utils_1.isIntLike)(idx) && (0, value_utils_1.toNumber)(idx) < 0) {
+            idx = obj.length + (0, value_utils_1.toNumber)(idx);
+        }
+        if ((0, value_utils_1.isIntLike)(idx)) {
+            idx = (0, value_utils_1.toNumber)(idx);
+        }
+        return obj[idx];
+    }
+    if (obj instanceof runtime_types_1.PyDict) {
+        return obj.get(index);
+    }
+    return null;
+}
+function computeSliceBounds(length, start, end, step) {
+    const stepValue = this.normalizeSliceStep(step);
+    const startProvided = start !== null && start !== undefined;
+    const endProvided = end !== null && end !== undefined;
+    let startValue = startProvided ? (0, value_utils_1.toNumber)(start) : null;
+    let endValue = endProvided ? (0, value_utils_1.toNumber)(end) : null;
+    if (startValue === null)
+        startValue = stepValue < 0 ? length - 1 : 0;
+    if (endValue === null)
+        endValue = stepValue < 0 ? -1 : length;
+    if (startProvided && startValue < 0)
+        startValue = length + startValue;
+    if (endProvided && endValue < 0)
+        endValue = length + endValue;
+    return { start: startValue, end: endValue, step: stepValue };
+}
+function computeSliceIndices(length, start, end, step) {
+    const bounds = this.computeSliceBounds(length, start, end, step);
+    const indices = [];
+    for (let i = bounds.start; bounds.step > 0 ? i < bounds.end : i > bounds.end; i += bounds.step) {
+        indices.push(i);
+    }
+    return indices;
+}
+function normalizeSliceStep(step) {
+    const stepValue = step !== null && step !== undefined ? (0, value_utils_1.toNumber)(step) : 1;
+    if (stepValue === 0) {
+        throw new runtime_types_1.PyException('ValueError', 'slice step cannot be zero');
+    }
+    return stepValue;
+}
+function getAttribute(obj, name, scope) {
+    if (obj && obj.__moduleScope__) {
+        if (obj.__moduleScope__.values.has(name)) {
+            return obj.__moduleScope__.values.get(name);
+        }
+    }
+    if (obj instanceof runtime_types_1.PyInstance) {
+        if (obj.attributes.has(name))
+            return obj.attributes.get(name);
+        const attr = this.findClassAttribute(obj.klass, name);
+        if (attr instanceof runtime_types_1.PyFunction) {
+            return (...args) => this.callFunction(attr, [obj, ...args], scope);
+        }
+        return attr;
+    }
+    if (obj instanceof runtime_types_1.PyClass) {
+        const attr = this.findClassAttribute(obj, name);
+        return attr;
+    }
+    if (obj instanceof runtime_types_1.PyFile) {
+        const value = obj[name];
+        if (typeof value === 'function')
+            return value.bind(obj);
+        return value;
+    }
+    if (obj instanceof runtime_types_1.PyGenerator) {
+        const value = obj[name];
+        if (typeof value === 'function')
+            return value.bind(obj);
+        return value;
+    }
+    if ((0, value_utils_1.isComplex)(obj)) {
+        if (name === 'real')
+            return new Number(obj.re);
+        if (name === 'imag')
+            return new Number(obj.im);
+    }
+    if (typeof obj === 'string') {
+        if (name === 'upper')
+            return () => obj.toUpperCase();
+        if (name === 'replace')
+            return (a, b) => {
+                return obj.replace(a, b);
+            };
+        if (name === 'format')
+            return (...args) => {
+                let kwargs = {};
+                if (args.length > 0) {
+                    const last = args[args.length - 1];
+                    if (last && last.__kwargs__) {
+                        kwargs = last.__kwargs__;
+                        args = args.slice(0, -1);
+                    }
+                }
+                let autoIndex = 0;
+                return obj.replace(/\{([^{}]*)\}/g, (_match, key) => {
+                    if (key === '') {
+                        const value = args[autoIndex++];
+                        return (0, value_utils_1.pyStr)(value);
+                    }
+                    if (/^\d+$/.test(key)) {
+                        const value = args[parseInt(key, 10)];
+                        return (0, value_utils_1.pyStr)(value);
+                    }
+                    if (key in kwargs) {
+                        return (0, value_utils_1.pyStr)(kwargs[key]);
+                    }
+                    return '';
+                });
+            };
+        if (name === 'count')
+            return (ch) => obj.split(ch).length - 1;
+    }
+    if (Array.isArray(obj)) {
+        if (name === 'append')
+            return (value) => obj.push(value);
+        if (name === 'count')
+            return (value) => obj.filter((item) => item === value).length;
+        if (name === 'index')
+            return (value) => obj.indexOf(value);
+        if (name === 'sort') {
+            return (...args) => {
+                let kwargs = {};
+                if (args.length > 0) {
+                    const last = args[args.length - 1];
+                    if (last && last.__kwargs__) {
+                        kwargs = last.__kwargs__;
+                        args = args.slice(0, -1);
+                    }
+                }
+                let keyFn = args.length > 0 ? args[0] : null;
+                if ('key' in kwargs)
+                    keyFn = kwargs.key;
+                const reverse = 'reverse' in kwargs ? Boolean(kwargs.reverse) : false;
+                if (keyFn) {
+                    const keyed = obj.map((item) => ({
+                        item,
+                        key: this.callFunction(keyFn, [item], scope),
+                    }));
+                    keyed.sort((a, b) => {
+                        if ((0, value_utils_1.isNumericLike)(a.key) && (0, value_utils_1.isNumericLike)(b.key)) {
+                            return (0, value_utils_1.toNumber)(a.key) - (0, value_utils_1.toNumber)(b.key);
+                        }
+                        return String(a.key).localeCompare(String(b.key));
+                    });
+                    obj.length = 0;
+                    obj.push(...keyed.map((entry) => entry.item));
+                }
+                else if (obj.every((value) => (0, value_utils_1.isNumericLike)(value))) {
+                    obj.sort((a, b) => (0, value_utils_1.toNumber)(a) - (0, value_utils_1.toNumber)(b));
+                }
+                else {
+                    obj.sort();
+                }
+                if (reverse)
+                    obj.reverse();
+                return null;
+            };
+        }
+    }
+    if (obj instanceof runtime_types_1.PyDict) {
+        if (name === 'items')
+            return () => Array.from(obj.entries()).map(([k, v]) => {
+                const tup = [k, v];
+                tup.__tuple__ = true;
+                return tup;
+            });
+        const value = obj[name];
+        if (typeof value === 'function')
+            return value.bind(obj);
+        return value;
+    }
+    if (obj instanceof Set) {
+        if (name === 'add')
+            return (value) => obj.add(value);
+        if (name === 'update')
+            return (values) => {
+                const items = Array.isArray(values) ? values : Array.from(values);
+                for (const item of items)
+                    obj.add(item);
+            };
+        if (name === 'remove')
+            return (value) => obj.delete(value);
+    }
+    if (obj && typeof obj === 'object' && obj.__typeName__) {
+        if (name === '__name__')
+            return obj.__typeName__;
+    }
+    if (obj && obj.__typeName__ === undefined && name === '__name__') {
+        return obj.name;
+    }
+    return obj[name];
+}
+function setAttribute(obj, name, value) {
+    if (obj && obj.__moduleScope__) {
+        obj.__moduleScope__.values.set(name, value);
+        return;
+    }
+    if (obj instanceof runtime_types_1.PyInstance) {
+        obj.attributes.set(name, value);
+        return;
+    }
+    obj[name] = value;
+}
+function findClassAttribute(klass, name) {
+    if (klass.attributes.has(name))
+        return klass.attributes.get(name);
+    for (const base of klass.bases) {
+        const attr = findClassAttribute(base, name);
+        if (attr !== undefined)
+            return attr;
+    }
+    return undefined;
+}
+//# sourceMappingURL=operations.js.map

package/dist/vm/runtime-types.d.ts

@@ -0,0 +1,84 @@
+export type ScopeValue = any;
+export declare class ReturnSignal {
+    value: any;
+    constructor(value: any);
+}
+export declare class BreakSignal {
+}
+export declare class ContinueSignal {
+}
+export declare class PyException extends Error {
+    pyType: string;
+    pyValue: any;
+    constructor(pyType: string, message?: string, pyValue?: any);
+}
+export declare class Scope {
+    values: Map<string, ScopeValue>;
+    parent: Scope | null;
+    globals: Set<string>;
+    nonlocals: Set<string>;
+    constructor(parent?: Scope | null);
+    get(name: string): ScopeValue;
+    set(name: string, value: ScopeValue): void;
+    root(): Scope;
+    findScopeWith(name: string): Scope | null;
+}
+export declare class PyFunction {
+    name: string;
+    params: any[];
+    body: any[];
+    closure: Scope;
+    isGenerator: boolean;
+    constructor(name: string, params: any[], body: any[], closure: Scope, isGenerator: boolean);
+}
+export declare class PyClass {
+    name: string;
+    bases: PyClass[];
+    attributes: Map<string, any>;
+    isException: boolean;
+    constructor(name: string, bases: PyClass[], attributes: Map<string, any>, isException?: boolean);
+}
+export declare class PyInstance {
+    klass: PyClass;
+    attributes: Map<string, any>;
+    constructor(klass: PyClass);
+}
+export declare class PyGenerator {
+    private iterator;
+    constructor(iterator: Generator<any, any, any>);
+    next(value?: any): any;
+    send(value?: any): any;
+    [Symbol.iterator](): Generator<any, any, any>;
+}
+export type DictEntry = {
+    key: any;
+    value: any;
+};
+export declare class PyDict {
+    private primitiveStore;
+    private objectStore;
+    get size(): number;
+    set(key: any, value: any): this;
+    get(key: any): any;
+    has(key: any): boolean;
+    delete(key: any): boolean;
+    entries(): IterableIterator<[any, any]>;
+    keys(): IterableIterator<any>;
+    values(): IterableIterator<any>;
+    [Symbol.iterator](): IterableIterator<[any, any]>;
+    private keyInfo;
+    private normalizeNumericKey;
+}
+export declare class PyFile {
+    path: string;
+    mode: string;
+    handle: number | null;
+    constructor(path: string, mode: string);
+    open(): void;
+    write(data: string): void;
+    read(): string;
+    close(): void;
+    __enter__(): this;
+    __exit__(): boolean;
+}
+//# sourceMappingURL=runtime-types.d.ts.map