rpicsim 0.1.0 → 0.2.1

data/lib/rpicsim/stack_pointer.rb

@@ -0,0 +1,41 @@
+module RPicSim
+  # Instances of this class represent the call stack pointer in a running
+  # simulation.
+  # A value of 0 means that the stack is empty, regardless of what device
+  # architecture you are simulating.
+  class StackPointer
+    # Initializes the StackPointer object.
+    # This be called when the call stack is empty, because this object uses
+    # the initial value of stkptr to deduce how it works.
+    # @param stkptr The STKPTR register of the simulation.
+    def initialize(stkptr)
+      @stkptr = stkptr
+      @stkptr_initial_value = @stkptr.value
+    end
+
+    def value
+      if @stkptr_initial_value > 0
+        raw_value = @stkptr.value
+        if raw_value == @stkptr_initial_value
+          0
+        else
+          raw_value + 1
+        end
+      else
+        @stkptr.value
+      end
+    end
+
+    def value=(value)
+      @stkptr.value = if @stkptr_initial_value > 0
+                        if value == 0
+                          @stkptr_initial_value
+                        else
+                          value - 1
+                        end
+                      else
+                        value
+                      end
+    end
+  end
+end

data/lib/rpicsim/stack_trace.rb

@@ -29,4 +29,4 @@ module RPicSim
       description
     end
   end
-end
+end

data/lib/rpicsim/storage/memory_integer.rb

@@ -0,0 +1,235 @@
+module RPicSim::Storage
+  # This class and its subclasses represent integers stored in RAM.
+  class MemoryInteger
+    attr_reader :name, :address
+    attr_writer :memory
+
+    # Creates a new MemoryInteger object not bound to any memory yet.
+    # @param name [Symbol] The name of the variable.
+    # @param address [Integer] should be the address of the variable
+    def initialize(name, address)
+      @name = name
+      @address = address
+    end
+
+    # Creates a new Variable that is bound to the specified memory.
+    # @param memory [RPicSim::Memory]
+    def bind(memory)
+      bound_var = dup
+      bound_var.memory = memory
+      bound_var
+    end
+
+    # @return [Range] The addresses of each byte that is part of this variable.
+    def addresses
+      address ... (address + size)
+    end
+
+    # Reads the value of the variable from memory.
+    # @return [Integer]
+    def value
+      raise NoMethodError, 'value not implemented'
+    end
+
+    # Writes to the value to the variable's memory.
+    # @return [Integer]
+    def value=(val)
+      raise NoMethodError, 'value= not implemented'
+    end
+
+    def memory_value=(val)
+      self.value = val
+    end
+
+    def memory_value(val)
+      value
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def inspect
+      '<%s %s 0x%x>' % [self.class, name, address]
+    end
+
+    private
+    def check_value(value, allowed_values)
+      if !allowed_values.include?(value)
+        raise ArgumentError, "Invalid value #{value} written to #{name}."
+      end
+    end
+  end
+
+  # Represents an unsigned 8-bit variable.
+  class MemoryUInt8 < MemoryInteger
+    def size
+      1
+    end
+
+    def value
+      @memory.read_byte(@address)
+    end
+
+    def value=(val)
+      check_value val, 0..255
+      @memory.write_byte(@address, val)
+    end
+
+  end
+
+  # Represents a signed 8-bit variable.
+  class MemoryInt8 < MemoryInteger
+    def size
+      1
+    end
+
+    def value
+      val = @memory.read_byte(@address)
+      val -= 0x100 if val >= 0x80
+      val
+    end
+
+    def value=(val)
+      check_value val, -0x80...0x80
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+    end
+  end
+
+  # Represents an unsigned 16-bit variable.
+  class MemoryUInt16 < MemoryInteger
+    def size
+      2
+    end
+
+    def value
+      @memory.read_byte(@address) + 256 * @memory.read_byte(@address + 1)
+    end
+
+    def value=(val)
+      check_value val, 0...0x10000
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+    end
+  end
+
+  # Represents a signed 16-bit variable.
+  class MemoryInt16 < MemoryInteger
+    def size
+      2
+    end
+
+    def value
+      val = @memory.read_byte(@address) + 256 * @memory.read_byte(@address + 1)
+      val -= 0x10000 if val >= 0x8000
+      val
+    end
+
+    def value=(val)
+      check_value val, -0x8000...0x8000
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+    end
+  end
+
+  # Represents an unsigned 24-bit variable.
+  class MemoryUInt24 < MemoryInteger
+    def size
+      3
+    end
+
+    def value
+      @memory.read_byte(@address) + 0x100 * @memory.read_byte(@address + 1) +
+        0x10000 * @memory.read_byte(@address + 2)
+    end
+
+    def value=(val)
+      check_value val, 0...0x1000000
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+      @memory.write_byte(@address + 2, (val >> 16) & 0xFF)
+    end
+  end
+
+  # Represents a signed 24-bit variable.
+  class MemoryInt24 < MemoryInteger
+    def size
+      3
+    end
+
+    def value
+      val = @memory.read_byte(@address) + 0x100 * @memory.read_byte(@address + 1) +
+        0x10000 * @memory.read_byte(@address + 2)
+      val -= 0x1000000 if val >= 0x800000
+      val
+    end
+
+    def value=(val)
+      check_value val, -0x800000..0x800000
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+      @memory.write_byte(@address + 2, (val >> 16) & 0xFF)
+    end
+  end
+
+  # Represents an unsigned 32-bit variable.
+  class MemoryUInt32 < MemoryInteger
+    def size
+      4
+    end
+
+    def value
+      @memory.read_byte(@address) + 0x100 * @memory.read_byte(@address + 1) +
+        0x10000 * @memory.read_byte(@address + 2) +
+        0x1000000 * @memory.read_byte(@address + 3)
+    end
+
+    def value=(val)
+      check_value val, 0...0x100000000
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+      @memory.write_byte(@address + 2, (val >> 16) & 0xFF)
+      @memory.write_byte(@address + 3, (val >> 24) & 0xFF)
+    end
+  end
+
+  # Represents a signed 32-bit variable.
+  class MemoryInt32 < MemoryInteger
+    def size
+      4
+    end
+
+    def value
+      val = @memory.read_byte(@address) + 0x100 * @memory.read_byte(@address + 1) +
+        0x10000 * @memory.read_byte(@address + 2) +
+        0x1000000 * @memory.read_byte(@address + 3) +
+        0x100000000 * @memory.read_byte(@address + 4)
+      val -= 0x100000000 if val >= 0x80000000
+      val
+    end
+
+    def value=(val)
+      check_value val, -0x80000000..0x80000000
+      @memory.write_byte(@address, val & 0xFF)
+      @memory.write_byte(@address + 1, (val >> 8) & 0xFF)
+      @memory.write_byte(@address + 2, (val >> 16) & 0xFF)
+      @memory.write_byte(@address + 3, (val >> 24) & 0xFF)
+    end
+  end
+
+  # Represents a word-sized variable.
+  # The size of the word will depend on the memory the variable lives in.
+  class MemoryWord < MemoryInteger
+    attr_accessor :size
+
+    def value
+      @memory.read_word(@address)
+    end
+
+    def value=(val)
+      @memory.write_word(@address, val)
+    end
+  end
+
+end

data/lib/rpicsim/{register.rb → storage/register.rb}

@@ -1,16 +1,16 @@
-module RPicSim
+module RPicSim::Storage
   class Register
     attr_reader :name
-    
+
     # The size of the register in bytes.
     attr_reader :size
-  
+
     # @param mplab_register [Mplab::MplabRegister]
     # @param memory An optional parameter that enables memory_value.
     def initialize(mplab_register, memory, width)
       @mplab_register = mplab_register
       @name = mplab_register.name.to_sym
-      
+
       @size = case width
               when 8 then 1
               when 16 then 2
@@ -18,14 +18,14 @@ module RPicSim
               when 32 then 4
               else raise "Unsupported register width: #{name} is #{width}-bit."
               end
-      
+
       var_type = case size
-                 when 1 then VariableU8
-                 when 2 then VariableU16
-                 when 3 then VariableU24
-                 when 4 then VariableU32
+                 when 1 then MemoryUInt8
+                 when 2 then MemoryUInt16
+                 when 3 then MemoryUInt24
+                 when 4 then MemoryUInt32
                  end
-      
+
       @var = var_type.new(name, address).bind(memory)
     end
 
@@ -34,13 +34,13 @@ module RPicSim
     def value=(val)
       @mplab_register.write val
     end
-    
+
     # Reads the value of the register.
     # @return [Integer]
     def value
       @mplab_register.read
     end
-    
+
     # For some registers, like STATUS, you cannot read and write the full
     # range of possible values using {#value=} because some bits are not
     # writable by the CPU.
@@ -49,7 +49,7 @@ module RPicSim
     def memory_value=(value)
       @var.value = value
     end
-    
+
     # Reads the value directly from the memory object backing the register.
     def memory_value
       @var.value
@@ -60,19 +60,19 @@ module RPicSim
     def address
       @mplab_register.address
     end
-    
+
     # Gets the range of addresses occupied.
     # @return [Range] A range of integers.
     def addresses
       address...(address + size)
     end
-    
+
     def to_s
       name.to_s
     end
-    
+
     def inspect
-      "<%s %s 0x%x>" % [self.class, name, address]
+      '<%s %s 0x%x>' % [self.class, name, address]
     end
   end
-end
+end

data/lib/rpicsim/variable.rb

@@ -1,236 +1,50 @@
 module RPicSim
-  # This class and its subclasses represent firmware-defined variables
-  # in RAM or flash.
-  #
-  # Instances of this class come in two varieties:
-  # - Unbound variables are just a name and an address.
-  # - Bound variables have a name and an address and they are attached to
-  #   a memory object so you can actually read and write values from them.
   class Variable
-    module ClassMethods
-      # @return (Integer) The size of this type of variable in memory words.
-      attr_reader :size
-
-      # Specifies the size of this class of variables in memory words.
-      # The units for this are usually bytes for RAM and more than a byte
-      # for flash.  This should be called inside the definition of a subclass of
-      # {Variable}, not from anywhere else.
-      def size_is(size)
-        @size = size
-      end
-    end
-
-    extend ClassMethods
-
-    attr_reader :name, :address
-    attr_writer :memory
-
-    # Creates a new Variable object not bound to any memory yet.
-    # @param name [Symbol] The name of the variable.
-    # @param address [Integer] should be the address of the variable
-    def initialize(name, address)
-      @name = name
-      @address = address
-    end
-
-    # Creates a new Variable that is bound to the specified memory.
-    # @param memory [RPicSim::Memory]
-    def bind(memory)
-      bound_var = dup
-      bound_var.memory = memory
-      bound_var
-    end
-
-    # @return [Range] The addresses of each byte that is part of this variable.
-    def addresses
-      address ... (address + self.class.size)
+    # Creates a new Variable object.
+    # @param storage The internal storage for the variable.
+    def initialize(storage)
+      @storage = storage
     end
 
-    # Reads the value of the variable from memory.
+    # Reads the value of the variable.
     # @return [Integer]
     def value
-      raise NoMethodError, "value not implemented"
+      @storage.value
     end
 
-    # Writes to the value to the variable's memory.
+    # Writes the value to the variable.
     # @return [Integer]
     def value=(val)
-      raise NoMethodError, "value= not implemented"
-    end
-
-    def to_s
-      name.to_s
-    end
-
-    def inspect
-      "<%s %s 0x%x>" % [self.class, name, address]
-    end
-    
-    private
-    def check_value(value, allowed_values)
-      if !allowed_values.include?(value)
-        raise ArgumentError, "Invalid value #{value} written to #{name}."
-      end
-    end
-  end
-
-  # Represents an unsigned 8-bit variable.
-  class VariableU8 < Variable
-    size_is 1
-
-    def value
-      @memory.read_word(@address)
-    end
-
-    def value=(val)
-      check_value val, 0..255
-      @memory.write_word(@address, val)
-    end
-
-  end
-
-  # Represents a signed 8-bit variable.
-  class VariableS8 < Variable
-    size_is 1
-
-    def value
-      val = @memory.read_word(@address)
-      val -= 0x100 if val >= 0x80
-      val
-    end
-
-    def value=(val)
-      check_value val, -0x80...0x80
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-    end
-  end
-
-  # Represents an unsigned 16-bit variable.
-  class VariableU16 < Variable
-    size_is 2
-
-    def value
-      @memory.read_word(@address) + 256 * @memory.read_word(@address + 1)
-    end
-
-    def value=(val)
-      check_value val, 0...0x10000
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-    end
-  end
-
-  # Represents a signed 16-bit variable.
-  class VariableS16 < Variable
-    size_is 2
-
-    def value
-      val = @memory.read_word(@address) + 256 * @memory.read_word(@address + 1)
-      val -= 0x10000 if val >= 0x8000
-      val
-    end
-
-    def value=(val)
-      check_value val, -0x8000...0x8000
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-    end
-  end
-
-  # Represents an unsigned 24-bit variable.
-  class VariableU24 < Variable
-    size_is 3
-
-    def value
-      @memory.read_word(@address) + 0x100 * @memory.read_word(@address + 1) +
-        0x10000 * @memory.read_word(@address + 2)
-    end
-
-    def value=(val)
-      check_value val, 0...0x1000000
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-      @memory.write_word(@address + 2, (val >> 16) & 0xFF)
-    end
-  end
-
-  # Represents a signed 24-bit variable.
-  class VariableS24 < Variable
-    size_is 3
-
-    def value
-      val = @memory.read_word(@address) + 0x100 * @memory.read_word(@address + 1) +
-        0x10000 * @memory.read_word(@address + 2)
-      val -= 0x1000000 if val >= 0x800000
-      val
-    end
-
-    def value=(val)
-      check_value val, -0x800000..0x800000
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-      @memory.write_word(@address + 2, (val >> 16) & 0xFF)
+      @storage.value = val
     end
-  end
-
-  # Represents an unsigned 32-bit variable.
-  class VariableU32 < Variable
-    size_is 4
 
-    def value
-      @memory.read_word(@address) + 0x100 * @memory.read_word(@address + 1) +
-        0x10000 * @memory.read_word(@address + 2) +
-        0x1000000 * @memory.read_word(@address + 3)
+    # Writes the value to the variable in a lower-level way that
+    # overrides any read-only bits.
+    # For some types of variables, this is the same as {#value=}.
+    def memory_value=(val)
+      @storage.memory_value = val
     end
 
-    def value=(val)
-      check_value val, 0...0x100000000
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-      @memory.write_word(@address + 2, (val >> 16) & 0xFF)
-      @memory.write_word(@address + 3, (val >> 24) & 0xFF)
+    # Reads the value directly from the memory object backing the register.
+    # For some types of variables, this is the same as {#value}.
+    def memory_value
+      @storage.memory_value
     end
-  end
 
-  # Represents a signed 32-bit variable.
-  class VariableS32 < Variable
-    size_is 4
-
-    def value
-      val = @memory.read_word(@address) + 0x100 * @memory.read_word(@address + 1) +
-        0x10000 * @memory.read_word(@address + 2) +
-        0x1000000 * @memory.read_word(@address + 3) +
-        0x100000000 * @memory.read_word(@address + 4)
-      val -= 0x100000000 if val >= 0x80000000
-      val
+    def to_s
+      @storage.to_s
     end
 
-    def value=(val)
-      check_value val, -0x80000000..0x80000000
-      @memory.write_word(@address, val & 0xFF)
-      @memory.write_word(@address + 1, (val >> 8) & 0xFF)
-      @memory.write_word(@address + 2, (val >> 16) & 0xFF)
-      @memory.write_word(@address + 3, (val >> 24) & 0xFF)
+    def addresses
+      @storage.addresses
     end
-  end
-
-  # Represents a word-sized variable.
-  # The size of the word will depend on the memory the variable lives in.
-  class VariableWord < Variable
-    size_is 1
-
-    attr_writer :max_value
 
-    def value
-      @memory.read_word(@address)
+    def address
+      @storage.address
     end
 
-    def value=(val)
-      if @max_value
-        check_value val, 0..@max_value
-      end
-      @memory.write_word(@address, val)
+    def name
+      @storage.name
     end
   end
 end