@lewin671/python-vm 0.1.0 → 0.1.1

package/src/parser/expressions.ts

@@ -1,462 +0,0 @@
-import type { Parser } from './parser';
-import { ASTNode, ASTNodeType, TokenType } from '../types';
-
-export function parseStringLiteral(this: Parser): ASTNode {
-  let value = '';
-  while (this.match(TokenType.STRING)) value += this.consume().value;
-  return { type: ASTNodeType.STRING_LITERAL, value };
-}
-
-export function parseLiteral(this: Parser): ASTNode {
-  const token = this.peek();
-  if (!token) throw new Error('Expected literal');
-  if (token.type === TokenType.NUMBER) {
-    this.consume();
-    return { type: ASTNodeType.NUMBER_LITERAL, value: token.value };
-  }
-  if (token.type === TokenType.STRING) return this.parseStringLiteral();
-  if (token.type === TokenType.BOOLEAN) {
-    this.consume();
-    return { type: ASTNodeType.BOOLEAN_LITERAL, value: token.value === 'True' };
-  }
-  if (token.type === TokenType.NONE) {
-    this.consume();
-    return { type: ASTNodeType.NONE_LITERAL, value: null };
-  }
-  throw new Error(`Unexpected token type for literal: ${TokenType[token.type]}`);
-}
-
-export function parseIdentifier(this: Parser): ASTNode {
-  const token = this.expect(TokenType.IDENTIFIER);
-  return { type: ASTNodeType.IDENTIFIER, name: token.value };
-}
-
-export function parseArguments(this: Parser): ASTNode[] {
-  const args: ASTNode[] = [];
-  if (!this.match(TokenType.RPAREN)) {
-    while (true) {
-      if (this.match(TokenType.OPERATOR, '*') || this.match(TokenType.OPERATOR, '**')) {
-        const op = this.consume().value;
-        const value = this.parseExpression();
-        args.push({ type: op === '*' ? 'StarArg' : 'KwArg', value } as any);
-      } else if (this.match(TokenType.IDENTIFIER) && this.peek(1)?.type === TokenType.ASSIGN) {
-        const name = this.consume().value;
-        this.consume();
-        const value = this.parseExpression();
-        args.push({ type: 'KeywordArg', name, value } as any);
-      } else {
-        args.push(this.parseExpression());
-      }
-      if (!this.match(TokenType.COMMA)) break;
-      this.consume();
-      if (this.match(TokenType.RPAREN)) break;
-    }
-  }
-  return args;
-}
-
-export function parseSlice(this: Parser): ASTNode {
-  let start: ASTNode | null = null;
-  let end: ASTNode | null = null;
-  let step: ASTNode | null = null;
-  if (!this.match(TokenType.COLON)) start = this.parseExpression();
-  if (this.match(TokenType.COLON)) {
-    this.consume();
-    if (!this.match(TokenType.COLON) && !this.match(TokenType.RBRACKET)) end = this.parseExpression();
-    if (this.match(TokenType.COLON)) {
-      this.consume();
-      if (!this.match(TokenType.RBRACKET)) step = this.parseExpression();
-    }
-    return { type: ASTNodeType.SLICE, start, end, step };
-  }
-  return start as ASTNode;
-}
-
-export function parsePatternAtom(this: Parser): ASTNode {
-  if (this.match(TokenType.NUMBER) || this.match(TokenType.STRING) || this.match(TokenType.BOOLEAN) || this.match(TokenType.NONE)) {
-    return { type: ASTNodeType.MATCH_PATTERN_VALUE, value: this.parseLiteral() } as any;
-  }
-  if (this.match(TokenType.IDENTIFIER)) {
-    const name = this.consume().value;
-    if (name === '_') return { type: ASTNodeType.MATCH_PATTERN_WILDCARD } as any;
-    return { type: ASTNodeType.MATCH_PATTERN_CAPTURE, name } as any;
-  }
-  if (this.match(TokenType.LBRACKET)) {
-    this.consume();
-    const elements: ASTNode[] = [];
-    if (!this.match(TokenType.RBRACKET)) {
-      elements.push(this.parsePattern());
-      while (this.match(TokenType.COMMA)) {
-        this.consume();
-        if (this.match(TokenType.RBRACKET)) break;
-        elements.push(this.parsePattern());
-      }
-    }
-    this.expect(TokenType.RBRACKET);
-    return { type: ASTNodeType.MATCH_PATTERN_SEQUENCE, elements } as any;
-  }
-  throw new Error(`Unexpected token in pattern: ${this.peek()?.value}`);
-}
-
-export function parsePattern(this: Parser): ASTNode {
-  let pattern = this.parsePatternAtom();
-  if (this.match(TokenType.OPERATOR, '|')) {
-    const patterns: ASTNode[] = [pattern];
-    while (this.match(TokenType.OPERATOR, '|')) {
-      this.consume();
-      patterns.push(this.parsePatternAtom());
-    }
-    pattern = { type: ASTNodeType.MATCH_PATTERN_OR, patterns } as any;
-  }
-  return pattern;
-}
-
-export function parseLambdaParameters(this: Parser): string[] {
-  const params: string[] = [];
-  if (this.match(TokenType.COLON)) return params;
-  while (true) {
-    if (this.match(TokenType.OPERATOR, '*')) {
-      this.consume();
-      params.push(`*${this.expect(TokenType.IDENTIFIER).value}`);
-    } else if (this.match(TokenType.OPERATOR, '**')) {
-      this.consume();
-      params.push(`**${this.expect(TokenType.IDENTIFIER).value}`);
-    } else {
-      const name = this.expect(TokenType.IDENTIFIER).value;
-      if (this.match(TokenType.ASSIGN)) {
-        this.consume();
-        this.parseExpression();
-      }
-      params.push(name);
-    }
-    if (!this.match(TokenType.COMMA)) break;
-    this.consume();
-  }
-  return params;
-}
-
-export function parseLambda(this: Parser): ASTNode {
-  this.consume(); // lambda
-  const params = this.parseLambdaParameters();
-  this.expect(TokenType.COLON);
-  const body = this.parseExpression();
-  return { type: ASTNodeType.LAMBDA, params, body };
-}
-
-export function parseAtom(this: Parser): ASTNode {
-  if (this.match(TokenType.LPAREN)) {
-    this.consume();
-    if (this.match(TokenType.RPAREN)) {
-      this.consume();
-      return { type: ASTNodeType.TUPLE_LITERAL, elements: [] };
-    }
-    const expr = this.parseExpression();
-    if (this.match(TokenType.KEYWORD, 'for')) {
-      const comprehension = this.parseComprehension(expr);
-      this.expect(TokenType.RPAREN);
-      return { type: ASTNodeType.GENERATOR_EXPR, expression: expr, comprehension };
-    }
-    if (this.match(TokenType.COMMA)) {
-      const elements = [expr];
-      while (this.match(TokenType.COMMA)) {
-        this.consume();
-        if (this.match(TokenType.RPAREN)) break;
-        elements.push(this.parseExpression());
-      }
-      this.expect(TokenType.RPAREN);
-      return { type: ASTNodeType.TUPLE_LITERAL, elements };
-    }
-    this.expect(TokenType.RPAREN);
-    return expr;
-  }
-  if (this.match(TokenType.KEYWORD, 'yield')) {
-    this.consume();
-    const value = this.match(TokenType.NEWLINE) || this.match(TokenType.COMMA) || this.match(TokenType.RPAREN) ? null : this.parseExpression();
-    return { type: ASTNodeType.YIELD, value };
-  }
-  if (this.match(TokenType.KEYWORD, 'lambda')) {
-    return this.parseLambda();
-  }
-  if (this.match(TokenType.LBRACKET)) {
-    this.consume();
-    if (this.match(TokenType.RBRACKET)) {
-      this.consume();
-      return { type: ASTNodeType.LIST_LITERAL, elements: [] };
-    }
-    const first = this.parseExpression();
-    if (this.match(TokenType.KEYWORD, 'for')) {
-      const comprehension = this.parseComprehension(first);
-      this.expect(TokenType.RBRACKET);
-      return { type: ASTNodeType.LIST_COMP, expression: first, comprehension };
-    }
-    const elements = [first];
-    while (this.match(TokenType.COMMA)) {
-      this.consume();
-      if (this.match(TokenType.RBRACKET)) break;
-      elements.push(this.parseExpression());
-    }
-    this.expect(TokenType.RBRACKET);
-    return { type: ASTNodeType.LIST_LITERAL, elements };
-  }
-  if (this.match(TokenType.LBRACE)) {
-    this.consume();
-    if (this.match(TokenType.RBRACE)) {
-      this.consume();
-      return { type: ASTNodeType.DICT_LITERAL, entries: [] };
-    }
-    const key = this.parseExpression();
-    if (this.match(TokenType.COLON)) {
-      this.consume();
-      const value = this.parseExpression();
-      if (this.match(TokenType.KEYWORD, 'for')) {
-        const comprehension = this.parseComprehension({ type: 'KeyValue', key, value } as any);
-        this.expect(TokenType.RBRACE);
-        return { type: ASTNodeType.DICT_COMP, key, value, comprehension };
-      }
-      const entries = [{ key, value }];
-      while (this.match(TokenType.COMMA)) {
-        this.consume();
-        if (this.match(TokenType.RBRACE)) break;
-        const k = this.parseExpression();
-        this.expect(TokenType.COLON);
-        const v = this.parseExpression();
-        entries.push({ key: k, value: v });
-      }
-      this.expect(TokenType.RBRACE);
-      return { type: ASTNodeType.DICT_LITERAL, entries };
-    }
-    if (this.match(TokenType.KEYWORD, 'for')) {
-      const comprehension = this.parseComprehension(key);
-      this.expect(TokenType.RBRACE);
-      return { type: ASTNodeType.SET_COMP, expression: key, comprehension };
-    }
-    const elements = [key];
-    while (this.match(TokenType.COMMA)) {
-      this.consume();
-      if (this.match(TokenType.RBRACE)) break;
-      elements.push(this.parseExpression());
-    }
-    this.expect(TokenType.RBRACE);
-    return { type: ASTNodeType.SET_LITERAL, elements };
-  }
-  if (this.match(TokenType.IDENTIFIER)) {
-    const name = this.consume().value;
-    return { type: ASTNodeType.IDENTIFIER, name };
-  }
-  return this.parseLiteral();
-}
-
-export function parsePostfix(this: Parser): ASTNode {
-  let expr = this.parseAtom();
-  while (
-    this.match(TokenType.LPAREN) ||
-    this.match(TokenType.LBRACKET) ||
-    (this.match(TokenType.DOT) && this.peek(1)?.type === TokenType.IDENTIFIER)
-  ) {
-    if (this.match(TokenType.LPAREN)) {
-      this.consume();
-      const args = this.parseArguments();
-      this.expect(TokenType.RPAREN);
-      expr = { type: ASTNodeType.CALL, callee: expr, args };
-    } else 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 parseUnary(this: Parser): ASTNode {
-  if (this.match(TokenType.OPERATOR, '+') || this.match(TokenType.OPERATOR, '-') || this.match(TokenType.OPERATOR, '~')) {
-    const operator = this.consume().value;
-    const operand = this.parseUnary();
-    return { type: ASTNodeType.UNARY_OPERATION, operator, operand };
-  }
-  if (this.match(TokenType.KEYWORD) && this.peek()?.value === 'not') {
-    this.consume();
-    const operand = this.parseUnary();
-    return { type: ASTNodeType.UNARY_OPERATION, operator: 'not', operand };
-  }
-  return this.parsePostfix();
-}
-
-export function parsePower(this: Parser): ASTNode {
-  let left = this.parseUnary();
-  if (this.match(TokenType.OPERATOR, '**')) {
-    this.consume();
-    const right = this.parsePower();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator: '**', left, right };
-  }
-  return left;
-}
-
-export function parseFactor(this: Parser): ASTNode {
-  let left = this.parsePower();
-  while (this.match(TokenType.OPERATOR, '*') || this.match(TokenType.OPERATOR, '/') || this.match(TokenType.OPERATOR, '//') || this.match(TokenType.OPERATOR, '%')) {
-    const operator = this.consume().value;
-    const right = this.parsePower();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator, left, right };
-  }
-  return left;
-}
-
-export function parseTerm(this: Parser): ASTNode {
-  let left = this.parseFactor();
-  while (this.match(TokenType.OPERATOR, '+') || this.match(TokenType.OPERATOR, '-')) {
-    const operator = this.consume().value;
-    const right = this.parseFactor();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator, left, right };
-  }
-  return left;
-}
-
-export function parseShift(this: Parser): ASTNode {
-  let left = this.parseTerm();
-  while (this.match(TokenType.OPERATOR, '<<') || this.match(TokenType.OPERATOR, '>>')) {
-    const operator = this.consume().value;
-    const right = this.parseTerm();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator, left, right };
-  }
-  return left;
-}
-
-export function parseBitAnd(this: Parser): ASTNode {
-  let left = this.parseShift();
-  while (this.match(TokenType.OPERATOR, '&')) {
-    this.consume();
-    const right = this.parseShift();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator: '&', left, right };
-  }
-  return left;
-}
-
-export function parseBitXor(this: Parser): ASTNode {
-  let left = this.parseBitAnd();
-  while (this.match(TokenType.OPERATOR, '^')) {
-    this.consume();
-    const right = this.parseBitAnd();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator: '^', left, right };
-  }
-  return left;
-}
-
-export function parseBitOr(this: Parser): ASTNode {
-  let left = this.parseBitXor();
-  while (this.match(TokenType.OPERATOR, '|')) {
-    this.consume();
-    const right = this.parseBitXor();
-    left = { type: ASTNodeType.BINARY_OPERATION, operator: '|', left, right };
-  }
-  return left;
-}
-
-export function parseComparison(this: Parser): ASTNode {
-  let left = this.parseBitOr();
-  const operators: string[] = [];
-  const comparators: ASTNode[] = [];
-  while (true) {
-    if (this.match(TokenType.KEYWORD, 'not') && this.peek(1)?.type === TokenType.KEYWORD && this.peek(1)?.value === 'in') {
-      this.consume();
-      this.consume();
-      operators.push('not in');
-      comparators.push(this.parseBitOr());
-      continue;
-    }
-    if (this.match(TokenType.KEYWORD, 'is') && this.peek(1)?.type === TokenType.KEYWORD && this.peek(1)?.value === 'not') {
-      this.consume();
-      this.consume();
-      operators.push('is not');
-      comparators.push(this.parseBitOr());
-      continue;
-    }
-    if (
-      this.match(TokenType.OPERATOR, '==') ||
-      this.match(TokenType.OPERATOR, '!=') ||
-      this.match(TokenType.OPERATOR, '<') ||
-      this.match(TokenType.OPERATOR, '>') ||
-      this.match(TokenType.OPERATOR, '<=') ||
-      this.match(TokenType.OPERATOR, '>=') ||
-      this.match(TokenType.KEYWORD, 'in') ||
-      this.match(TokenType.KEYWORD, 'is')
-    ) {
-      operators.push(this.consume().value);
-      comparators.push(this.parseBitOr());
-      continue;
-    }
-    break;
-  }
-  if (operators.length === 0) return left;
-  return { type: ASTNodeType.COMPARE, left, ops: operators, comparators };
-}
-
-export function parseNot(this: Parser): ASTNode {
-  if (this.match(TokenType.KEYWORD, 'not')) {
-    this.consume();
-    const operand = this.parseNot();
-    return { type: ASTNodeType.UNARY_OPERATION, operator: 'not', operand };
-  }
-  return this.parseComparison();
-}
-
-export function parseAnd(this: Parser): ASTNode {
-  let left = this.parseNot();
-  while (this.match(TokenType.KEYWORD, 'and')) {
-    this.consume();
-    const right = this.parseNot();
-    left = { type: ASTNodeType.BOOL_OPERATION, operator: 'and', values: [left, right] };
-  }
-  return left;
-}
-
-export function parseOr(this: Parser): ASTNode {
-  let left = this.parseAnd();
-  while (this.match(TokenType.KEYWORD, 'or')) {
-    this.consume();
-    const right = this.parseAnd();
-    left = { type: ASTNodeType.BOOL_OPERATION, operator: 'or', values: [left, right] };
-  }
-  return left;
-}
-
-export function parseIfExpression(this: Parser): ASTNode {
-  const expr = this.parseOr();
-  if (this.match(TokenType.KEYWORD, 'if')) {
-    this.consume();
-    const test = this.parseOr();
-    this.expect(TokenType.KEYWORD, 'else');
-    const alternate = this.parseIfExpression();
-    return { type: ASTNodeType.IF_EXPRESSION, test, consequent: expr, alternate };
-  }
-  return expr;
-}
-
-export function parseExpression(this: Parser): ASTNode {
-  return this.parseIfExpression();
-}
-
-export function parseExpressionNoIf(this: Parser): ASTNode {
-  return this.parseOr();
-}
-
-export function parseComprehension(this: Parser, expression: ASTNode): ASTNode {
-  const clauses: any[] = [];
-  while (this.match(TokenType.KEYWORD, 'for')) {
-    this.consume();
-    const target = this.parseTarget();
-    this.expect(TokenType.KEYWORD, 'in');
-    const iter = this.parseExpressionNoIf();
-    const ifs: ASTNode[] = [];
-    while (this.match(TokenType.KEYWORD, 'if')) {
-      this.consume();
-      ifs.push(this.parseExpression());
-    }
-    clauses.push({ target, iter, ifs });
-  }
-  return { clauses, expression } as any;
-}

package/src/parser/index.ts

@@ -1 +0,0 @@
-export { Parser } from './parser';

package/src/parser/parser.ts

@@ -1,102 +0,0 @@
-import { Token, TokenType, ASTNode } from '../types';
-import * as Expr from './expressions';
-import * as Target from './targets';
-import * as Stmt from './statements';
-
-export class Parser {
-  tokens: Token[];
-  pos = 0;
-
-  constructor(tokens: Token[]) {
-    this.tokens = tokens;
-  }
-
-  peek(offset: number = 0): Token | null {
-    return this.pos + offset < this.tokens.length ? this.tokens[this.pos + offset] : null;
-  }
-
-  consume(): Token {
-    if (this.pos >= this.tokens.length) throw new Error('Unexpected end of input');
-    return this.tokens[this.pos++];
-  }
-
-  match(type: TokenType, value?: string): boolean {
-    const token = this.peek();
-    return !!token && token.type === type && (value === undefined || token.value === value);
-  }
-
-  expect(type: TokenType, value?: string): Token {
-    const token = this.peek();
-    if (!token) throw new Error(`Expected ${TokenType[type]}${value ? ` \"${value}\"` : ''}, but got end of input`);
-    if (token.type !== type) {
-      throw new Error(
-        `Expected ${TokenType[type]}${value ? ` \"${value}\"` : ''}, but got ${TokenType[token.type]} \"${token.value}\" at line ${token.line}`
-      );
-    }
-    if (value !== undefined && token.value !== value) {
-      throw new Error(`Expected \"${value}\", but got \"${token.value}\" at line ${token.line}`);
-    }
-    return this.consume();
-  }
-
-  skipNewlines(): void {
-    while (this.match(TokenType.NEWLINE)) {
-      this.consume();
-    }
-  }
-
-  // Expression parsing
-  parseStringLiteral = Expr.parseStringLiteral;
-  parseLiteral = Expr.parseLiteral;
-  parseIdentifier = Expr.parseIdentifier;
-  parseArguments = Expr.parseArguments;
-  parseSlice = Expr.parseSlice;
-  parsePatternAtom = Expr.parsePatternAtom;
-  parsePattern = Expr.parsePattern;
-  parseLambdaParameters = Expr.parseLambdaParameters;
-  parseLambda = Expr.parseLambda;
-  parseAtom = Expr.parseAtom;
-  parsePostfix = Expr.parsePostfix;
-  parsePostfixTarget = Target.parsePostfixTarget;
-  parseTargetElement = Target.parseTargetElement;
-  parseTarget = Target.parseTarget;
-  parseUnary = Expr.parseUnary;
-  parsePower = Expr.parsePower;
-  parseFactor = Expr.parseFactor;
-  parseTerm = Expr.parseTerm;
-  parseShift = Expr.parseShift;
-  parseBitAnd = Expr.parseBitAnd;
-  parseBitXor = Expr.parseBitXor;
-  parseBitOr = Expr.parseBitOr;
-  parseComparison = Expr.parseComparison;
-  parseNot = Expr.parseNot;
-  parseAnd = Expr.parseAnd;
-  parseOr = Expr.parseOr;
-  parseIfExpression = Expr.parseIfExpression;
-  parseExpression = Expr.parseExpression;
-  parseExpressionNoIf = Expr.parseExpressionNoIf;
-  parseComprehension = Expr.parseComprehension;
-
-  // Statement parsing
-  parseExpressionStatement = Stmt.parseExpressionStatement;
-  parseExpressionList = Stmt.parseExpressionList;
-  parseAssignmentOrExpression = Stmt.parseAssignmentOrExpression;
-  parseBlock = Stmt.parseBlock;
-  parseIfStatement = Stmt.parseIfStatement;
-  parseWhileStatement = Stmt.parseWhileStatement;
-  parseForStatement = Stmt.parseForStatement;
-  parseFunctionParameters = Stmt.parseFunctionParameters;
-  parseFunctionDef = Stmt.parseFunctionDef;
-  parseClassDef = Stmt.parseClassDef;
-  parseDecorators = Stmt.parseDecorators;
-  parseTryStatement = Stmt.parseTryStatement;
-  parseWithStatement = Stmt.parseWithStatement;
-  parseMatchStatement = Stmt.parseMatchStatement;
-  parseImportStatement = Stmt.parseImportStatement;
-  parseStatement = Stmt.parseStatement;
-  parseProgram = Stmt.parseProgram;
-
-  parse(): ASTNode {
-    return this.parseProgram();
-  }
-}