编写 brainfuck 解释器

import fs from 'node:fs';
import { stdin, stdout } from 'node:process';
import {readBytes} from "./util.mjs";

export const SHR = 0x3E; // > 的 charCode

export const SHL = 0x3C; // <

export const ADD = 0x2B; // +

export const SUB = 0x2D; // -

export const PUTCHAR = 0x2E; // .

export const GETCHAR = 0x2C; // ,

export const LB = 0x5B; // [

export const RB = 0x5D; // ]

export class Code {
  instrs = []
  jtable = new Map()

  static shared = new Code();

  constructor() {
  }

  from(data) {
    const dict = new Set([
      SHR,
      SHL,
      ADD,
      SUB,
      PUTCHAR,
      GETCHAR,
      LB,
      RB,
    ]);

    this.instrs = data.filter(code => {
      if (!dict.has(code)) {
        // 跳过不支持的操作服或空格
        return false;
      }
      return true;
    });

    const stack = []
    for (let i=0; i<this.instrs.length; i++) {
      const code = this.instrs[i];

      if (code === LB) {
        stack.push(i);
      }

      if (code === RB) {
        let j = stack.pop();
        this.jtable.set(i, j);
        this.jtable.set(j, i);
      }
    }

    return this;
  }
}

import {stdin, stdout} from "node:process";
import {readBytes} from "./util.mjs";
import {ADD, GETCHAR, LB, PUTCHAR, RB, SHL, SHR, SUB} from "./opcode.mjs";

export class Interpreter {
  stack = [0]
  constructor() {
  }

  run(code) {
    const codeLen = code.instrs.length;
    let programCount = 0;
    let stackPointer = 0;

    while (true) {
      if (programCount >= codeLen) { // 代码已结束
        break;
      }

      const c = code.instrs[programCount] // 过滤后的代码数组

      switch (c) {
        case SHR:
          stackPointer += 1;
          if (stackPointer === this.stack.length) { // 纸带不够了
            this.stack.push(0);
          }
          break;
        case SHL:
          if (stackPointer !== 0) {
            stackPointer -= 1;
          }
          break;
        case ADD:
          this.stack[stackPointer] = (this.stack[stackPointer] + 1)  % 256;
          break;
        case SUB:
          let tmp = this.stack[stackPointer] -1;
          this.stack[stackPointer] = tmp < 0 ? tmp + 256 : tmp;
          break;
        case PUTCHAR:
          stdout.write(Buffer.from([this.stack[stackPointer]]),  'utf-8');
          break;
        case GETCHAR:
          const buf = readBytes(stdin.fd, 1);
          this.stack[stackPointer] = buf[0];
          break;
        case LB:
          if (this.stack[stackPointer] === 0x00) {
            programCount = code.jtable.get(programCount);
          }
          break;
        case RB:
          if (this.stack[stackPointer] !== 0x00) {
            programCount = code.jtable.get(programCount);
          }
          break;
        default:
        // never
      }
      // console.log(String.fromCharCode(c), this.stack);
      programCount += 1; // 读入下一个指令
    }

  }
}

import fs from "node:fs";

export const readBytes = (fd, count) => {
  const buffer = Buffer.allocUnsafe(count);
  for (let i = 0; i < count;) {
    let result = 0;
    try {
      result = fs.readSync(fd, buffer, i, count - i);
    } catch (error) {
      if (error.code === 'EAGAIN') {  // when there is nothing to read at the current time (Unix)
        //TODO: it is good to slow down loop here or do other tasks in meantime, e.g. async sleep
        continue;
      }
      throw error;
    }
    if (result === 0) {
      throw new Error('Input stream reading error.');  // consider to use your own solution on this case
    }
    i += result;
  }
  return buffer;
};