@lewin671/python-vm 0.1.0 → 0.1.1

package/src/parser/statements.ts

@@ -1,366 +0,0 @@
-import type { Parser } from './parser';
-import { ASTNode, ASTNodeType, TokenType } from '../types';
-
-export function parseExpressionStatement(this: Parser): ASTNode {
-  return { type: ASTNodeType.EXPRESSION_STATEMENT, expression: this.parseExpression() };
-}
-
-export function parseExpressionList(this: Parser): ASTNode {
-  const first = this.parseExpression();
-  if (this.match(TokenType.COMMA)) {
-    const elements: ASTNode[] = [first];
-    while (this.match(TokenType.COMMA)) {
-      this.consume();
-      if (this.match(TokenType.NEWLINE) || this.match(TokenType.RPAREN) || this.match(TokenType.RBRACKET) || this.match(TokenType.RBRACE)) break;
-      elements.push(this.parseExpression());
-    }
-    return { type: ASTNodeType.TUPLE_LITERAL, elements };
-  }
-  return first;
-}
-
-export function parseAssignmentOrExpression(this: Parser): ASTNode {
-  const startPos = this.pos;
-  const target = this.parseTarget();
-  if (this.match(TokenType.ASSIGN)) {
-    this.consume();
-    const value = this.parseExpressionList();
-    return { type: ASTNodeType.ASSIGNMENT, targets: [target], value };
-  }
-  if (this.match(TokenType.OPERATOR) && ['+=', '-=', '*=', '/=', '%=', '//=', '**='].includes(this.peek()?.value || '')) {
-    const op = this.consume().value;
-    const value = this.parseExpressionList();
-    return { type: ASTNodeType.AUG_ASSIGNMENT, target, operator: op, value };
-  }
-  this.pos = startPos;
-  return this.parseExpressionStatement();
-}
-
-export function parseBlock(this: Parser): ASTNode[] {
-  this.expect(TokenType.NEWLINE);
-  this.expect(TokenType.INDENT);
-  const body: ASTNode[] = [];
-  while (!this.match(TokenType.DEDENT) && !this.match(TokenType.EOF)) {
-    const stmt = this.parseStatement();
-    body.push(stmt);
-    this.skipNewlines();
-  }
-  this.expect(TokenType.DEDENT);
-  return body;
-}
-
-export function parseIfStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'if');
-  const test = this.parseExpression();
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  const elifs: Array<{ test: ASTNode; body: ASTNode[] }> = [];
-  while (this.match(TokenType.KEYWORD, 'elif')) {
-    this.consume();
-    const elifTest = this.parseExpression();
-    this.expect(TokenType.COLON);
-    const elifBody = this.parseBlock();
-    elifs.push({ test: elifTest, body: elifBody });
-  }
-  let orelse: ASTNode[] = [];
-  if (this.match(TokenType.KEYWORD, 'else')) {
-    this.consume();
-    this.expect(TokenType.COLON);
-    orelse = this.parseBlock();
-  }
-  return { type: ASTNodeType.IF_STATEMENT, test, body, elifs, orelse };
-}
-
-export function parseWhileStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'while');
-  const test = this.parseExpression();
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  return { type: ASTNodeType.WHILE_STATEMENT, test, body };
-}
-
-export function parseForStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'for');
-  const target = this.parseTarget();
-  this.expect(TokenType.KEYWORD, 'in');
-  const iter = this.parseExpression();
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  return { type: ASTNodeType.FOR_STATEMENT, target, iter, body };
-}
-
-export function parseFunctionParameters(this: Parser): ASTNode[] {
-  const params: ASTNode[] = [];
-  if (!this.match(TokenType.RPAREN)) {
-    while (true) {
-      if (this.match(TokenType.OPERATOR, '*')) {
-        this.consume();
-        const name = this.expect(TokenType.IDENTIFIER).value;
-        params.push({ type: 'VarArg', name } as any);
-      } else if (this.match(TokenType.OPERATOR, '**')) {
-        this.consume();
-        const name = this.expect(TokenType.IDENTIFIER).value;
-        params.push({ type: 'KwArg', name } as any);
-      } else if (this.match(TokenType.IDENTIFIER)) {
-        const name = this.consume().value;
-        let defaultValue: ASTNode | null = null;
-        if (this.match(TokenType.ASSIGN)) {
-          this.consume();
-          defaultValue = this.parseExpression();
-        }
-        params.push({ type: 'Param', name, defaultValue } as any);
-      }
-      if (!this.match(TokenType.COMMA)) break;
-      this.consume();
-      if (this.match(TokenType.RPAREN)) break;
-    }
-  }
-  return params;
-}
-
-export function parseFunctionDef(this: Parser, decorators: ASTNode[] = []): ASTNode {
-  this.expect(TokenType.KEYWORD, 'def');
-  const name = this.expect(TokenType.IDENTIFIER).value;
-  this.expect(TokenType.LPAREN);
-  const params = this.parseFunctionParameters();
-  this.expect(TokenType.RPAREN);
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  return { type: ASTNodeType.FUNCTION_DEF, name, params, body, decorators };
-}
-
-export function parseClassDef(this: Parser, decorators: ASTNode[] = []): ASTNode {
-  this.expect(TokenType.KEYWORD, 'class');
-  const name = this.expect(TokenType.IDENTIFIER).value;
-  let bases: ASTNode[] = [];
-  if (this.match(TokenType.LPAREN)) {
-    this.consume();
-    if (!this.match(TokenType.RPAREN)) {
-      bases.push(this.parseExpression());
-      while (this.match(TokenType.COMMA)) {
-        this.consume();
-        if (this.match(TokenType.RPAREN)) break;
-        bases.push(this.parseExpression());
-      }
-    }
-    this.expect(TokenType.RPAREN);
-  }
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  return { type: ASTNodeType.CLASS_DEF, name, bases, body, decorators };
-}
-
-export function parseDecorators(this: Parser): ASTNode[] {
-  const decorators: ASTNode[] = [];
-  while (this.match(TokenType.AT)) {
-    this.consume();
-    const decorator = this.parseExpression();
-    decorators.push(decorator);
-    this.expect(TokenType.NEWLINE);
-  }
-  return decorators;
-}
-
-export function parseTryStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'try');
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  const handlers: Array<{ exceptionType: ASTNode | null; name: string | null; body: ASTNode[] }> = [];
-  while (this.match(TokenType.KEYWORD, 'except')) {
-    this.consume();
-    let exceptionType: ASTNode | null = null;
-    let name: string | null = null;
-    if (!this.match(TokenType.COLON)) {
-      exceptionType = this.parseExpression();
-      if (this.match(TokenType.KEYWORD, 'as')) {
-        this.consume();
-        name = this.expect(TokenType.IDENTIFIER).value;
-      }
-    }
-    this.expect(TokenType.COLON);
-    const handlerBody = this.parseBlock();
-    handlers.push({ exceptionType, name, body: handlerBody });
-  }
-  let orelse: ASTNode[] = [];
-  if (this.match(TokenType.KEYWORD, 'else')) {
-    this.consume();
-    this.expect(TokenType.COLON);
-    orelse = this.parseBlock();
-  }
-  let finalbody: ASTNode[] = [];
-  if (this.match(TokenType.KEYWORD, 'finally')) {
-    this.consume();
-    this.expect(TokenType.COLON);
-    finalbody = this.parseBlock();
-  }
-  return { type: ASTNodeType.TRY_STATEMENT, body, handlers, orelse, finalbody };
-}
-
-export function parseWithStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'with');
-  const items: any[] = [];
-  while (true) {
-    const context = this.parseExpression();
-    let target: ASTNode | null = null;
-    if (this.match(TokenType.KEYWORD, 'as')) {
-      this.consume();
-      target = this.parseTarget();
-    }
-    items.push({ context, target });
-    if (!this.match(TokenType.COMMA)) break;
-    this.consume();
-  }
-  this.expect(TokenType.COLON);
-  const body = this.parseBlock();
-  return { type: ASTNodeType.WITH_STATEMENT, items, body };
-}
-
-export function parseMatchStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'match');
-  const subject = this.parseExpression();
-  this.expect(TokenType.COLON);
-  this.expect(TokenType.NEWLINE);
-  this.expect(TokenType.INDENT);
-  const cases: Array<{ pattern: ASTNode; guard: ASTNode | null; body: ASTNode[] }> = [];
-  while (!this.match(TokenType.DEDENT) && !this.match(TokenType.EOF)) {
-    this.expect(TokenType.KEYWORD, 'case');
-    const pattern = this.parsePattern();
-    let guard: ASTNode | null = null;
-    if (this.match(TokenType.KEYWORD, 'if')) {
-      this.consume();
-      guard = this.parseExpression();
-    }
-    this.expect(TokenType.COLON);
-    const body = this.parseBlock();
-    cases.push({ pattern, guard, body });
-  }
-  this.expect(TokenType.DEDENT);
-  return { type: ASTNodeType.MATCH_STATEMENT, subject, cases };
-}
-
-export function parseImportStatement(this: Parser): ASTNode {
-  this.expect(TokenType.KEYWORD, 'import');
-  const names: Array<{ name: string; alias: string | null }> = [];
-  const parseName = () => {
-    let name = this.expect(TokenType.IDENTIFIER).value;
-    while (this.match(TokenType.DOT)) {
-      this.consume();
-      name += `.${this.expect(TokenType.IDENTIFIER).value}`;
-    }
-    let alias: string | null = null;
-    if (this.match(TokenType.KEYWORD, 'as')) {
-      this.consume();
-      alias = this.expect(TokenType.IDENTIFIER).value;
-    }
-    names.push({ name, alias });
-  };
-  parseName();
-  while (this.match(TokenType.COMMA)) {
-    this.consume();
-    parseName();
-  }
-  return { type: ASTNodeType.IMPORT_STATEMENT, names };
-}
-
-export function parseStatement(this: Parser): ASTNode {
-  this.skipNewlines();
-  if (this.match(TokenType.AT)) {
-    const decorators = this.parseDecorators();
-    if (this.match(TokenType.KEYWORD, 'async')) {
-      this.consume();
-      if (!this.match(TokenType.KEYWORD, 'def')) throw new Error('async must be followed by def');
-      const node = this.parseFunctionDef(decorators);
-      (node as any).isAsync = true;
-      return node;
-    }
-    if (this.match(TokenType.KEYWORD, 'def')) return this.parseFunctionDef(decorators);
-    if (this.match(TokenType.KEYWORD, 'class')) return this.parseClassDef(decorators);
-    throw new Error('Decorator must be followed by def or class');
-  }
-  if (this.match(TokenType.KEYWORD, 'async')) {
-    this.consume();
-    if (!this.match(TokenType.KEYWORD, 'def')) throw new Error('async must be followed by def');
-    const node = this.parseFunctionDef();
-    (node as any).isAsync = true;
-    return node;
-  }
-  if (this.match(TokenType.KEYWORD, 'import')) return this.parseImportStatement();
-  if (this.match(TokenType.KEYWORD, 'def')) return this.parseFunctionDef();
-  if (this.match(TokenType.KEYWORD, 'class')) return this.parseClassDef();
-  if (this.match(TokenType.KEYWORD, 'if')) return this.parseIfStatement();
-  if (this.match(TokenType.KEYWORD, 'for')) return this.parseForStatement();
-  if (this.match(TokenType.KEYWORD, 'while')) return this.parseWhileStatement();
-  if (this.match(TokenType.KEYWORD, 'try')) return this.parseTryStatement();
-  if (this.match(TokenType.KEYWORD, 'with')) return this.parseWithStatement();
-  if (this.match(TokenType.KEYWORD, 'match')) return this.parseMatchStatement();
-  if (this.match(TokenType.KEYWORD, 'return')) {
-    this.consume();
-    const value = this.match(TokenType.NEWLINE) ? null : this.parseExpressionList();
-    return { type: ASTNodeType.RETURN_STATEMENT, value };
-  }
-  if (this.match(TokenType.KEYWORD, 'break')) {
-    this.consume();
-    return { type: ASTNodeType.BREAK_STATEMENT };
-  }
-  if (this.match(TokenType.KEYWORD, 'continue')) {
-    this.consume();
-    return { type: ASTNodeType.CONTINUE_STATEMENT };
-  }
-  if (this.match(TokenType.KEYWORD, 'pass')) {
-    this.consume();
-    return { type: ASTNodeType.PASS_STATEMENT };
-  }
-  if (this.match(TokenType.KEYWORD, 'assert')) {
-    this.consume();
-    const test = this.parseExpression();
-    let message: ASTNode | null = null;
-    if (this.match(TokenType.COMMA)) {
-      this.consume();
-      message = this.parseExpression();
-    }
-    return { type: ASTNodeType.ASSERT_STATEMENT, test, message };
-  }
-  if (this.match(TokenType.KEYWORD, 'raise')) {
-    this.consume();
-    const exc = this.match(TokenType.NEWLINE) ? null : this.parseExpression();
-    return { type: ASTNodeType.RAISE_STATEMENT, exception: exc };
-  }
-  if (this.match(TokenType.KEYWORD, 'global')) {
-    this.consume();
-    const names: string[] = [];
-    names.push(this.expect(TokenType.IDENTIFIER).value);
-    while (this.match(TokenType.COMMA)) {
-      this.consume();
-      names.push(this.expect(TokenType.IDENTIFIER).value);
-    }
-    return { type: ASTNodeType.GLOBAL_STATEMENT, names };
-  }
-  if (this.match(TokenType.KEYWORD, 'nonlocal')) {
-    this.consume();
-    const names: string[] = [];
-    names.push(this.expect(TokenType.IDENTIFIER).value);
-    while (this.match(TokenType.COMMA)) {
-      this.consume();
-      names.push(this.expect(TokenType.IDENTIFIER).value);
-    }
-    return { type: ASTNodeType.NONLOCAL_STATEMENT, names };
-  }
-  if (this.match(TokenType.KEYWORD, 'del')) {
-    this.consume();
-    const target = this.parseExpression();
-    return { type: ASTNodeType.DELETE_STATEMENT, target };
-  }
-  return this.parseAssignmentOrExpression();
-}
-
-export function parseProgram(this: Parser): ASTNode {
-  const body: ASTNode[] = [];
-  this.skipNewlines();
-  while (this.pos < this.tokens.length && !this.match(TokenType.EOF)) {
-    const stmt = this.parseStatement();
-    body.push(stmt);
-    this.skipNewlines();
-  }
-  this.expect(TokenType.EOF);
-  return { type: ASTNodeType.PROGRAM, body };
-}

package/src/parser/targets.ts

@@ -1,71 +0,0 @@
-import type { Parser } from './parser';
-import { ASTNode, ASTNodeType, TokenType } from '../types';
-
-export function parsePostfixTarget(this: Parser): ASTNode {
-  let expr = this.parseAtom();
-  while (
-    this.match(TokenType.LBRACKET) ||
-    (this.match(TokenType.DOT) && this.peek(1)?.type === TokenType.IDENTIFIER)
-  ) {
-    if (this.match(TokenType.LBRACKET)) {
-      this.consume();
-      const index = this.parseSlice();
-      this.expect(TokenType.RBRACKET);
-      expr = { type: ASTNodeType.SUBSCRIPT, object: expr, index };
-    } else if (this.match(TokenType.DOT)) {
-      this.consume();
-      const name = this.expect(TokenType.IDENTIFIER).value;
-      expr = { type: ASTNodeType.ATTRIBUTE, object: expr, name };
-    }
-  }
-  return expr;
-}
-
-export function parseTargetElement(this: Parser): ASTNode {
-  if (this.match(TokenType.OPERATOR, '*')) {
-    this.consume();
-    const target = this.parseTargetElement();
-    return { type: ASTNodeType.STARRED, target };
-  }
-  if (this.match(TokenType.IDENTIFIER)) return this.parsePostfixTarget();
-  if (this.match(TokenType.LPAREN)) {
-    this.consume();
-    const target = this.parseTarget();
-    this.expect(TokenType.RPAREN);
-    return target;
-  }
-  if (this.match(TokenType.LBRACKET)) {
-    this.consume();
-    const elements: ASTNode[] = [];
-    if (!this.match(TokenType.RBRACKET)) {
-      elements.push(this.parseTarget());
-      while (this.match(TokenType.COMMA)) {
-        this.consume();
-        if (this.match(TokenType.RBRACKET)) break;
-        elements.push(this.parseTarget());
-      }
-    }
-    this.expect(TokenType.RBRACKET);
-    return { type: ASTNodeType.LIST_LITERAL, elements };
-  }
-  return this.parsePostfixTarget();
-}
-
-export function parseTarget(this: Parser): ASTNode {
-  if (this.match(TokenType.OPERATOR, '*')) {
-    this.consume();
-    const target = this.parseTargetElement();
-    return { type: ASTNodeType.STARRED, target };
-  }
-  const first = this.parseTargetElement();
-  if (this.match(TokenType.COMMA)) {
-    const elements = [first];
-    while (this.match(TokenType.COMMA)) {
-      this.consume();
-      if (this.match(TokenType.NEWLINE) || this.match(TokenType.EOF)) break;
-      elements.push(this.parseTargetElement());
-    }
-    return { type: ASTNodeType.TUPLE_LITERAL, elements };
-  }
-  return first;
-}

package/src/types/ast.ts

@@ -1,64 +0,0 @@
-/**
- * AST 节点类型定义
- */
-export interface ASTNode {
-  type: string;
-  [key: string]: any;
-}
-
-export enum ASTNodeType {
-  PROGRAM = 'Program',
-  ASSIGNMENT = 'Assignment',
-  AUG_ASSIGNMENT = 'AugAssignment',
-  EXPRESSION_STATEMENT = 'ExpressionStatement',
-  IF_STATEMENT = 'IfStatement',
-  WHILE_STATEMENT = 'WhileStatement',
-  FOR_STATEMENT = 'ForStatement',
-  FUNCTION_DEF = 'FunctionDef',
-  RETURN_STATEMENT = 'ReturnStatement',
-  BREAK_STATEMENT = 'BreakStatement',
-  CONTINUE_STATEMENT = 'ContinueStatement',
-  PASS_STATEMENT = 'PassStatement',
-  IMPORT_STATEMENT = 'ImportStatement',
-  CLASS_DEF = 'ClassDef',
-  TRY_STATEMENT = 'TryStatement',
-  WITH_STATEMENT = 'WithStatement',
-  ASSERT_STATEMENT = 'AssertStatement',
-  RAISE_STATEMENT = 'RaiseStatement',
-  GLOBAL_STATEMENT = 'GlobalStatement',
-  NONLOCAL_STATEMENT = 'NonlocalStatement',
-  DELETE_STATEMENT = 'DeleteStatement',
-  MATCH_STATEMENT = 'MatchStatement',
-  MATCH_CASE = 'MatchCase',
-  MATCH_PATTERN_VALUE = 'MatchPatternValue',
-  MATCH_PATTERN_CAPTURE = 'MatchPatternCapture',
-  MATCH_PATTERN_WILDCARD = 'MatchPatternWildcard',
-  MATCH_PATTERN_OR = 'MatchPatternOr',
-  MATCH_PATTERN_SEQUENCE = 'MatchPatternSequence',
-
-  BINARY_OPERATION = 'BinaryOperation',
-  UNARY_OPERATION = 'UnaryOperation',
-  NUMBER_LITERAL = 'NumberLiteral',
-  STRING_LITERAL = 'StringLiteral',
-  BOOLEAN_LITERAL = 'BooleanLiteral',
-  NONE_LITERAL = 'NoneLiteral',
-  LIST_LITERAL = 'ListLiteral',
-  TUPLE_LITERAL = 'TupleLiteral',
-  DICT_LITERAL = 'DictLiteral',
-  SET_LITERAL = 'SetLiteral',
-  IDENTIFIER = 'Identifier',
-  ATTRIBUTE = 'Attribute',
-  SUBSCRIPT = 'Subscript',
-  SLICE = 'Slice',
-  CALL = 'Call',
-  COMPARE = 'Compare',
-  BOOL_OPERATION = 'BoolOperation',
-  IF_EXPRESSION = 'IfExpression',
-  LAMBDA = 'Lambda',
-  LIST_COMP = 'ListComp',
-  DICT_COMP = 'DictComp',
-  SET_COMP = 'SetComp',
-  GENERATOR_EXPR = 'GeneratorExpr',
-  YIELD = 'Yield',
-  STARRED = 'Starred',
-}

package/src/types/bytecode.ts

@@ -1,50 +0,0 @@
-/**
- * 字节码类型定义
- */
-export interface ByteCode {
-  instructions: Instruction[];
-  constants: any[];
-  names: string[];
-  ast?: any;
-}
-
-export interface Instruction {
-  opcode: OpCode;
-  arg?: number;
-}
-
-export enum OpCode {
-  // Loading and storing
-  LOAD_CONST,
-  LOAD_NAME,
-  STORE_NAME,
-
-  // Binary operations
-  BINARY_ADD,
-  BINARY_SUBTRACT,
-  BINARY_MULTIPLY,
-  BINARY_DIVIDE,
-  BINARY_MODULO,
-  BINARY_POWER,
-
-  // Comparison operations
-  COMPARE_EQ,
-  COMPARE_NE,
-  COMPARE_LT,
-  COMPARE_GT,
-  COMPARE_LE,
-  COMPARE_GE,
-
-  // Logical operations
-  LOGICAL_AND,
-  LOGICAL_OR,
-  LOGICAL_NOT,
-
-  // Function calls
-  CALL_FUNCTION,
-  RETURN_VALUE,
-
-  // Print
-  PRINT_ITEM,
-  PRINT_NEWLINE,
-}

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export * from './token';
-export * from './ast';
-export * from './bytecode';

package/src/types/token.ts

@@ -1,44 +0,0 @@
-/**
- * Token 类型定义
- */
-export interface Token {
-  type: TokenType;
-  value: string;
-  line: number;
-  column: number;
-}
-
-export enum TokenType {
-  // Keywords
-  KEYWORD,
-  // Identifiers
-  IDENTIFIER,
-  // Literals
-  NUMBER,
-  STRING,
-  BOOLEAN,
-  NONE,
-  // Operators
-  OPERATOR,
-  // Parentheses
-  LPAREN,
-  RPAREN,
-  LBRACKET,
-  RBRACKET,
-  LBRACE,
-  RBRACE,
-  // Assignment
-  ASSIGN,
-  // Colon
-  COLON,
-  // Comma
-  COMMA,
-  DOT,
-  AT,
-  // End of file
-  EOF,
-  // Indentation
-  INDENT,
-  DEDENT,
-  NEWLINE,
-}