Rdcpu16 0.0.3.1 → 0.0.4.alpha

data/lib/dcpu16/screen.rb

@@ -0,0 +1,155 @@
+require 'observer'
+
+# Text VRAM starts at 0x8000 and is word-based (16bits per address cell)
+# like other memory and is in the same address space as the rest of the processor uses.
+
+# The low 8 bits determine the character shown.
+
+# The high 8 bits determine the color;
+# the highest 4 are the foreground and the lowest 4 are the background.
+
+# The color nibbles use (from LSB to MSB) blue, green, red, highlight.
+# (Normal 16color from PCs, though probably with darkyellow instead of brown)
+
+# The screen appears to be 32 characters by 12 lines, with a character cell of 4x8 pixels,
+# suggesting possible graphics modes of 128x96 pixels at that resolution.
+
+# require 'dcpu16'; cpu = DCPU16::CPU.new; screen = DCPU16::Screen.new(cpu.memory); cpu.memory.write(0x8000, 0x30)
+
+
+# TODO: OUTPUT
+# require 'dcpu16'; debugger = DCPU16::Debugger.new
+module DCPU16
+  class Screen
+    include Observable
+
+    X_OFFSET = 2
+    Y_OFFSET = 2
+
+    attr_reader :width, :height, :memory_offset, :chars
+
+    def initialize(memory, options = {})
+      @memory = memory
+      @width  = options[:width]  || 32
+      @height = options[:height] || 12
+      @memory_offset = options[:memory_offset] || 0x8000
+
+      @x_offset = options[:x_offset] || X_OFFSET
+      @y_offset = options[:y_offset] || Y_OFFSET
+
+
+      # Initial Screen dump
+      @chars  = []
+      @height.times do |h|
+        @width.times do |w|
+          offset = h * @width + w
+          value = @memory.read(@memory_offset + 2*offset).value
+          @chars[offset] = Char.new(value, w + @x_offset, h + @y_offset)
+        end
+      end
+
+      @memory.add_observer(self)
+#      print self
+    end
+
+    def size
+      @size ||= @width * @height
+    end
+
+    def memory_offset_end
+      @memory_offset_end ||= 0x82FE#@memory_offset + size*2 - 2
+    end
+
+    def to_s
+      return @to_s if @to_s
+
+      @to_s =  "\e[?1049h\e[17;1H"
+      @to_s << chars.join
+      @to_s << frame
+    end
+
+    # Use a fancy border around console
+    def frame
+      return @frame if @frame
+
+      chars = []
+      # 4 corners
+      chars << Char.new(0x23, @x_offset - 1, @y_offset - 1)               # TopLeft
+      chars << Char.new(0x23, @x_offset + @width, @y_offset - 1)          # TopRight
+      chars << Char.new(0x23, @x_offset - 1, @y_offset + @height)         # BottomLeft
+      chars << Char.new(0x23, @x_offset + @width, @y_offset  + @height)   # BottomRight
+
+      # horiz
+      @width.times { |x| chars << Char.new(0x2d, x + @x_offset, @y_offset - 1) }
+      @width.times { |x| chars << Char.new(0x2d, x + @x_offset, @y_offset + @height) }
+
+      # vertical
+      @height.times { |y| chars << Char.new(0x7c, @x_offset - 1, y + @y_offset) }
+      @height.times { |y| chars << Char.new(0x7c, @x_offset + @width, y + @y_offset) }
+      @frame = ""
+      @frame << chars.join
+    end
+
+    # Callback from observed memory
+    def update(offset, value)
+      return unless (memory_offset..memory_offset_end).include?(offset)
+#      @to_s = nil
+
+      diff = (offset - @memory_offset) / 2
+      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]
+    end
+  end
+
+  # DOC
+  # Inspired by: https://github.com/judofyr/rcpu/blob/master/lib/rcpu/libraries.rb
+  class Char
+    attr_reader :output
+    def initialize(value, x, y)
+      @char     = (value & 0x007F).chr
+#      @bg_color = (value >> 8) & 0x0F
+#      @fg_color = value >> 12
+
+      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"
+      @output = "\e7\e[#{y};#{x}H#{@color}#{@char}\e8"
+    end
+
+    def to_s
+      @output
+    end
+
+    def color_to_ansi(bit)
+      ((bit & 1) << 2) | (bit & 2) | ((bit & 4) >> 2)
+    end
+  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.3.1"
+  VERSION = "0.0.4.alpha"
 end
 

data/lib/dcpu16/version.rb~

@@ -1,4 +1,4 @@
 module DCPU16
-  VERSION = "0.0.4"
+  VERSION = "0.0.3.2"
 end
 

data/lib/dcpu16.rb

@@ -1,5 +1,9 @@
 require 'dcpu16/assembler'
 require 'dcpu16/cpu'
+require 'dcpu16/debugger'
+require 'dcpu16/literal'
+require 'dcpu16/memory'
+require 'dcpu16/screen'
 require 'dcpu16/version'
 
 module DCPU16

data/spec/fixtures/example.dasm16

@@ -0,0 +1,20 @@
+; Patrick Helm, deradon87@gmail.com
+;
+; Flash Screen with chars (Benchmark)
+;
+; Output:
+;   * Cycle: 519002     (Cycle needed to finish)
+;   * Clock: 100000     (Clock-Speed of CPU [defined])
+;   *    HZ: 99999.02   (Clock-Speed of CPU [real])
+
+SET C, 0x30                       ; Init OuterLoop
+:outer_loop SET B, 0              ; Init InnerLoop
+:inner_loop SET [0x8000+B], C     ;draw
+ADD B, 1
+IFG 0x0300, B
+SET PC, inner_loop                ;jmp inner_loop
+
+ADD C,1
+IFG 0x7B, C
+SET PC, outer_loop                ;jmp outer_loop
+

data/spec/spec_helper.rb

@@ -1,2 +1,7 @@
 require 'dcpu16'
 
+# Don't run broken specs
+RSpec.configure do |c|
+  c.filter_run_excluding :broken => true
+end
+

data/spec/unit/assembler_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper.rb'
+
+describe DCPU16::Assembler do
+  let(:asm) { File.open(File.join('spec', 'fixtures', 'example.dasm16')).read }
+  subject { DCPU16::Assembler.new(asm) }
+
+  its(:input) { should == asm }
+  its(:dump) { should be_a_kind_of(Array) }
+  specify do
+#    puts subject.dump
+    puts subject.dump.first.bytes.length
+  end
+end
+

data/spec/unit/{dcpu16_cpu_spec.rb → cpu/cpu_spec.rb}

@@ -7,11 +7,11 @@ describe DCPU16::CPU do
 
   describe "Register" do
     its(:registers) { subject.length == 8 }
-    its(:registers) { subject[0] == be_kind_of(DCPU16::Register) }
+    its(:registers) { subject[0] == be_kind_of(DCPU16::CPU::Register) }
 
-    its(:PC) { should be_kind_of(DCPU16::Register) }
-    its(:SP) { should be_kind_of(DCPU16::Register) }
-    its(:O)  { should be_kind_of(DCPU16::Register) }
+    its(:PC) { should be_kind_of(DCPU16::CPU::Register) }
+    its(:SP) { should be_kind_of(DCPU16::CPU::Register) }
+    its(:O)  { should be_kind_of(DCPU16::CPU::Register) }
   end
 
   its(:cycle) { should == 0 }

data/spec/unit/{dcpu16_instruction_spec.rb → cpu/instruction_spec.rb}

@@ -1,25 +1,25 @@
 require 'spec_helper.rb'
 
-describe DCPU16::Instruction do
+describe DCPU16::CPU::Instruction do
   context "when initialized with 0x00" do
-    let(:word) { DCPU16::Word.new(0x00) }
-    subject { DCPU16::Instruction.new(word) }
+    let(:word) { DCPU16::Memory::Word.new(0x00) }
+    subject { DCPU16::CPU::Instruction.new(word) }
     its(:opcode) { should == 0 }
     its(:a) { should == 0 }
     its(:b) { should be_nil }
   end
 
   context "when initialized with 0x0001" do
-    let(:word) { DCPU16::Word.new(0x0001) }
-    subject { DCPU16::Instruction.new(word) }
+    let(:word) { DCPU16::Memory::Word.new(0x0001) }
+    subject { DCPU16::CPU::Instruction.new(word) }
     its(:opcode) { should == 1 }
     its(:a) { should == 0 }
     its(:b) { should == 0 }
   end
 
   context "when initialized with 0xa861" do
-    let(:word) { DCPU16::Word.new(0xa861) }
-    subject { DCPU16::Instruction.new(word) }
+    let(:word) { DCPU16::Memory::Word.new(0xa861) }
+    subject { DCPU16::CPU::Instruction.new(word) }
     its(:opcode) { should == 1 }
     its(:a) { should == 0x6 }
     its(:b) { should == 0xa + 0x20 } # Literal value (offset += 0x20)

data/spec/unit/{dcpu16_operand_spec.rb → cpu/operand_spec.rb}

@@ -4,14 +4,14 @@ describe DCPU16::Instructions do
   let(:cpu) { DCPU16::CPU.new }
 
   context "when value is between 0x00 and 0x07" do
-    specify { DCPU16::Operand.new(cpu, 0x0).should == cpu.A }
-    specify { DCPU16::Operand.new(cpu, 0x1).should == cpu.B }
-    specify { DCPU16::Operand.new(cpu, 0x2).should == cpu.C }
-    specify { DCPU16::Operand.new(cpu, 0x3).should == cpu.X }
-    specify { DCPU16::Operand.new(cpu, 0x4).should == cpu.Y }
-    specify { DCPU16::Operand.new(cpu, 0x5).should == cpu.Z }
-    specify { DCPU16::Operand.new(cpu, 0x6).should == cpu.I }
-    specify { DCPU16::Operand.new(cpu, 0x7).should == cpu.J }
+    specify { cpu.get_operand(0x0).should == cpu.A }
+    specify { cpu.get_operand(0x1).should == cpu.B }
+    specify { cpu.get_operand(0x2).should == cpu.C }
+    specify { cpu.get_operand(0x3).should == cpu.X }
+    specify { cpu.get_operand(0x4).should == cpu.Y }
+    specify { cpu.get_operand(0x5).should == cpu.Z }
+    specify { cpu.get_operand(0x6).should == cpu.I }
+    specify { cpu.get_operand(0x7).should == cpu.J }
   end
 
   context "when value is between 0x08 and 0x17" do
@@ -20,8 +20,8 @@ describe DCPU16::Instructions do
       cpu.registers.each { |r| r.write(0x1000) }
     end
 
-    specify { DCPU16::Operand.new(cpu, 0x8).value.should == 0x2a }
-    specify { DCPU16::Operand.new(cpu, 0xF).value.should == 0x2a }
+    specify { cpu.get_operand(0x8).value.should == 0x2a }
+    specify { cpu.get_operand(0xF).value.should == 0x2a }
   end
 
 
@@ -62,15 +62,15 @@ describe DCPU16::Instructions do
   end
 
   context "when value is between 0x20 and 0x3f" do
-    specify { DCPU16::Operand.new(cpu, 0x20).should be_a_kind_of(DCPU16::Literal) }
-    specify { DCPU16::Operand.new(cpu, 0x20).value.should == 0x0 }
-    specify { DCPU16::Operand.new(cpu, 0x3f).value.should == 0x1f }
+    specify { cpu.get_operand(0x20).should be_a_kind_of(DCPU16::Literal) }
+    specify { cpu.get_operand(0x20).value.should == 0x0 }
+    specify { cpu.get_operand(0x3f).value.should == 0x1f }
   end
 
   context "when value is > 0x3f" do
     specify do
       expect {
-        DCPU16::Operand.new(cpu, 0x40)
+        cpu.get_operand(0x40)
       }.to raise_error(DCPU16::Operand::NotFound)
     end
   end

data/spec/unit/cpu/register_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper.rb'
+
+describe DCPU16::CPU::Register do
+  subject { DCPU16::CPU::Register.new(0x00) }
+end
+

data/spec/unit/{dcpu16_memory_spec.rb → memory/memory_spec.rb}

@@ -5,7 +5,7 @@ describe DCPU16::Memory do
   its(:length) { should == 0x10000 }
 
   describe "#read" do
-    specify { subject.read(0).should be_a_kind_of(DCPU16::Word) }
+    specify { subject.read(0).should be_a_kind_of(DCPU16::Memory::Word) }
   end
 
 

data/spec/unit/{dcpu16_word_spec.rb → memory/word_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper.rb'
 
-describe DCPU16::Word do
+describe DCPU16::Memory::Word do
   let(:memory) { DCPU16::Memory.new }
-  subject { DCPU16::Word.new(2, memory, 0) }
+  subject { DCPU16::Memory::Word.new(2, memory, 0) }
 
-  specify { subject.should be_a_kind_of(DCPU16::Word) }
+  specify { subject.should be_a_kind_of(DCPU16::Memory::Word) }
   its(:value) { should == 2 }
   its(:read)  { should == 2 }
 

data/spec/unit/screen_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'unit/support/screen_observer'
+
+describe DCPU16::Screen do
+  let(:memory) { DCPU16::Memory.new }
+  subject { DCPU16::Screen.new(memory) }
+
+  describe "initialize" do
+    specify { expect { DCPU16::Screen.new }.to raise_error(ArgumentError) }
+    specify { expect { DCPU16::Screen.new(memory) }.to_not raise_error }
+    its(:width) { should == 32 }
+    its(:height) { should == 12 }
+    its(:memory_offset) { should == 0x8000 }
+    its(:chars) { subject.length.should == 32*12 } # width * height + newlines
+
+    context "when called with options" do
+      let(:options) { {:width => 40, :height => 200, :memory_offset => 0x9000} }
+      subject { DCPU16::Screen.new(memory, options) }
+
+      its(:width) { should == 40 }
+      its(:height) { should == 200 }
+      its(:memory_offset) { should == 0x9000 }
+      its(:chars) { subject.length.should == 40 * 200 }
+    end
+  end
+
+  describe "#to_s" do
+    context "in initial state" do
+      pending
+#      let(:expected) { String.new(" "*32 + "\n") * 12 }
+#      its(:to_s) { should == expected }
+    end
+  end
+
+  describe "observable" do
+    let(:observer) { DCPU16::ScreenObserver.new }
+    before(:all) { subject.add_observer(observer) }
+
+    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) } }
+    end
+    context "memory of screen changed" do
+      pending "Disabled Observer right now!"
+#      specify { observer.should_receive(:update).tap { memory.write(0x8000, 40) } }
+#      specify { observer.should_receive(:update).tap { memory.write(0x82FE, 40) } }
+    end
+  end
+end
+

data/spec/unit/support/screen_observer.rb

@@ -0,0 +1,13 @@
+module DCPU16
+  class ScreenObserver
+    attr_reader :screen
+
+    def initialize
+    end
+
+    def update(screen)
+      @screen
+    end
+  end
+end
+

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: Rdcpu16
 version: !ruby/object:Gem::Version
-  version: 0.0.3.1
-  prerelease: 
+  version: 0.0.4.alpha
+  prerelease: 6
 platform: ruby
 authors:
 - Patrick Helm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-09 00:00:00.000000000 Z
+date: 2012-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70293790 !ruby/object:Gem::Requirement
+  requirement: &85435200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70293790
+  version_requirements: *85435200
 description: This is a simple Ruby port of the fictive 16-bit-cpu DCPU16.
 email:
 - deradon87@gmail.com
@@ -29,34 +29,39 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/dcpu16.rb
 - lib/dcpu16/cpu.rb
 - lib/dcpu16/assembler.rb
-- lib/dcpu16/operand.rb
 - lib/dcpu16/memory.rb
-- lib/dcpu16/word.rb
 - lib/dcpu16/version.rb
+- lib/dcpu16/memory/word.rb
+- lib/dcpu16/cpu/operand.rb
+- lib/dcpu16/cpu/instruction.rb
 - lib/dcpu16/cpu/instructions.rb
+- lib/dcpu16/cpu/register.rb
+- lib/dcpu16/screen.rb
 - lib/dcpu16/support/debug.rb
 - lib/dcpu16/version.rb~
 - lib/dcpu16/literal.rb
-- lib/dcpu16/instruction.rb
-- lib/dcpu16/register.rb
+- lib/dcpu16/debugger.rb
 - lib/dcpu16.rb
 - MIT-LICENSE
 - Rakefile
 - README.rdoc
-- spec/fixtures/example.asm
+- spec/fixtures/example.dasm16
 - spec/integration/example1_spec.rb
-- spec/unit/dcpu16_assembler_spec.rb
-- spec/unit/dcpu16_word_spec.rb
+- spec/unit/assembler_spec.rb
+- spec/unit/memory/memory_spec.rb
+- spec/unit/memory/word_spec.rb
+- spec/unit/cpu/operand_spec.rb
+- spec/unit/cpu/instruction_spec.rb
+- spec/unit/cpu/register_spec.rb
+- spec/unit/cpu/instructions_spec.rb
+- spec/unit/cpu/cpu_spec.rb
 - spec/unit/support/sample_observer.rb
+- spec/unit/support/screen_observer.rb
 - spec/unit/support/memory_observer.rb
-- spec/unit/dcpu16_register_spec.rb
-- spec/unit/dcpu16_cpu_spec.rb
-- spec/unit/dcpu16_memory_spec.rb
-- spec/unit/dcpu16_instructions_spec.rb
-- spec/unit/dcpu16_operand_spec.rb
-- spec/unit/dcpu16_instruction_spec.rb
+- spec/unit/screen_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Deradon/Rdcpu16
 licenses: []
@@ -73,9 +78,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10
@@ -83,16 +88,18 @@ signing_key:
 specification_version: 3
 summary: Ruby port of DCPU16
 test_files:
-- spec/fixtures/example.asm
+- spec/fixtures/example.dasm16
 - spec/integration/example1_spec.rb
-- spec/unit/dcpu16_assembler_spec.rb
-- spec/unit/dcpu16_word_spec.rb
+- spec/unit/assembler_spec.rb
+- spec/unit/memory/memory_spec.rb
+- spec/unit/memory/word_spec.rb
+- spec/unit/cpu/operand_spec.rb
+- spec/unit/cpu/instruction_spec.rb
+- spec/unit/cpu/register_spec.rb
+- spec/unit/cpu/instructions_spec.rb
+- spec/unit/cpu/cpu_spec.rb
 - spec/unit/support/sample_observer.rb
+- spec/unit/support/screen_observer.rb
 - spec/unit/support/memory_observer.rb
-- spec/unit/dcpu16_register_spec.rb
-- spec/unit/dcpu16_cpu_spec.rb
-- spec/unit/dcpu16_memory_spec.rb
-- spec/unit/dcpu16_instructions_spec.rb
-- spec/unit/dcpu16_operand_spec.rb
-- spec/unit/dcpu16_instruction_spec.rb
+- spec/unit/screen_spec.rb
 - spec/spec_helper.rb

data/lib/dcpu16/operand.rb

@@ -1,61 +0,0 @@
-# TODO: Test && Refacoring
-module DCPU16
-  class Operand
-    class NotFound < StandardError; end
-
-    def self.new(cpu, value)
-      if (0x00..0x07).include?(value)
-        # register (A, B, C, X, Y, Z, I or J, in that order)
-        return cpu.registers[value]
-      elsif (0x08..0x0f).include?(value)
-        # [register]
-        register = cpu.registers[value - DCPU16::CPU::REGISTERS_COUNT]
-        return cpu.memory.read(register)
-      elsif (0x10..0x17).include?(value)
-        cpu.cycle += 1
-        offset = cpu.memory.read(cpu.PC).value
-        cpu.PC += 1
-        return cpu.memory.read(offset + cpu.registers[value - 0x10].read)
-      elsif value == 0x18
-        # POP / [SP++]
-        r = cpu.memory.read(cpu.SP)
-        cpu.SP += 1
-        return r
-      elsif value == 0x19
-        # PEEK / [SP]
-        return cpu.memory.read(cpu.SP)
-      elsif value == 0x1a
-        # PUSH / [--SP]
-        cpu.SP -= 1
-        cpu.memory.read(cpu.SP)
-      elsif value == 0x1b
-        # SP
-        return cpu.SP
-      elsif value == 0x1c
-        # PC
-        return cpu.PC
-      elsif value == 0x1d
-        # O
-        return cpu.O
-      elsif value == 0x1e
-        # [next word]
-        cpu.cycle += 1
-        offset = cpu.memory.read(cpu.PC)
-        cpu.PC += 1
-        return cpu.memory.read(offset)
-      elsif value == 0x1f
-        # next word (literal)
-        cpu.cycle += 1
-        r = cpu.memory.read(cpu.PC)
-        cpu.PC += 1
-        return r
-      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/register.rb

@@ -1,35 +0,0 @@
-module DCPU16
-  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
-

data/lib/dcpu16/word.rb

@@ -1,20 +0,0 @@
-module DCPU16
-  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
-