rpicsim 0.1.0 → 0.2.1

data/lib/rpicsim/rspec/be_predicate.rb

@@ -9,4 +9,4 @@ class RSpec::Matchers::BuiltIn::BePredicate
   def failure_message_for_should_not
     "expected #{actual.inspect}.#{predicate}#{args_to_s} to return false, got #{@result.inspect}"
   end
-end
+end

data/lib/rpicsim/rspec/helpers.rb

@@ -13,7 +13,7 @@ module RPicSim
     # integration with RSpec.
     module Helpers
       include RPicSim::RSpec::PersistentExpectations
-      
+
       # This attribute allows you to type +sim+ in your specs instead of +@sim+ to
       # get access to the {RPicSim::Sim} instance which represents the simulation.
       # You must call {#start_sim} before using +sim+.

data/lib/rpicsim/rspec/persistent_expectations.rb

@@ -45,9 +45,24 @@ module RPicSim
       #     expecting main_output_pin: be_driving_high
       #
       # To remove an expectation on an object, just provide +nil+ for the matcher.
+      #
+      # If given a block, applies the new expectations, executes the
+      # block, then resets expectations to their former state.
+      # Expectation blocks may be nested and freely mixed with other
+      # calls to `expecting`.
       def expecting(hash)
-        expectations.merge! hash
+        if block_given?
+          saved_expectations = expectations.clone
+          begin
+            expecting(hash)
+            yield
+          ensure
+            @expectations = saved_expectations
+          end
+        else
+          expectations.merge! hash
+        end
       end
     end
   end
-end
+end

data/lib/rpicsim/rspec/sim_diagnostics.rb

@@ -21,7 +21,7 @@ RSpec::Core::Formatters::BaseTextFormatter
 # different functions so you can easily customize any of them without messing up
 # the other ones.
 class RSpec::Core::Formatters::BaseTextFormatter
-  alias dump_backtrace_without_sim_diagnostics dump_backtrace
+  alias_method :dump_backtrace_without_sim_diagnostics, :dump_backtrace
 
   def dump_backtrace(example)
     dump_backtrace_without_sim_diagnostics(example)
@@ -35,7 +35,7 @@ class RSpec::Core::Formatters::BaseTextFormatter
 
   def dump_sim_cycle_count(example)
     cycle_count = example.metadata[:sim_cycle_count] or return
-    output.puts long_padding
+    output.puts
     output.printf long_padding + "Simulation cycle count: %d\n", cycle_count
   end
 
@@ -44,8 +44,8 @@ class RSpec::Core::Formatters::BaseTextFormatter
   # appropriate indentation.
   def dump_sim_stack_trace(example)
     sim_stack_trace = example.metadata[:sim_stack_trace] or return
-    output.puts long_padding
-    output.puts long_padding + "Simulation stack trace:"
+    output.puts
+    output.puts long_padding + 'Simulation stack trace:'
     sim_stack_trace.output(output, long_padding)
   end
-end
+end

data/lib/rpicsim/search.rb

@@ -17,4 +17,4 @@ module RPicSim
       end
     end
   end
-end
+end

data/lib/rpicsim/sim.rb

@@ -1,47 +1,42 @@
-# TODO: for performance, consider making people explicitly enable (or construct?) the ram_watcher
-# before they can use it.  See if this would affect the run time of rcs03a specs before committing to it.
-
 require 'forwardable'
 
 require_relative 'mplab'
 require_relative 'flaws'
 require_relative 'pin'
 require_relative 'memory'
-require_relative 'register'
-require_relative 'variable'
+require_relative 'composite_memory'
+require_relative 'storage/register'
+require_relative 'variable_set'
 require_relative 'program_counter'
 require_relative 'label'
 require_relative 'memory_watcher'
 require_relative 'program_file'
+require_relative 'stack_pointer'
 require_relative 'stack_trace'
 
 module RPicSim
   # This class represents a PIC microcontroller simulation.
   # This class keeps track of the state of the simulation and provides methods for
   # running the simulation, reading the state, and changing the state.
-  # This the main class of RPicSim.
   class Sim
 
     # These methods should be called while defining a subclass of {Sim}.
     module ClassDefinitionMethods
 
-      # Specifies what exact device the firmware runs on.  In theory we could extract this
-      # from the COF file instead of requiring it to be specified in subclasses of {Sim}, but
-      # MPLAB X classes do not seem to make that easy.
+      # Specifies what exact device the firmware runs on.
       # @param device [String] The device name, for example "PIC10F322".
-      def device_is(device)
+      def use_device(device)
         @device = device
         @assembly = Mplab::MplabAssembly.new(device)
-        @code_word_max_value = @assembly.device_info.code_word_max_value
       end
 
       # Specifies the path to the firmware file.  The file can be a HEX or COF file, but
       # COF is recommended so that you can access label addresses and other debugging information.
-      # You must call {#device_is} before calling this.
-      def filename_is(filename)
-        raise "Must specify device before filename (e.g. 'device_is \"PIC10F322\"')" unless @device
+      # You must call {#use_device} before calling this.
+      def use_file(filename)
+        raise "The device needs to be specified before filename (e.g. 'use_device \"PIC10F322\"')" unless @device
         @filename = filename
-        initialize_symbols
+        load_program_file
       end
 
       # Define a pin alias.
@@ -58,17 +53,19 @@ module RPicSim
         self::Shortcuts.send(:define_method, our_name) { pin our_name }
       end
 
-      # Define a RAM variable.
+      # Define a variable.
       # @param name [Symbol] Specifies what you would like to call the variable.
       #   A method with this name will be added to your class's +Shortcuts+ module so it
       #   is available as a method on instances of your class and also in your RSpec tests.
       #   The method will return a {Variable} object that you can use to read or write the
       #   value of the actual variable in the simulation.
       # @param type [Symbol] Specifies how to interpret the data in the variable and its size.
-      #   For integers, it should be one of +:u8+, +:s8+, +:u16+, +:s16+, +:u24+, +:s24+, +:u32+, or +:s32+.
+      #   For integers, it should be one of +:uint8+, +:int8+, +:uint16+, +:int16+, +:uint24+, +:int24+, +:uint32+, +:int32+, or +:word+.
       #   The +s+ stands for signed and the +u+ stands for unsigned, and the number stands for the number
       #   of bits.  All multi-byte integers are considered to be little Endian.
       # @param opts [Hash] Specifies additional options.  The options are:
+      #   * +:memory+: Specifies the memory that the variable lives in.
+      #     Valid values are +:ram+ (default), +:eeprom+, and +:program_memory+.
       #   * +:symbol+: By default, we look for a symbol with the same name as the variable and
       #     use that as the location of the variable.  This option lets you specify a different
       #     symbol to look for in the firmware, so you could call the variable one thing in your
@@ -76,98 +73,15 @@ module RPicSim
       #     This option is ignored if +:address is specified.
       #   * +:address+: An integer to use as the address of the variable.
       def def_var(name, type, opts={})
-        allowed_keys = [:symbol]
-        invalid_keys = opts.keys - allowed_keys
-        if !invalid_keys.empty?
-          raise ArgumentError, "Unrecognized options: #{invalid_keys.join(", ")}"
-        end
-
-        name = name.to_sym
-
-        if opts[:address]
-          address = opts[:address].to_i
-        else
-          symbol = (opts[:symbol] || name).to_sym
-          if symbol.to_s.include?('@')
-            raise "Limitations in Microchip's code prevent us from accessing " +
-              "variables with '@' in the name like '#{symbol}'"
-          end
-          address = @var_address[symbol] or raise "Cannot find variable named '#{symbol}'."
+        if @variable_set.nil?
+          raise 'The device and filename need to be specified before defining variables.'
         end
 
-        klass = case type
-                  when Class then type
-                  when :u8 then VariableU8
-                  when :s8 then VariableS8
-                  when :u16 then VariableU16
-                  when :s16 then VariableS16
-                  when :u24 then VariableU24
-                  when :s24 then VariableS24
-                  when :u32 then VariableU32
-                  when :s32 then VariableS32
-                  else raise "Unknown type '#{type}'."
-                end
-
-        variable = klass.new(name, address)
-        variable.addresses.each do |address|
-          if @vars_by_address[address]
-            raise "Variable %s overlaps with %s at 0x%x" %
-              [variable, @vars_by_address[address], address]
-          end
-          @vars_by_address[address] = variable
-        end
-        @vars[name] = variable
+        @variable_set.def_var(name, type, opts)
 
         self::Shortcuts.send(:define_method, name) { var name }
       end
 
-      # Define a flash (program memory or user ID) variable.
-      # @param name [Symbol] Specifies what you would like to call the variable.
-      #   A method with this name will be added to your class's +Shortcuts+ module so it
-      #   is available as a method on instances of your class and also in your RSpec tests.
-      #   The method will return a {Variable} object that you can use to read or write the
-      #   value of the actual variable in the simulation.
-      # @param type [Symbol] Specifies how to interpret the data in the variable and its size.
-      #   The only supported option current is +:word+, which represents a full word of flash.
-      # @param opts [Hash] Specifies additional options.  The options are:
-      #   * +:symbol+: By default, we look for a symbol with the same name as the variable and
-      #     use that as the location of the variable.  This option lets you specify a different
-      #     symbol to look for in the firmware.
-      #   * +:address+: An integer to use as the address of the variable.
-      def def_flash_var(name, type, opts={})
-        allowed_keys = [:symbol, :address]
-        invalid_keys = opts.keys - allowed_keys
-        if !invalid_keys.empty?
-          raise ArgumentError, "Unrecognized options: #{invalid_keys.join(", ")}"
-        end
-
-        name = name.to_sym
-
-        if opts[:address]
-          address = opts[:address].to_i
-        else
-          symbol = (opts[:symbol] || name).to_sym
-          if symbol.to_s.include?('@')
-            raise "Limitations in Microchip's code prevent us from accessing " +
-              "variables with '@' in the name like '#{symbol}'"
-          end
-          label = labels[symbol] or raise "Could not find label named '#{symbol}'."
-          address = label.address
-        end
-
-        klass = case type
-                  when Class then type
-                  when :word then VariableWord
-                  else raise "Unknown type '#{type}'."
-                end
-
-        variable = klass.new(name, address)
-        variable.max_value = @code_word_max_value
-        @flash_vars[name] = variable
-
-        self::Shortcuts.send(:define_method, name) { flash_var name }
-      end
-
     end
 
     # These are class methods that you can call on subclasses of {Sim}.
@@ -183,13 +97,9 @@ module RPicSim
       # pin names (like :RB3).  These aliases are defined by {ClassDefinitionMethods#def_pin}.
       attr_reader :pin_aliases
 
-      # A hash that associates RAM variable names to (unbound) {Variable} objects.
-      # The variables are defined by {ClassDefinitionMethods#def_var}.
-      attr_reader :vars
-
-      # A hash that associates flash variable names to (unbound) {Variable} objects.
-      # The variables are defined by {ClassDefinitionMethods#def_flash_var}.
-      attr_reader :flash_vars
+      # A {VariableSet} that holds information about all the variables that were defined
+      # with {ClassDefinitionMethods#def_var def_var}.
+      attr_reader :variable_set
 
       # A hash that associates label names as symbols to {Label} objects.
       attr_reader :labels
@@ -202,19 +112,20 @@ module RPicSim
       def inherited(subclass)
         subclass.instance_eval do
           @pin_aliases = {}
-          @vars = {}
-          @vars_by_address = {}
-          @flash_vars = {}
           const_set :Shortcuts, Module.new
           include self::Shortcuts
         end
-
       end
 
-      def initialize_symbols
+      def load_program_file
         @program_file = ProgramFile.new(@filename, @device)
-        @var_address = program_file.var_addresses
         @labels = program_file.labels
+
+        @variable_set = VariableSet.new
+        @variable_set.address_increment = program_file.address_increment
+        @variable_set.def_memory_type :ram, program_file.symbols_in_ram
+        @variable_set.def_memory_type :program_memory, program_file.symbols_in_program_memory
+        @variable_set.def_memory_type :eeprom, program_file.symbols_in_eeprom
       end
 
     end
@@ -231,26 +142,31 @@ module RPicSim
       # instead of +sim.cycle_count+.
       ForwardedMethods = [
         :cycle_count,
+        :eeprom,
         :every_step,
-        :flash_var,
         :goto,
         :label,
         :location_address,
-        :nmmr,
+        :new_ram_watcher,
         :pc,
         :pc_description,
         :pin,
-        :ram_watcher,
+        :program_file,
+        :program_memory,
+        :ram,
         :run_cycles,
         :run_steps,
         :run_subroutine,
         :run_to,
         :run_to_cycle_count,
-        :sfr,
-        :sfr_or_nmmr,
+        :reg,
+        :stack_contents,
+        :stack_push,
+        :stack_trace,
         :step,
         :var,
         :wreg,
+        :stack_pointer,
         :stkptr,
       ]
 
@@ -265,20 +181,40 @@ module RPicSim
     # @return [RPicSim::ProgramCounter]
     attr_reader :pc
 
-    # Returns a {MemoryWatcher} object configured to watch for changes to RAM.
-    # @return [MemoryWatcher]
-    attr_reader :ram_watcher
-
-    # Returns a {Register} object corresponding to WREG.  You can use this
+    # Returns a {Variable} object corresponding to WREG.  You can use this
     # to read and write the value of the W register.
     # @return [Register]
     attr_reader :wreg
 
-    # Returns a {Register} object corresponding to the stack pointer.  You can use
-    # this to read and write the value of the stack pointer.
+    # Returns a {Variable} object corresponding to the stack pointer register.
+    # You can use this to read and write the value of the stack pointer.
     # @return [Register]
     attr_reader :stkptr
 
+    # Returns a {StackPointer} object that is like {#stkptr} but it works
+    # consistently across all PIC devices.  The initial value is always 0
+    # when the stack is empty and it points to the first unused space in
+    # the stack.
+    # @return [StackPointer]
+    attr_reader :stack_pointer
+
+    # Returns a {Memory} object that allows direct reading and writing of the
+    # bytes in the simulated RAM.
+    # @return [Memory]
+    attr_reader :ram
+
+    # Returns a {Memory} object that allows direct reading and writing of the
+    # data in the program memory.
+    # Besides the main program, the program memory also contains the
+    # configuration words and the user IDs.
+    # @return [Memory]
+    attr_reader :program_memory
+
+    # Returns a {Memory} object that allows direct reading and writing of the
+    # bytes in the simulated EEPROM.
+    # @return [Memory]
+    attr_reader :eeprom
+
     # Returns a string like "PIC10F322" specifying the PIC device number.
     # @return [String]
     def device; self.class.device; end
@@ -294,33 +230,39 @@ module RPicSim
       @simulator = @assembly.simulator
       @processor = @simulator.processor
 
-      # Set up our stores and helper objects.
-      @fr_memory = Memory.new @simulator.fr_memory
-      @sfr_memory = Memory.new @simulator.sfr_memory
-      @nmmr_memory = Memory.new @simulator.nmmr_memory
-      @program_memory = Memory.new @simulator.program_memory
-      @stack_memory = Memory.new @simulator.stack_memory
-      @test_memory = Memory.new @simulator.test_memory
-
-      @pc = ProgramCounter.new(@simulator.processor)
-
-      @step_callbacks = []
-
+      initialize_memories
       initialize_pins
       initialize_sfrs_and_nmmrs
       initialize_vars
-      initialize_flash_vars
 
-      @ram_watcher = MemoryWatcher.new(self, @simulator.fr_memory, @vars.values + @sfrs.values)
+      @pc = ProgramCounter.new @simulator.processor
+
+      @step_callbacks = []
+
+      @stack_pointer = StackPointer.new(stkptr)
     end
 
     private
 
+    def initialize_memories
+      # Set up our stores and helper objects.
+      @ram = Memory.new @simulator.fr_memory
+      @eeprom = Memory.new @simulator.eeprom_memory
+      @sfr_memory = Memory.new @simulator.sfr_memory
+      @nmmr_memory = Memory.new @simulator.nmmr_memory
+      @stack_memory = Memory.new @simulator.stack_memory
+
+      # config_memory must be before test_memory, because test_memory provides
+      # bad values for the configuration words.
+      @program_memory = Memory.new CompositeMemory.new [
+        @simulator.program_memory,
+        @simulator.config_memory,
+        @simulator.test_memory,
+      ]
+    end
+
     def initialize_pins
-      pins = @simulator.pins.collect { |mplab_pin| Pin.new(mplab_pin) }
-      
-      #pins.reject! { |p| p.to_s == "VDD" } or raise "Failed to filter out VDD pin."
-      #pins.reject! { |p| p.to_s == "VSS" } or raise "Failed to filter out VSS pin."
+      pins = @simulator.pins.map { |mplab_pin| Pin.new(mplab_pin) }
 
       @pins_by_name = {}
       pins.each do |pin|
@@ -330,45 +272,32 @@ module RPicSim
       end
 
       self.class.pin_aliases.each do |our_name, datasheet_name|
-         @pins_by_name[our_name] = @pins_by_name[datasheet_name] or raise "Pin #{datasheet_name} not found."
+        @pins_by_name[our_name] = @pins_by_name[datasheet_name] or raise "Pin #{datasheet_name} not found."
       end
     end
 
     def initialize_vars
-      @vars = {}
-      self.class.vars.each do |name, unbound_var|
-        @vars[name] = unbound_var.bind(@fr_memory)
-      end
-    end
-
-    def initialize_flash_vars
-      @flash_vars = {}
-      memories = [@program_memory, @test_memory]
-      self.class.flash_vars.each do |name, unbound_var|
-        possible_memories = memories.select { |m| m.is_valid_address?(unbound_var.address) }
-        if possible_memories.empty?
-          raise "Flash variable has an invalid address: #{unbound_var.inspect}"
-        elsif possible_memories.size > 1
-          raise "Flash variable's address is valid in both program memory and test memory.  Not sure which memory to use: #{unbound_var.inspect}."
-        end
-
-        @flash_vars[name] = unbound_var.bind(possible_memories.first)
-      end
+      memories = {
+        ram: ram,
+        program_memory: program_memory,
+        eeprom: eeprom,
+      }
+      @vars = self.class.variable_set.bind(memories)
     end
 
     def initialize_sfrs_and_nmmrs
       @sfrs = {}
       @assembly.device_info.sfrs.each do |sfr|
-        @sfrs[sfr.name.to_sym] = Register.new @processor.get_sfr(sfr.name), @sfr_memory, sfr.width
+        @sfrs[sfr.name.to_sym] = Variable.new Storage::Register.new @processor.get_sfr(sfr.name), @sfr_memory, sfr.width
       end
-      
+
       @nmmrs = {}
       @assembly.device_info.nmmrs.each do |nmmr|
-        @nmmrs[nmmr.name.to_sym] = Register.new @processor.get_nmmr(nmmr.name), @nmmr_memory, nmmr.width
+        @nmmrs[nmmr.name.to_sym] = Variable.new Storage::Register.new @processor.get_nmmr(nmmr.name), @nmmr_memory, nmmr.width
       end
 
-      @wreg = sfr_or_nmmr(:WREG)
-      @stkptr = sfr_or_nmmr(:STKPTR)
+      @wreg = reg(:WREG)
+      @stkptr = reg(:STKPTR)
     end
 
     public
@@ -381,51 +310,29 @@ module RPicSim
       @pins_by_name[name.to_sym] or raise ArgumentError, "Cannot find pin named '#{name}'."
     end
 
-    # Returns a {Register} object if an SFR by that name is found,
-    # or raises an exception.
-    # @param name [Symbol] The name from the datasheet.
-    # @return [Register]
-    def sfr(name)
-      @sfrs[name.to_sym] or raise ArgumentError, "Cannot find SFR named '#{name}'."
-    end
-
-    # Returns a {Register} object if an SFR or NMMR by that name is found,
-    # or raises an exception.
+    # Returns a {Variable} object if a Special Function Register (SFR) or
+    # Non-Memory-Mapped Register (NMMR) by that name is found.
+    # If the register cannot be found, this method raises an exception.
     # @param name [Symbol] The name from the datasheet.
     # @return [Register]
-    def sfr_or_nmmr(name)
+    def reg(name)
       name = name.to_sym
       @sfrs[name] || @nmmrs[name] or raise ArgumentError, "Cannot find SFR or NMMR named '#{name}'."
     end
 
-    # Returns a {Register} object if an NMMR by that name is found,
-    # or raises an exception.
-    # @param name [Symbol] The name from the datasheet.
-    # @return [Register]
-    def nmmr(name)
-      @nmmrs[name.to_sym] or raise ArgumentError, "Cannot find NMMR named '#{name}'."
-    end
-
-    # Returns a {Variable} object if a RAM variable by that name is found,
-    # or raises an exception.
+    # Returns a {Variable} object if a variable by that name is found.
+    # If the variable cannot be found, this method raises an exception.
     # @return [Variable]
     def var(name)
       @vars[name.to_sym] or raise ArgumentError, "Cannot find var named '#{name}'."
     end
 
-    # Returns a {Variable} object if a flash (program memory) variable by that name is found,
-    # or raises an exception.
-    # @return [Variable]
-    def flash_var(name)
-      @flash_vars[name.to_sym] or raise ArgumentError, "Cannot find flash var named '#{name}'."
-    end
-
     # Returns a {Label} object if a program label by that name is found.
     # The name is specified in the code that defined the label.  If you are using a C compiler,
     # you will probably need to prefix the name with an underscore.
     # @return [Label]
     def label(name)
-      self.class.program_file.label(name)
+      program_file.label(name)
     end
 
     # Returns the number of instruction cycles simulated in this simulation.
@@ -488,10 +395,10 @@ module RPicSim
     def run_to(conditions, opts={})
       conditions = Array(conditions)
       if conditions.empty?
-        raise ArgumentError, "Must specify at least one condition."
+        raise ArgumentError, 'Must specify at least one condition.'
       end
 
-      condition_procs = conditions.collect &method(:convert_condition_to_proc)
+      condition_procs = conditions.map(&method(:convert_condition_to_proc))
 
       allowed_keys = [:cycle_limit, :cycles]
       invalid_keys = opts.keys - allowed_keys
@@ -500,7 +407,7 @@ module RPicSim
       end
 
       if opts[:cycles] && opts[:cycle_limit]
-        raise ArgumentError, "Cannot specify both :cycles and :cycle_limit."
+        raise ArgumentError, 'Cannot specify both :cycles and :cycle_limit.'
       end
 
       start_cycle = cycle_count
@@ -514,7 +421,7 @@ module RPicSim
       end
 
       # Loop as long as none of the conditions are satisfied.
-      while !(met_condition_index = condition_procs.find_index &:call)
+      while !(met_condition_index = condition_procs.find_index(&:call))
         if max_cycle && cycle_count >= max_cycle
           raise "Failed to reach #{conditions.inspect} after #{cycle_count - start_cycle} cycles."
         end
@@ -530,7 +437,7 @@ module RPicSim
       end
 
       # Return the argument that specified the condition that was satisfied.
-      return met_condition
+      met_condition
     end
 
     # Gets the address of the specified location in program memory.
@@ -587,9 +494,7 @@ module RPicSim
     # given cycle count.
     # @param count [Integer]
     def run_to_cycle_count(count)
-      while cycle_count < count
-        step
-      end
+      step while cycle_count < count
     end
 
     # Simulates a return instruction being executed by popping the top value off
@@ -597,35 +502,35 @@ module RPicSim
     # This can be useful for speeding up your tests when you have a very slow function
     # and just want to skip it.
     def return
-      if stkptr.value == 0
-        raise "Cannot return because stack pointer is 0."
+      if stack_pointer.value == 0
+        raise 'Cannot return because stack is empty.'
       end
 
       # Simulate popping the stack.
-      stkptr.value -= 1
-      pc.value = @stack_memory.read_word(stkptr.value)
+      stack_pointer.value -= 1
+      pc.value = @stack_memory.read_word(stack_pointer.value)
     end
 
     # Generates a friendly human-readable string description of where the
     # program counter is currently using the symbol table.
     def pc_description
-      self.class.program_file.address_description(pc.value)
+      program_file.address_description(pc.value)
     end
 
     # Pushes the given address onto the simulated call stack.
     def stack_push(value)
-      if !@stack_memory.is_valid_address?(stkptr.value)
-        raise "Simulated stack is full (stack pointer = #{stkptr.value})."
+      if !@stack_memory.valid_address?(stack_pointer.value)
+        raise "Simulated stack is full (stack pointer = #{stack_pointer.value})."
       end
 
-      @stack_memory.write_word(stkptr.value, value)
-      stkptr.value += 1
+      @stack_memory.write_word(stack_pointer.value, value)
+      stack_pointer.value += 1
     end
 
     # Gets the contents of the stack as an array of integers.
     # @return [Array(Integer)] An array of integers.
     def stack_contents
-      (0...stkptr.value).collect do |n|
+      (0...stack_pointer.value).map do |n|
         @stack_memory.read_word(n)
       end
     end
@@ -636,17 +541,20 @@ module RPicSim
     # @return [StackTrace]
     def stack_trace
       # The stack stores return addresses, not call addresses.
-      # We get the call addresses by calling pred (subtract 1).
-      # TODO: make this work for PIC18 devices where we probably have to subtract 2
-      addresses = stack_contents.collect(&:pred) + [pc.value]
-      entries = addresses.collect do |address|
-        StackTraceEntry.new address, self.class.program_file.address_description(address)
+      # We get the call addresses by subtracting the address increment,
+      # which is the number of address units that each word of program memory takes up.
+      addresses = stack_contents.map do |return_address|
+        return_address - address_increment
+      end
+      addresses << pc.value
+      entries = addresses.map do |address|
+        StackTraceEntry.new address, program_file.address_description(address)
       end
       StackTrace.new(entries)
     end
 
     def inspect
-      "#<#{self.class}:0x%x, #{pc_description}, stkptr = #{stkptr.value}>" % object_id
+      "#<#{self.class}:0x%x, #{pc_description}, stack_pointer = #{stack_pointer.value}>" % object_id
     end
 
     # Converts the specified condition into a Proc that, when called, will return a
@@ -674,13 +582,13 @@ module RPicSim
         Proc.new { pc.value == c }
 
       when :return
-        current_val = stkptr.value
+        current_val = stack_pointer.value
         if current_val == 0
-          raise "The stack pointer is 0; waiting for a return would be strange and might not work."
+          raise 'The stack pointer is 0; waiting for a return would be strange and might not work.'
         else
           target_val = current_val - 1
         end
-        Proc.new { stkptr.value == target_val }
+        Proc.new { stack_pointer.value == target_val }
 
       when Label
         convert_condition_to_proc c.address
@@ -693,10 +601,27 @@ module RPicSim
       end
     end
 
+    # Creates and returns a {MemoryWatcher} object configured to watch for
+    # changes to RAM.  For more information, see {file:RamWatcher.md}.
+    # @return [MemoryWatcher]
+    def new_ram_watcher
+      MemoryWatcher.new(self, @simulator.fr_memory, @ram_vars.values + @sfrs.values)
+    end
+
     def shortcuts
       self.class::Shortcuts
     end
+
+    # Returns the {RPicSim::ProgramFile} representing the firmware being simulated.
+    # @return [ProgramFile]
+    def program_file
+      self.class.program_file
+    end
+
+    private
+    def address_increment
+      @assembly.device_info.code_address_increment
+    end
   end
 
 end
-