origen_memory_image 0.5.2 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dbd9fff5f4d4a999086de046e0c99a016a475f15
-  data.tar.gz: a06173b18adeab5d1ce72f919cfa6b239bc04712
+SHA256:
+  metadata.gz: 90f929c547d4a00df7450faf892f6f4ebed1c56d18b64e9315d810dd7774f55c
+  data.tar.gz: e209715c41348a5975f549f27babdc1d4e2c0473f6e935fff12148d2f2e7a5f0
 SHA512:
-  metadata.gz: 549bd0444aa5942e410d5ceece65c21bed5d4561932e1632e9ca605838f8599eafeb4dd50cf6b24616564645b90b3eaf67550e6a6ea86d07fb2f2b6be38f7298
-  data.tar.gz: cb109a9dc9fa36c486e8026ea5804ce7dd721882ecb2da6e76e63e915c6a07fcb6abd3ef3973632d1a8b766a4050ef0e94702135f669c5e7226bda6c1ce4b308
+  metadata.gz: 2319ac1964ce679181d45b9b79343604a90aad3149d3015ab1e8daf3e1edaf2045bf41aaba40680f371131f6278a363187caf2407b60fd7508cb4ecdc3792cdc
+  data.tar.gz: c8dae0921e4490b7a108cfbbb0a1ef0d93585fe8191c8e61dd2ef3debf624bd6333771d2f7ee24de638cb265f33653729e8def0e7bcc6812eeac689470f89a90

data/config/boot.rb

@@ -0,0 +1 @@
+require "origen_memory_image"

data/config/version.rb

@@ -1,8 +1,7 @@
 module OrigenMemoryImage
   MAJOR = 0
-  MINOR = 5
-  BUGFIX = 2
+  MINOR = 8
+  BUGFIX = 1
   DEV = nil
-
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
 end

data/lib/origen_memory_image.rb

@@ -1,8 +1,13 @@
 require 'origen'
 require_relative '../config/application.rb'
-require_relative '../config/environment.rb'
 
 module OrigenMemoryImage
+  autoload :Base, 'origen_memory_image/base'
+  autoload :SRecord, 'origen_memory_image/s_record'
+  autoload :Hex, 'origen_memory_image/hex'
+  autoload :Binary, 'origen_memory_image/binary'
+  autoload :IntelHex, 'origen_memory_image/intel_hex'
+
   def self.new(file, options = {})
     unless options[:source] == String
       file = Origen.file_handler.clean_path_to(file)
@@ -16,11 +21,19 @@ module OrigenMemoryImage
     if options[:source] == String
       snippet = file.split("\n")
     else
-      snippet = File.foreach(file.to_s).first(1)
+      snippet = File.foreach(file.to_s).first(10)
     end
     case
+    # Always do the binary first since the others won't be able to process
+    # a binary snippet
+    when options[:type] == :binary || (options[:source] != String && Binary.match?(file))
+      Binary
+    when options[:source] == String && Binary.match?(snippet, true)
+      Binary
     when options[:type] == :srecord || SRecord.match?(snippet)
       SRecord
+    when options[:type] == :intel_hex || IntelHex.match?(snippet)
+      IntelHex
     when options[:type] == :hex || Hex.match?(snippet)
       Hex
     else

data/lib/origen_memory_image/base.rb

@@ -8,6 +8,7 @@ module OrigenMemoryImage
       else
         @file = file
       end
+      @ljust_partial_data = options[:ljust_partial_data]
     end
 
     # Returns the code execution start address as an int
@@ -50,7 +51,7 @@ module OrigenMemoryImage
 
       if options[:flip_endianness] || options[:endianness_change]
         data.map do |v|
-          [v[0], flip_endianness(v[1], 4)]
+          [v[0], flip_endianness(v[1], options[:data_width_in_bytes])]
         end
       else
         data

data/lib/origen_memory_image/binary.rb

@@ -0,0 +1,69 @@
+module OrigenMemoryImage
+  class Binary < Base
+    def self.match?(file, snippet = false)
+      if snippet
+        file.all? { |l| l.strip =~ /^[01]*$/ }
+      else
+        # detect whether the data is mostly not alpha numeric
+        filedata = (File.read(file, 256) || '')
+        (filedata.gsub(/\s+/, '').gsub(/\w/, '').length.to_f / filedata.length.to_f) > 0.3
+      end
+    end
+
+    # Always returns 0 since binary files do not contain addresses
+    def start_address
+      0
+    end
+
+    def create_test_file
+      data = [
+        0x1EE0021C, 0x22401BE0, 0x021C2243,
+        0x18E0021C, 0x5A780A43, 0x03E0034B,
+        0xF7215A78, 0x0A400020, 0x22E08442,
+        0x22D31FE0, 0x84421FD9, 0x1CE08442,
+        0x002B20D1, 0x03E0012A, 0x01D1002B,
+        0x1BD00223, 0x2340022A, 0x02D1002B,
+        0x15D103E0, 0x032A01D1, 0x78000018,
+        0x7C000018, 0x82000018, 0x88000018
+      ]
+      data = data.map { |d| d.to_s(2).rjust(32, '0') }.join
+      File.open('examples/bin1.bin', 'wb') do |output|
+        output.write [data].pack('B*')
+      end
+    end
+
+    private
+
+    # Returns an array containing all address/data from the given s-record
+    # No address manipulation is performed, that is left to the caller to apply
+    # any scrambling as required by the target system
+    def extract_addr_data(options = {})
+      options = {
+        data_width_in_bytes: 4
+      }.merge(options)
+
+      result = []
+      width = options[:data_width_in_bytes]
+      address = 0
+
+      if file
+        raw = File.binread(file)
+        bytes = raw.unpack('C*')
+      else
+        raw = lines.map(&:strip).join
+        bytes = raw.scan(/.{1,8}/).map { |s| s.to_i(2) }
+      end
+
+      bytes.each_slice(width) do |d|
+        v = 0
+        width.times do |i|
+          v |= d[i] << ((width - 1 - i) * 8) if d[i]
+        end
+        result << [address, v]
+        address += width
+      end
+
+      result
+    end
+  end
+end

data/lib/origen_memory_image/hex.rb

@@ -46,7 +46,11 @@ module OrigenMemoryImage
           end
           # If a partial word is left over
           if (remainder = data.length % (2 * options[:data_width_in_bytes])) > 0
-            result << [@address, data[data.length - remainder..data.length].to_i(16)]
+            if @ljust_partial_data
+              result << [@address, data[data.length - remainder..data.length].ljust(options[:data_width_in_bytes] * 2, '0').to_i(16)]
+            else
+              result << [@address, data[data.length - remainder..data.length].to_i(16)]
+            end
           end
         end
       end

data/lib/origen_memory_image/intel_hex.rb

@@ -0,0 +1,98 @@
+module OrigenMemoryImage
+  class IntelHex < Base
+    def self.match?(snippet)
+      snippet.all? do |line|
+        line.empty? || line =~ /^:[0-9A-Fa-f]{6}0[0-5]/
+      end
+    end
+
+    def start_address
+      @start_address ||= begin
+        addrs = []
+        lines.each do |line|
+          line = line.strip
+          if start_linear_address?(line)
+            addrs << decode(line)[:data].to_i(16)
+          end
+        end
+        addrs.last || 0
+      end
+    end
+
+    private
+
+    def decode(line)
+      d = {}
+      if line =~ /^:([0-9A-Fa-f]{2})([0-9A-Fa-f]{4})(\d\d)([0-9A-Fa-f]+)([0-9A-Fa-f]{2})$/
+        d[:byte_count] = Regexp.last_match(1).to_i(16)
+        d[:address] = Regexp.last_match(2).to_i(16)
+        d[:record_type] = Regexp.last_match(3).to_i(16)
+        d[:data] = Regexp.last_match(4)
+        d[:checksum] = Regexp.last_match(5).to_i(16)
+      else
+        fail "Invalid line encountered in Intel Hex formatted file: #{line}"
+      end
+      d
+    end
+
+    def data?(line)
+      !!(line =~ /^:[0-9A-Fa-f]{6}00/)
+    end
+
+    def extended_segment_address?(line)
+      !!(line =~ /^:[0-9A-Fa-f]{6}02/)
+    end
+
+    def extended_linear_address?(line)
+      !!(line =~ /^:[0-9A-Fa-f]{6}04/)
+    end
+
+    def start_linear_address?(line)
+      !!(line =~ /^:[0-9A-Fa-f]{6}05/)
+    end
+
+    def upper_addr
+      @upper_addr || 0
+    end
+
+    def segment_address
+      @segment_address || 0
+    end
+
+    # Returns an array containing all address/data from the given s-record
+    # No address manipulation is performed, that is left to the caller to apply
+    # any scrambling as required by the target system
+    def extract_addr_data(options = {})
+      options = {
+        data_width_in_bytes: 4
+      }.merge(options)
+
+      result = []
+      lines.each do |line|
+        line = line.strip
+        if extended_segment_address?(line)
+          @segment_address = decode(line)[:data].to_i(16) * 16
+
+        elsif extended_linear_address?(line)
+          @upper_addr = (decode(line)[:data].to_i(16)) << 16
+
+        elsif data?(line)
+          d = decode(line)
+          addr = d[:address] + segment_address + upper_addr
+
+          data = d[:data]
+          data_matcher = '\w\w' * options[:data_width_in_bytes]
+          data.scan(/#{data_matcher}/).each do |data_packet|
+            result << [addr, data_packet.to_i(16)]
+            addr += options[:data_width_in_bytes]
+          end
+          # If a partial word is left over
+          if (remainder = data.length % (2 * options[:data_width_in_bytes])) > 0
+            result << [addr, data[data.length - remainder..data.length].to_i(16)]
+          end
+        end
+      end
+      result
+    end
+  end
+end

data/lib/origen_memory_image/s_record.rb

@@ -202,7 +202,11 @@ module OrigenMemoryImage
           end
           # If a partial word is left over
           if (remainder = data.length % (2 * options[:data_width_in_bytes])) > 0
-            result << [addr, data[data.length - remainder..data.length].to_i(16)]
+            if @ljust_partial_data
+              result << [addr, data[data.length - remainder..data.length].ljust(options[:data_width_in_bytes] * 2, '0').to_i(16)]
+            else
+              result << [addr, data[data.length - remainder..data.length].to_i(16)]
+            end
           end
         end
       end

data/templates/web/index.md.erb

@@ -58,6 +58,25 @@ my_srec = OrigenMemoryImage.new("source_files/test_atd.abs.S19")
 my_hex  = OrigenMemoryImage.new("source_files/math.hex")
 ~~~
 
+By default any partial data words are right justified. Change this behavior to left justified like this:
+
+~~~ruby
+my_srec = OrigenMemoryImage.new("source_files/test_atd.abs.S19", ljust_partial_data: true)
+my_hex  = OrigenMemoryImage.new("source_files/math.hex", ljust_partial_data: true)
+~~~
+
+Partial data example:
+
+~~~
+0304FE
+
+# Default interpretation into 32-bit word:
+0x0003_04FE
+
+# Left justified interpretation into 32-bit word:
+0x0304_FE00
+~~~
+
 Memory images can also be created directly from a string:
 
 ~~~ruby
@@ -135,6 +154,32 @@ The data lines can be grouped into any size:
 780000187C0000188200001888000018 
 ~~~
 
+#### Binary Files
+
+A binary file:
+
+~~~text
+00001101000101010000111100010011
+00001110000101000001000000010010
+00000000000000000000010000010111
+00000100000000110000010100000110
+~~~
+
+#### Intel Hex
+
+Any valid Intel Hex file:
+
+~~~text
+:020000040022D8
+:10010000214601360121470136007EFE09D2190140
+:100110002146017E17C20001FF5F16002148011928
+:020000040023D7
+:10012000194E79234623965778239EDA3F01B2CAA7
+:100130003F0156702B5E712B722B732146013421C7
+:0400000500000000F7
+:00000001FF
+~~~
+
 ### How To Setup a Development Environment
 
 [Clone the repository from Github](https://github.com/Origen-SDK/origen_memory_image).

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_memory_image
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.8.1
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-06 00:00:00.000000000 Z
+date: 2021-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -46,14 +46,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/application.rb
+- config/boot.rb
 - config/commands.rb
-- config/development.rb
-- config/environment.rb
-- config/users.rb
 - config/version.rb
 - lib/origen_memory_image.rb
 - lib/origen_memory_image/base.rb
+- lib/origen_memory_image/binary.rb
 - lib/origen_memory_image/hex.rb
+- lib/origen_memory_image/intel_hex.rb
 - lib/origen_memory_image/s_record.rb
 - templates/web/index.md.erb
 - templates/web/layouts/_basic.html.erb
@@ -77,11 +77,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Provides a standard API for consuming memory image files in any format e.g.
   s-record, hex
 test_files: []
-has_rdoc: 

data/config/development.rb

@@ -1,12 +0,0 @@
-# This file is similar to environment.rb and will be loaded
-# automatically at the start of each invocation of Origen.
-#
-# However the major difference is that it will not be loaded
-# if the application is imported by a 3rd party app - in that
-# case only environment.rb is loaded.
-#
-# Therefore this file should be used to load anything you need
-# to setup a development environment for this app, normally
-# this would be used to load some dummy classes to instantiate
-# your objects so that they can be tested and/or interacted with
-# in the console.

data/config/environment.rb

@@ -1,40 +0,0 @@
-# This file will be required by Origen before your target is loaded, you 
-# can use this to require all of your files, which is the easiest way
-# to get started. As your experience grows you may wish to require only the
-# minimum files required to allow the target to be initialized and let 
-# each class require its own dependencies.
-#
-# It is recommended that you keep all of your application logic in lib/
-# The lib directory has already been added to the search path and so any files
-# in there can be referenced from here with a relative path.
-#
-# Note that pattern files do not need to be referenced from here and these
-# will be located automatically by origen.
-#
-# Examples
-# --------
-# This says load the file "lib/pioneer.rb" the first time anyone makes a 
-# reference to the class name 'Pioneer'.
-#autoload :Pioneer,   "pioneer"
-#
-# This is generally preferable to using require which will load the file
-# regardless of whether it is needed by the current target or not:
-#require "pioneer"
-#
-# Sometimes you have to use require however:-
-#   1. When defining a test program interface:
-#require "interfaces/j750"
-#   2. If you want to extend a class defined by an imported plugin, in
-#      this case your must use required and supply a full path (to distinguish
-#      it from the one in the parent application):
-#require "#{Origen.root}/c90_top_level/p2"
-
-# Plugins should not use a wildcard import of the lib directory to help
-# prevent long start up times, only require what is necessary to boot and
-# use autoload for everything else.
-module OrigenMemoryImage
-  autoload :Base, "origen_memory_image/base"
-  autoload :SRecord, "origen_memory_image/s_record"
-  autoload :Hex, "origen_memory_image/hex"
-end
-require "origen_memory_image"

data/config/users.rb

@@ -1,18 +0,0 @@
-# This file defines the users associated with your project, it is basically the 
-# mailing list for release notes.
-#
-# You can split your users into "admin" and "user" groups, the main difference 
-# between the two is that admin users will get all tag emails, users will get
-# emails on external/official releases only.
-#
-# Users are also prohibited from running the "origen tag" task, but this is 
-# really just to prevent a casual user from executing it inadvertently and is
-# not intended to be a serious security gate.
-module Origen
-  module Users
-    def users
-      @users ||= [
-      ]
-    end
-  end
-end