空白言語WhiteSpaceとは？Rubyで実装してみた

$ ruby whitespace.rb count.ws
1
・
・
10

def tokenize # 字句解析
  result = []
  scanner = StringScanner.new(@code)
  while !(scanner.eos?) # スキャンが最後尾まで達したか
    para = nil # パラメーターをnilに
    unless scanner.scan(/\A( |\n|\t[ \n\t])/)
      raise Exception, "undefined imp"
    end
    imps = {
      " " => :stack,
      "\t " => :arithmetic,
      "\t\t" => :heap,
      "\n" => :flow,
      "\t\n" => :io
    }
    imp = imps[scanner[0]]
    case imp
   #-----スタック操作-----
    when :stack
      unless scanner.scan(/ |\n[ \t\n]/)
        raise Exception, "undefined cmd of stack"
      end
      cmds = {
        " " => :push,
        "\n " => :duplicate,
        "\n\t" => :swap,
        "\n\n" => :discard
      }
      cmd = cmds[scanner[0]]
      if cmd == :push # pushの場合パラメータを取得
        unless scanner.scan(/[ \t]+\n/) # \nが来るまではパラメーター
          raise Exception, "undefined parameter of stack"
        end
        para = scanner[0]
      end

   #-----演算-----
    when :arithmetic
      unless scanner.scan(/ [ \t\n]|\t[ \t]/)
         raise Exception, "undefined cmd of arithmetic"
      end
      cmds = {
        " " => :addition,
        " \t" => :subtraction,
        " \n" => :multiplicate,
        "\t " => :integer_division,
        "\t\t" => :modulo
      }
      cmd = cmds[scanner[0]]

   #-----ヒープ操作-----
    when :heap
      unless scanner.scan(/ |\t/)
       raise Exception, "undefined cmd of heap"
      end
      cmds = {
        " " => :store,
        "\t" => :retrieve
      }
      cmd = cmds[scanner[0]]

   #-----制御命令-----
    when :flow
      unless scanner.scan(/ [ \t\n]|\t[ \t\n]|\n\n/)
        raise Exception, "undefined cmd of flow"
      end
      cmds = {
        " " => :mark,
        " \t" => :call,
        " \n" => :jump_uncondionally,
        "\t " => :jump_zero,
        "\t\t" => :jump_negative,
        "\t\n" => :end_and_transfer,
        "\n\n" => :end,
      }
      cmd = cmds[scanner[0]]
      unless (cmd == :end_and_transfer) || (cmd == :end) #end_and_transferもしくはend以外のコマンドの場合パラメータを取得
        unless scanner.scan(/[ \t]+\n/) # \nが来るまではパラメーター
          raise Exception, "undefined parameter of flow"
        end
        para = scanner[0]
      end

   #-----入出力-----
    when :io
      unless scanner.scan(/ [ \t]|\t[ \t]/)
        raise Exception, "undefined cmd of io"
      end
      cmds = {
        " " => :output_character,
        " \t" => :output_number,
        "\t " => :read_character,
        "\t\t" => :read_number
      }
      cmd = cmds[scanner[0]]
    end
    result << [imp,cmd,para] # それぞれを配列に格納
  end
  result
end

def evaluate
  @tokens = []
  @tokens_sub =tokenize # パラメータを数値に変換するための配列
  @stack = []
  @call_stack = []
  @heap = {}
  pc = 0 # カウンター
  @tokens_sub.each do |im,cm,pa| # パラメーターを全て数値に変換
    pa2 = pa
    if pa #パラメーターがnilでない場合のみ
      pa2.gsub!(/ /,"0")
      pa2.gsub!(/\t/,"1")
      sign= pa2.slice!(0) # 符号を取得
      pa2 = pa2.to_i(2) # 10進数に変換
      if sign == "1"
        pa2 = pa2 * (-1) # 負の値に
      end
    end
    @tokens << [im,cm,pa2] # 本命の@tokensに格納
  end
  count=0
  while true do
    imp , cmd , para = @tokens
    count = count +1
   (省略)

case imp
  #-----スタック操作-----
  when :stack
    pc = pc + 1
    cmds = {
      " " => :push,
      "\n " => :duplicate,
      "\n\t" => :swap,
      "\n\n" => :discard
    }
    case cmd
    when :push
      @stack.push(para)
    when :duplicate
      @stack.push(@stack.first)
    when :swap
      top_second = @stack.delete_at(@stack.size-2) # topの2つを入れ替える
      @stack.push(top_second)
    when :discard
      @stack.pop
    end

  #-----演算-----
  when :arithmetic
    pc = pc + 1
    elm = @stack.pop
    elm2 = @stack.pop
    case cmd
    when :addition # 和
      @stack.push(elm2 + elm)
    when :subtraction # 差
      @stack.push(elm2 - elm)
    when :multiplicate # 積
      @stack.push(elm2 * elm)
    when :integer_division # 商
      @stack.push(elm2 / elm)
    when :modulo # 剰余
      @stack.push(elm2 % elm)
    end

  #-----ヒープ操作-----
  when :heap
    pc = pc + 1
    case cmd
    when :store # ハッシュに保存
      value = @stack.pop
      key =@stack.pop
      @heap.store(key,value)
    when :retrieve # スタックに追加
      key = @stack.pop
      @stack.push(@heap[key])
    end

#-----制御命令-----
  when :flow
    case cmd
    when :mark
      pc += 1
    when :jump_uncondionally # ジャンプ
      n = 0
      @tokens.each {|im,cm,pa|
        if cm == :mark && pa == para
          pc = n+1
        end
        n += 1
        }
    when :call
      @call_stack.push(pc) # スタックに現在の位置をプッシュ
      n=0
      @tokens.each {|im,cm,pa|
        if cm == :mark && pa == para
          pc = n+1
        end
        n += 1
      }
    when :jump_zero # スタックの先頭が0ならジャンプ
      if @stack.pop == 0
        n = 0
        @tokens.each {|im,cm,pa|
          if cm == :mark && pa == para
            pc = n+1
          end
          n += 1
        }
      else
        pc += 1
      end
    when :jump_negative # スタックの先頭が負ならジャンプ
      if @stack.pop < 0
        n = 0
        @tokens.each {|im,cm,pa|
          if cm == :mark && pa == para
            pc = n+1
          end
          n += 1
        }
      else
        pc += 1
      end
    when :end_and_transfer
      pc = @call_stack.pop
      pc =pc +1
    when :end # 終了
      exit
  end

    #-----入出力-----
    when :io
      pc = pc + 1
      case cmd
      when :output_character # 文字を出力
        print @stack.pop.chr
      when :output_number # 数値を出力
        puts @stack.pop.to_s
      when :read_character # 文字コードの入力
        key = @stack.pop
        print("入力=>")
        value =STDIN.gets.ord # 文字コードに変換
        @heap.store(key,value)
      when :read_number #数値の入力
        key = @stack.pop
        print("入力=>")
        value =STDIN.gets.to_i # 整数に変換
        @heap.store(key,value)
      end

require "strscan"

class WhiteSpace
  def initialize
    @code = ""
    @file_name = ARGV[0]
    @file = open(@file_name) # コマンドライン引数で渡されたファイルの内容を取得
    @file.each do |line|
      @code << line
    end
    tokenize()
    evaluate()
  end
(中略)
end
WhiteSpace.new