Rdcpu16 0.0.3.1 → 0.0.4.alpha

data/bin/dcpu16.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'dcpu16'
+rescue LoadError
+  $LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+  require 'dcpu16'
+end
+
+if ARGV.length == 1
+  filename = ARGV[0]
+  if filename.end_with?(".o")
+    dump = File.open(filename, "rb").read.unpack("S>*")
+  else
+    require 'tempfile'
+    file = File.open(filename)
+    assembler = DCPU16::Assembler.new(file.read)
+    tmp_file = Tempfile.new("obj")
+    assembler.write(tmp_file.path)
+    dump = tmp_file.read.unpack("S>*")
+  end
+  debugger = DCPU16::Debugger.new(dump)
+  debugger.run
+elsif ARGV.length == 2
+  file = File.open(ARGV[0])
+  assembler = DCPU16::Assembler.new(file.read)
+  assembler.write(ARGV[1])
+else
+  puts "Usage: dcpu16 <input> <output>"
+  exit
+end
+

data/lib/dcpu16/assembler.rb

@@ -1,33 +1,275 @@
 # WIP
+# Taken from: https://github.com/dcpu16/dcpu16-rb/blob/master/asm.rb
 module DCPU16
   class Assembler
+    class Instruction
+      attr_accessor :inst, :a, :b
+      attr_reader :num, :line
+
+      def initialize(num, line)
+        @num, @line = num, line
+        @inst, @a, @b = 0, 0, 0
+        @extensions = []
+        @references = []
+      end
+
+      def extend(value)
+        # Check value against max int
+        @extensions << value
+      end
+
+      def reference(label)
+        @references[@extensions.size] = label
+        @extensions << 0 # Placeholder
+      end
+
+      def resolve(labels)
+        @references.each_with_index do |label, i|
+          next unless label
+          location = labels[label]
+          error("Cannot find label #{label} in #{labels.keys.join(", ")}") unless location
+          @extensions[i] = location
+        end
+      end
+
+      def word
+        @inst + (@a << 4) + (@b << 10)
+      end
+
+      def words
+        [word] + @extensions.dup
+      end
+
+      def bytes
+        words.map{|w| [w].pack('n') }.join("")
+      end
+
+      def size
+        @extensions.size + 1
+      end
+
+      def hex(w)
+        "%04x" % w
+      end
+
+      def to_s
+        "#{@num}: #{words.map{|w| hex(w)}.join(" ")}" # ; #{line}"
+      end
+
+      def error(message)
+        raise Exception.new("Line #{num}: #{message}\n#{line}")
+      end
+    end
+
+
+
+    def self.declare(map, start, string)
+      count = start
+      string.split(" ").each do |token|
+        map[token] = count
+        count += 1
+      end
+    end
+
+    HEX_RE = /^0x[0-9a-fA-F]+$/
+    INT_RE = /^\d+$/
+    REG_RE = /^[A-Z]+$/
+    LABEL_RE = /^[a-z_]+$/
+    INDIRECT_RE = /^\[.+\]/
+    INDIRECT_OFFSET_RE = /^[^+]+\+[^+]+$/
+
+    EXT_PREFIX = 0
+
+    INDIRECT = 0x08
+    INDIRECT_OFFSET = 0x10
+    INDIRECT_NEXT = 0x1e
+    NEXT = 0x1f
+    LITERAL = 0x20
+
+    INSTRUCTIONS = {}
+    EXTENDED_INSTRUCTIONS = {}
+    VALUES = {}
+
+    declare(INSTRUCTIONS, 1, "SET ADD SUB MUL DIV MOD SHL SHR AND BOR XOR IFE IFN IFG IFB")
+    declare(EXTENDED_INSTRUCTIONS, 1, "JSR")
+    declare(VALUES, 0, "A B C X Y Z I J")
+    declare(VALUES, 0x18, "POP PEEK PUSH SP PC O")
+
     attr_reader :input
-    def initialize(text)
-      @input = text
+    def initialize(input)
+      @body = []
+      @label_these = []
+      @input = input
+      self.assemble
+    end
+
+    def clean(line)
+      line.gsub(/;.*/, "").gsub(/,/, " ").gsub(/\s+/, " ").strip
+    end
+
+    def dehex(token)
+      return token.hex.to_s if HEX_RE === token
+      token
+    end
+
+    def parse_value(token, op)
+      token = dehex(token)
+
+      case token
+      when INT_RE
+        value = token.to_i
+        return LITERAL + value if value <= 31
+        op.extend value
+        return NEXT
+
+      when REG_RE
+        return VALUES[token]
+
+      when LABEL_RE
+        op.reference(token)
+        return NEXT
+
+      when INDIRECT_RE
+        inner = dehex(token[1..-2])
+        case inner
+        when INT_RE
+          value = inner.to_i
+          op.extend value
+          return INDIRECT_NEXT
+
+        when REG_RE
+          reg = VALUES[inner]
+          op.error("Can't use indirect addressing on non-basic reg #{reg}") unless reg <= VALUES["J"]
+          return INDIRECT + reg
+
+        when LABEL_RE
+          op.reference(inner)
+          return INDIRECT_NEXT
+
+        when INDIRECT_OFFSET_RE
+          offset, reg = inner.split("+").map{|x| x.strip }
+          offset = dehex(offset)
+
+          op.error("Malformed indirect offset value #{inner}") unless INT_RE === offset && REG_RE === reg
+          value = offset.to_i# + VALUES[reg]
+          op.extend value
+
+          return INDIRECT_OFFSET + VALUES[reg]
+        end
+      else
+        op.error("Unrecognized value #{token}")
+      end
     end
 
-    def dump
-      raise "TODO #{caller.first}"
-      lines = []
-      @input.each_line do |line|
-        empty   = (line =~ /^\s*$/)
-        comment = (line =~ /^\s*;+.*$/)
+    def parse_op(op, tokens)
+      inst_name = tokens.shift
+
+      inst_code = INSTRUCTIONS[inst_name]
+      if inst_code
+        op.inst = inst_code
+        op.a = parse_value(tokens.shift, op)
+        op.b = parse_value(tokens.shift, op)
+        return
+      end
+
+      inst_code = EXTENDED_INSTRUCTIONS[inst_name]
+      if inst_code
+        op.inst = EXT_PREFIX
+        op.a = inst_code
+        op.b = parse_value(tokens.shift, op)
+      end
+
+      raise Exception.new("No such instruction: #{inst_name}") unless inst_code
+    end
+
+    def assemble#(text)
+      text = @input
+      labels = {}
+
+      num = 0
+      location = 0
+      text.each_line do |line|
+        num += 1
+        op = Instruction.new(num, line)
+
+        cleaned = clean(line)
+        next if cleaned.empty?
+
+        tokens = cleaned.split(/\s/)
+        op.error("Wrong number of tokens - #{tokens}") unless (2..4) === tokens.size
+
+        labels[tokens.shift[1..-1]] = location if tokens[0].start_with?(":")
+        parse_op(op, tokens)
+
+        @body << op
+        location += op.size
+      end
+
+      @body.each {|op| op.resolve(labels) }
+
+      #display
+    end
 
-        next if empty || comment
+    def display
+      @body.each { |op| puts op }
+    end
 
-        line.gsub!(/^\s*([^;]*).*$/) { $1 } # Strip some spaces
 
-        regex = /^(:\w*)?\s*(\w*)\s*([^,\s]*),?\s?([^\s]*).*$/
-        match = line.match(regex)
+    def dump#(filename)
+      @body
+#      File.open(filename, "w") do |file|
+#        @body.each {|inst| file.write(inst.bytes) }
+#      end
+    end
 
-        line = { :label => match[1],
-                 :op    => match[2],
-                 :a => match[3],
-                 :b => match[4] }
-        puts line
-        lines << line
+    def write(filename)
+      File.open(filename, "w") do |file|
+        @body.each {|inst| file.write(inst.bytes) }
       end
     end
   end
 end
 
+
+#if __FILE__ == $PROGRAM_NAME
+#  asm = Assembler.new
+#  filename = "#{ARGV.first || "out.s"}.o"
+#  asm.assemble ARGF
+#  asm.dump filename
+#end
+
+
+
+
+
+
+
+
+
+#attr_reader :input
+#def initialize(text)
+#  @input = text
+#end
+
+#def dump
+#  lines = []
+#  @input.each_line do |line|
+#    empty   = (line =~ /^\s*$/)
+#    comment = (line =~ /^\s*;+.*$/)
+
+#    next if empty || comment
+
+#    line.gsub!(/^\s*([^;]*).*$/) { $1 } # Strip some spaces
+
+#    regex = /^(:\w*)?\s*(\w*)\s*([^,\s]*),?\s?([^\s]*).*$/
+#    match = line.match(regex)
+
+#    line = { :label => match[1],
+#             :op    => match[2],
+#             :a => match[3],
+#             :b => match[4] }
+#    puts line
+#    lines << line
+#  end
+#end
+

data/lib/dcpu16/{instruction.rb → cpu/instruction.rb}

@@ -19,38 +19,40 @@
 # 1111 1100 0000 0000 -> 0xfc00
 
 module DCPU16
-  class Instruction
-    INSTRUCTIONS = [
-      :reserved,
-      :set, :add, :sub, :mul, :div, :mod,
-      :shl, :shr,
-      :and, :bor, :xor,
-      :ife, :ifn, :ifg, :ifb
-    ]
-
-    NON_BASIC_INSTRUCTIONS = [
-      :reserved,
-      :jsr
-    ]
-
-    attr_reader :opcode, :a, :b, :word
-
-    def initialize(word = nil)
-      @word   = word.value
-      @opcode = @word & 0x000F
-
-      if @opcode == 0x0
-        @non_basic = true
-        @opcode = (@word >> 4) & 0x3f
-        @a      = @word >> 10
-      else
-        @a = (@word >> 4) & 0x3f
-        @b = @word >> 10
+  class CPU
+    class Instruction
+      INSTRUCTIONS = [
+        :reserved,
+        :set, :add, :sub, :mul, :div, :mod,
+        :shl, :shr,
+        :and, :bor, :xor,
+        :ife, :ifn, :ifg, :ifb
+      ]
+
+      NON_BASIC_INSTRUCTIONS = [
+        :reserved,
+        :jsr
+      ]
+
+      attr_reader :opcode, :a, :b, :word
+
+      def initialize(word = nil)
+        @word   = word.value
+        @opcode = @word & 0x000F
+
+        if @opcode == 0x0
+          @non_basic = true
+          @opcode = (@word >> 4) & 0x3f
+          @a      = @word >> 10
+        else
+          @a = (@word >> 4) & 0x3f
+          @b = @word >> 10
+        end
       end
-    end
 
-    def op
-      @non_basic ? NON_BASIC_INSTRUCTIONS[@opcode] : INSTRUCTIONS[@opcode]
+      def op
+        @non_basic ? NON_BASIC_INSTRUCTIONS[@opcode] : INSTRUCTIONS[@opcode]
+      end
     end
   end
 end

data/lib/dcpu16/cpu/operand.rb

@@ -0,0 +1,43 @@
+# TODO: Test && Refacoring
+module DCPU16
+  module Operand
+    class NotFound < StandardError; end
+
+    def get_operand(value)
+      if (0x00..0x07).include?(value)     # register (A, B, C, X, Y, Z, I or J, in that order)
+        @registers[value]
+      elsif (0x08..0x0f).include?(value)  # [register]
+        register = @registers[value - 0x08]
+        @memory[register]
+      elsif (0x10..0x17).include?(value)
+        @cycle += 1
+        offset = @memory[@PC].value + @registers[value - 0x10].value
+        @memory[offset].tap { @PC += 1 }
+      elsif value == 0x18                 # POP / [@SP++]
+        @memory[@SP].tap { @SP += 1 }
+      elsif value == 0x19                 # PEEK / [@SP]
+        @memory[@SP]
+      elsif value == 0x1a                 # PUSH / [--@SP]
+        @SP -= 1
+        @memory[@SP]
+      elsif value == 0x1b                 # @SP
+        @SP
+      elsif value == 0x1c                 # @PC
+        @PC
+      elsif value == 0x1d                 # O
+        @O
+      elsif value == 0x1e                 # [next word]
+        @cycle += 1
+        @memory[@memory[@PC]].tap { @PC += 1 }
+      elsif value == 0x1f                 # next word (literal)
+        @cycle += 1
+        @memory[@PC].tap { @PC += 1 }
+      elsif (0x20..0x3f).include?(value)  # literal value 0x00-0x1f (literal)
+        DCPU16::Literal.new(value - 0x20)
+      else
+        raise NotFound
+      end
+    end
+  end
+end
+

data/lib/dcpu16/cpu/register.rb

@@ -0,0 +1,37 @@
+module DCPU16
+  class CPU
+    class Register
+      attr_reader :value
+
+      def initialize(value = 0x0)
+        @default_value = value
+        reset
+      end
+
+      def value
+        warn "[Register #{self}] No Value defined" unless @value
+        @value
+      end
+      alias_method :read, :value
+
+      def +(value)
+        @value += value
+        self
+      end
+
+      def -(value)
+        @value -= value
+        self
+      end
+
+      def write(value)
+        @value = value
+      end
+
+      def reset
+        @value = @default_value
+      end
+    end
+  end
+end
+

data/lib/dcpu16/cpu.rb

@@ -1,18 +1,16 @@
+require "observer"
 require 'dcpu16/support/debug'
 
+require 'dcpu16/cpu/instruction'
 require 'dcpu16/cpu/instructions'
+require 'dcpu16/cpu/operand'
+require 'dcpu16/cpu/register'
 
-require 'dcpu16/instruction'
-require 'dcpu16/literal'
-require 'dcpu16/memory'
-require 'dcpu16/operand'
-require 'dcpu16/register'
-
-require "observer"
 
 module DCPU16
   class CPU
     include DCPU16::Debug
+    include DCPU16::Operand
     include DCPU16::Instructions
     include Observable
 
@@ -34,10 +32,10 @@ module DCPU16
     def initialize(memory = [])
       @cycle      = 0
       @memory     = DCPU16::Memory.new(memory)
-      @registers  = Array.new(REGISTERS_COUNT) { DCPU16::Register.new }
-      @PC = DCPU16::Register.new(0x0)
-      @SP = DCPU16::Register.new(0xFFFF)
-      @O  = DCPU16::Register.new(0x0)
+      @registers  = Array.new(REGISTERS_COUNT) { Register.new }
+      @PC = Register.new(0x0)
+      @SP = Register.new(0xFFFF)
+      @O  = Register.new(0x0)
 
       @clock_cycle = CLOCK_CYCLE
       @debug = true
@@ -85,7 +83,7 @@ module DCPU16
     end
 
     # Perform a single step
-    # TODO: Refacor if/else/if/else ...
+    # TODO: Refacor if/else/if/else ... hacky mess here
     def step
       @instruction = Instruction.new(@memory.read(@PC))
       @PC += 1
@@ -97,22 +95,32 @@ module DCPU16
       if @skip
         @skip = false
       else
-        if b
+        if b # Basic Instruction
           result = self.send(op, a.value, b.value)
-        else
+        else # Non-Basic Instruction
           result = self.send(op, a.value)
         end
         a.write(result) if result
       end
 
+      # Notify observers
       changed
       notify_observers(self)
     end
 
-    # TODO: May be removed
-    def get_operand(value)
-      DCPU16::Operand.new(self, value)
+    def to_s
+      <<EOF
+###########
+### CPU ###
+
+* Cycle: #{cycle}
+# Clock: #{clock_cycle}
+*    HZ: #{hz}
+*  Last: #{last_instruction.inspect}
+*  Reg.: #{registers.inspect}
+EOF
     end
+
   end
 end
 

data/lib/dcpu16/debugger.rb

@@ -0,0 +1,31 @@
+module DCPU16
+  class Debugger
+    attr_reader :cpu, :screen
+    def initialize(dump = [])
+      @cpu    = DCPU16::CPU.new(dump)
+      @screen = DCPU16::Screen.new(@cpu.memory)
+
+      @cpu.add_observer(self)
+    end
+
+    def run
+      clear_screen
+      begin
+        @cpu.run
+      rescue DCPU16::Instructions::Reserved => e
+        puts @cpu.to_s
+      end
+    end
+
+    # Observer
+    def update(cpu)
+      #cpu
+    end
+
+    # Clears screen for output
+    def clear_screen
+      print @screen.to_s
+    end
+  end
+end
+

data/lib/dcpu16/memory/word.rb

@@ -0,0 +1,22 @@
+module DCPU16
+  class Memory
+    class Word
+      def initialize(value, memory = nil, offset = nil)
+        @value  = value
+        @memory = memory
+        @offset = offset
+      end
+
+      def value
+        @value
+      end
+      alias_method :read, :value
+
+      def write(value)
+        @value = value
+        @memory.write(@offset, value)
+      end
+    end
+  end
+end
+

data/lib/dcpu16/memory.rb

@@ -1,4 +1,4 @@
-require 'dcpu16/word'
+require 'dcpu16/memory/word'
 require "observer"
 
 module DCPU16
@@ -21,7 +21,7 @@ module DCPU16
       # HACK: so we can just pass a Fixnum or a Register
       offset = offset.value if offset.respond_to? :value
 
-      DCPU16::Word.new(@memory[offset], self, offset)
+      Word.new(@memory[offset], self, offset)
     end
 
     def write(offset, value)
@@ -29,6 +29,8 @@ module DCPU16
       offset = offset.value if offset.respond_to? :value
 
       @memory[offset] = value
+
+      # Notify observers
       changed
       notify_observers(offset, value)
     end
@@ -40,13 +42,12 @@ module DCPU16
       @memory.length
     end
 
-    private
     def [](key)
-      super(key)
+      read(key)
     end
 
     def []=(key, value)
-      super(key, value)
+      write(key, value)
     end
   end
 end