rggen-default-register-map 0.16.0 → 0.21.0

data/lib/rggen/default_register_map/bit_field/type/{rw.rb → rw_w1.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RgGen.define_list_item_feature(:bit_field, :type, :rw) do
+RgGen.define_list_item_feature(:bit_field, :type, [:rw, :w1]) do
   register_map do
     read_write
     non_volatile

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

@@ -6,5 +6,22 @@ RgGen.define_list_item_feature(:bit_field, :type, [:rwe, :rwl]) do
     volatile? { !bit_field.reference? }
     initial_value require: true
     reference use: true, width: 1
+
+    verify(:all) do
+      error_condition do
+        bit_field.reference? &&
+          register.full_name == reference_register.full_name
+      end
+      message do
+        'bit field within the same register is not allowed for ' \
+        "reference bit field: #{bit_field.reference.full_name}"
+      end
+    end
+
+    private
+
+    def reference_register
+      bit_field.reference.register
+    end
   end
 end

data/lib/rggen/default_register_map/bit_field/type/{wo.rb → wo_wo1.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RgGen.define_list_item_feature(:bit_field, :type, :wo) do
+RgGen.define_list_item_feature(:bit_field, :type, [:wo, :wo1]) do
   register_map do
     write_only
     non_volatile

data/lib/rggen/default_register_map/common/comment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+[:register_block, :register_file, :register, :bit_field].each do |layer|
+  RgGen.define_simple_feature(layer, :comment) do
+    register_map do
+      property :comment, initial: -> { '' }
+
+      build do |value|
+        @comment =
+          (value.is_a?(Array) && value.join("\n") || value.to_s).chomp
+      end
+
+      printable :comment do
+        comment.empty? ? nil : comment
+      end
+    end
+  end
+end

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

@@ -3,16 +3,14 @@
 RgGen.define_simple_feature(:register, :name) do
   register_map do
     property :name
+    property :full_name, forward_to: :get_full_name
 
     input_pattern variable_name
 
     build do |value|
-      @name =
-        if pattern_matched?
-          match_data.to_s
-        else
-          error "illegal input value for register name: #{value.inspect}"
-        end
+      pattern_matched? ||
+        (error "illegal input value for register name: #{value.inspect}")
+      @name = match_data.to_s
     end
 
     verify(:feature) do
@@ -25,12 +23,29 @@ RgGen.define_simple_feature(:register, :name) do
       message { "duplicated register name: #{name}" }
     end
 
-    printable :name
+    printable(:name) do
+      array_name
+    end
+
+    printable(:layer_name) do
+      [register_file&.printables&.fetch(:layer_name), array_name]
+        .compact.join('.')
+    end
 
     private
 
+    def get_full_name(separator = '.')
+      [*register_file&.full_name(separator), name].join(separator)
+    end
+
     def duplicated_name?
-      register_block.registers.any? { |register| register.name == name }
+      files_and_registers
+        .any? { |file_or_register| file_or_register.name == name }
+    end
+
+    def array_name
+      RgGen::Core::Utility::CodeUtility
+        .array_name(name, register.array_size)
     end
   end
 end

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

@@ -2,7 +2,8 @@
 
 RgGen.define_simple_feature(:register, :offset_address) do
   register_map do
-    property :offset_address
+    property :offset_address, initial: -> { default_offset_address }
+    property :expanded_offset_addresses, forward_to: :expand_addresses
     property :address_range, initial: -> { start_address..end_address }
     property :overlap?, forward_to: :overlap_address_range?
 
@@ -15,11 +16,6 @@ RgGen.define_simple_feature(:register, :offset_address) do
         end
     end
 
-    verify(:feature) do
-      error_condition { !offset_address }
-      message { 'no offset address is given' }
-    end
-
     verify(:feature) do
       error_condition { offset_address.negative? }
       message { "offset address is less than 0: #{offset_address}" }
@@ -34,7 +30,10 @@ RgGen.define_simple_feature(:register, :offset_address) do
     end
 
     verify(:component) do
-      error_condition { end_address > register_block.byte_size }
+      error_condition do
+        register.parent.register_block? &&
+          end_address > register_block.byte_size
+      end
       message do
         'offset address range exceeds byte size of register block' \
         "(#{register_block.byte_size}): " \
@@ -44,24 +43,51 @@ RgGen.define_simple_feature(:register, :offset_address) do
 
     verify(:component) do
       error_condition do
-        register_block.registers.any? do |register|
-          overlap_address_range?(register) &&
-            support_unique_range_only?(register)
+        files_and_registers.any? do |other|
+          overlap_address_range?(other) && exclusive_range?(other)
         end
       end
       message do
         'offset address range overlaps with other offset address range: ' \
-        "0x#{start_address.to_s(16)}-0x#{end_address.to_s(16)}"
+        "0x#{start_address(true).to_s(16)}-0x#{end_address(true).to_s(16)}"
       end
     end
 
     printable(:offset_address) do
-      [start_address, end_address]
-        .map(&method(:printable_address)).join(' - ')
+      expand_addresses.map(&method(:format_address))
     end
 
     private
 
+    def default_offset_address
+      register.component_index.zero? && 0 ||
+        (previous_component.offset_address + previous_component.byte_size)
+    end
+
+    def start_address(full = false)
+      full && expand_addresses.first || offset_address
+    end
+
+    def end_address(full = false)
+      start_address(full) + register.byte_size - 1
+    end
+
+    def expand_addresses
+      upper_offsets = register_file&.expanded_offset_addresses || [0]
+      upper_offsets.product(expand_local_addresses).map(&:sum)
+    end
+
+    def expand_local_addresses
+      Array.new(shared_address? && 1 || register.count) do |i|
+        offset_address + register.byte_width * i
+      end
+    end
+
+    def previous_component
+      index = register.component_index - 1
+      files_and_registers[index]
+    end
+
     def bus_width
       configuration.bus_width
     end
@@ -70,35 +96,30 @@ RgGen.define_simple_feature(:register, :offset_address) do
       configuration.byte_width
     end
 
-    def start_address
-      offset_address
-    end
-
-    def end_address
-      start_address + register.byte_size - 1
+    def overlap_address_range?(other)
+      overlap_range?(other) && competitive_access?(other)
     end
 
-    def overlap_address_range?(other_register)
-      overlap_range?(other_register) && match_access?(other_register)
+    def overlap_range?(other)
+      self_range = address_range
+      othre_range = other.address_range
+      self_range.include?(othre_range.first) || othre_range.include?(self_range.first)
     end
 
-    def overlap_range?(other_register)
-      own = address_range
-      other = other_register.address_range
-      own.include?(other.first) || other.include?(own.first)
+    def competitive_access?(other)
+      other.register_file? ||
+        [:writable?, :readable?].any? { |access| [register, other].all?(&access) }
     end
 
-    def match_access?(other_register)
-      (register.writable? && other_register.writable?) ||
-        (register.readable? && other_register.readable?)
+    def exclusive_range?(other)
+      other.register_file? || !(shared_address? && register.match_type?(other))
     end
 
-    def support_unique_range_only?(other_register)
-      !(register.settings[:support_overlapped_address] &&
-        register.match_type?(other_register))
+    def shared_address?
+      register.settings[:support_shared_address]
     end
 
-    def printable_address(address)
+    def format_address(address)
       print_width = (register_block.local_address_width + 3) / 4
       format('0x%0*x', print_width, address)
     end

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

@@ -5,10 +5,10 @@ RgGen.define_simple_feature(:register, :size) do
     property :size
     property :width, initial: -> { calc_width }
     property :byte_width, initial: -> { width / 8 }
-    property :byte_size, initial: -> { calc_byte_size }
+    property :byte_size, forward_to: :calc_byte_size
     property :array?, forward_to: :array_register?
     property :array_size, forward_to: :array_registers
-    property :count, initial: -> { calc_count }
+    property :count, forward_to: :calc_count
 
     input_pattern [
       /(#{integer}(:?,#{integer})*)/,
@@ -26,10 +26,6 @@ RgGen.define_simple_feature(:register, :size) do
       end
     end
 
-    printable(:array_size) do
-      (array_register? || nil) && "[#{array_registers.join(', ')}]"
-    end
-
     private
 
     def parse_values(values)
@@ -72,9 +68,9 @@ RgGen.define_simple_feature(:register, :size) do
         .max
     end
 
-    def calc_byte_size
-      if register.settings[:byte_size]
-        instance_exec(&register.settings[:byte_size])
+    def calc_byte_size(whole_size = true)
+      if !whole_size || register.settings[:support_shared_address]
+        byte_width
       else
         Array(@size).reduce(1, :*) * byte_width
       end
@@ -88,8 +84,8 @@ RgGen.define_simple_feature(:register, :size) do
       array_register? && @size || nil
     end
 
-    def calc_count
-      Array(array_registers).reduce(1, :*)
+    def calc_count(whole_count = true)
+      whole_count ? (@count ||= Array(array_registers).reduce(1, :*)) : 1
     end
   end
 end

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

@@ -31,12 +31,8 @@ RgGen.define_list_feature(:register, :type) do
           settings[:support_array] = true
         end
 
-        def byte_size(&block)
-          settings[:byte_size] = block
-        end
-
-        def support_overlapped_address
-          settings[:support_overlapped_address] = true
+        def support_shared_address
+          settings[:support_shared_address] = true
         end
       end
 

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

@@ -6,11 +6,22 @@ RgGen.define_list_item_feature(:register, :type, :external) do
     readable? { true }
     no_bit_fields
 
+    verify(:feature) do
+      error_condition { register.parent.register_file? }
+      message do
+        'external register type is not allowed to be put within register file'
+      end
+    end
+
     verify(:component) do
       error_condition { register.size && register.size.length > 1 }
       message do
         'external register type supports single size definition only'
       end
     end
+
+    printable(:byte_size) do
+      "#{register.byte_size} bytes"
+    end
   end
 end

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

@@ -3,35 +3,8 @@
 RgGen.define_list_item_feature(:register, :type, :indirect) do
   register_map do
     define_helpers do
-      index_verifier = Class.new do
-        def initialize(&block)
-          instance_eval(&block)
-        end
-
-        def error_condition(&block)
-          @error_condition = block
-        end
-
-        def message(&block)
-          @message = block
-        end
-
-        def verify(feature, index)
-          error?(feature, index) && raise_error(feature, index)
-        end
-
-        def error?(feature, index)
-          feature.instance_exec(index, &@error_condition)
-        end
-
-        def raise_error(feature, index)
-          error_message = feature.instance_exec(index, &@message)
-          feature.__send__(:error, error_message)
-        end
-      end
-
-      define_method(:verify_index) do |&block|
-        index_verifiers << index_verifier.new(&block)
+      def verify_index(&block)
+        index_verifiers << create_verifier(&block)
       end
 
       def index_verifiers
@@ -67,21 +40,25 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
       index_entries.map { |entry| entry.find_index_field(bit_fields) }
     end
 
-    byte_size { byte_width }
+    support_shared_address
     support_array_register
-    support_overlapped_address
 
     input_pattern [
-      /(#{variable_name}\.#{variable_name})/,
-      /(#{variable_name}\.#{variable_name}):(#{integer})?/,
-      /(#{variable_name})/,
-      /(#{variable_name}):(#{integer})?/
+      /(#{variable_name}(?:\.#{variable_name})*)/,
+      /(#{variable_name}(?:\.#{variable_name})*):(#{integer})/
     ], match_automatically: false
 
     build do
       @index_entries = parse_index_entries
     end
 
+    verify(:component) do
+      error_condition do
+        !(register.array? || array_index_fields.empty?)
+      end
+      message { 'array indices are given to non-array register' }
+    end
+
     verify(:component) do
       error_condition do
         register.array? &&
@@ -95,7 +72,7 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
         register.array? &&
           register.array_size.length > array_index_fields.length
       end
-      message { 'less array indices are given' }
+      message { 'few array indices are given' }
     end
 
     verify(:all) do
@@ -122,17 +99,27 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
 
     verify_index do
       error_condition do |index|
-        index_field(index).register.name == register.name
+        index_field(index).register.full_name == register.full_name
       end
       message do |index|
         "own bit field is not allowed for indirect index: #{index.name}"
       end
     end
 
+    verify_index do
+      error_condition do |index|
+        index_field(index).register_files.any?(&:array?)
+      end
+      message do |index|
+        'bit field within array register file is not allowed ' \
+        "for indirect index: #{index.name}"
+      end
+    end
+
     verify_index do
       error_condition { |index| index_field(index).register.array? }
       message do |index|
-        'bit field of array register is not allowed ' \
+        'bit field within array register is not allowed ' \
         "for indirect index: #{index.name}"
       end
     end
@@ -246,8 +233,8 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
     end
 
     def distinguishable?
-      register_block
-        .registers.select { |other| share_same_range?(other) }
+      files_and_registers
+        .select { |other| other.register? && share_same_range?(other) }
         .all? { |other| distinguishable_indices?(other.index_entries) }
     end