lny-interpreter 0.99.0

package/src/parser/parser.ts

@@ -0,0 +1,711 @@
+import { Token, TokenType, Lexer } from '../lexer/lexer';
+import * as AST from '../ast/ast';
+import { Language, I18n } from '../i18n/i18n';
+
+export class Parser {
+  private tokens: Token[];
+  private current: number = 0;
+  private i18n: I18n;
+
+  constructor(source: string, language: Language = 'de') {
+    this.i18n = new I18n(language);
+    const lexer = new Lexer(source, language);
+    this.tokens = lexer.tokenize();
+  }
+
+  private syntax(message: string): Error {
+    const token = this.getErrorToken();
+    if (token) {
+      return new Error(
+        `${this.i18n.t('error_syntax')}: ${message} (line ${token.line}, column ${token.column})`
+      );
+    }
+    return new Error(`${this.i18n.t('error_syntax')}: ${message}`);
+  }
+
+  private getErrorToken(): Token | undefined {
+    if (this.current >= 0 && this.current < this.tokens.length) {
+      return this.tokens[this.current];
+    }
+    if (this.current > 0 && this.current - 1 < this.tokens.length) {
+      return this.tokens[this.current - 1];
+    }
+    return undefined;
+  }
+
+  parse(): AST.Program {
+    const statements: AST.Statement[] = [];
+    while (!this.isAtEnd()) {
+      const stmt = this.parseStatement();
+      if (stmt) {
+        statements.push(stmt);
+      }
+    }
+    return {
+      type: 'Program',
+      body: statements,
+    };
+  }
+
+  private parseStatement(): AST.Statement | null {
+    // Comments
+    if (this.match(TokenType.REM)) {
+      return this.parseComment();
+    }
+
+    // Variable declaration
+    if (this.match(TokenType.VAR)) {
+      return this.parseVariableDeclaration();
+    }
+
+    // Explicit variable assignment with SET keyword
+    if (this.match(TokenType.SET)) {
+      return this.parseSetAssignment();
+    }
+
+
+
+    // Variable assignment
+    if (this.check(TokenType.IDENTIFIER)) {
+      const checkpoint = this.current;
+      const identifier = this.advance();
+
+      if (this.isAssignmentOperator(this.peek().type)) {
+        return this.parseAssignmentFromIdentifier(identifier.value);
+      }
+
+      // If not assignment, reset and parse as expression statement
+      this.current = checkpoint;
+    }
+
+    // Control Flow
+    if (this.match(TokenType.IF)) {
+      return this.parseIfStatement();
+    }
+
+    if (this.match(TokenType.WHILE)) {
+      return this.parseWhileStatement();
+    }
+
+    if (this.match(TokenType.FOR)) {
+      return this.parseForStatement();
+    }
+
+    // Procedure declaration
+    if (this.match(TokenType.PROC)) {
+      return this.parseProcedureDeclaration();
+    }
+
+    // Log statement
+    if (this.match(TokenType.LOG)) {
+      return this.parseLogStatement();
+    }
+
+    // Return statement
+    if (this.match(TokenType.RETURN)) {
+      return this.parseReturnStatement();
+    }
+
+    // Expression statement
+    if (!this.isAtEnd()) {
+      return {
+        type: 'ExpressionStatement',
+        expression: this.parseExpression(),
+      };
+    }
+
+    return null;
+  }
+
+  private parseComment(): AST.CommentStatement {
+    // Das aktuelle Token ist das Kommentar-Token (REM), also einfach übernehmen
+    const token = this.peek();
+    const text = token.value;
+    this.advance(); // Zum nächsten Token weitergehen
+    return {
+      type: 'CommentStatement',
+      text: text.trim(),
+    };
+  }
+
+  private parseVariableDeclaration(): AST.VariableDeclaration {
+    const varToken = this.previous();
+    const name = this.expectIdentifier('Expected variable name after VAR');
+    let initialValue: AST.Expression | undefined;
+
+    if (this.match(TokenType.ASSIGN)) {
+      initialValue = this.parseExpression();
+    }
+
+    return {
+      type: 'VariableDeclaration',
+      name,
+      initialValue,
+      line: varToken.line,
+      column: varToken.column
+    };
+  }
+
+  private parseSetAssignment(): AST.VariableAssignment {
+    const setToken = this.previous();
+    const name = this.expectIdentifier('Expected variable name after SETZE');
+    if (!this.match(TokenType.AUF)) {
+      throw this.syntax('Expected AUF after variable name in SETZE statement');
+    }
+    const value = this.parseExpression();
+    return {
+      type: 'VariableAssignment',
+      name,
+      operator: 'AUF',
+      value,
+      line: setToken.line,
+      column: setToken.column
+    };
+  }
+
+  private parseAssignmentFromIdentifier(name: string): AST.VariableAssignment {
+    const nameToken = this.previous();
+    if (!this.isAssignmentOperator(this.peek().type)) {
+      throw this.syntax('Expected assignment operator (<<, +=, -=, *=, /=)');
+    }
+
+    const operator = this.advance().value;
+    const value = this.parseExpression();
+
+    return {
+      type: 'VariableAssignment',
+      name,
+      operator,
+      value,
+      line: nameToken.line,
+      column: nameToken.column
+    };
+  }
+
+  private parseIfStatement(): AST.IfStatement {
+    const condition = this.parseExpression();
+
+    if (!this.match(TokenType.THEN)) {
+      throw this.syntax('Expected THEN after IF condition');
+    }
+
+    const consequent: AST.Statement[] = [];
+    while (!this.check(TokenType.ELSE) && !this.check(TokenType.END) && !this.isAtEnd()) {
+      const stmt = this.parseStatement();
+      if (stmt) consequent.push(stmt);
+    }
+
+    let alternate: AST.Statement[] | undefined;
+
+    if (this.match(TokenType.ELSE)) {
+      alternate = [];
+      while (!this.check(TokenType.END) && !this.isAtEnd()) {
+        const stmt = this.parseStatement();
+        if (stmt) alternate.push(stmt);
+      }
+    }
+
+    // Allow EOF as implicit END (for REPL)
+    if (!this.match(TokenType.END)) {
+      if (!this.isAtEnd()) {
+        throw this.syntax('Expected END after IF statement');
+      }
+    }
+
+    return {
+      type: 'IfStatement',
+      condition,
+      consequent,
+      alternate,
+    };
+  }
+
+  private parseWhileStatement(): AST.WhileStatement {
+    const condition = this.parseExpression();
+
+    const body: AST.Statement[] = [];
+    while (!this.check(TokenType.END) && !this.isAtEnd()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+    }
+
+    // Allow EOF as implicit END (for REPL)
+    if (!this.match(TokenType.END)) {
+      if (!this.isAtEnd()) {
+        throw this.syntax('Expected END after WHILE body');
+      }
+    }
+
+    return {
+      type: 'WhileStatement',
+      condition,
+      body,
+    };
+  }
+
+  private parseForStatement(): AST.ForStatement {
+    const variable = this.expectIdentifier('Expected variable name after FOR');
+
+    if (!this.match(TokenType.IN)) {
+      throw this.syntax('Expected IN after FOR variable');
+    }
+
+    const iterable = this.parseExpression();
+
+    const body: AST.Statement[] = [];
+    while (!this.check(TokenType.END) && !this.isAtEnd()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+    }
+
+    // Allow EOF as implicit END (for REPL)
+    if (!this.match(TokenType.END)) {
+      if (!this.isAtEnd()) {
+        throw this.syntax('Expected END after FOR body');
+      }
+    }
+
+    return {
+      type: 'ForStatement',
+      variable,
+      iterable,
+      body,
+    };
+  }
+
+  private parseProcedureDeclaration(): AST.ProcedureDeclaration {
+    const name = this.expectIdentifier('Expected procedure name');
+    const parameters: string[] = [];
+
+    // Parse parameters if they exist
+    if (this.match(TokenType.LPAREN)) {
+      if (!this.check(TokenType.RPAREN)) {
+        do {
+          parameters.push(this.expectIdentifier('Expected parameter name'));
+        } while (this.match(TokenType.COMMA));
+      }
+
+      if (!this.match(TokenType.RPAREN)) {
+        throw this.syntax('Expected ) after parameters');
+      }
+    }
+
+    const body: AST.Statement[] = [];
+    while (!this.check(TokenType.END) && !this.isAtEnd()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+    }
+
+    if (!this.match(TokenType.END)) {
+      throw this.syntax('Expected END after PROC body');
+    }
+
+    return {
+      type: 'ProcedureDeclaration',
+      name,
+      parameters,
+      body,
+    };
+  }
+
+  private parseLogStatement(): AST.LogStatement {
+    const expression = this.parseExpression();
+    return {
+      type: 'LogStatement',
+      expression,
+    };
+  }
+
+  private parseReturnStatement(): AST.ReturnStatement {
+    let argument: AST.Expression | undefined;
+
+    if (!this.isAtEnd() && !this.check(TokenType.END) && !this.check(TokenType.ELSE)) {
+      argument = this.parseExpression();
+    }
+
+    return {
+      type: 'ReturnStatement',
+      argument,
+    };
+  }
+
+  private parseExpression(): AST.Expression {
+    return this.parseOrExpression();
+  }
+
+  // --- List and Range Parsing ---
+  private parseListLiteral(): AST.Expression {
+    this.expect(TokenType.LBRACKET, 'Expected [');
+    // Check for range: [start..end]
+    const first = this.parseExpression();
+    if (this.match(TokenType.DOT) && this.match(TokenType.DOT)) {
+      // [start..end]
+      const end = this.parseExpression();
+      this.expect(TokenType.RBRACKET, 'Expected ] after range');
+      return {
+        type: 'RangeLiteral',
+        start: first,
+        end: end,
+      };
+    }
+    // Otherwise, normal list
+    const elements = [first];
+    while (this.match(TokenType.COMMA)) {
+      elements.push(this.parseExpression());
+    }
+    this.expect(TokenType.RBRACKET, 'Expected ] after list');
+    return {
+      type: 'ListLiteral',
+      elements,
+    };
+  }
+
+  private parseOrExpression(): AST.Expression {
+    let expr = this.parseAndExpression();
+
+    while (this.match(TokenType.OR)) {
+      const operator = this.previous().value;
+      const right = this.parseAndExpression();
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseAndExpression(): AST.Expression {
+    let expr = this.parseEqualityExpression();
+
+    while (this.match(TokenType.AND)) {
+      const operator = this.previous().value;
+      const right = this.parseEqualityExpression();
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseEqualityExpression(): AST.Expression {
+    let expr = this.parseRelationalExpression();
+
+    while (this.match(TokenType.EQUAL, TokenType.NOT_EQUAL)) {
+      const operator = this.previous().value;
+      const right = this.parseRelationalExpression();
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseRelationalExpression(): AST.Expression {
+    let expr = this.parseAdditiveExpression();
+
+    while (this.match(TokenType.LESS, TokenType.GREATER, TokenType.LESS_EQUAL, TokenType.GREATER_EQUAL)) {
+      const operator = this.previous().value;
+      const right = this.parseAdditiveExpression();
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseAdditiveExpression(): AST.Expression {
+    let expr = this.parseMultiplicativeExpression();
+
+    while (this.match(TokenType.PLUS, TokenType.MINUS)) {
+      const operator = this.previous().value;
+      const right = this.parseMultiplicativeExpression();
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseMultiplicativeExpression(): AST.Expression {
+    let expr = this.parseExponentiationExpression();
+
+    while (this.match(TokenType.MULTIPLY, TokenType.DIVIDE, TokenType.MODULO)) {
+      const operator = this.previous().value;
+      const right = this.parseExponentiationExpression();
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseExponentiationExpression(): AST.Expression {
+    let expr = this.parseUnaryExpression();
+
+    if (this.match(TokenType.POWER)) {
+      const operator = this.previous().value;
+      const right = this.parseExponentiationExpression(); // Right associative
+      expr = {
+        type: 'BinaryExpression',
+        left: expr,
+        operator,
+        right,
+      };
+    }
+
+    return expr;
+  }
+
+  private parseUnaryExpression(): AST.Expression {
+    if (this.match(TokenType.NOT, TokenType.MINUS)) {
+      const operator = this.previous().value;
+      const argument = this.parseUnaryExpression();
+      return {
+        type: 'UnaryExpression',
+        operator,
+        argument,
+      };
+    }
+
+    return this.parsePostfixExpression();
+  }
+
+  private parsePostfixExpression(): AST.Expression {
+    let expr = this.parsePrimaryExpression();
+
+    while (true) {
+      if (this.match(TokenType.LPAREN)) {
+        // Function call
+        if (expr.type !== 'Identifier') {
+          throw this.syntax('Only identifiers can be called');
+        }
+        const args: AST.Expression[] = [];
+
+        if (!this.check(TokenType.RPAREN)) {
+          do {
+            args.push(this.parseExpression());
+          } while (this.match(TokenType.COMMA));
+        }
+
+        if (!this.match(TokenType.RPAREN)) {
+          throw this.syntax('Expected ) after function arguments');
+        }
+
+        expr = {
+          type: 'CallExpression',
+          callee: expr as AST.Identifier,
+          arguments: args,
+        };
+      } else {
+        break;
+      }
+    }
+
+    return expr;
+  }
+
+  private parsePrimaryExpression(): AST.Expression {
+
+
+    // Numbers
+    if (this.check(TokenType.NUMBER)) {
+      const value = parseFloat(this.advance().value);
+      return {
+        type: 'NumberLiteral',
+        value,
+      };
+    }
+
+    // Strings
+    if (this.check(TokenType.STRING)) {
+      const value = this.advance().value;
+      return {
+        type: 'StringLiteral',
+        value,
+      };
+    }
+
+    // Booleans
+    if (this.match(TokenType.TRUE)) {
+      return {
+        type: 'BooleanLiteral',
+        value: true,
+      };
+    }
+
+    if (this.match(TokenType.FALSE)) {
+      return {
+        type: 'BooleanLiteral',
+        value: false,
+      };
+    }
+
+    // Nothing
+    if (this.match(TokenType.NOTHING)) {
+      return {
+        type: 'NothingLiteral',
+      };
+    }
+
+    // Lists (inkl. Bereichsoperator)
+    if (this.check(TokenType.LBRACKET)) {
+      return this.parseListLiteral();
+    }
+
+    // Parenthesized expressions
+    if (this.match(TokenType.LPAREN)) {
+      const expression = this.parseExpression();
+
+      if (!this.match(TokenType.RPAREN)) {
+        throw this.syntax('Expected ) after expression');
+      }
+
+      return {
+        type: 'ParenthesizedExpression',
+        expression,
+      };
+    }
+
+    // Private attribute access
+    if (this.match(TokenType.PRIVATE)) {
+      const name = this.expectIdentifier('Expected attribute name after PRIVATE');
+      return {
+        type: 'PrivateAttribute',
+        name,
+      };
+    }
+
+    // Global attribute access
+    if (this.match(TokenType.GLOBAL)) {
+      const name = this.expectIdentifier('Expected attribute name after GLOBAL');
+      return {
+        type: 'GlobalAttribute',
+        name,
+      };
+    }
+
+    // Identifiers
+    if (this.match(TokenType.IDENTIFIER)) {
+      const token = this.previous();
+      return {
+        type: 'Identifier',
+        name: token.value,
+        line: token.line,
+        column: token.column
+      };
+    }
+
+    throw this.syntax(`Unexpected token: ${this.peek().value}`);
+  }
+
+  // Helper methods
+  private expectIdentifier(expectedMessage: string): string {
+    const token = this.peek();
+
+    if (token.type === TokenType.IDENTIFIER) {
+      return this.advance().value;
+    }
+
+    if (this.isReservedWordToken(token.type)) {
+      throw this.syntax(this.i18n.t('error_reserved_word', { name: token.value }));
+    }
+
+    throw this.syntax(expectedMessage);
+  }
+
+  private isReservedWordToken(type: TokenType): boolean {
+    // Prüfe reservierte Wörter nur für die aktuelle Sprache
+    // y ist z.B. nur in Spanisch reserviert, nicht in Deutsch/Englisch
+    const reserved: TokenType[] = [
+      TokenType.IF, TokenType.THEN, TokenType.ELSE, TokenType.END, TokenType.WHILE, TokenType.FOR, TokenType.IN,
+      TokenType.VAR, TokenType.SET, TokenType.AUF, TokenType.LIST, TokenType.PROC, TokenType.RETURN, TokenType.LOG, TokenType.REM,
+      TokenType.NOT, TokenType.TRUE, TokenType.FALSE, TokenType.NOTHING, TokenType.PRIVATE, TokenType.GLOBAL
+    ];
+    // AND und OR nur reserviert, wenn sie in der aktuellen Sprache wirklich so heißen
+    if (this.i18n.t('kw_and').toLowerCase() === 'and' && type === TokenType.AND) return true;
+    if (this.i18n.t('kw_or').toLowerCase() === 'or' && type === TokenType.OR) return true;
+    // In anderen Sprachen (z.B. Spanisch: 'y' für AND) ist AND nur reserviert, wenn das aktuelle Keyword so heißt
+    if (type === TokenType.AND && this.i18n.t('kw_and').toLowerCase() !== 'and') return false;
+    if (type === TokenType.OR && this.i18n.t('kw_or').toLowerCase() !== 'or') return false;
+    return reserved.includes(type);
+  }
+
+  private isAssignmentOperator(type: TokenType): boolean {
+    return (
+      type === TokenType.ASSIGN ||
+      type === TokenType.PLUS_ASSIGN ||
+      type === TokenType.MINUS_ASSIGN ||
+      type === TokenType.MULT_ASSIGN ||
+      type === TokenType.DIV_ASSIGN
+    );
+  }
+
+  private match(...types: TokenType[]): boolean {
+    for (const type of types) {
+      if (this.check(type)) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private check(type: TokenType): boolean {
+    if (this.isAtEnd()) return false;
+    return this.peek().type === type;
+  }
+
+  private advance(): Token {
+    if (!this.isAtEnd()) {
+      this.current++;
+    }
+    return this.previous();
+  }
+
+  private isAtEnd(): boolean {
+    return this.peek().type === TokenType.EOF;
+  }
+
+  private peek(): Token {
+    return this.tokens[this.current];
+  }
+
+  private previous(): Token {
+    return this.tokens[this.current - 1];
+  }
+
+  /**
+   * Consumes the next token if it matches the expected type, otherwise throws a syntax error.
+   * @param type The expected token type
+   * @param message The error message if the token does not match
+   */
+  private expect(type: TokenType, message: string): Token {
+    if (this.check(type)) {
+      return this.advance();
+    }
+    throw this.syntax(message);
+  }
+}