rggen-default-register-map 0.29.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a715cb1298469ed180728f9252c8a82bc879a156b427f08b7f5f0ead4881a79d
-  data.tar.gz: eebb8fdf95cc6727a48145089812049540b3bd900c78a91e9dd55d8844a9e9a1
+  metadata.gz: '096c64fcca6cd793439076e3d9c1c453cb936224698a9d59674eaf0d216945fc'
+  data.tar.gz: 2ff4dcdb1f202d3fde23a4a2856caf865201258684d736a3827b84869d657506
 SHA512:
-  metadata.gz: b4b816a40f826f0545c84040ed25d33b808de5dacbba83ccd75fe813183b8789767c7ea450f846ac780256850e7c20ef4780a23d5d37b28489e3e0003a544452
-  data.tar.gz: b9a9949aea2259f9cb66f4d9bb123a92ff9e6dc9513ea8b9074e72f3121ddb6f260128cc9612fda20595694f6cc12fc77c0ccfa513f8e439f22b2e8099ddd3ed
+  metadata.gz: 97d25fb253e1dc48ce3c96b5a50eb10c37d4b84eb7546cd1531c3e1e4842b7a754cdad2423f7a824f0d3be1d7c1233e0c3573cd3a895c376ca0ba7d65df96b3c
+  data.tar.gz: c5f8aca4a7e382e370b04cd29ad9ae31f90aa436f785697bd9d3eb7dfa606eb1f209dd7002a69e4b75dbcd7ff40e21b7efcd9044ca9b70993059188c8c5a3c69

data/lib/rggen/default_register_map/bit_field/bit_assignment.rb

@@ -122,11 +122,14 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
     end
 
     def parse_value(input_value, key, variable_name)
-      input_value.key?(key) &&
-        instance_variable_set(variable_name, Integer(input_value[key]))
-    rescue ArgumentError, TypeError
-      error "cannot convert #{input_value[key].inspect} into " \
-            "bit assignment(#{key.to_s.tr('_', ' ')})"
+      return unless input_value.key?(key)
+
+      value =
+        to_int(input_value[key]) do
+          "cannot convert #{input_value[key].inspect} into " \
+          "bit assignment(#{key.to_s.tr('_', ' ')})"
+        end
+      instance_variable_set(variable_name, value)
     end
 
     def lsb_base
@@ -150,25 +153,33 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
     end
 
     def lsb_bit(index = 0)
-      lsb_msb_bit(index, lsb_base)
+      lsb_msb_bit(index, 0)
     end
 
     def msb_bit(index = 0)
-      lsb_msb_bit(index, lsb_base + width - 1)
+      lsb_msb_bit(index, width - 1)
     end
 
-    def lsb_msb_bit(index, base)
-      calc_bit_position((sequential? && index) || 0, base)
-    end
-
-    def calc_bit_position(index, base)
-      if integer?(index)
-        base + step * index
-      else
+    def lsb_msb_bit(index, offset)
+      base = lsb_base + offset
+      if base_lsb_msb?(index)
+        base
+      elsif !integer?(index)
         "#{base}+#{step}*#{index}"
+      else
+        sequential_lsb_list[index]&.+(offset)
       end
     end
 
+    def base_lsb_msb?(index)
+      !sequential? || integer?(index) && index.zero?
+    end
+
+    def sequential_lsb_list
+      @sequential_lsb_list ||=
+        Array.new(sequence_size) { |i| lsb_base + step * i }
+    end
+
     def calc_bit_map
       Array.new(sequence_size || 1) { |i| (2**width - 1) << lsb(i) }.inject(:|)
     end

data/lib/rggen/default_register_map/bit_field/initial_value.rb

@@ -153,9 +153,7 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
     end
 
     def parse_value(value)
-      Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into initial value"
+      to_int(value) { |v| "cannot convert #{v.inspect} into initial value" }
     end
 
     def verify_initial_value(value)

data/lib/rggen/default_register_map/bit_field/labels.rb

@@ -92,9 +92,7 @@ RgGen.define_feature(:bit_field, :labels) do
       end
 
       def convert_label_value(value)
-        Integer(value)
-      rescue ArgumentError, TypeError
-        error "cannot convert #{value.inspect} into label value", value
+        to_int(value) { |v| "cannot convert #{v.inspect} into label value" }
       end
 
       def unique_value?(value)

data/lib/rggen/default_register_map/bit_field/type/custom.rb

@@ -86,20 +86,10 @@ RgGen.define_list_item_feature(:bit_field, :type, :custom) do
     end
 
     def parse_options(options)
-      merge_options(options)
-        .each_with_object({}) do |(key, value), option_hash|
-          option_name = convert_to_option_name(key)
-          option_hash[option_name] = parse_option(option_name, key, value)
-        end
-    end
-
-    def merge_options(options)
-      options.each_with_object({}) do |option, merged_options|
-        option_hash = hash?(option) && option || [option].to_h
-        merged_options.update(option_hash)
+      options.each_with_object({}) do |(key, value), optin_hash|
+        name = convert_to_option_name(key)
+        optin_hash[name] = parse_option(name, key, value)
       end
-    rescue ArgumentError, TypeError
-      error "invalid options are given: #{options.inspect}"
     end
 
     def convert_to_option_name(key)

data/lib/rggen/default_register_map/bit_field/type.rb

@@ -108,7 +108,7 @@ RgGen.define_list_feature(:bit_field, :type) do
     end
 
     factory do
-      value_format :value_with_options
+      value_format :option_hash
 
       convert_value do |value|
         types = target_features.keys

data/lib/rggen/default_register_map/global/address_width.rb

@@ -5,9 +5,8 @@ RgGen.define_simple_feature(:global, :address_width) do
     property :address_width, default: 32
 
     build do |value|
-      @address_width = Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into address width"
+      @address_width =
+        to_int(value) { |v| "cannot convert #{v.inspect} into address width" }
     end
 
     verify(:component) do

data/lib/rggen/default_register_map/global/bus_width.rb

@@ -6,9 +6,8 @@ RgGen.define_simple_feature(:global, :bus_width) do
     property :byte_width, initial: -> { bus_width / 8 }
 
     build do |value|
-      @bus_width = Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into bus width"
+      @bus_width =
+        to_int(value) { |v| "cannot convert #{v.inspect} into bus width" }
     end
 
     verify(:feature) do

data/lib/rggen/default_register_map/register/offset_address.rb

@@ -8,9 +8,8 @@ RgGen.define_simple_feature(:register, :offset_address) do
     property :overlap?, body: ->(other) { overlap_address_range?(other, false) }
 
     build do |value|
-      @offset_address = Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into offset address"
+      @offset_address =
+        to_int(value) { |v| "cannot convert #{v.inspect} into offset address" }
     end
 
     verify(:feature) do
@@ -58,7 +57,7 @@ RgGen.define_simple_feature(:register, :offset_address) do
 
     def default_offset_address
       register.component_index.zero? && 0 ||
-        (previous_component.offset_address + previous_component.byte_size)
+        (previous_component.offset_address + previous_component.total_byte_size)
     end
 
     def start_address(full = false)
@@ -66,16 +65,16 @@ RgGen.define_simple_feature(:register, :offset_address) do
     end
 
     def end_address(full = false)
-      start_address(full) + register.byte_size - 1
+      start_address(full) + register.total_byte_size - 1
     end
 
     def expand_addresses
-      upper_offsets = register_file&.expanded_offset_addresses || [0]
-      upper_offsets.product(expand_local_addresses).map(&:sum)
+      (register_file&.expanded_offset_addresses || [0])
+        .product(expand_local_addresses).map(&:sum)
     end
 
     def expand_local_addresses
-      width = shared_address? && 0 || register.byte_width
+      width = shared_address? && 0 || register.entry_byte_size
       Array.new(register.count) { |i| offset_address + width * i }
     end
 

data/lib/rggen/default_register_map/register/size.rb

@@ -1,122 +1,134 @@
 # frozen_string_literal: true
 
-RgGen.define_simple_feature(:register, :size) do
+RgGen.define_feature(:register, :size) do
   register_map do
-    property :size
-    property :width, initial: -> { calc_width }
-    property :byte_width, initial: -> { width / 8 }
-    property :byte_size, forward_to: :calc_byte_size
-    property :array?, forward_to: :array_register?
-    property :array_size, forward_to: :array_registers
-    property :count, forward_to: :calc_count
-
-    input_pattern [
-      /(#{integer}(:?,#{integer})*)/,
-      /\[(#{integer}(:?,#{integer})*)\]/
-    ], match_automatically: false
-
-    build do |values|
-      @size = parse_values(values)
-    end
+    feature do
+      property :size
+      property :width, initial: -> { calc_width }
+      property :byte_width, initial: -> { width / 8 }
+      property :entry_byte_size, body: -> { @step || byte_width }
+      property :total_byte_size, forward_to: :calc_total_byte_size
+      property :array?, forward_to: :array_register?
+      property :array_size, forward_to: :array_registers
+      property :count, forward_to: :calc_count
+
+      build do |values, options|
+        @size = parse_register_size(values)
+        @step = parse_step_size(options)
+      end
 
-    verify(:feature) do
-      error_condition { size && !size.all?(&:positive?) }
-      message do
-        "non positive value(s) are not allowed for register size: #{size}"
+      verify(:feature) do
+        error_condition { size && !size.all?(&:positive?) }
+        message do
+          "non positive value(s) are not allowed for register size: #{size}"
+        end
       end
-    end
 
-    verify(:component) do
-      error_condition do
-        !configuration.enable_wide_register? && byte_width > 8
+      verify(:component) do
+        error_condition { @step && !array_register? }
+        message do
+          'step size cannot be specified for non-array register'
+        end
       end
-      message do
-        "register width wider than 8 bytes is not allowed: #{byte_width} bytes"
+
+      verify(:component) do
+        error_condition { @step && @step < byte_width }
+        message do
+          "step size is less than register width: #{@step}"
+        end
       end
-    end
 
-    private
+      verify(:component) do
+        error_condition { @step && (@step % configuration.byte_width).positive? }
+        message do
+          "step size is not multiple of bus width: #{@step}"
+        end
+      end
 
-    def parse_values(values)
-      Array(
-        string?(values) && parse_string_values(values) || values
-      ).map(&method(:convert_value))
-    end
+      verify(:component) do
+        error_condition do
+          !configuration.enable_wide_register? && entry_byte_size > 8
+        end
+        message do
+          "register width wider than 8 bytes is not allowed: #{entry_byte_size} bytes"
+        end
+      end
 
-    def parse_string_values(values)
-      if match_pattern(values)
-        split_match_data(match_data)
-      else
-        error "illegal input value for register size: #{values.inspect}"
+      private
+
+      def parse_register_size(values)
+        values.map do |value|
+          to_int(value) { |v| "cannot convert #{v.inspect} into register size" }
+        end
       end
-    end
 
-    def split_match_data(match_data)
-      match_data.captures.first.split(',')
-    end
+      def parse_step_size(options)
+        return unless options.key?(:step)
 
-    def convert_value(value)
-      Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into register size"
-    end
+        to_int(options[:step]) { |v| "cannot convert #{v.inspect} into step size" }
+      end
 
-    def calc_width
-      bus_width = configuration.bus_width
-      if register.bit_fields.empty?
-        bus_width
-      else
-        ((max_msb + bus_width) / bus_width) * bus_width
+      def calc_width
+        bus_width = configuration.bus_width
+        if register.bit_fields.empty?
+          bus_width
+        else
+          ((max_msb + bus_width) / bus_width) * bus_width
+        end
       end
-    end
 
-    def max_msb
-      register
-        .bit_fields
-        .map { |bit_field| bit_field.msb((bit_field.sequence_size || 1) - 1) }
-        .max
-    end
+      def max_msb
+        register
+          .bit_fields
+          .map { |bit_field| bit_field.msb(-1) }
+          .max
+      end
 
-    def calc_byte_size(whole_size = true, hierarchical: false)
-      return byte_width unless whole_size
+      def calc_total_byte_size(hierarchical: false)
+        include_register = !register.settings[:support_shared_address]
+        byte_size = entry_byte_size
+        collect_size(hierarchical, include_register, false).reduce(1, :*) * byte_size
+      end
 
-      include_register = !register.settings[:support_shared_address]
-      collect_size(hierarchical, include_register, false).reduce(1, :*) * byte_width
-    end
+      def array_register?(hierarchical: false)
+        return true if hierarchical && register_files.any?(&:array?)
+        register.settings.fetch(:support_array, false) && !@size.nil?
+      end
 
-    def array_register?(hierarchical: false)
-      return true if hierarchical && register_files.any?(&:array?)
-      register.settings[:support_array] && !@size.nil? || false
-    end
+      def array_registers(hierarchical: false)
+        size = collect_size(hierarchical, true, true)
+        !size.empty? && size || nil
+      end
 
-    def array_registers(hierarchical: false)
-      size = collect_size(hierarchical, true, true)
-      !size.empty? && size || nil
-    end
+      def calc_count(whole_count = true)
+        whole_count && (@count ||= calc_whole_count) || 1
+      end
 
-    def calc_count(whole_count = true)
-      if whole_count
-        @count ||= collect_size(false, true, true).reduce(1, :*)
-      else
-        1
+      def calc_whole_count
+        collect_size(false, true, true).reduce(1, :*)
       end
-    end
 
-    def collect_size(inculde_register_file, include_register, array_only)
-      size = []
-      collect_register_file_size(size, inculde_register_file)
-      collect_register_size(size, include_register, array_only)
-      size.compact
-    end
+      def collect_size(inculde_register_file, include_register, array_only)
+        size = []
+        collect_register_file_size(size, inculde_register_file)
+        collect_register_size(size, include_register, array_only)
+        size.compact
+      end
 
-    def collect_register_file_size(size, inculde_register_file)
-      inculde_register_file &&
-        size.concat(register_files.flat_map(&:array_size))
+      def collect_register_file_size(size, inculde_register_file)
+        inculde_register_file &&
+          size.concat(register_files.flat_map(&:array_size))
+      end
+
+      def collect_register_size(size, include_register, array_only)
+        @size && include_register && (!array_only || array_register?) &&
+          size.concat(@size)
+      end
     end
 
-    def collect_register_size(size, include_register, array_only)
-      @size && include_register && (!array_only || array_register?) &&
-        size.concat(@size)
+    factory do
+      value_format :option_hash,
+                   multiple_values: true, allowed_options: [:step]
     end
   end
 end

data/lib/rggen/default_register_map/register/type/external.rb

@@ -21,7 +21,7 @@ RgGen.define_list_item_feature(:register, :type, :external) do
     end
 
     printable(:byte_size) do
-      "#{register.byte_size} bytes"
+      "#{register.total_byte_size} bytes"
     end
   end
 end

data/lib/rggen/default_register_map/register/type/indirect.rb

@@ -204,9 +204,7 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
     end
 
     def convert_index_value(value)
-      Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into indirect index value"
+      to_int(value) { |v| "cannot convert #{v.inspect} into indirect index value" }
     end
 
     def verify_indirect_index(index)

data/lib/rggen/default_register_map/register/type/rw.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:register, :type, :rw) do
+  register_map do
+    writable? { true }
+    readable? { true }
+    support_array_register
+  end
+end

data/lib/rggen/default_register_map/register/type.rb

@@ -84,7 +84,7 @@ RgGen.define_list_feature(:register, :type) do
     end
 
     factory do
-      value_format :value_with_options
+      value_format :option_array
 
       convert_value do |value|
         find_type(value)

data/lib/rggen/default_register_map/register_block/byte_size.rb

@@ -6,10 +6,9 @@ RgGen.define_simple_feature(:register_block, :byte_size) do
     property :local_address_width
 
     build do |value|
-      @byte_size = Integer(value)
+      @byte_size =
+        to_int(value) { |v| "cannot convert #{v.inspect} into byte size" }
       @local_address_width = (@byte_size - 1).bit_length
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into byte size"
     end
 
     verify(:feature) do

data/lib/rggen/default_register_map/register_file/offset_address.rb

@@ -7,9 +7,8 @@ RgGen.define_simple_feature(:register_file, :offset_address) do
     property :address_range, initial: -> { start_address..end_address }
 
     build do |value|
-      @offset_address = Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into offset address"
+      @offset_address =
+        to_int(value) { |v| "cannot convert #{v.inspect} into offset address" }
     end
 
     verify(:feature) do
@@ -55,7 +54,7 @@ RgGen.define_simple_feature(:register_file, :offset_address) do
 
     def defalt_offset_address
       register_file.component_index.zero? && 0 ||
-        (previous_component.offset_address + previous_component.byte_size)
+        (previous_component.offset_address + previous_component.total_byte_size)
     end
 
     def previous_component
@@ -68,17 +67,17 @@ RgGen.define_simple_feature(:register_file, :offset_address) do
     end
 
     def end_address(full = false)
-      start_address(full) + register_file.byte_size - 1
+      start_address(full) + register_file.total_byte_size - 1
     end
 
     def expand_addresses
-      uppser_addresses = register_file(:upper)&.expanded_offset_addresses || [0]
-      uppser_addresses.product(expand_local_addresses).map(&:sum)
+      (register_file(:upper)&.expanded_offset_addresses || [0])
+        .product(expand_local_addresses).map(&:sum)
     end
 
     def expand_local_addresses
       Array.new(register_file.array_size&.inject(:*) || 1) do |i|
-        offset_address + register_file.byte_size(false) * i
+        offset_address + register_file.entry_byte_size * i
       end
     end
 

data/lib/rggen/default_register_map/register_file/size.rb

@@ -1,60 +1,83 @@
 # frozen_string_literal: true
 
-RgGen.define_simple_feature(:register_file, :size) do
+RgGen.define_feature(:register_file, :size) do
   register_map do
-    property :size
-    property :byte_size, forward_to: :calc_byte_size
-    property :array?, body: -> { !@size.nil? }
-    property :array_size, forward_to: :size
-    property :count, forward_to: :calc_count
-
-    input_pattern [
-      /(#{integer}(:?,#{integer})*)/,
-      /\[(#{integer}(:?,#{integer})*)\]/
-    ], match_automatically: false
-
-    build do |values|
-      @size =
-        (string?(values) && parse_string_value(values) || Array(values))
-          .map(&method(:convert_value))
-    end
+    feature do
+      property :size
+      property :entry_byte_size, forward_to: :calc_entry_byte_size
+      property :total_byte_size, forward_to: :calc_total_byte_size
+      property :array?, body: -> { !@size.nil? }
+      property :array_size, forward_to: :size
+      property :count, forward_to: :calc_count
 
-    verify(:feature) do
-      error_condition { array? && !size.all?(&:positive?) }
-      message do
-        "non positive value(s) are not allowed for register file size: #{size}"
+      build do |values, options|
+        @size = parse_register_file_size(values)
+        @step = parse_step_size(options)
       end
-    end
 
-    private
+      verify(:feature) do
+        error_condition { array? && !size.all?(&:positive?) }
+        message do
+          "non positive value(s) are not allowed for register file size: #{size}"
+        end
+      end
 
-    def parse_string_value(value)
-      match_pattern(value) && match_data.captures.first.split(',') ||
-        (error "illegal input value for register file size: #{value.inspect}")
-    end
+      verify(:component) do
+        error_condition { @step && @step < actual_byte_size }
+        message do
+          "step size is less than actual byte size: #{@step}"
+        end
+      end
 
-    def convert_value(value)
-      Integer(value)
-    rescue ArgumentError, TypeError
-      error "cannot convert #{value.inspect} into register file size"
-    end
+      verify(:component) do
+        error_condition { @step && (@step % configuration.byte_width).positive? }
+        message do
+          "step size is not multiple of bus width: #{@step}"
+        end
+      end
 
-    def calc_byte_size(whole_size = true)
-      (whole_size ? total_entries : 1) * entry_byte_size
-    end
+      private
 
-    def entry_byte_size
-      register_file.files_and_registers
-        .map { |r| r.offset_address + r.byte_size }.max
-    end
+      def parse_register_file_size(values)
+        values.map do |value|
+          to_int(value) do |v|
+            "cannot convert #{v.inspect} into register file size"
+          end
+        end
+      end
+
+      def parse_step_size(options)
+        return unless options.key?(:step)
 
-    def calc_count(whole_count = true)
-      (whole_count ? total_entries : 1) *
-        register_file.files_and_registers.sum(&:count)
+        to_int(options[:step]) { |v| "cannot convert #{v.inspect} into step size" }
+      end
+
+      def calc_entry_byte_size
+        @step || actual_byte_size
+      end
+
+      def actual_byte_size
+        register_file.files_and_registers
+          .map { |r| r.offset_address + r.total_byte_size }.max
+      end
+
+      def calc_total_byte_size
+        total_entries * calc_entry_byte_size
+      end
+
+      def calc_count(whole_count = true)
+        (whole_count ? total_entries : 1) *
+          register_file.files_and_registers.sum(&:count)
+      end
+
+      def total_entries
+        size&.inject(:*) || 1
+      end
     end
 
-    def total_entries
-      size&.inject(:*) || 1
+    factory do
+      value_format :option_hash,
+                   multiple_values: true, allowed_options: [:step]
     end
   end
 end

data/lib/rggen/default_register_map/version.rb

@@ -2,6 +2,6 @@
 
 module RgGen
   module DefaultRegisterMap
-    VERSION = '0.29.0'
+    VERSION = '0.31.0'
   end
 end

data/lib/rggen/default_register_map.rb

@@ -23,6 +23,7 @@ RgGen.setup_plugin :'rggen-default-register-map' do |plugin|
     'default_register_map/register/type/external',
     'default_register_map/register/type/indirect',
     'default_register_map/register/type/reserved',
+    'default_register_map/register/type/rw',
     'default_register_map/register/comment',
     'default_register_map/bit_field/name',
     'default_register_map/bit_field/bit_assignment',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-default-register-map
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-02 00:00:00.000000000 Z
+date: 2023-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,7 @@ files:
 - lib/rggen/default_register_map/register/type/external.rb
 - lib/rggen/default_register_map/register/type/indirect.rb
 - lib/rggen/default_register_map/register/type/reserved.rb
+- lib/rggen/default_register_map/register/type/rw.rb
 - lib/rggen/default_register_map/register_block/byte_size.rb
 - lib/rggen/default_register_map/register_block/comment.rb
 - lib/rggen/default_register_map/register_block/name.rb
@@ -107,8 +108,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
-summary: rggen-default-register-map-0.29.0
+summary: rggen-default-register-map-0.31.0
 test_files: []