Rdcpu16 0.0.4.beta → 0.0.4.0

data/bin/dcpu16

@@ -19,12 +19,19 @@ if ARGV.length == 1
     assembler.write(tmp_file.path)
     dump = tmp_file.read.unpack("S>*")
   end
-  debugger = DCPU16::Debugger.new(dump)
+
+  # TODO: get args from command line
+  debugger = DCPU16::Debugger.new(dump, :update_every => 10000, :step_mode => false)
   debugger.run
 elsif ARGV.length == 2
   file = File.open(ARGV[0])
   assembler = DCPU16::Assembler.new(file.read)
   assembler.write(ARGV[1])
+
+  File.open(ARGV[1] + ".hex", "w") do |file|
+    file.write(assembler.to_s)
+  end
+
 else
   puts "Usage: dcpu16 <input> <output>"
   exit

data/lib/dcpu16/assembler.rb

@@ -1,275 +1,88 @@
-# 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
+require 'dcpu16/assembler/constants'
+require 'dcpu16/assembler/instruction'
+require 'dcpu16/assembler/line'
 
-      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")
 
+module DCPU16
+  class Assembler
     attr_reader :input
-    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
+    def initialize(text)
+      @input = text
+      assemble
     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 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
+    # Assemble the given input.
+    def assemble
       location = 0
-      text.each_line do |line|
-        num += 1
-        op = Instruction.new(num, line)
-
-        cleaned = clean(line)
-        next if cleaned.empty?
+      @labels  = {}
+      @body    = []
 
-        tokens = cleaned.split(/\s/)
-        op.error("Wrong number of tokens - #{tokens}") unless (2..4) === tokens.size
+      lines.each do |line|
+        # Set label location
+        @labels[line.label] = location if line.label
 
-        labels[tokens.shift[1..-1]] = location if tokens[0].start_with?(":")
-        parse_op(op, tokens)
+        # Skip when no op
+        next if line.op.empty?
 
+        op = Instruction.create(line.op, line.args, location)
         @body << op
         location += op.size
       end
 
-      @body.each {|op| op.resolve(labels) }
-
-      #display
+      # Apply labels
+      begin
+        @body.each { |op| op.apply_labels(@labels) }
+      rescue Exception => e
+        puts @labels.inspect
+        raise e
+      end
     end
 
-    def display
-      @body.each { |op| puts op }
+    # Returns assembled bytes
+    def bytes
+      @body.map { |op| op.bytes }.join
     end
 
+    def to_s
+      @body.join("\n")
+    end
 
-    def dump#(filename)
-      @body
-#      File.open(filename, "w") do |file|
-#        @body.each {|inst| file.write(inst.bytes) }
-#      end
+    def lines
+      @lines ||= read_lines
     end
 
+    # Write bytes to file
     def write(filename)
-      File.open(filename, "w") do |file|
-        @body.each {|inst| file.write(inst.bytes) }
-      end
+      File.open(filename, "w") { |file| file.write(bytes) }
     end
-  end
-end
-
-
-#if __FILE__ == $PROGRAM_NAME
-#  asm = Assembler.new
-#  filename = "#{ARGV.first || "out.s"}.o"
-#  asm.assemble ARGF
-#  asm.dump filename
-#end
 
 
 
+    private
 
+    def read_lines
+      @lines = []
+      @input.each_line do |line|
+        empty   = (line =~ RE_LINE_EMPTY)
+        comment = (line =~ RE_LINE_COMMENT)
 
+        next if empty || comment
 
+        line.gsub!(RE_LINE_CLEAN) { $1 }
 
+        match = line.match(RE_LINE)
+        label = match[1]
+        op    = match[2]
+        args  = match[3]
+        args  = args.scan( RE_ARGS ).flatten.compact
 
+        line = Line.new(label, op, args)
+        @lines << line
+      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
+      return @lines
+    end
+  end
+end
 

data/lib/dcpu16/assembler/constants.rb

@@ -0,0 +1,48 @@
+module DCPU16
+  class Assembler
+    RE_LINE_EMPTY   = /^\s*$/
+    RE_LINE_COMMENT = /^\s*;+.*$/
+
+    #RE_LINE_CLEAN   = /^\s*([^;]*).*$/
+    # "asd" | 'asd' | [^"';"]
+    RE_LINE_CLEAN   = /^\s*((?:(?:"[^"]*")|(?:'[^']*')|(?:[^;'"]*))*).*$/
+
+    # Parsing the line
+    RE_LINE = /\A
+      (:\w*)?       # label
+      \s*
+      (\w*)         # op
+      \s*
+      (.*?)         # args
+      \s*
+    \Z/x
+
+    # Parsing the arguments
+    # TODO: no comma needed atm, fix this
+    RE_ARGS = /([^'",\s]+)|("[^"]+")|('[^']+')/
+#    args.scan( RE_ARGS ).flatten.compact
+
+
+    # Regex against a op: 1: label | 2: OP | 3: A | 4: b
+    #RE_OP = /^(:\w*)?\s*(\w*)\s*([^,\s]*),?\s?([^\s]*).*$/
+    RE_OP = /^(:\w*)?\s*(\w*)\s*([^,\n]*),?\s?([^\s]*).*$/
+
+    REGISTER = {
+      :A => 0x0,
+      :B => 0x1,
+      :C => 0x2,
+      :X => 0x3,
+      :Y => 0x4,
+      :Z => 0x5,
+      :I => 0x6,
+      :J => 0x7,
+      :POP  => 0x18,
+      :PEEK => 0x19,
+      :PUSH => 0x1a,
+      :SP   => 0x1b,
+      :PC   => 0x1c,
+      :O    => 0x1d
+    }
+  end
+end
+

data/lib/dcpu16/assembler/instruction.rb

@@ -0,0 +1,235 @@
+module DCPU16
+  class Assembler
+
+    BASIC_INSTRUCTIONS = {
+      :SET => 0x1,
+      :ADD => 0x2,
+      :SUB => 0x3,
+      :MUL => 0x4,
+      :DIV => 0x5,
+      :MOD => 0x6,
+      :SHL => 0x7,
+      :SHR => 0x8,
+      :AND => 0x9,
+      :BOR => 0xa,
+      :XOR => 0xb,
+      :IFE => 0xc,
+      :IFN => 0xd,
+      :IFG => 0xe,
+      :IFB => 0xf
+    }
+
+    NON_BASIC_INSTRUCTIONS = {
+      :JSR => 0x01
+    }
+
+    INSTRUCTIONS = BASIC_INSTRUCTIONS.merge(NON_BASIC_INSTRUCTIONS)
+    # INDIRECT: [x+y] =>
+
+  # + 0x00-0x07: register (A, B, C, X, Y, Z, I or J, in that order)             SET A               0x0001
+  # I 0x08-0x0f: [register]                                                     SET [A]             0x????
+  # I 0x10-0x17: [next word + register]                                         SET [A+0x1000]      0x???? 0x????
+  # +      0x18: POP / [SP++]
+  # +      0x19: PEEK / [SP]
+  # +      0x1a: PUSH / [--SP]
+  # +      0x1b: SP
+  # +      0x1c: PC
+  # +      0x1d: O
+  # I      0x1e: [next word]                                                    SET [0x1000]        0x???? 0x????
+  # V      0x1f: next word (literal)                                            SET 0x1000          0x???? 0x????
+  # V 0x20-0x3f: literal value 0x00-0x1f (literal)                              SET 0x????          0x????
+    class Instruction; end;
+
+    # BasicInstruction like: SET, ADD, ...
+    class BasicInstruction < Instruction
+      def initialize(op, a, b, location)
+        super(op, location)
+        @a = value(a)
+        @b = value(b)
+      end
+
+      def word
+        @op_value + (@a << 4) + (@b << 10)
+      end
+    end
+
+    # NonBasicInstruction like: JSR
+    class NonBasicInstruction < Instruction
+      def initialize(op, a, location)
+        super(op, location)
+        @a = value(a)
+      end
+
+
+
+      def word
+        (@op_value << 4) + (@a << 10)
+      end
+    end
+
+    # DatInstruction: dat "foobar"
+    class DatInstruction < Instruction
+      def initialize(op, args, location)
+        super(op, location)
+
+        args.each do |arg|
+          # TODO: shitty string detection here, refactor please
+          re_string = /^"([^"]*)"|'([^']*)'$/
+          match = arg.match(re_string)
+          if match
+            s = match[1] || match[2]
+            s.each_byte { |b| @words << b } # Add chars
+          else
+            @words << dehex(arg) # No string given, assume value/label here
+          end
+        end
+      end
+
+      def words
+        @words
+      end
+
+      def size
+        @words.size
+      end
+    end
+
+
+
+
+    class Instruction #< Struct.new(:op, :args, :location)
+      RE_INDIRECT = /^\[([^+]+)\+?([^+]+)?\]$/
+      RE_HEX = /^0[xX][0-9a-fA-F]{1,4}$/
+      RE_INT = /^\d{1,5}$/
+      LITERALS = (0x00..0x1f)
+
+      attr_accessor :a, :b, :location, :op
+
+      class << self
+        def instruction_type(op)
+          return :basic     if BASIC_INSTRUCTIONS[op]
+          return :non_basic if NON_BASIC_INSTRUCTIONS[op]
+          return op
+        end
+
+        # InstructionFactory
+        def create(op, args, location)
+          @op = op.upcase.intern
+
+          case instruction_type(@op)
+          when :basic
+            BasicInstruction.new(@op, args[0], args[1], location)
+          when :non_basic
+            NonBasicInstruction.new(@op, args[0], location)
+          when :DAT
+            DatInstruction.new(@op, args, location)
+          else
+            raise "Instruction not found: #{@op}"
+          end
+        end
+      end
+
+
+      def initialize(op, location)
+        @words    = []
+        @op       = op
+        @location = location
+        @op_value = INSTRUCTIONS[@op]
+      end
+
+
+      def add_word(value)
+        raise "NilValue" unless value
+        @words << value
+      end
+
+      def value(operand)
+        operand = operand.to_s
+
+        register = REGISTER[operand.upcase.intern]
+        return register if register
+
+        # Is a indirect: [A], [0x8000], [0x8000 + A], [0x30]
+        indirect = operand.match(RE_INDIRECT)
+        if indirect
+          if indirect[2]
+            # hacky implementation
+            r = REGISTER[indirect[2].upcase.intern]
+            i = 1
+            if !r
+              r = REGISTER[indirect[1].upcase.intern]
+              i = 2
+            end
+            raise "Something went wrong (yeah, its a stupid message right here) [#{operand}]" unless r
+            add_word(dehex(indirect[i]))
+
+            # 0x10-0x17: [next word + register]
+            return (r + 0x10)
+          else
+            r = REGISTER[indirect[1].upcase.intern]
+            if r
+              # 0x08-0x0f: [register]
+              return (r + 0x08)
+            else
+              # 0x1e:      [next word]
+              add_word(dehex(indirect[1]))
+              return 0x1e
+            end
+          end
+        end
+
+        value = dehex(operand)
+        if (0x00..0x1f).include?(value)
+          # 0x20-0x3f: literal value 0x00-0x1f (literal)
+          return (value + 0x20)
+        else
+          # 0x1f: next word (literal) || next word (label)
+          add_word(value)
+          return 0x1f
+        end
+      end
+
+      def word
+        raise "Must be implemented by #{self.class.name}!"
+      end
+
+      # Returns size of Instruction in bytes
+      def size
+        @words.size + 1
+      end
+
+      # Add Labels to values
+      def apply_labels(labels = {})
+        @words.map! { |word| labels[word] || dehex(word, :raise => true) }
+      end
+
+      def words
+        [word] + @words
+      end
+
+      def bytes
+        words.map { |w| [w].pack('n') }.join("")
+      end
+
+      def to_s(options = {:line_number => false})
+        raw = words.map{|w| hex(w)}.join(" ")
+        options[:line_number] ? "#{location.to_s(16)}:\t#{raw}" : raw
+      end
+
+      # Convert string to hex or dec value; if none of them return input
+      # Raise error if option enabled and no hex/dec value
+      def dehex(v, options = {:raise => false})
+        v = v.to_s
+        return v.hex  if v.match(RE_HEX)
+        return v.to_i if v.match(RE_INT)
+        raise "'#{v}' is no Hex or Int (label not found?) [#{@words.inspect}]\n" if options[:raise]
+        return v.downcase
+      end
+
+      def hex(w)
+        "%04x" % w
+      end
+    end
+  end
+end
+

data/lib/dcpu16/assembler/line.rb

@@ -0,0 +1,16 @@
+module DCPU16
+  class Assembler
+    class Line < Struct.new(:raw_label, :op, :args)
+      # TODO: refactor
+      def label
+        return @label if @label || raw_label.nil?
+
+        @label = raw_label.downcase
+        @label = @label[1, @label.length] if @label.start_with?(":")
+
+        return @label
+      end
+    end
+  end
+end
+

data/lib/dcpu16/cpu.rb

@@ -32,7 +32,9 @@ module DCPU16
     def initialize(memory = [])
       @cycle      = 0
       @memory     = DCPU16::Memory.new(memory)
-      @registers  = Array.new(REGISTERS_COUNT) { Register.new }
+      @registers  = []
+      [:A, :B, :C, :X, :Y, :Z, :I, :J].each { |r| @registers << Register.new(0x0, r) }
+
       @PC = Register.new(0x0)
       @SP = Register.new(0xFFFF)
       @O  = Register.new(0x0)
@@ -62,7 +64,9 @@ module DCPU16
 
     # Current clock_cycle
     def hz
-      diff = Time.now - (@started_at || Time.now)
+      now = Time.now
+      @started_at ||= now
+      diff = now - @started_at
       diff = 1 if diff == 0
       @cycle / diff
     end
@@ -84,28 +88,30 @@ module DCPU16
 
     # Perform a single step
     # TODO: Refacor if/else/if/else ... hacky mess here
-    def step
-      @instruction = Instruction.new(@memory.read(@PC))
-      @PC += 1
-
-      op  = @instruction.op
-      a   = get_operand(@instruction.a)
-      b   = get_operand(@instruction.b) if @instruction.b
-
-      if @skip
-        @skip = false
-      else
-        if b # Basic Instruction
-          result = self.send(op, a.value, b.value)
-        else # Non-Basic Instruction
-          result = self.send(op, a.value)
+    def step(steps = 1)
+      steps.times do
+        @instruction = Instruction.new(@memory.read(@PC))
+        @PC += 1
+
+        op  = @instruction.op
+        a   = get_operand(@instruction.a)
+        b   = get_operand(@instruction.b) if @instruction.b
+
+        if @skip
+          @skip = false
+        else
+          if b # Basic Instruction
+            result = self.send(op, a.value, b.value)
+          else # Non-Basic Instruction
+            result = self.send(op, a.value)
+          end
+          a.write(result) if result
         end
-        a.write(result) if result
-      end
 
-      # Notify observers
-      changed
-      notify_observers(self)
+        # Notify observers
+        changed
+        notify_observers(self)
+      end
     end
 
     def to_s
@@ -117,7 +123,11 @@ module DCPU16
 # Clock: #{clock_cycle}
 *    HZ: #{hz}
 *  Last: #{last_instruction.inspect}
-*  Reg.: #{registers.inspect}
+*  Reg.: #{registers.join("\n         ")}
+*    SP: #{@SP}
+*    PC: #{@PC}
+*     O: #{@O}
+ 0x8000: #{memory[0x8000].value.to_s(16)}
 EOF
     end
 

data/lib/dcpu16/cpu/instruction.rb

@@ -50,6 +50,7 @@ module DCPU16
         end
       end
 
+      # TODO: what if noop found?
       def op
         @non_basic ? NON_BASIC_INSTRUCTIONS[@opcode] : INSTRUCTIONS[@opcode]
       end

data/lib/dcpu16/cpu/register.rb

@@ -3,8 +3,9 @@ module DCPU16
     class Register
       attr_reader :value
 
-      def initialize(value = 0x0)
+      def initialize(value = 0x0, name = nil)
         @default_value = value
+        @name = name
         reset
       end
 
@@ -16,21 +17,33 @@ module DCPU16
 
       def +(value)
         @value += value
+        @value &= 0xFFFF
         self
       end
 
       def -(value)
         @value -= value
+        @value &= 0xFFFF
         self
       end
 
       def write(value)
-        @value = value
+        @value = value & 0xFFFF
       end
 
       def reset
         @value = @default_value
       end
+
+      def inspect
+        { :name => @name, :value => @value, :default_value => @default_value }
+      end
+
+      def to_s
+        vh = ""
+        dh =
+        "name: #{@name}\tvalue: 0x%04x(#{@value})\tdefault: 0x%04x#{@default_value}" % [@value, @default_value]
+      end
     end
   end
 end

data/lib/dcpu16/debugger.rb

@@ -1,25 +1,51 @@
 module DCPU16
   class Debugger
     attr_reader :cpu, :screen
-    def initialize(dump = [])
+    def initialize(dump = [], options = {})
       @cpu    = DCPU16::CPU.new(dump)
       @screen = DCPU16::Screen.new(@cpu.memory)
+      @update_every = options[:update_every] || 100000
+      @step_mode    = false || options[:step_mode]
 
       @cpu.add_observer(self)
     end
 
     def run
-      clear_screen
+      at_exit do
+        print @screen
+        puts @cpu.to_s
+      end
+
       begin
-        @cpu.run
+        if @step_mode
+          @update_every = nil
+          while a = $stdin.gets
+            a = a.to_i
+            a = (@last_step_count || 1) if a < 1
+            @last_step_count = a
+
+            @cpu.step(a)
+            print @screen
+            print @cpu.to_s
+          end
+        else
+          clear_screen
+          @cpu.run
+        end
       rescue DCPU16::Instructions::Reserved => e
-        puts @cpu.to_s
+        print @cpu.to_s
       end
     end
 
     # Observer
     def update(cpu)
-      #cpu
+      @counter ||= 0
+      if @update_every && @counter > @update_every
+        @counter = 0
+        clear_screen
+        print @cpu.to_s
+      end
+      @counter += 1
     end
 
     # Clears screen for output

data/lib/dcpu16/memory.rb

@@ -28,6 +28,7 @@ module DCPU16
       # HACK: so we can just pass a Fixnum or a Register
       offset = offset.value if offset.respond_to? :value
 
+      value &= 0xFFFF
       @memory[offset] = value
 
       # Notify observers

data/lib/dcpu16/memory/word.rb

@@ -13,6 +13,7 @@ module DCPU16
       alias_method :read, :value
 
       def write(value)
+        value &= 0xFFFF
         @value = value
         @memory.write(@offset, value)
       end

data/lib/dcpu16/screen.rb

@@ -39,6 +39,7 @@ module DCPU16
 
 
       # Initial Screen dump
+      # CHECK: might be buggy
       @chars  = []
       @height.times do |h|
         @width.times do |w|
@@ -57,14 +58,14 @@ module DCPU16
     end
 
     def memory_offset_end
-      @memory_offset_end ||= 0x82FE#@memory_offset + size*2 - 2
+      @memory_offset_end ||= @memory_offset + size - 1
     end
 
     def to_s
       return @to_s if @to_s
 
       @to_s =  "\e[?1049h\e[17;1H"
-      @to_s << chars.join
+      @to_s << @chars.join
       @to_s << frame
     end
 
@@ -93,16 +94,16 @@ module DCPU16
     # Callback from observed memory
     def update(offset, value)
       return unless (memory_offset..memory_offset_end).include?(offset)
-#      @to_s = nil
+      @to_s = nil
 
-      diff = (offset - @memory_offset) / 2
+      diff = offset - @memory_offset
       h    = diff / @width
       w    = diff % @width
       @chars[diff] = Char.new(value, w + @x_offset, h + @y_offset)
       print @chars[diff]
-#      changed
-#      notify_observers(self)
-#      print @chars[diff]
+      changed
+      notify_observers(self)
+      print @chars[diff]
     end
   end
 
@@ -137,19 +138,3 @@ module DCPU16
   end
 end
 
-
-
-#The high 8 bits determine the color; the highest 4 are the foreground and the lowest 4 are the background
-
-#args = []
-#args << (value >> 15)
-#if value > 0x7F
-#  args << color_to_ansi(value >> 12) + 30
-#  args << color_to_ansi(value >> 8)  + 40
-#end
-
-#char = " " if char.ord.zero?
-
-#color = "\e[#{args*';'}m"
-#print "\e7\e[#{rows+1};#{cols+1}H#{color}#{char}\e8"
-

data/lib/dcpu16/version.rb

@@ -1,4 +1,4 @@
 module DCPU16
-  VERSION = "0.0.4.beta"
+  VERSION = "0.0.4.0"
 end
 

data/lib/dcpu16/version.rb~

@@ -1,4 +1,4 @@
 module DCPU16
-  VERSION = "0.0.4.alpha2"
+  VERSION = "0.0.4.0"
 end
 

data/spec/fixtures/example.dasm16

@@ -7,6 +7,8 @@
 ;   * Clock: 100000     (Clock-Speed of CPU [defined])
 ;   *    HZ: 99999.02   (Clock-Speed of CPU [real])
 
+SET C, [0x3000]                   ; Example
+SET C, 0x2000
 SET C, 0x30                       ; Init OuterLoop
 :outer_loop SET B, 0              ; Init InnerLoop
 :inner_loop SET [0x8000+B], C     ;draw

data/spec/unit/assembler_spec.rb

@@ -5,10 +5,11 @@ describe DCPU16::Assembler do
   subject { DCPU16::Assembler.new(asm) }
 
   its(:input) { should == asm }
-  its(:dump) { should be_a_kind_of(Array) }
+  its(:lines) { should be_a_kind_of(Array) }
   specify do
-#    puts subject.dump
-    puts subject.dump.first.bytes.length
+#    subject.lines
+    subject.assemble
+    #assert false
   end
 end
 

data/spec/unit/screen_spec.rb

@@ -39,7 +39,7 @@ describe DCPU16::Screen do
     specify { subject.should_receive(:update).tap { memory.write(0x8000, 40) } }
     context "memory outside of screen changed" do
       specify { observer.should_not_receive(:update).tap { memory.write(0x7FFF, 40) } }
-      specify { observer.should_not_receive(:update).tap { memory.write(0x8000 + 0x180, 40) } }
+      specify { observer.should_not_receive(:update).tap { memory.write(0x8000 + 0x300, 40) } }
     end
     context "memory of screen changed" do
       pending "Disabled Observer right now!"

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: Rdcpu16
 version: !ruby/object:Gem::Version
-  version: 0.0.4.beta
-  prerelease: 6
+  version: 0.0.4.0
+  prerelease: 
 platform: ruby
 authors:
 - Patrick Helm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-11 00:00:00.000000000 Z
+date: 2012-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &71628860 !ruby/object:Gem::Requirement
+  requirement: &84851380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *71628860
+  version_requirements: *84851380
 description: This is a simple Ruby port of the fictive 16-bit-cpu DCPU16.
 email:
 - deradon87@gmail.com
@@ -35,6 +35,9 @@ files:
 - lib/dcpu16/assembler.rb
 - lib/dcpu16/memory.rb
 - lib/dcpu16/version.rb
+- lib/dcpu16/assembler/line.rb
+- lib/dcpu16/assembler/instruction.rb
+- lib/dcpu16/assembler/constants.rb
 - lib/dcpu16/memory/word.rb
 - lib/dcpu16/cpu/operand.rb
 - lib/dcpu16/cpu/instruction.rb
@@ -79,9 +82,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10