@lewin671/python-vm 0.1.0 → 0.1.2

package/src/vm/operations.ts

@@ -1,414 +0,0 @@
-import type { VirtualMachine } from './vm';
-import { ASTNodeType } from '../types';
-import { PyClass, PyDict, PyException, PyFile, PyFunction, PyGenerator, PyInstance, Scope } from './runtime-types';
-import {
-  bigIntFloorDiv,
-  isComplex,
-  isFloatLike,
-  isIntLike,
-  isNumericLike,
-  numericEquals,
-  pythonModulo,
-  shouldUseBigInt,
-  toBigIntValue,
-  toComplex,
-  toNumber,
-  pyStr,
-  pyTypeName,
-} from './value-utils';
-
-export function applyBinary(this: VirtualMachine, op: string, left: any, right: any): any {
-  if (isComplex(left) || isComplex(right)) {
-    const a = toComplex(left);
-    const b = 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 PyException('TypeError', `unsupported complex operator ${op}`);
-    }
-  }
-  switch (op) {
-    case '+':
-      if (Array.isArray(left) && Array.isArray(right)) {
-        const result = [...left, ...right];
-        if ((left as any).__tuple__ && (right as any).__tuple__) {
-          (result as any).__tuple__ = true;
-        }
-        return result;
-      }
-      if (isFloatLike(left) || isFloatLike(right)) {
-        return new Number(toNumber(left) + toNumber(right));
-      }
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) + 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 (isFloatLike(left) || isFloatLike(right)) {
-        return new Number(toNumber(left) - toNumber(right));
-      }
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) - toBigIntValue(right);
-      }
-      return left - right;
-    case '*':
-      if (typeof left === 'string' && isIntLike(right)) {
-        const count = toNumber(right);
-        if (count <= 0) return '';
-        return left.repeat(count);
-      }
-      if (typeof right === 'string' && isIntLike(left)) {
-        const count = toNumber(left);
-        if (count <= 0) return '';
-        return right.repeat(count);
-      }
-      if (Array.isArray(left) && isIntLike(right)) {
-        const count = toNumber(right);
-        if (count <= 0) {
-          const result: any[] = [];
-          if ((left as any).__tuple__) {
-            (result as any).__tuple__ = true;
-          }
-          return result;
-        }
-        const result = Array(count).fill(null).flatMap(() => left);
-        if ((left as any).__tuple__) {
-          (result as any).__tuple__ = true;
-        }
-        return result;
-      }
-      if (isFloatLike(left) || isFloatLike(right)) {
-        return new Number(toNumber(left) * toNumber(right));
-      }
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) * toBigIntValue(right);
-      }
-      return left * right;
-    case '/':
-      if (right === 0 || right === 0n) throw new PyException('ZeroDivisionError', 'division by zero');
-      return new Number(toNumber(left) / toNumber(right));
-    case '//':
-      if (right === 0 || right === 0n) throw new PyException('ZeroDivisionError', 'division by zero');
-      if (isFloatLike(left) || isFloatLike(right)) {
-        return new Number(Math.floor(toNumber(left) / toNumber(right)));
-      }
-      if (shouldUseBigInt(left, right)) {
-        return bigIntFloorDiv(toBigIntValue(left), toBigIntValue(right));
-      }
-      return Math.floor(left / right);
-    case '%':
-      if (typeof left === 'string') {
-        return this.formatPercent(left, right);
-      }
-      return pythonModulo(left, right);
-    case '**':
-      if (isIntLike(left) && isIntLike(right) && !isFloatLike(left) && !isFloatLike(right)) {
-        const exponentNum = toNumber(right);
-        if (Number.isInteger(exponentNum) && exponentNum >= 0) {
-          const approx = Math.pow(toNumber(left), exponentNum);
-          if (shouldUseBigInt(left, right) || !Number.isSafeInteger(approx)) {
-            return toBigIntValue(left) ** toBigIntValue(right);
-          }
-        }
-      }
-      if (shouldUseBigInt(left, right)) {
-        const exponent = toBigIntValue(right);
-        if (exponent < 0n) {
-          return new Number(Math.pow(toNumber(left), toNumber(right)));
-        }
-        return toBigIntValue(left) ** exponent;
-      }
-      return Math.pow(toNumber(left), toNumber(right));
-    case '&':
-      if (left instanceof Set && right instanceof Set) {
-        const result = new Set<any>();
-        for (const item of left.values()) {
-          if (right.has(item)) result.add(item);
-        }
-        return result;
-      }
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) & toBigIntValue(right);
-      }
-      return left & right;
-    case '|':
-      if (left instanceof Set && right instanceof Set) {
-        const result = new Set<any>(left);
-        for (const item of right.values()) result.add(item);
-        return result;
-      }
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) | toBigIntValue(right);
-      }
-      return left | right;
-    case '^':
-      if (left instanceof Set && right instanceof Set) {
-        const result = new Set<any>();
-        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 (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) ^ toBigIntValue(right);
-      }
-      return left ^ right;
-    case '<<':
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) << toBigIntValue(right);
-      }
-      return left << right;
-    case '>>':
-      if (shouldUseBigInt(left, right)) {
-        return toBigIntValue(left) >> toBigIntValue(right);
-      }
-      return left >> right;
-    default:
-      throw new PyException('TypeError', `unsupported operator ${op}`);
-  }
-}
-
-export function formatPercent(this: VirtualMachine, format: string, value: any): string {
-  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);
-  });
-}
-
-export function getSubscript(this: VirtualMachine, obj: any, index: any): any {
-  if (index && index.type === 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: any[] = [];
-    for (const idx of indices) result.push(obj[idx]);
-    if (typeof obj === 'string') return result.join('');
-    if (Array.isArray(obj) && (obj as any).__tuple__) {
-      (result as any).__tuple__ = true;
-    }
-    return result;
-  }
-  if (Array.isArray(obj) || typeof obj === 'string') {
-    let idx = index;
-    if (isIntLike(idx) && toNumber(idx) < 0) {
-      idx = obj.length + toNumber(idx);
-    }
-    if (isIntLike(idx)) {
-      idx = toNumber(idx);
-    }
-    return obj[idx];
-  }
-  if (obj instanceof PyDict) {
-    return obj.get(index);
-  }
-  return null;
-}
-
-export function computeSliceBounds(this: VirtualMachine, length: number, start: any, end: any, step: any) {
-  const stepValue = this.normalizeSliceStep(step);
-  const startProvided = start !== null && start !== undefined;
-  const endProvided = end !== null && end !== undefined;
-  let startValue = startProvided ? toNumber(start) : null;
-  let endValue = endProvided ? 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 };
-}
-
-export function computeSliceIndices(this: VirtualMachine, length: number, start: any, end: any, step: any) {
-  const bounds = this.computeSliceBounds(length, start, end, step);
-  const indices: number[] = [];
-  for (let i = bounds.start; bounds.step > 0 ? i < bounds.end : i > bounds.end; i += bounds.step) {
-    indices.push(i);
-  }
-  return indices;
-}
-
-export function normalizeSliceStep(step: any) {
-  const stepValue = step !== null && step !== undefined ? toNumber(step) : 1;
-  if (stepValue === 0) {
-    throw new PyException('ValueError', 'slice step cannot be zero');
-  }
-  return stepValue;
-}
-
-export function getAttribute(this: VirtualMachine, obj: any, name: string, scope: Scope): any {
-  if (obj && obj.__moduleScope__) {
-    if (obj.__moduleScope__.values.has(name)) {
-      return obj.__moduleScope__.values.get(name);
-    }
-  }
-  if (obj instanceof PyInstance) {
-    if (obj.attributes.has(name)) return obj.attributes.get(name);
-    const attr = this.findClassAttribute(obj.klass, name);
-    if (attr instanceof PyFunction) {
-      return (...args: any[]) => this.callFunction(attr, [obj, ...args], scope);
-    }
-    return attr;
-  }
-  if (obj instanceof PyClass) {
-    const attr = this.findClassAttribute(obj, name);
-    return attr;
-  }
-  if (obj instanceof PyFile) {
-    const value = (obj as any)[name];
-    if (typeof value === 'function') return value.bind(obj);
-    return value;
-  }
-  if (obj instanceof PyGenerator) {
-    const value = (obj as any)[name];
-    if (typeof value === 'function') return value.bind(obj);
-    return value;
-  }
-  if (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: any, b: any) => {
-        return obj.replace(a, b);
-      };
-    if (name === 'format')
-      return (...args: any[]) => {
-        let kwargs: Record<string, any> = {};
-        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 pyStr(value);
-          }
-          if (/^\d+$/.test(key)) {
-            const value = args[parseInt(key, 10)];
-            return pyStr(value);
-          }
-          if (key in kwargs) {
-            return pyStr(kwargs[key]);
-          }
-          return '';
-        });
-      };
-    if (name === 'count') return (ch: any) => obj.split(ch).length - 1;
-  }
-  if (Array.isArray(obj)) {
-    if (name === 'append') return (value: any) => obj.push(value);
-    if (name === 'count') return (value: any) => obj.filter((item: any) => item === value).length;
-    if (name === 'index') return (value: any) => obj.indexOf(value);
-    if (name === 'sort') {
-      return (...args: any[]) => {
-        let kwargs: Record<string, any> = {};
-        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: any) => ({
-            item,
-            key: this.callFunction(keyFn, [item], scope),
-          }));
-          keyed.sort((a, b) => {
-            if (isNumericLike(a.key) && isNumericLike(b.key)) {
-              return toNumber(a.key) - 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: any) => isNumericLike(value))) {
-          obj.sort((a: any, b: any) => toNumber(a) - toNumber(b));
-        } else {
-          obj.sort();
-        }
-        if (reverse) obj.reverse();
-        return null;
-      };
-    }
-  }
-  if (obj instanceof PyDict) {
-    if (name === 'items')
-      return () =>
-        Array.from(obj.entries()).map(([k, v]) => {
-          const tup = [k, v];
-          (tup as any).__tuple__ = true;
-          return tup;
-        });
-    const value = (obj as any)[name];
-    if (typeof value === 'function') return value.bind(obj);
-    return value;
-  }
-  if (obj instanceof Set) {
-    if (name === 'add') return (value: any) => obj.add(value);
-    if (name === 'update')
-      return (values: any) => {
-        const items = Array.isArray(values) ? values : Array.from(values);
-        for (const item of items) obj.add(item);
-      };
-    if (name === 'remove') return (value: any) => 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 as any)[name];
-}
-
-export function setAttribute(this: VirtualMachine, obj: any, name: string, value: any) {
-  if (obj && obj.__moduleScope__) {
-    obj.__moduleScope__.values.set(name, value);
-    return;
-  }
-  if (obj instanceof PyInstance) {
-    obj.attributes.set(name, value);
-    return;
-  }
-  (obj as any)[name] = value;
-}
-
-export function findClassAttribute(klass: PyClass, name: string): any {
-  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;
-}

package/src/vm/runtime-types.ts

@@ -1,292 +0,0 @@
-import * as fs from 'fs';
-
-export type ScopeValue = any;
-
-export class ReturnSignal {
-  value: any;
-  constructor(value: any) {
-    this.value = value;
-  }
-}
-
-export class BreakSignal {}
-export class ContinueSignal {}
-
-export class PyException extends Error {
-  pyType: string;
-  pyValue: any;
-  constructor(pyType: string, message?: string, pyValue?: any) {
-    super(message || pyType);
-    this.pyType = pyType;
-    this.pyValue = pyValue;
-  }
-}
-
-export class Scope {
-  values: Map<string, ScopeValue> = new Map();
-  parent: Scope | null;
-  globals: Set<string> = new Set();
-  nonlocals: Set<string> = new Set();
-
-  constructor(parent: Scope | null = null) {
-    this.parent = parent;
-  }
-
-  get(name: string): ScopeValue {
-    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: string, value: ScopeValue): void {
-    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(): Scope {
-    let scope: Scope = this;
-    while (scope.parent) {
-      scope = scope.parent;
-    }
-    return scope;
-  }
-
-  findScopeWith(name: string): Scope | null {
-    let scope: Scope | null = this;
-    while (scope) {
-      if (scope.values.has(name)) return scope;
-      scope = scope.parent;
-    }
-    return null;
-  }
-}
-
-export class PyFunction {
-  name: string;
-  params: any[];
-  body: any[];
-  closure: Scope;
-  isGenerator: boolean;
-
-  constructor(name: string, params: any[], body: any[], closure: Scope, isGenerator: boolean) {
-    this.name = name;
-    this.params = params;
-    this.body = body;
-    this.closure = closure;
-    this.isGenerator = isGenerator;
-  }
-}
-
-export class PyClass {
-  name: string;
-  bases: PyClass[];
-  attributes: Map<string, any>;
-  isException: boolean;
-
-  constructor(name: string, bases: PyClass[], attributes: Map<string, any>, isException: boolean = false) {
-    this.name = name;
-    this.bases = bases;
-    this.attributes = attributes;
-    this.isException = isException;
-  }
-}
-
-export class PyInstance {
-  klass: PyClass;
-  attributes: Map<string, any>;
-
-  constructor(klass: PyClass) {
-    this.klass = klass;
-    this.attributes = new Map();
-  }
-}
-
-export class PyGenerator {
-  private iterator: Generator<any, any, any>;
-
-  constructor(iterator: Generator<any, any, any>) {
-    this.iterator = iterator;
-  }
-
-  next(value?: any) {
-    const result = this.iterator.next(value === undefined ? null : value);
-    if (result.done) {
-      throw new PyException('StopIteration', 'StopIteration');
-    }
-    return result.value;
-  }
-
-  send(value?: any) {
-    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;
-  }
-}
-
-export type DictEntry = { key: any; value: any };
-
-export class PyDict {
-  private primitiveStore: Map<string, DictEntry> = new Map();
-  private objectStore: Map<any, DictEntry> = new Map();
-
-  get size(): number {
-    return this.primitiveStore.size + this.objectStore.size;
-  }
-
-  set(key: any, value: any): this {
-    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: any): any {
-    const info = this.keyInfo(key);
-    const entry = info.store.get(info.id);
-    return entry ? entry.value : undefined;
-  }
-
-  has(key: any): boolean {
-    const info = this.keyInfo(key);
-    return info.store.has(info.id);
-  }
-
-  delete(key: any): boolean {
-    const info = this.keyInfo(key);
-    return info.store.delete(info.id);
-  }
-
-  *entries(): IterableIterator<[any, any]> {
-    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(): IterableIterator<any> {
-    for (const entry of this.primitiveStore.values()) {
-      yield entry.key;
-    }
-    for (const entry of this.objectStore.values()) {
-      yield entry.key;
-    }
-  }
-
-  *values(): IterableIterator<any> {
-    for (const entry of this.primitiveStore.values()) {
-      yield entry.value;
-    }
-    for (const entry of this.objectStore.values()) {
-      yield entry.value;
-    }
-  }
-
-  [Symbol.iterator](): IterableIterator<[any, any]> {
-    return this.entries();
-  }
-
-  private keyInfo(key: any): { store: Map<any, DictEntry>; id: any } {
-    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 };
-  }
-
-  private normalizeNumericKey(key: any): number | bigint | null {
-    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;
-  }
-}
-
-export class PyFile {
-  path: string;
-  mode: string;
-  handle: number | null;
-
-  constructor(path: string, mode: string) {
-    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: string) {
-    this.open();
-    if (this.handle === null) return;
-    fs.writeSync(this.handle, data);
-  }
-
-  read(): string {
-    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;
-  }
-}