空白言語WhiteSpaceを実装してみる

$ 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

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