rggen-default-register-map 0.16.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a07cecea3878d609e000fc36d1e8f41e045686d28548774ba19b44d00089986f
-  data.tar.gz: 8347d41f0d9ffea4fa01e2d0860f2df4fcc2ab0e8d65ff9f1f7ab6ac84a79590
+  metadata.gz: ae013f1baa39fec2b34473f60af4a530444b1bf1124d97f19d266604cf7eb5ff
+  data.tar.gz: d3f9ee6009f22d81eab9157f2a3277e3f436aa2167054a2745af71f3e3a8790a
 SHA512:
-  metadata.gz: d6375a8b050dbb6ea1a22f384555272cb6b1afc63860d0307625447501b1121941a1fe350f6952f1057eed370e833173ec0497981f85c69ca6973cf518198ac1
-  data.tar.gz: 54fda95836bd1ab2442885e43e3bb405f81e80918c58f05d0213f09de34a58062de302896492bc157a460a3247d8e658cace7434219d03b5942b9c7a9b1cc5a2
+  metadata.gz: 49cb8841485f9d1dba72f4ee7b79af0551a91718079a9df6785b9490c0d9c9efddaacba22057421c818134ad0c6fd5383faf3ae69ccb4a4c5f0c3d4466d36ab7
+  data.tar.gz: 1a822488fdefcc6947e8e4a2578ed335b557615effa70e0f57f9b82a29626f0c2658d30e4073461cdd5b1e1d3969d953948f1e3fb66d7dd3b9ca710d5df09c60

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 Taichi Ishitani
+Copyright (c) 2019-2020 Taichi Ishitani
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,12 +1,12 @@
 [![Gem Version](https://badge.fury.io/rb/rggen-default-register-map.svg)](https://badge.fury.io/rb/rggen-default-register-map)
-[![Build Status](https://travis-ci.com/rggen/rggen-default-register-map.svg?branch=master)](https://travis-ci.com/rggen/rggen-default-register-map)
+[![CI](https://github.com/rggen/rggen-default-register-map/workflows/CI/badge.svg)](https://github.com/rggen/rggen-default-register-map/actions?query=workflow%3ACI)
 [![Maintainability](https://api.codeclimate.com/v1/badges/73177494e096af47f09e/maintainability)](https://codeclimate.com/github/rggen/rggen-default-register-map/maintainability)
 [![codecov](https://codecov.io/gh/rggen/rggen-default-register-map/branch/master/graph/badge.svg)](https://codecov.io/gh/rggen/rggen-default-register-map)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=rggen_rggen-default-register-map&metric=alert_status)](https://sonarcloud.io/dashboard?id=rggen_rggen-default-register-map)
 [![Gitter](https://badges.gitter.im/rggen/rggen.svg)](https://gitter.im/rggen/rggen?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 
-# Rggen::DefaultRegisterMap
+# RgGen::DefaultRegisterMap
 
 RgGen::DefaultRegisterMap provides following features.
 
@@ -38,7 +38,7 @@ Feedbacks, bug reports, questions and etc. are wellcome! You can post them by us
 
 ## Copyright & License
 
-Copyright © 2019 Taichi Ishitani. RgGen::DefaultRegisterMap is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
+Copyright © 2019-2020 Taichi Ishitani. RgGen::DefaultRegisterMap is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
 
 ## Code of Conduct
 

data/lib/rggen/default_register_map.rb

@@ -6,7 +6,6 @@ module RgGen
   module DefaultRegisterMap
     FEATURES = [
       'default_register_map/bit_field/bit_assignment',
-      'default_register_map/bit_field/comment',
       'default_register_map/bit_field/initial_value',
       'default_register_map/bit_field/name',
       'default_register_map/bit_field/reference',
@@ -16,14 +15,15 @@ module RgGen
       'default_register_map/bit_field/type/ro',
       'default_register_map/bit_field/type/rof',
       'default_register_map/bit_field/type/rs',
-      'default_register_map/bit_field/type/rw',
+      'default_register_map/bit_field/type/rw_w1',
       'default_register_map/bit_field/type/rwc_rws',
       'default_register_map/bit_field/type/rwe_rwl',
       'default_register_map/bit_field/type/w0c_w1c',
       'default_register_map/bit_field/type/w0crs_w1crs_w0src_w1src',
       'default_register_map/bit_field/type/w0s_w1s',
       'default_register_map/bit_field/type/w0trg_w1trg',
-      'default_register_map/bit_field/type/wo',
+      'default_register_map/bit_field/type/wo_wo1',
+      'default_register_map/common/comment',
       'default_register_map/global/address_width',
       'default_register_map/global/bus_width',
       'default_register_map/register/name',
@@ -33,7 +33,10 @@ module RgGen
       'default_register_map/register/type/external',
       'default_register_map/register/type/indirect',
       'default_register_map/register_block/byte_size',
-      'default_register_map/register_block/name'
+      'default_register_map/register_block/name',
+      'default_register_map/register_file/name',
+      'default_register_map/register_file/offset_address',
+      'default_register_map/register_file/size'
     ].freeze
 
     def self.load_features

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

@@ -19,13 +19,13 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
     end
 
     verify(:feature) do
-      error_condition { [@lsb, @width, @sequence_size, @step].none? }
+      error_condition { [@lsb_base, @width, @sequence_size, @step].none? }
       message { 'no bit assignment is given' }
     end
 
     verify(:feature) do
-      error_condition { !@lsb }
-      message { 'no lsb is given' }
+      error_condition { [@lsb_base, @width].none? }
+      message { 'neither lsb nor width is given' }
     end
 
     verify(:feature) do
@@ -61,7 +61,11 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
 
     private
 
-    KEYS = [:lsb, :width, :sequence_size, :step].freeze
+    VARIABLE_NAMES = {
+      lsb: :@lsb_base, width: :@width, sequence_size: :@sequence_size, step: :@step
+    }.freeze
+
+    KEYS = VARIABLE_NAMES.keys.freeze
 
     def preprocess(value)
       if value.is_a?(Hash)
@@ -83,18 +87,38 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
 
     def parse_value(input_value, key)
       input_value.key?(key) &&
-        instance_variable_set("@#{key}", Integer(input_value[key]))
+        instance_variable_set(VARIABLE_NAMES[key], Integer(input_value[key]))
     rescue ArgumentError, TypeError
       error "cannot convert #{input_value[key].inspect} into " \
             "bit assignment(#{key.to_s.tr('_', ' ')})"
     end
 
+    def lsb_base
+      @lsb_base ||=
+        ((bit_field.component_index.zero? && 0) || calc_next_lsb(previous_bit_field))
+    end
+
+    def previous_bit_field
+      index = bit_field.component_index - 1
+      bit_fields[index]
+    end
+
+    def calc_next_lsb(bit_field)
+      compact_sequential_bit_field?(bit_field) &&
+        (bit_field.lsb + bit_field.width * bit_field.sequence_size) ||
+        (bit_field.lsb + bit_field.width)
+    end
+
+    def compact_sequential_bit_field?(bit_field)
+      bit_field.sequential? && (bit_field.step == bit_field.width)
+    end
+
     def lsb_bit(index = 0)
-      lsb_msb_bit(index, @lsb)
+      lsb_msb_bit(index, lsb_base)
     end
 
     def msb_bit(index = 0)
-      lsb_msb_bit(index, @lsb + width - 1)
+      lsb_msb_bit(index, lsb_base + width - 1)
     end
 
     def lsb_msb_bit(index, base)
@@ -114,9 +138,7 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
     end
 
     def overlap?
-      register
-        .bit_fields
-        .any? { |bit_field| (bit_field.bit_map & bit_map).nonzero? }
+      bit_fields.any? { |bit_field| (bit_field.bit_map & bit_map).nonzero? }
     end
   end
 end

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

@@ -2,16 +2,35 @@
 
 RgGen.define_simple_feature(:bit_field, :initial_value) do
   register_map do
-    property :initial_value, default: 0
-    property :initial_value?, body: -> { !@initial_value.nil? }
+    property :initial_value
+    property :initial_values
+    property :initial_value?, forward_to: :initial_value_set?
+    property :fixed_initial_value?, forward_to: :fixed?
+    property :initial_value_array?, forward_to: :array?
+
+    input_pattern [{ parameterized: /default:(#{integer})/,
+                     array: /#{integer}(?:[,\n]#{integer})+/ }]
 
     build do |value|
-      @initial_value =
-        begin
-          Integer(value)
-        rescue ArgumentError, TypeError
-          error "cannot convert #{value.inspect} into initial value"
+      @input_format =
+        if value.is_a?(Hash) || match_index == :parameterized
+          :parameterized
+        elsif value.is_a?(Array) || match_index == :array
+          :array
+        else
+          :single
         end
+      @initial_value, @initial_values = parse_initial_value(value)
+    end
+
+    define_helpers do
+      def verify_initial_value(&block)
+        initial_value_verifiers << create_verifier(&block)
+      end
+
+      def initial_value_verifiers
+        @initial_value_verifiers ||= []
+      end
     end
 
     verify(:component) do
@@ -20,40 +39,130 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
     end
 
     verify(:component) do
-      error_condition { initial_value? && initial_value < min_initial_value }
+      error_condition do
+        @input_format == :array && !bit_field.sequential?
+      end
       message do
-        'input initial value is less than minimum initial value: ' \
-        "initial value #{initial_value} " \
-        "minimum initial value #{min_initial_value}"
+        'arrayed initial value is not allowed for non sequential bit field'
       end
     end
 
     verify(:component) do
-      error_condition { initial_value? && initial_value > max_initial_value }
-      message do
-        'input initial value is greater than maximum initial value: ' \
-        "initial value #{initial_value} " \
-        "maximum initial value #{max_initial_value}"
+      error_condition do
+        @input_format == :array && initial_values.size > bit_field.sequence_size
       end
+      message { 'too many initial values are given' }
     end
 
     verify(:component) do
-      error_condition { initial_value? && !match_valid_condition? }
-      message do
-        "does not match the valid initial value condition: #{initial_value}"
+      error_condition do
+        @input_format == :array && initial_values.size < bit_field.sequence_size
+      end
+      message { 'few initial values are given' }
+    end
+
+    verify(:component) do
+      check_error do
+        Array(initial_value || initial_values)
+          .each(&method(:verify_initial_value))
+      end
+    end
+
+    verify_initial_value do
+      error_condition { |value| value < min_initial_value }
+      message do |value|
+        'input initial value is less than minimum initial value: ' \
+        "initial value #{value} minimum initial value #{min_initial_value}"
+      end
+    end
+
+    verify_initial_value do
+      error_condition { |value| value > max_initial_value }
+      message do |value|
+        'input initial value is greater than maximum initial value: ' \
+        "initial value #{value} maximum initial value #{max_initial_value}"
+      end
+    end
+
+    verify_initial_value do
+      error_condition { |value| !match_valid_condition?(value) }
+      message do |value|
+        "does not match the valid initial value condition: #{value}"
       end
     end
 
     printable(:initial_value) do
-      @initial_value &&
-        begin
-          print_width = (bit_field.width + 3) / 4
-          format('0x%0*x', print_width, @initial_value)
-        end
+      if @input_format == :parameterized
+        "default: #{format_value(initial_value)}"
+      elsif @input_format == :array
+        initial_values.map(&method(:format_value))
+      elsif initial_value?
+        format_value(initial_value)
+      end
     end
 
     private
 
+    def initial_value_format
+      @initial_value_format ||=
+        if @input_format == :parameterized
+          bit_field.sequential? && :array || :single
+        else
+          @input_format
+        end
+    end
+
+    def array?
+      initial_value_format == :array
+    end
+
+    def fixed?
+      [:array, :single].include?(@input_format)
+    end
+
+    def parse_initial_value(input_value)
+      if @input_format == :parameterized
+        [parse_parameterized_initial_value(input_value), nil]
+      elsif @input_format == :array
+        [nil, parse_arrayed_initial_value(input_value)]
+      else
+        [parse_value(input_value), nil]
+      end
+    end
+
+    def parse_parameterized_initial_value(input_value)
+      value =
+        if pattern_matched?
+          match_data.captures.first
+        else
+          input_value
+            .fetch(:default) { error 'no default value is given' }
+        end
+      parse_value(value)
+    end
+
+    def parse_arrayed_initial_value(input_value)
+      values =
+        if pattern_matched?
+          input_value.split(/[,\n]/)
+        else
+          input_value
+        end
+      values.map(&method(:parse_value))
+    end
+
+    def parse_value(value)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      error "cannot convert #{value.inspect} into initial value"
+    end
+
+    def verify_initial_value(value)
+      helper.initial_value_verifiers.each do |verifier|
+        verifier.verify(self, value)
+      end
+    end
+
     def settings
       @settings ||=
         (bit_field.settings && bit_field.settings[:initial_value]) || {}
@@ -67,9 +176,18 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
       2**bit_field.width - 1
     end
 
-    def match_valid_condition?
+    def match_valid_condition?(value)
       !settings.key?(:valid_condition) ||
-        instance_exec(@initial_value, &settings[:valid_condition])
+        instance_exec(value, &settings[:valid_condition])
+    end
+
+    def initial_value_set?
+      [@initial_value, @initial_values].any?
+    end
+
+    def format_value(value)
+      print_width = (bit_field.width + 3) / 4
+      format('0x%0*x', print_width, value)
     end
   end
 end

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

@@ -2,19 +2,15 @@
 
 RgGen.define_simple_feature(:bit_field, :name) do
   register_map do
-    property :name, initial: -> { register.name }
+    property :name, default: -> { register.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 bit field name: #{value.inspect}"
-        end
-      @full_name = [register.name, @name]
+      pattern_matched? ||
+        (error "illegal input value for bit field name: #{value.inspect}")
+      @name = match_data.to_s
     end
 
     verify(:feature) do
@@ -22,16 +18,19 @@ RgGen.define_simple_feature(:bit_field, :name) do
       message { "duplicated bit field name: #{name}" }
     end
 
-    printable :name
+    printable(:name) do
+      RgGen::Core::Utility::CodeUtility
+        .array_name(name, Array(bit_field.sequence_size))
+    end
 
     private
 
     def get_full_name(separator = '.')
-      @full_name&.join(separator) || register.name
+      [register.full_name(separator), *@name].join(separator)
     end
 
     def duplicated_name?
-      register.bit_fields.any? { |bit_field| bit_field.name == name }
+      bit_fields.any? { |bit_field| bit_field.name == name }
     end
   end
 end

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

@@ -7,18 +7,12 @@ RgGen.define_simple_feature(:bit_field, :reference) do
     property :reference_width, forward_to: :required_width
     property :find_reference, forward_to: :find_reference_bit_field
 
-    input_pattern [
-      /(#{variable_name})\.(#{variable_name})/,
-      /(#{variable_name})/
-    ]
+    input_pattern /(#{variable_name}(?:\.#{variable_name})*)/
 
     build do |value|
-      @input_reference =
-        if pattern_matched?
-          match_data[1..2].compact.join('.')
-        else
-          error "illegal input value for reference: #{value.inspect}"
-        end
+      pattern_matched? ||
+        (error "illegal input value for reference: #{value.inspect}")
+      @input_reference = match_data.to_s
     end
 
     verify(:component) do
@@ -38,20 +32,46 @@ RgGen.define_simple_feature(:bit_field, :reference) do
 
     verify(:all) do
       error_condition do
-        reference? && !register.array? && reference_bit_field.register.array?
+        reference? && within_array?(reference_bit_field) &&
+          (bit_field.depth != reference_bit_field.depth)
       end
       message do
-        'bit field of array register is not allowed for ' \
-        "reference bit field: #{@input_reference}"
+        'depth of layer is not matched: ' \
+        "own #{bit_field.depth} " \
+        "reference #{reference_bit_field.depth}"
+      end
+    end
+
+    define_helpers do
+      def verify_array(&block)
+        array_verifiers << create_verifier(&block)
+      end
+
+      def array_verifiers
+        @array_verifiers ||= []
       end
     end
 
     verify(:all) do
-      error_condition { reference? && !match_array_size? }
-      message do
+      check_error do
+        reference? && within_array?(reference_bit_field) &&
+          helper.array_verifiers.each(&method(:verify_array))
+      end
+    end
+
+    verify_array do
+      error_condition { |own, ref| !own.array? && ref.array? }
+      message do |*_, layer|
+        "bit field within array #{layer.to_s.tr('_', ' ')} is not allowed for " \
+        "reference bit field: #{@input_reference}"
+      end
+    end
+
+    verify_array do
+      error_condition { |own, ref| unmatch_array_size?(own, ref) }
+      message do |own, ref|
         'array size is not matched: ' \
-        "own #{register.array_size} " \
-        "reference #{reference_bit_field.register.array_size}"
+        "own #{own.array_size} reference #{ref.array_size}"
       end
     end
 
@@ -66,7 +86,7 @@ RgGen.define_simple_feature(:bit_field, :reference) do
     end
 
     verify(:all) do
-      error_condition { reference? && !match_sequence_size? }
+      error_condition { reference? && unmatch_sequence_size? }
       message do
         'sequence size is not matched: ' \
         "own #{bit_field.sequence_size} " \
@@ -125,14 +145,23 @@ RgGen.define_simple_feature(:bit_field, :reference) do
       find_reference_bit_field(register_block.bit_fields)
     end
 
-    def match_array_size?
-      !(register.array? && reference_bit_field.register.array?) ||
-        register.array_size == reference_bit_field.register.array_size
+    def within_array?(bit_field)
+      bit_field.register_files.any?(&:array?) || bit_field.register.array?
+    end
+
+    def verify_array(verifier)
+      [*register_files, register]
+        .zip([*reference_bit_field.register_files, reference_bit_field.register])
+        .each { |own, ref| verifier.verify(self, own, ref, own.layer) }
+    end
+
+    def unmatch_array_size?(own, ref)
+      own.array? && ref.array? && own.array_size != ref.array_size
     end
 
-    def match_sequence_size?
-      !(bit_field.sequential? && reference_bit_field.sequential?) ||
-        bit_field.sequence_size == reference_bit_field.sequence_size
+    def unmatch_sequence_size?
+      bit_field.sequential? && reference_bit_field.sequential? &&
+        (bit_field.sequence_size != reference_bit_field.sequence_size)
     end
 
     def required_width