lny-interpreter 0.99.0

package/src/interpreter/interpreter.ts

@@ -0,0 +1,453 @@
+import * as AST from '../ast/ast';
+import { World, LnyValue, LnyEnvironment, LnyProcedure, BuiltInFunction } from '../world/world';
+import { I18n, Language } from '../i18n/i18n';
+
+export interface InterpreterOptions {
+  worldWidth?: number;
+  worldHeight?: number;
+}
+
+export class ReturnValue extends Error {
+  constructor(public value: LnyValue) {
+    super();
+  }
+}
+
+export class BreakException extends Error {
+  constructor() {
+    super();
+  }
+}
+
+export class Interpreter {
+  private world: World;
+  private i18n: I18n;
+  private globalEnv: LnyEnvironment;
+  private currentEnv: LnyEnvironment;
+  private output: string[] = [];
+
+  constructor(language: Language = 'de', options: InterpreterOptions = {}) {
+    this.i18n = new I18n(language);
+    this.world = new World(language, options.worldWidth, options.worldHeight);
+    this.globalEnv = this.world.getEnvironment();
+    this.currentEnv = this.globalEnv;
+  }
+
+  setLanguage(language: Language): void {
+    this.i18n.setLanguage(language);
+    this.world.setLanguage(language);
+  }
+
+  interpret(program: AST.Program): LnyValue {
+    try {
+      // Top-Level: KEIN neues Environment erzeugen, sondern globalEnv verwenden
+      for (const statement of program.body) {
+        this.executeStatement(statement);
+      }
+      return null;
+    } catch (e) {
+      if (e instanceof ReturnValue) {
+        return e.value;
+      }
+      throw e;
+    }
+  }
+
+  private executeBlock(statements: AST.Statement[], env: LnyEnvironment): void {
+    const previousEnv = this.currentEnv;
+    this.currentEnv = env;
+
+    try {
+      for (const statement of statements) {
+        this.executeStatement(statement);
+      }
+    } finally {
+      this.currentEnv = previousEnv;
+    }
+  }
+
+  private executeStatement(stmt: AST.Statement): void {
+    switch (stmt.type) {
+      case 'ExpressionStatement':
+        this.evaluate((stmt as AST.ExpressionStatement).expression);
+        break;
+
+      case 'VariableDeclaration': {
+        const varDecl = stmt as AST.VariableDeclaration;
+        const value = varDecl.initialValue ? this.evaluate(varDecl.initialValue) : null;
+        this.currentEnv.define(varDecl.name, value);
+        break;
+      }
+
+      case 'VariableAssignment': {
+        const assignment = stmt as AST.VariableAssignment;
+        const currentValue = this.currentEnv.get(assignment.name);
+        let newValue: LnyValue;
+
+        if (assignment.operator === '<<') {
+          newValue = this.evaluate(assignment.value);
+        } else if (assignment.operator === 'AUF') {
+          newValue = this.evaluate(assignment.value);
+        } else {
+          const rightValue = this.evaluate(assignment.value);
+          newValue = this.applyCompoundOperator(
+            assignment.operator,
+            currentValue as number,
+            rightValue as number
+          );
+        }
+
+        this.currentEnv.set(assignment.name, newValue);
+        break;
+      }
+
+      case 'IfStatement':
+        this.executeIfStatement(stmt as AST.IfStatement);
+        break;
+
+      case 'WhileStatement':
+        this.executeWhileStatement(stmt as AST.WhileStatement);
+        break;
+
+      case 'ForStatement':
+        this.executeForStatement(stmt as AST.ForStatement);
+        break;
+
+      case 'ProcedureDeclaration': {
+        const procDecl = stmt as AST.ProcedureDeclaration;
+        const procedure: LnyProcedure = {
+          parameters: procDecl.parameters,
+          body: procDecl.body,
+          closure: this.currentEnv,
+        };
+        this.currentEnv.define(procDecl.name, procedure);
+        break;
+      }
+
+      case 'ReturnStatement': {
+        const returnStmt = stmt as AST.ReturnStatement;
+        const value = returnStmt.argument ? this.evaluate(returnStmt.argument) : null;
+        throw new ReturnValue(value);
+      }
+
+      case 'LogStatement': {
+        const logStmt = stmt as AST.LogStatement;
+        const value = this.evaluate(logStmt.expression);
+        this.output.push(this.lnyValueToString(value));
+        break;
+      }
+
+      case 'CommentStatement':
+        // Comments are ignored
+        break;
+
+      case 'Block':
+        this.executeBlock((stmt as AST.Block).statements, new LnyEnvironment(this.currentEnv));
+        break;
+    }
+  }
+
+  private executeIfStatement(stmt: AST.IfStatement): void {
+    const condition = this.isTruthy(this.evaluate(stmt.condition));
+
+    if (condition) {
+      this.executeBlock(stmt.consequent, new LnyEnvironment(this.currentEnv));
+    } else if (stmt.alternate) {
+      this.executeBlock(stmt.alternate, new LnyEnvironment(this.currentEnv));
+    }
+  }
+
+  private executeWhileStatement(stmt: AST.WhileStatement): void {
+    while (this.isTruthy(this.evaluate(stmt.condition))) {
+      try {
+        this.executeBlock(stmt.body, new LnyEnvironment(this.currentEnv));
+      } catch (e) {
+        if (e instanceof BreakException) {
+          break;
+        }
+        throw e;
+      }
+    }
+  }
+
+  private executeForStatement(stmt: AST.ForStatement): void {
+    const iterable = this.evaluate(stmt.iterable);
+    const env = new LnyEnvironment(this.currentEnv);
+
+    if (!Array.isArray(iterable)) {
+      throw new Error(this.i18n.t('error_for_iterable_must_list'));
+    }
+
+    for (const item of iterable) {
+      env.define(stmt.variable, item);
+
+      try {
+        this.executeBlock(stmt.body, env);
+      } catch (e) {
+        if (e instanceof BreakException) {
+          break;
+        }
+        throw e;
+      }
+    }
+  }
+
+  private evaluate(expr: AST.Expression): LnyValue {
+    switch (expr.type) {
+      case 'RangeLiteral': {
+        const rangeExpr = expr as AST.RangeLiteral;
+        const start = this.evaluate(rangeExpr.start);
+        const end = this.evaluate(rangeExpr.end);
+        if (typeof start !== 'number' || typeof end !== 'number') {
+          throw new Error(this.i18n.t('error_type_mismatch'));
+        }
+        const result = [];
+        if (start <= end) {
+          for (let i = start; i <= end; i++) result.push(i);
+        } else {
+          for (let i = start; i >= end; i--) result.push(i);
+        }
+        return result;
+      }
+      case 'NumberLiteral':
+        return (expr as AST.NumberLiteral).value;
+
+      case 'StringLiteral':
+        return (expr as AST.StringLiteral).value;
+
+      case 'BooleanLiteral':
+        return (expr as AST.BooleanLiteral).value;
+
+      case 'NothingLiteral':
+        return null;
+
+      case 'ListLiteral': {
+        const listExpr = expr as AST.ListLiteral;
+        return listExpr.elements.map((el) => this.evaluate(el));
+      }
+
+      case 'Identifier': {
+        const idExpr = expr as AST.Identifier;
+        // 1. Variable?
+        if (this.currentEnv.has(idExpr.name)) {
+          const value = this.currentEnv.get(idExpr.name);
+          // 2. Prozedur? Dann direkt ausführen (ohne Argumente)
+          if (value && typeof value === 'object' && 'parameters' in value && 'body' in value) {
+            const procedure = value as LnyProcedure;
+            if (procedure.parameters.length === 0) {
+              // Keine Argumente nötig
+              const procEnv = new LnyEnvironment(procedure.closure);
+              try {
+                this.executeBlock(procedure.body, procEnv);
+                return null;
+              } catch (e) {
+                if (e instanceof ReturnValue) {
+                  return e.value;
+                }
+                throw e;
+              }
+            } else {
+              throw new Error(this.i18n.t('error_invalid_arguments') + ': Prozedur benötigt Argumente');
+            }
+          }
+          // Normale Variable
+          return value;
+        }
+        // 3. Built-In?
+        const builtIn = this.world.getBuiltIn(idExpr.name);
+        if (builtIn) {
+          return builtIn([]);
+        }
+        // 4. Nicht gefunden
+        let posInfo = '';
+        if (typeof idExpr.line === 'number' && typeof idExpr.column === 'number') {
+          posInfo = ` (Zeile ${idExpr.line}, Spalte ${idExpr.column})`;
+        }
+        throw new Error(this.i18n.t('error_undefined_variable', { name: idExpr.name }) + posInfo);
+      }
+
+      case 'BinaryExpression':
+        return this.evaluateBinaryExpression(expr as AST.BinaryExpression);
+
+      case 'UnaryExpression':
+        return this.evaluateUnaryExpression(expr as AST.UnaryExpression);
+
+      case 'CallExpression':
+        return this.evaluateCallExpression(expr as AST.CallExpression);
+
+      case 'ParenthesizedExpression': {
+        const parenExpr = expr as AST.ParenthesizedExpression;
+        return this.evaluate(parenExpr.expression);
+      }
+
+      case 'PrivateAttribute': {
+        const privExpr = expr as AST.PrivateAttribute;
+        const state = this.world.getLennyState();
+        return (state as any)[privExpr.name] ?? null;
+      }
+
+      case 'GlobalAttribute': {
+        const globExpr = expr as AST.GlobalAttribute;
+        try {
+          return this.world.getGlobal(globExpr.name);
+        } catch {
+          return null;
+        }
+      }
+
+      default:
+        throw new Error(
+          this.i18n.t('error_unknown_expression_type', {
+            type: (expr as any).type,
+          })
+        );
+    }
+  }
+
+  private evaluateBinaryExpression(expr: AST.BinaryExpression): LnyValue {
+    const left = this.evaluate(expr.left);
+    const right = this.evaluate(expr.right);
+
+    const operators: { [key: string]: (l: any, r: any) => any } = {
+      '+': (l, r) => l + r,
+      '-': (l, r) => l - r,
+      '*': (l, r) => l * r,
+      '/': (l, r) => {
+        if (r === 0) throw new Error(this.i18n.t('error_division_by_zero'));
+        return l / r;
+      },
+      '%': (l, r) => l % r,
+      '**': (l, r) => Math.pow(l, r),
+      '<': (l, r) => l < r,
+      '>': (l, r) => l > r,
+      '<=': (l, r) => l <= r,
+      '>=': (l, r) => l >= r,
+      '==': (l, r) => l === r,
+      '<>': (l, r) => l !== r,
+      'and': (l, r) => this.isTruthy(l) && this.isTruthy(r),
+      'und': (l, r) => this.isTruthy(l) && this.isTruthy(r),
+      'et': (l, r) => this.isTruthy(l) && this.isTruthy(r),
+      'y': (l, r) => this.isTruthy(l) && this.isTruthy(r),
+      'e': (l, r) => this.isTruthy(l) && this.isTruthy(r),
+      'or': (l, r) => this.isTruthy(l) || this.isTruthy(r),
+      'oder': (l, r) => this.isTruthy(l) || this.isTruthy(r),
+      'ou': (l, r) => this.isTruthy(l) || this.isTruthy(r),
+      'o': (l, r) => this.isTruthy(l) || this.isTruthy(r),
+    };
+
+    const operator = operators[expr.operator];
+    if (!operator) {
+      throw new Error(this.i18n.t('error_unknown_operator', { op: expr.operator }));
+    }
+
+    return operator(left, right);
+  }
+
+  private evaluateUnaryExpression(expr: AST.UnaryExpression): LnyValue {
+    const operand = this.evaluate(expr.argument);
+    switch (expr.operator.toLowerCase()) {
+      case 'not':
+      case 'nicht':
+      case 'no':
+        return !this.isTruthy(operand);
+      case '+':
+        if (operand === null || operand === undefined) return 0;
+        return +operand;
+      case '-':
+        if (operand === null || operand === undefined) return 0;
+        return -operand;
+      default:
+        throw new Error(this.i18n.t('error_unknown_unary_operator', { op: expr.operator }));
+    }
+  }
+
+  private evaluateCallExpression(expr: AST.CallExpression): LnyValue {
+    // Funktionsaufruf: callee kann Identifier sein
+    const callee = expr.callee;
+    if (callee.type !== 'Identifier') {
+      throw new Error(this.i18n.t('error_undefined_function', { name: '?' }));
+    }
+    const fnName = callee.name;
+    // 1. Prozedur?
+    if (this.currentEnv.has(fnName)) {
+      const value = this.currentEnv.get(fnName);
+      if (value && typeof value === 'object' && 'parameters' in value && 'body' in value) {
+        const procedure = value as LnyProcedure;
+        if (procedure.parameters.length !== expr.arguments.length) {
+          throw new Error(this.i18n.t('error_invalid_arguments'));
+        }
+        const procEnv = new LnyEnvironment(procedure.closure);
+        for (let i = 0; i < procedure.parameters.length; i++) {
+          procEnv.define(procedure.parameters[i], this.evaluate(expr.arguments[i]));
+        }
+        try {
+          this.executeBlock(procedure.body, procEnv);
+          return null;
+        } catch (e) {
+          if (e instanceof ReturnValue) {
+            return e.value;
+          }
+          throw e;
+        }
+      }
+    }
+    // 2. Built-In?
+    const builtIn = this.world.getBuiltIn(fnName);
+    if (builtIn) {
+      return builtIn(expr.arguments.map(arg => this.evaluate(arg)));
+    }
+    // 3. Nicht gefunden
+    const pos = (callee.line && callee.column) ? ` (line ${callee.line}, column ${callee.column})` : '';
+    throw new Error(this.i18n.t('error_undefined_function', { name: fnName }) + pos);
+  }
+
+  private applyCompoundOperator(operator: string, left: number, right: number): number {
+    switch (operator) {
+      case '+=':
+        return left + right;
+      case '-=':
+        return left - right;
+      case '*=':
+        return left * right;
+      case '/=':
+        if (right === 0) throw new Error(this.i18n.t('error_division_by_zero'));
+        return left / right;
+      default:
+        throw new Error(this.i18n.t('error_unknown_compound_operator', { op: operator }));
+    }
+  }
+
+  private isTruthy(value: LnyValue): boolean {
+    if (value === null || value === undefined) return false;
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number') return value !== 0;
+    if (typeof value === 'string') return value.length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return true;
+  }
+
+  private lnyValueToString(value: LnyValue): string {
+    if (value === null || value === undefined) {
+      return this.i18n.t('kw_nothing');
+    }
+    if (typeof value === 'boolean') {
+      return value ? this.i18n.t('kw_true') : this.i18n.t('kw_false');
+    }
+    if (Array.isArray(value)) {
+      return '[' + value.map((v) => this.lnyValueToString(v)).join(', ') + ']';
+    }
+    return String(value);
+  }
+
+  getOutput(): string {
+    return this.output.join('\n');
+  }
+
+  clearOutput(): void {
+    this.output = [];
+  }
+
+  getWorld(): World {
+    return this.world;
+  }
+}