freelang-v4 4.3.0

package/src/runtime/value.ts

@@ -0,0 +1,322 @@
+/**
+ * FreeLang Runtime Value System
+ * 모든 런타임 값을 나타내는 tagged union 타입
+ */
+
+/**
+ * 런타임에서 사용되는 모든 값의 타입
+ * Discriminated Union 패턴 사용으로 타입 안전성 보장
+ */
+export type Value =
+  | { type: 'null' }
+  | { type: 'bool'; value: boolean }
+  | { type: 'int'; value: number }
+  | { type: 'float'; value: number }
+  | { type: 'string'; value: string }
+  | { type: 'array'; value: Value[] }
+  | { type: 'object'; value: Map<string, Value> }
+  | { type: 'function'; params: string[]; body: any }
+  | { type: 'builtin'; name: string; arity: number };
+
+/**
+ * Value 타입의 유틸리티 함수들
+ */
+export class ValueHandler {
+  /**
+   * Value를 문자열로 변환
+   */
+  static toString(v: Value): string {
+    switch (v.type) {
+      case 'null':
+        return 'null';
+      case 'bool':
+        return v.value ? 'true' : 'false';
+      case 'int':
+        return String(v.value);
+      case 'float':
+        return String(v.value);
+      case 'string':
+        return v.value;
+      case 'array':
+        return `[${v.value.map(item => this.toString(item)).join(', ')}]`;
+      case 'object':
+        const entries = Array.from(v.value.entries());
+        const pairs = entries.map(([k, val]) => `${k}: ${this.toString(val)}`);
+        return `{${pairs.join(', ')}}`;
+      case 'function':
+        return `<function(${v.params.join(', ')})>`;
+      case 'builtin':
+        return `<builtin: ${v.name}/${v.arity}>`;
+    }
+  }
+
+  /**
+   * Value를 숫자로 변환 (JavaScript 의미론)
+   */
+  static toNumber(v: Value): number {
+    switch (v.type) {
+      case 'null':
+        return 0;
+      case 'bool':
+        return v.value ? 1 : 0;
+      case 'int':
+      case 'float':
+        return v.value;
+      case 'string':
+        const n = parseFloat(v.value);
+        return isNaN(n) ? 0 : n;
+      case 'array':
+        return v.value.length; // 배열의 길이
+      case 'object':
+        return v.value.size; // 객체의 크기
+      default:
+        return 0;
+    }
+  }
+
+  /**
+   * Value를 불린으로 변환 (JavaScript truthy/falsy 의미론)
+   */
+  static toBoolean(v: Value): boolean {
+    switch (v.type) {
+      case 'null':
+        return false;
+      case 'bool':
+        return v.value;
+      case 'int':
+        return v.value !== 0;
+      case 'float':
+        return v.value !== 0.0;
+      case 'string':
+        return v.value.length > 0;
+      case 'array':
+        return v.value.length > 0;
+      case 'object':
+        return v.value.size > 0;
+      case 'function':
+      case 'builtin':
+        return true;
+    }
+  }
+
+  /**
+   * Value의 타입을 문자열로 반환
+   */
+  static typeOf(v: Value): string {
+    switch (v.type) {
+      case 'null':
+        return 'null';
+      case 'bool':
+        return 'bool';
+      case 'int':
+        return 'int';
+      case 'float':
+        return 'float';
+      case 'string':
+        return 'string';
+      case 'array':
+        return 'array';
+      case 'object':
+        return 'object';
+      case 'function':
+        return 'function';
+      case 'builtin':
+        return 'builtin';
+    }
+  }
+
+  /**
+   * Value의 길이를 반환 (string, array, object 타입)
+   */
+  static getLength(v: Value): number {
+    switch (v.type) {
+      case 'string':
+        return v.value.length;
+      case 'array':
+        return v.value.length;
+      case 'object':
+        return v.value.size;
+      default:
+        return 0;
+    }
+  }
+
+  /**
+   * 두 Value가 같은지 비교 (==)
+   */
+  static equals(a: Value, b: Value): boolean {
+    // 같은 타입끼리만 비교 (엄격한 비교)
+    if (a.type !== b.type) {
+      return false;
+    }
+
+    switch (a.type) {
+      case 'null':
+        return true;
+      case 'bool':
+        return a.value === (b as typeof a).value;
+      case 'int':
+      case 'float':
+        return a.value === (b as typeof a).value;
+      case 'string':
+        return a.value === (b as typeof a).value;
+      case 'array': {
+        const bArr = (b as typeof a).value;
+        if (a.value.length !== bArr.length) return false;
+        return a.value.every((v, i) => this.equals(v, bArr[i]));
+      }
+      case 'object': {
+        const bObj = (b as typeof a).value;
+        if (a.value.size !== bObj.size) return false;
+        for (const [k, v] of a.value) {
+          const bVal = bObj.get(k);
+          if (!bVal || !this.equals(v, bVal)) return false;
+        }
+        return true;
+      }
+      case 'function':
+        return false; // 함수는 참조로 비교 (추후 개선 가능)
+      case 'builtin':
+        return a.name === (b as typeof a).name;
+    }
+  }
+
+  /**
+   * 숫자 비교 (<)
+   */
+  static lessThan(a: Value, b: Value): boolean {
+    const aNum = this.toNumber(a);
+    const bNum = this.toNumber(b);
+    return aNum < bNum;
+  }
+
+  /**
+   * Value를 깊은 복사 (Deep Clone)
+   */
+  static clone(v: Value): Value {
+    switch (v.type) {
+      case 'null':
+      case 'bool':
+      case 'int':
+      case 'float':
+      case 'string':
+        return v;
+      case 'array':
+        return {
+          type: 'array',
+          value: v.value.map(item => this.clone(item)),
+        };
+      case 'object': {
+        const newMap = new Map<string, Value>();
+        for (const [k, val] of v.value) {
+          newMap.set(k, this.clone(val));
+        }
+        return {
+          type: 'object',
+          value: newMap,
+        };
+      }
+      case 'function':
+        return v; // 함수는 참조로 복사
+      case 'builtin':
+        return v;
+    }
+  }
+
+  /**
+   * Value를 JSON 호환 형식으로 변환
+   */
+  static toJSON(v: Value): any {
+    switch (v.type) {
+      case 'null':
+        return null;
+      case 'bool':
+        return v.value;
+      case 'int':
+      case 'float':
+        return v.value;
+      case 'string':
+        return v.value;
+      case 'array':
+        return v.value.map(item => this.toJSON(item));
+      case 'object': {
+        const obj: any = {};
+        for (const [k, val] of v.value) {
+          obj[k] = this.toJSON(val);
+        }
+        return obj;
+      }
+      case 'function':
+        return '[Function]';
+      case 'builtin':
+        return '[Builtin]';
+    }
+  }
+
+  /**
+   * JSON에서 Value로 변환
+   */
+  static fromJSON(obj: any): Value {
+    if (obj === null) {
+      return { type: 'null' };
+    }
+    if (typeof obj === 'boolean') {
+      return { type: 'bool', value: obj };
+    }
+    if (typeof obj === 'number') {
+      return Number.isInteger(obj)
+        ? { type: 'int', value: obj }
+        : { type: 'float', value: obj };
+    }
+    if (typeof obj === 'string') {
+      return { type: 'string', value: obj };
+    }
+    if (Array.isArray(obj)) {
+      return {
+        type: 'array',
+        value: obj.map(item => this.fromJSON(item)),
+      };
+    }
+    if (typeof obj === 'object') {
+      const map = new Map<string, Value>();
+      for (const [k, v] of Object.entries(obj)) {
+        map.set(k, this.fromJSON(v));
+      }
+      return { type: 'object', value: map };
+    }
+    return { type: 'null' };
+  }
+}
+
+/**
+ * 자주 사용되는 Value 상수들
+ */
+export const NULL: Value = { type: 'null' };
+export const TRUE: Value = { type: 'bool', value: true };
+export const FALSE: Value = { type: 'bool', value: false };
+
+/**
+ * Value를 생성하는 헬퍼 함수들
+ */
+export const Value = {
+  null: (): Value => ({ type: 'null' }),
+  bool: (b: boolean): Value => ({ type: 'bool', value: b }),
+  int: (n: number): Value => ({ type: 'int', value: Math.floor(n) }),
+  float: (n: number): Value => ({ type: 'float', value: n }),
+  string: (s: string): Value => ({ type: 'string', value: s }),
+  array: (arr: Value[]): Value => ({ type: 'array', value: arr }),
+  object: (obj: Map<string, Value>): Value => ({
+    type: 'object',
+    value: obj,
+  }),
+  function: (params: string[], body: any): Value => ({
+    type: 'function',
+    params,
+    body,
+  }),
+  builtin: (name: string, arity: number): Value => ({
+    type: 'builtin',
+    name,
+    arity,
+  }),
+};

package/src/runtime/vm.ts

@@ -0,0 +1,354 @@
+/**
+ * FreeLang Virtual Machine
+ * 스택 기반의 간단한 인터프리터
+ */
+
+import { Value, ValueHandler } from './value';
+import { Instruction, OpcodeType } from './bytecode';
+
+/**
+ * 함수 호출 프레임
+ */
+interface Frame {
+  name: string;
+  returnAddr: number;
+  localVariables: Map<number, Value>;
+}
+
+/**
+ * 런타임 에러
+ */
+export class RuntimeError extends Error {
+  constructor(
+    message: string,
+    public line: number = 0,
+    public column: number = 0
+  ) {
+    super(message);
+    this.name = 'RuntimeError';
+  }
+}
+
+/**
+ * FreeLang Virtual Machine
+ */
+export class VirtualMachine {
+  private stack: Value[] = [];
+  private memory: Map<number, Value> = new Map(); // 힙 메모리
+  private globals: Map<string, Value> = new Map(); // 전역 변수
+  private locals: Map<number, Value> = new Map(); // 지역 변수
+  private callStack: Frame[] = [];
+  private pc: number = 0; // 프로그램 카운터
+  private instructions: Instruction[] = [];
+  private builtins: Map<string, Function> = new Map();
+  private nextPtr: number = 0; // 메모리 포인터
+
+  constructor() {
+    this.registerBuiltins();
+  }
+
+  /**
+   * 표준 내장 함수 등록
+   */
+  private registerBuiltins(): void {
+    // 나중에 stdlib 모듈에서 자동으로 등록됨
+  }
+
+  /**
+   * Bytecode 실행
+   */
+  public execute(instructions: Instruction[]): Value {
+    this.instructions = instructions;
+    this.pc = 0;
+    this.stack = [];
+
+    try {
+      while (this.pc < instructions.length) {
+        const instr = instructions[this.pc];
+        this.executeInstruction(instr);
+        this.pc++;
+      }
+      return this.stack.pop() || { type: 'null' };
+    } catch (error) {
+      if (error instanceof RuntimeError) {
+        throw error;
+      }
+      throw new RuntimeError(
+        `VM Error: ${error instanceof Error ? error.message : String(error)}`,
+        instructions[this.pc]?.line || 0,
+        instructions[this.pc]?.column || 0
+      );
+    }
+  }
+
+  /**
+   * 개별 명령어 실행
+   */
+  private executeInstruction(instr: Instruction): void {
+    switch (instr.op) {
+      case OpcodeType.PUSH:
+        this.stack.push(instr.arg);
+        break;
+
+      case OpcodeType.POP:
+        if (this.stack.length === 0) {
+          throw new RuntimeError('Stack underflow');
+        }
+        this.stack.pop();
+        break;
+
+      case OpcodeType.DUP:
+        if (this.stack.length === 0) {
+          throw new RuntimeError('Stack underflow');
+        }
+        const top = this.stack[this.stack.length - 1];
+        this.stack.push(ValueHandler.clone(top));
+        break;
+
+      // 산술 연산
+      case OpcodeType.ADD:
+        this.binaryOp((a, b) => a + b, instr);
+        break;
+
+      case OpcodeType.SUB:
+        this.binaryOp((a, b) => a - b, instr);
+        break;
+
+      case OpcodeType.MUL:
+        this.binaryOp((a, b) => a * b, instr);
+        break;
+
+      case OpcodeType.DIV:
+        this.binaryOp((a, b) => {
+          if (b === 0) throw new RuntimeError('Division by zero');
+          return a / b;
+        }, instr);
+        break;
+
+      case OpcodeType.MOD:
+        this.binaryOp((a, b) => {
+          if (b === 0) throw new RuntimeError('Division by zero');
+          return a % b;
+        }, instr);
+        break;
+
+      // 비교 연산
+      case OpcodeType.EQ: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result = ValueHandler.equals(a, b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.NE: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result = !ValueHandler.equals(a, b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.LT: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result = ValueHandler.lessThan(a, b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.LTE: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result =
+          ValueHandler.lessThan(a, b) || ValueHandler.equals(a, b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.GT: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result = ValueHandler.lessThan(b, a);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.GTE: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result =
+          ValueHandler.lessThan(b, a) || ValueHandler.equals(a, b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      // 논리 연산
+      case OpcodeType.AND: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result =
+          ValueHandler.toBoolean(a) && ValueHandler.toBoolean(b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.OR: {
+        const b = this.popValue(instr);
+        const a = this.popValue(instr);
+        const result =
+          ValueHandler.toBoolean(a) || ValueHandler.toBoolean(b);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      case OpcodeType.NOT: {
+        const a = this.popValue(instr);
+        const result = !ValueHandler.toBoolean(a);
+        this.stack.push({ type: 'bool', value: result });
+        break;
+      }
+
+      // 제어 흐름
+      case OpcodeType.JUMP:
+        this.pc = instr.arg - 1; // -1은 pc++이 되기 때문
+        break;
+
+      case OpcodeType.JUMP_IF_TRUE: {
+        const cond = this.popValue(instr);
+        if (ValueHandler.toBoolean(cond)) {
+          this.pc = instr.arg - 1;
+        }
+        break;
+      }
+
+      case OpcodeType.JUMP_IF_FALSE: {
+        const cond = this.popValue(instr);
+        if (!ValueHandler.toBoolean(cond)) {
+          this.pc = instr.arg - 1;
+        }
+        break;
+      }
+
+      // 변수 접근
+      case OpcodeType.LOAD_LOCAL: {
+        const index = instr.arg;
+        const value = this.locals.get(index) || { type: 'null' };
+        this.stack.push(value);
+        break;
+      }
+
+      case OpcodeType.STORE_LOCAL: {
+        const index = instr.arg;
+        const value = this.popValue(instr);
+        this.locals.set(index, value);
+        break;
+      }
+
+      case OpcodeType.LOAD_GLOBAL: {
+        const name = instr.arg;
+        const value = this.globals.get(name) || { type: 'null' };
+        this.stack.push(value);
+        break;
+      }
+
+      case OpcodeType.STORE_GLOBAL: {
+        const name = instr.arg;
+        const value = this.popValue(instr);
+        this.globals.set(name, value);
+        break;
+      }
+
+      case OpcodeType.PRINT: {
+        const value = this.popValue(instr);
+        process.stdout.write(ValueHandler.toString(value));
+        break;
+      }
+
+      case OpcodeType.HALT:
+        this.pc = this.instructions.length; // 프로그램 종료
+        break;
+
+      case OpcodeType.NOP:
+        // No operation
+        break;
+
+      default:
+        throw new RuntimeError(`Unknown opcode: ${instr.op}`);
+    }
+  }
+
+  /**
+   * 이진 연산 수행
+   */
+  private binaryOp(
+    op: (a: number, b: number) => number,
+    instr: Instruction
+  ): void {
+    const b = this.popNumber(instr);
+    const a = this.popNumber(instr);
+    const result = op(a, b);
+
+    // 결과 타입 결정 (정수인지 실수인지)
+    const isInt = Number.isInteger(result);
+    this.stack.push(
+      isInt ? { type: 'int', value: result } : { type: 'float', value: result }
+    );
+  }
+
+  /**
+   * 스택에서 Value 팝
+   */
+  private popValue(instr: Instruction): Value {
+    if (this.stack.length === 0) {
+      throw new RuntimeError('Stack underflow', instr.line, instr.column);
+    }
+    return this.stack.pop()!;
+  }
+
+  /**
+   * 스택에서 숫자 팝
+   */
+  private popNumber(instr: Instruction): number {
+    const value = this.popValue(instr);
+    if (value.type !== 'int' && value.type !== 'float') {
+      throw new RuntimeError(
+        `Expected number, got ${value.type}`,
+        instr.line,
+        instr.column
+      );
+    }
+    return value.value;
+  }
+
+  /**
+   * 내장 함수 등록
+   */
+  public registerBuiltin(name: string, fn: Function): void {
+    this.builtins.set(name, fn);
+  }
+
+  /**
+   * 내장 함수 호출
+   */
+  public callBuiltin(name: string, args: Value[]): Value {
+    const fn = this.builtins.get(name);
+    if (!fn) {
+      throw new RuntimeError(`Unknown builtin function: ${name}`);
+    }
+    return fn(this, args) as Value;
+  }
+
+  /**
+   * 스택 상태 확인 (디버깅용)
+   */
+  public getStackTrace(): string {
+    const trace: string[] = [];
+    trace.push(`PC: ${this.pc}`);
+    trace.push(`Stack (${this.stack.length} items):`);
+    this.stack.forEach((v, i) => {
+      trace.push(`  [${i}] ${ValueHandler.toString(v)}`);
+    });
+    return trace.join('\n');
+  }
+}