whitespace-ruby 1.0.0

data/lib/whitespace/instructions/flow_control/zjmp.rb

@@ -0,0 +1,20 @@
+module Whitespace::ISA
+  class Zjmp < Instruction
+    attr_reader :name
+
+    def initialize(vm, name)
+      unless Whitespace::Util.is_label?(name)
+        raise ArgumentError, "must be a label: #{name}"
+      end
+      super(vm)
+      @name = name
+    end
+
+    def execute
+      if vm.vstack.pop == 0
+        index = Whitespace::Util.find_label(vm.instructions, name)
+        vm.pc.change_to index + 1
+      end
+    end
+  end
+end

data/lib/whitespace/instructions/heap_access/retrieve.rb

@@ -0,0 +1,9 @@
+module Whitespace::ISA
+  class Retrieve < Instruction
+    def execute
+      address = vm.vstack.pop
+
+      vm.vstack.push vm.memory[address]
+    end
+  end
+end

data/lib/whitespace/instructions/heap_access/store.rb

@@ -0,0 +1,10 @@
+module Whitespace::ISA
+  class Store < Instruction
+    def execute
+      value = vm.vstack.pop
+      address = vm.vstack.pop
+
+      vm.memory[address] = value
+    end
+  end
+end

data/lib/whitespace/instructions/instruction.rb

@@ -0,0 +1,13 @@
+module Whitespace::ISA
+  class Instruction
+    attr_reader :vm
+
+    def initialize(vm)
+      @vm = vm
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+  end
+end

data/lib/whitespace/instructions/io/putc.rb

@@ -0,0 +1,15 @@
+module Whitespace::ISA
+  class Putc < Instruction
+    attr_reader :console
+
+    def initialize(vm, console)
+      super(vm)
+      @console = console
+    end
+
+    def execute
+      n = vm.vstack.pop
+      console.printc n
+    end
+  end
+end

data/lib/whitespace/instructions/io/putn.rb

@@ -0,0 +1,15 @@
+module Whitespace::ISA
+  class Putn < Instruction
+    attr_reader :console
+
+    def initialize(vm, console)
+      super(vm)
+      @console = console
+    end
+
+    def execute
+      n = vm.vstack.pop
+      console.printn n
+    end
+  end
+end

data/lib/whitespace/instructions/io/readc.rb

@@ -0,0 +1,16 @@
+module Whitespace::ISA
+  class Readc < Instruction
+    attr_reader :console
+
+    def initialize(vm, console)
+      super(vm)
+      @console = console
+    end
+
+    def execute
+      ch = console.getc
+      address = vm.vstack.pop
+      vm.memory[address] = ch.ord
+    end
+  end
+end

data/lib/whitespace/instructions/io/readn.rb

@@ -0,0 +1,16 @@
+module Whitespace::ISA
+  class Readn < Instruction
+    attr_reader :console
+
+    def initialize(vm, console)
+      super(vm)
+      @console = console
+    end
+
+    def execute
+      n = console.getn
+      address = vm.vstack.pop
+      vm.memory[address] = n
+    end
+  end
+end

data/lib/whitespace/instructions/stack_manipulation/discard.rb

@@ -0,0 +1,7 @@
+module Whitespace::ISA
+  class Discard < Instruction
+    def execute
+      vm.vstack.pop
+    end
+  end
+end

data/lib/whitespace/instructions/stack_manipulation/dup.rb

@@ -0,0 +1,7 @@
+module Whitespace::ISA
+  class Dup < Instruction
+    def execute
+      vm.vstack.push vm.vstack.top
+    end
+  end
+end

data/lib/whitespace/instructions/stack_manipulation/push.rb

@@ -0,0 +1,17 @@
+module Whitespace::ISA
+  class Push < Instruction
+    attr_reader :n
+
+    def initialize(vm, n)
+      unless Whitespace::Util.is_integer?(n)
+        raise ArgumentError, "must be an integer: #{n}"
+      end
+      super(vm)
+      @n = n
+    end
+
+    def execute
+      vm.vstack.push n
+    end
+  end
+end

data/lib/whitespace/instructions/stack_manipulation/swap.rb

@@ -0,0 +1,11 @@
+module Whitespace::ISA
+  class Swap < Instruction
+    def execute
+      a = vm.vstack.pop
+      b = vm.vstack.pop
+
+      vm.vstack.push a
+      vm.vstack.push b
+    end
+  end
+end

data/lib/whitespace/isa.rb

@@ -0,0 +1,9 @@
+module Whitespace
+  module ISA
+  end
+end
+
+require_relative "instructions/instruction"
+Dir.glob(File.expand_path("instructions/**/*.rb", File.dirname(__FILE__))) do |f|
+  require f
+end

data/lib/whitespace/parser.rb

@@ -0,0 +1,243 @@
+module Whitespace
+  class Parser
+    attr_reader :vm, :console
+
+    def initialize(vm, console)
+      @vm = vm
+      @console = console
+    end
+
+    def parse(src)
+      parse_init(src)
+      parse_start
+    end
+
+    SPACE = " "
+    TAB   = "\t"
+    LF    = "\n"
+
+    private
+
+    attr_reader :instructions
+
+    def parse_init(src)
+      @tokens = src.to_s.gsub(/[^ \t\n]+/, '')
+      @index = 0
+      @instructions = []
+    end
+
+    def parse_start
+      case next_token
+      when SPACE
+        parse_stack_manipulation
+      when TAB
+        case next_token
+        when SPACE
+          parse_arithmetic
+        when TAB
+          parse_heap
+        when LF
+          parse_io
+        else
+          raise ParseError, "must be an IMP"
+        end
+      when LF
+        parse_flow_control
+      else
+        instructions
+      end
+    end
+
+    def parse_stack_manipulation
+      case next_token
+      when SPACE
+        n = parse_number
+        append_and_continue ISA::Push.new(vm, n)
+      when LF
+        case next_token
+        when SPACE
+          append_and_continue ISA::Dup.new(vm)
+        when TAB
+          append_and_continue ISA::Swap.new(vm)
+        when LF
+          append_and_continue ISA::Discard.new(vm)
+        else
+          raise ParseError, "must be a stack manipulation instruction"
+        end
+      else
+        raise ParseError, "must be a stack manipulation instruction"
+      end
+    end
+
+    def parse_arithmetic
+      case next_token
+      when SPACE
+        case next_token
+        when SPACE
+          append_and_continue ISA::Add.new(vm)
+        when TAB
+          append_and_continue ISA::Sub.new(vm)
+        when LF
+          append_and_continue ISA::Mul.new(vm)
+        else
+          raise ParseError, "must be an arithmetic instruction"
+        end
+      when TAB
+        case next_token
+        when SPACE
+          append_and_continue ISA::Div.new(vm)
+        when TAB
+          append_and_continue ISA::Mod.new(vm)
+        else
+          raise ParseError, "must be an arithmetic instruction"
+        end
+      else
+        raise ParseError, "must be an arithmetic instruction"
+      end
+    end
+
+    def parse_heap
+      case next_token
+      when SPACE
+        append_and_continue ISA::Store.new(vm)
+      when TAB
+        append_and_continue ISA::Retrieve.new(vm)
+      else
+        raise ParseError, "must be a heap instruction"
+      end
+    end
+
+    def parse_flow_control
+      case next_token
+      when SPACE
+        case next_token
+        when SPACE
+          name = parse_name
+          append_and_continue ISA::Label.new(vm, name)
+        when TAB
+          name = parse_name
+          append_and_continue ISA::Call.new(vm, name)
+        when LF
+          name = parse_name
+          append_and_continue ISA::Ujmp.new(vm, name)
+        else
+          raise ParseError, "must be a flow control instruction"
+        end
+      when TAB
+        case next_token
+        when SPACE
+          name = parse_name
+          append_and_continue ISA::Zjmp.new(vm, name)
+        when TAB
+          name = parse_name
+          append_and_continue ISA::Njmp.new(vm, name)
+        when LF
+          append_and_continue ISA::Return.new(vm)
+        else
+          raise ParseError, "must be a flow control instruction"
+        end
+      when LF
+        case next_token
+        when LF
+          append_and_continue ISA::End.new(vm)
+        else
+          raise ParseError, "must be a flow control instruction"
+        end
+      else
+        raise ParseError, "must be a flow control instruction"
+      end
+    end
+
+    def parse_io
+      case next_token
+      when SPACE
+        case next_token
+        when SPACE
+          append_and_continue ISA::Putc.new(vm, console)
+        when TAB
+          append_and_continue ISA::Putn.new(vm, console)
+        else
+          raise ParseError, "must be an I/O instruction"
+        end
+      when TAB
+        case next_token
+        when SPACE
+          append_and_continue ISA::Readc.new(vm, console)
+        when TAB
+          append_and_continue ISA::Readn.new(vm, console)
+        else
+          raise ParseError, "must be an I/O instruction"
+        end
+      else
+        raise ParseError, "must be an I/O instruction"
+      end
+    end
+
+    def parse_number
+      parse_sign * parse_value
+    end
+
+    def parse_sign
+      case next_token
+      when SPACE
+        1
+      when TAB
+        -1
+      else
+        raise ParseError, "must be a sign token"
+      end
+    end
+
+    def parse_value
+      parse_value_rec(0, 0, next_token)
+    end
+
+    def parse_value_rec(n, len, token)
+      case token
+      when SPACE
+        parse_value_rec(2 * n, len + 1, next_token)
+      when TAB
+        parse_value_rec(2 * n + 1, len + 1, next_token)
+      when LF
+        if len > 0
+          n
+        else
+          raise ParseError, "number must have a value part"
+        end
+      else
+        raise ParseError, "number must be terminated by a LF"
+      end
+    end
+
+    def parse_name
+      parse_name_rec("", 0, next_token)
+    end
+
+    def parse_name_rec(name, len, token)
+      case token
+      when SPACE
+        parse_name_rec(name + " ", len + 1, next_token)
+      when TAB
+        parse_name_rec(name + "\t", len + 1, next_token)
+      when LF
+        if len > 0
+          name
+        else
+          raise ParseError, "name must be non-empty"
+        end
+      else
+        raise ParseError, "name must be terminated by a LF"
+      end
+    end
+
+    def next_token
+      @index += 1
+      @tokens[@index - 1]
+    end
+
+    def append_and_continue(instruction)
+      @instructions << instruction
+      parse_start
+    end
+  end
+end

data/lib/whitespace/util.rb

@@ -0,0 +1,37 @@
+module Whitespace
+  module Util
+    class << self
+      def is_integer?(n)
+        n.is_a? Integer
+      end
+
+      def is_ascii?(n)
+        n == 10 || n == 13 || (n >= 32 && n <= 127)
+      end
+
+      def is_binop?(op)
+        BINOPS.include? op
+      end
+
+      def is_label?(name)
+        name.instance_of?(String) && !/\A[ \t]+\z/.match(name).nil?
+      end
+
+      def find_label(instructions, name)
+        instructions.each_with_index do |instr, i|
+          return i if instr.instance_of?(ISA::Label) && instr.name == name
+        end
+
+        raise LabelError, "missing: \"#{name}\""
+      end
+    end
+
+    BINOPS = {
+      add: lambda { |l, r| l + r },
+      sub: lambda { |l, r| l - r },
+      mul: lambda { |l, r| l * r },
+      div: lambda { |l, r| l / r },
+      mod: lambda { |l, r| l % r }
+    }
+  end
+end