rpicsim 0.1.0 → 0.2.1

data/lib/rpicsim/mplab/mplab_device_info.rb

@@ -2,39 +2,39 @@ require_relative 'mplab_sfr_info'
 require_relative 'mplab_nmmr_info'
 
 module RPicSim::Mplab
-  # DeviceInfo is a wrapper for the MPLAB xPIC class which gives us information
-  # about the target PIC device.
+  # DeviceInfo is a wrapper for the com.microchip.mplab.crownkingx.xPIC class
+  # which gives us information about the target PIC device.
   class MplabDeviceInfo
     # Makes a new DeviceInfo object.
     # @param xpic [com.microchip.mplab.crownkingx.xPIC]
     def initialize(xpic)
       @xpic = xpic
     end
-  
+
     def code_word_max_value
       # Assumption: the initial value is the same as the maximum value
       # because all bits start as 1.
       @xpic.getMemTraits.getCodeWordTraits.getInitValue
     end
-    
-    # The number that a flash address increases when you
-    # advance to the next word of flash.
+
+    # The number that a code-space address increases by when you
+    # advance to the next word of code space.
     # For PIC18s this is 2.
     # For other architectures this is 1.
     def code_address_increment
       @xpic.getMemTraits.getCodeWordTraits.getAddrInc
     end
-    
+
     def sfrs
       @sfrs ||= @xpic.getAddrOntoSFR.map do |addr, node|
         MplabSfrInfo.new addr, com.microchip.crownking.edc.Register.new(node)
       end
     end
-    
+
     def nmmrs
       @xpic.getIDOntoCoreNMMR.map do |id, node|
         MplabNmmrInfo.new id, com.microchip.crownking.edc.Register.new(node)
       end
     end
   end
-end
+end

data/lib/rpicsim/mplab/mplab_disassembler.rb

@@ -6,18 +6,17 @@ module RPicSim::Mplab
     def initialize(disasm)
       @disasm = disasm
     end
-    
+
     def disassemble(address)
       # To avoid showing a large, difficult to understand Java trace, we
       # catch the InvalidInstructionException here.
       begin
         instr = @disasm.Disassemble(address, nil, nil)
-      rescue Java::ComMicrochipMplabMdbcoreDisasm::InvalidInstructionException => e
-        # TODO: actually this should not be an exception because it is expected;
-        # so probably you should return nil
-        raise "Invalid instruction at address 0x%x." % address
+      rescue Java::ComMicrochipMplabMdbcoreDisasm::InvalidInstructionException
+        # The instruction is invalid.
+        return :invalid
       end
       MplabInstruction.new instr
     end
   end
-end
+end

data/lib/rpicsim/mplab/mplab_instruction.rb

@@ -1,32 +1,103 @@
 module RPicSim::Mplab
+  # This class wraps a com.microchip.mplab.mdbcore.disasm.Instruction, which
+  # represents a disassembled instruction from Microchip's disassembler.
   class MplabInstruction
+    attr_reader :opcode
+
     # @param instruction [com.microchip.mplab.mdbcore.disasm.Instruction]
     def initialize(instruction)
       @instruction = instruction
+
+      @opcode = @instruction.opcode
+      @string = @instruction.instruction
+
+      # Fix a typo in MPLAB X.
+      if @opcode == 'RBLRD+*'
+        @opcode = 'TBLRD+*'
+        @string = @string.gsub('RBLRD', 'TBLRD')
+      end
+      @opcode.freeze
     end
-    
-    def opcode
-      @instruction.opcode
-    end
-    
+
     def instruction_string
-      @instruction.instruction
+      @string
     end
-    
+
     def operands
       @operands ||= operands_hash(@instruction.operands)
     end
-    
-    # The number of bytes that the instruction takes.
-    def inc
-      @instruction.inc
+
+    # Returns the size of the instruction in the same units that are used
+    # for program memory addresses.  (Bytes for the PIC18, otherwise words.)
+    # @param address_increment The number of address units per word of
+    #   program memory in this architecture.  See {MplabDeviceInfo#code_address_increment}.
+    def compute_size(address_increment)
+      if RPicSim::Flaws[:instruction_inc_is_in_byte_units]
+        # Convert the increment, which is the number of bytes, into 'size',
+        # which is the same units as the program memory address space.
+        if address_increment == 1
+          # Non-PIC18 architectures: program memory addresses are in terms of words
+          # so we divide by two to convert from bytes to words.
+          @instruction.inc / 2
+        elsif address_increment == 2
+          # PIC18 architecture: No change necessary because both are in terms
+          # of bytes.
+          @instruction.inc
+        else
+          raise "Cannot handle address increment value of #{@address_increment}."
+        end
+      else
+        # inc is in the same units as the code space addresses.
+        @instruction.inc
+      end
     end
-    
+
     private
+
     def operands_hash(map)
-      # Convert from Map<String, Integer> to a Ruby hash.
-      # TODO: use symbols for keys instead of strings
-      map.to_hash
+      operands = convert_map_to_hash(map)
+      fix_signed_fields(operands)
+      operands
+    end
+
+    def convert_map_to_hash(map)
+      # Convert from Map<String, Integer> to a Ruby hash
+      # with symbols as keys instead of strings.
+      operands = {}
+      map.each do |operand_name, value|
+        operands[operand_name.to_sym] = value
+      end
+      operands
+    end
+
+    # Warning: This mutates the supplied hash.
+    def fix_signed_fields(operands)
+      case opcode
+      when 'BC', 'BN', 'BNC', 'BNN', 'BNOV', 'BNZ', 'BOV', 'BZ'
+        convert_if_present(operands, :n, 8)   # PIC18
+      when 'RCALL'
+        convert_if_present(operands, :n, 11)  # PIC18
+      when 'BRA'
+        convert_if_present(operands, :n, 11)  # PIC18
+        convert_if_present(operands, :k, 9)   # enhanced midrange
+      when 'ADDFSR'
+        convert_if_present(operands, :k, 6)   # enhanced midrange
+      end
+
+      operands
+    end
+
+    def convert_if_present(operands, name, bits)
+      operands[name] = convert_unsigned_to_signed(operands[name], bits) if operands[name]
+    end
+
+    def convert_unsigned_to_signed(unsigned, bits)
+      if unsigned >= (1 << (bits - 1))
+        unsigned - (1 << bits)
+      else
+        unsigned
+      end
     end
+
   end
-end
+end

data/lib/rpicsim/mplab/mplab_loader.rb

@@ -0,0 +1,106 @@
+require 'java'
+require 'pathname'
+require 'singleton'
+
+module RPicSim::Mplab
+  # This class helps find MPLAB X on the disk, add it to the Java class path
+  # so we can use it from JRuby, and figure out what version of MPLAB X we
+  # are using.
+  #
+  # It should not be confused with com.microchip.mplab.mdbcore.loader.Loader,
+  # which is used for loading program files.
+  class MplabLoader
+    include Singleton
+
+    # Adds all the needed MPLAB X jar files to the classpath so we can use the
+    # classes.
+    def load
+      %w{ mdbcore/modules/*.jar
+          mplablibs/modules/*.jar
+          mplablibs/modules/ext/*.jar
+          platform/lib/org-openide-util*.jar
+          platform/lib/org-openide-util.jar
+          mdbcore/modules/ext/org-openide-filesystems.jar
+      }.each do |pattern|
+        Dir.glob(jar_dir + pattern).each do |jar_file|
+          $CLASSPATH << jar_file
+        end
+      end
+
+      # Do a quick test to make sure we can load some MPLAB X classes.
+      # In case MPLAB X was uninstalled and its directory remains, this can provide
+      # a useful error message to the user.
+      begin
+        org.openide.util.Lookup
+        com.microchip.mplab.mdbcore.simulator.Simulator
+      rescue NameError
+        $stderr.puts "Failed to load MPLAB X classes.\n" +
+          "MPLAB X dir: #{dir}\nMPLAB X jar dir: #{jar_dir}\nClass path:\n" + $CLASSPATH.to_a.join("\n") + "\n\n"
+        raise
+      end
+    end
+
+    # Returns a string like "1.95" representing the version of MPLAB X we are using.
+    # NOTE: You should probably NOT be calling this to work around flaws in MPLAB X.
+    # Instead, you should add a new entry in flaws.rb and then use
+    # RPicSim::Flaws[:FLAWNAME] to see if the flaw exists and choose the appropriate workaround.
+    def mplab_version
+      # This implementation is not pretty; I would prefer to just find the right function
+      # to call.
+      @mplab_version ||= begin
+        glob_pattern = 'Uninstall_MPLAB_X_IDE_v*'
+        paths = Dir.glob(dir + glob_pattern)
+        if paths.empty?
+          raise "Cannot detect MPLAB X version.  No file matching #{glob_pattern} found in #{dir}."
+        end
+        matches = paths.map { |p| p.match(/IDE_v([0-9][0-9\.]*[0-9]+)\./) }.compact
+        match_data = matches.first
+        if !match_data
+          raise "Failed to get version number from #{paths.inspect}."
+        end
+        match_data[1]
+      end
+    end
+
+    private
+
+    # Returns a Pathname object representing the directory of the MPLAB X we are using.
+    # This can either come from the +RPICSIM_MPLABX+ environment variable or it can
+    # be auto-detected by looking in the standard places that MPLAB X is installed.
+    # @return [Pathname]
+    def dir
+      @dir ||= begin
+        dir = ENV['RPICSIM_MPLABX'] || auto_detect_mplab_dir
+        raise "MPLABX directory does not exist: #{dir}" if !File.directory?(dir)
+        Pathname(dir)
+      end
+    end
+
+    def auto_detect_mplab_dir
+      # Default installation directories for MPLAB X:
+      candidates = [
+        'C:/Program Files (x86)/Microchip/MPLABX/',  # 64-bit Windows
+        'C:/Program Files/Microchip/MPLABX/',        # 32-bit Windows
+        '/opt/microchip/mplabx/',                    # Linux
+        '/Applications/microchip/mplabx/',           # Mac OS X
+      ]
+      dir = candidates.find { |d| File.directory?(d) }
+      raise cannot_find_mplab_error if !dir
+      dir
+    end
+
+    def cannot_find_mplab_error
+      'Cannot find MPLABX.  Install it in the standard location or ' +
+      'set the RPICSIM_MPLABX environment variable to its full path.'
+    end
+
+    def jar_dir
+      @jar_dir ||=  if (dir + 'mplab_ide.app').exist?
+                      # Mac OS X
+                      dir + 'mplab_ide.app/Contents/Resources/mplab_ide'
+                    else
+                      dir + 'mplab_ide'
+                    end
+    end
+  end
+end

data/lib/rpicsim/mplab/mplab_memory.rb

@@ -6,20 +6,33 @@ module RPicSim::Mplab
     def initialize(memory)
       @memory = memory
     end
-    
+
+    def read_byte(address)
+      array = [0].to_java(:byte)
+      @memory.Read(address, 1, array)
+      array.ubyte_get(0)
+    end
+
+    def write_byte(address, byte)
+      array = Java.byte[1].new
+      array.ubyte_set(0, byte)
+      @memory.Write(address, 1, array)
+      byte
+    end
+
     def write_word(address, value)
       @memory.WriteWord(address, value)
       value
     end
-    
+
     def read_word(address)
       @memory.ReadWord(address)
     end
-    
-    def is_valid_address?(address)
+
+    def valid_address?(address)
       @memory.IsValidAddress(address)
     end
-    
+
     def on_change(&callback)
       MplabObserver.new(@memory) do |event|
         next if event.EventType != Mdbcore.memory::MemoryEvent::EVENTS::MEMORY_CHANGED
@@ -30,4 +43,4 @@ module RPicSim::Mplab
       end
     end
   end
-end
+end

data/lib/rpicsim/mplab/mplab_nmmr_info.rb

@@ -1,21 +1,21 @@
 module RPicSim::Mplab
   class MplabNmmrInfo
     attr_reader :id
-  
+
     # @param id The id of the register.  This is like an address.
     # @param register [com.microchip.crownking.edc.Register]
     def initialize(id, register)
       @id = id
       @register = register
     end
-    
+
     # Returns how many bits the register has.
     def width
       @register.width
     end
-    
+
     def name
       @register.name
     end
   end
-end
+end

data/lib/rpicsim/mplab/mplab_observer.rb

@@ -1,12 +1,17 @@
-class MplabObserver
-  include Java::comMicrochipMplabUtilObservers::Observer
+module RPicSim::Mplab
+  # This class implements the com.microchip.mplab.util.observers.Observer
+  # interface, so we can easily receive events from objects that support
+  # sending updates to observers.
+  class MplabObserver
+    include Java::ComMicrochipMplabUtilObservers::Observer
 
-  def initialize(subject, &callback)
-    @callback = callback
-    subject.Attach(self, nil)
-  end
-  
-  def Update(event)
-    @callback.call(event)
+    def initialize(subject, &callback)
+      @callback = callback
+      subject.Attach(self, nil)
+    end
+
+    def Update(event)
+      @callback.call(event)
+    end
   end
-end
+end

data/lib/rpicsim/mplab/mplab_pin.rb

@@ -3,7 +3,7 @@ module RPicSim::Mplab
     # Initializes a new Pin object to wrap the given PinPhysical.
     # @param pin_physical [com.microchip.mplab.mdbcore.simulator.PinPhysical]
     def initialize(pin_physical)
-      raise ArgumentError, "pin_physical is nil" if pin_physical.nil?
+      raise ArgumentError, 'pin_physical is nil' if pin_physical.nil?
       @pin_physical = pin_physical
     end
 
@@ -47,12 +47,12 @@ module RPicSim::Mplab
     end
 
     def names
-      @pin_physical.collect(&:name)
+      @pin_physical.map(&:name)
     end
 
     def name
       @pin_physical.pinName
-    end    
+    end
 
     PinState = Mdbcore.simulator.Pin::PinState   # HIGH or LOW
     IoState = Mdbcore.simulator.Pin::IOState     # INPUT or OUTPUT

data/lib/rpicsim/mplab/mplab_processor.rb

@@ -6,25 +6,25 @@ module RPicSim::Mplab
     def initialize(processor)
       @processor = processor
     end
-    
+
     def get_pc
       @processor.getPC
     end
-    
+
     def set_pc(value)
       @processor.setPC(value)
     end
-    
+
     def get_sfr(name)
       reg = @processor.getSFRSet.getSFR(name)
       raise "Cannot find SFR named '#{name}'." if !reg
       MplabRegister.new(reg)
     end
-    
+
     def get_nmmr(name)
       reg = @processor.getNMMRSet.getNMMR(name)
       raise "Cannot find NMMR named '#{name}'." if !reg
       MplabRegister.new(reg)
     end
   end
-end
+end