rggen-default-register-map 0.27.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e1b5c8952df6d5cf956a991019f222ff1fa5789316a37b2f82b0c204fe7a30a
-  data.tar.gz: a2740678c7e416b435f294652fafa074b7a4090656f9c52ba8487a9866a6362c
+  metadata.gz: 9fac466f73de34a7e0a0575920f09cf424d4712b8a17a6b787d580d7252dac6f
+  data.tar.gz: 0fd170d8deb150dfd7d6fe8cd15f357b9e5781f32649bd709c53d7a1b1d76d45
 SHA512:
-  metadata.gz: 4b562f3dda473595d8b96ab350da36654e5c75a78cd56afb25dfc4b0a45666dbf77185aa85261938cda985d72b7878b346c7b5331c8e837155a2310ebba83c0d
-  data.tar.gz: '09288fa36647791243feb903e3752350b66197111ac960223be51e7766af0be2848fbcd086a2035e600dce2af8ea399940e528d9ed743bd8b739a05dd2b19601'
+  metadata.gz: c3872a9705e22a74c0c0e2ed45a09ffdf3e8e2e96ed6ca84c179636de0227f09560b2f266fde6450f2121524ba10fa830efa311560bf94469b05c33431f28e74
+  data.tar.gz: 9afaa664572a6c282027e15f382bb81f3d7b0413506c9c0d02d31b71bfae37b051532b388948666e87da97d6f3a18b013d4bcf2846845d2bea584dc26a59c958

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

@@ -85,7 +85,7 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
     end
 
     def preprocess(value)
-      if value.is_a?(Hash)
+      if hash?(value)
         value
       elsif match_pattern(value)
         split_match_data(match_data)
@@ -154,7 +154,7 @@ RgGen.define_simple_feature(:bit_field, :bit_assignment) do
     end
 
     def calc_bit_position(index, base)
-      if index.is_a?(Integer)
+      if integer?(index)
         base + step * index
       else
         "#{base}+#{step}*#{index}"

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

@@ -5,17 +5,17 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
     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?
+    property :fixed_initial_value?, forward_to: :fixed_format?
+    property :initial_value_array?, forward_to: :array_format?
 
     input_pattern [{ parameterized: /default:(#{integer})/,
                      array: /#{integer}(?:[,\n]#{integer})+/ }]
 
     build do |value|
       @input_format =
-        if value.is_a?(Hash) || match_index == :parameterized
+        if hash?(value) || match_index == :parameterized
           :parameterized
-        elsif value.is_a?(Array) || match_index == :array
+        elsif array?(value) || match_index == :array
           :array
         else
           :single
@@ -34,7 +34,7 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
     end
 
     verify(:component) do
-      error_condition { settings[:require] && !initial_value? }
+      error_condition { need_initial_value? && !initial_value? }
       message { 'no initial value is given' }
     end
 
@@ -112,11 +112,11 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
         end
     end
 
-    def array?
+    def array_format?
       initial_value_format == :array
     end
 
-    def fixed?
+    def fixed_format?
       [:array, :single].include?(@input_format)
     end
 
@@ -169,6 +169,13 @@ RgGen.define_simple_feature(:bit_field, :initial_value) do
         (bit_field.settings && bit_field.settings[:initial_value]) || {}
     end
 
+    def need_initial_value?
+      case settings[:require]
+      when Proc then instance_exec(&settings[:require])
+      else settings[:require]
+      end
+    end
+
     def min_initial_value
       bit_field.width == 1 ? 0 : -(2**(bit_field.width - 1))
     end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :custom) do
+  register_map do
+    property :sw_read, body: -> { option_value(:sw_read) }
+    property :sw_write, body: -> { option_value(:sw_write) }
+    property :sw_write_once?, body: -> { option_value(:sw_write_once) }
+    property :hw_write?, body: -> { option_value(:hw_write) }
+    property :hw_set?, body: -> { option_value(:hw_set) }
+    property :hw_clear?, body: -> { option_value(:hw_clear) }
+    property :sw_update?, forward_to: :update_by_sw?
+    property :hw_update?, forward_to: :update_by_hw?
+    property :read_trigger?, body: -> { option_value(:read_trigger) }
+    property :write_trigger?, body: -> { option_value(:write_trigger) }
+
+    readable? { bit_field.sw_read != :none }
+    writable? { bit_field.sw_write != :none }
+    volatile? { !bit_field.sw_update? && bit_field.readable? || bit_field.hw_update? }
+    initial_value require: -> { bit_field.sw_update? || bit_field.hw_update? }
+
+    input_pattern [
+      true => truthy_pattern, false => falsey_pattern,
+      sw_common: /(none|default|set|clear)/i,
+      sw_write: /(set_[01]|clear_[01]|toggle_[01])/i
+    ], match_automatically: false
+
+    build do |_, options|
+      @options = parse_options(options)
+    end
+
+    verify(:component) do
+      error_condition { sw_write_once? && !writable? }
+      message { 'cannot enable sw_write_once option for unwritable bit field' }
+    end
+
+    verify(:component) do
+      error_condition { hw_write? && reserved? }
+      message { 'cannot enable hw_write option for reserved bit field' }
+    end
+
+    verify(:component) do
+      error_condition { hw_set? && reserved? }
+      message { 'cannot enable hw_set option for reserved bit field' }
+    end
+
+    verify(:component) do
+      error_condition { hw_clear? && reserved? }
+      message { 'cannot enable hw_clear option for reserved bit field' }
+    end
+
+    verify(:component) do
+      error_condition { read_trigger? && !readable? }
+      message { 'cannot enable read_trigger option for unreadable bit field' }
+    end
+
+    verify(:component) do
+      error_condition { write_trigger? && !writable? }
+      message { 'cannot enable write_trigger option for unwritable bit field' }
+    end
+
+    printable(:type) do
+      options =
+        [:sw_read, :sw_write, :sw_write_once, :hw_write, :hw_set, :hw_clear]
+          .map { |o| "#{o}: #{option_value(o)}" }
+      [type, *options]
+    end
+
+    private
+
+    def option_value(name)
+      default_value =
+        if boolean_option?(name)
+          false
+        else
+          :default
+        end
+      @options.fetch(name, default_value)
+    end
+
+    def update_by_sw?
+      [:set, :clear].include?(sw_read) || sw_write != :none
+    end
+
+    def update_by_hw?
+      hw_write? || hw_set? || hw_clear?
+    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)
+      end
+    rescue ArgumentError, TypeError
+      error "invalid options are given: #{options.inspect}"
+    end
+
+    def convert_to_option_name(key)
+      return key unless string?(key) || symbol?(key)
+      key.to_sym.downcase
+    end
+
+    def parse_option(option_name, key, value)
+      case option_name
+      when :sw_read
+        parse_value_option(:sw_read, [:sw_common], value)
+      when :sw_write
+        parse_value_option(:sw_write, [:sw_common, :sw_write], value)
+      when method(:boolean_option?)
+        parse_boolean_option(option_name, value)
+      else
+        error "unknown option is given: #{key.inspect}"
+      end
+    end
+
+    def parse_value_option(option_name, allowed_patterns, value)
+      match_data, match_index = match_pattern(value)
+
+      if match_data && allowed_patterns.include?(match_index)
+        match_data.captures.first.downcase.to_sym
+      else
+        error "invalid value for #{option_name} option: #{value.inspect}"
+      end
+    end
+
+    def boolean_option?(option_name)
+      [
+        :sw_write_once, :hw_write, :hw_set, :hw_clear,
+        :read_trigger, :write_trigger
+      ].include?(option_name)
+    end
+
+    def parse_boolean_option(option_name, value)
+      boolean_value = convert_to_boolean_value(value)
+
+      if [true, false].include?(boolean_value)
+        boolean_value
+      else
+        error "invalid value for #{option_name} option: #{value.inspect}"
+      end
+    end
+
+    def convert_to_boolean_value(value)
+      _, boolean_value =
+        case value
+        when true then [nil, true]
+        when false then [nil, false]
+        else match_pattern(value)
+        end
+      boolean_value
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :rol) do
+  register_map do
+    read_only
+    initial_value require: true
+    reference use: true, width: 1
+  end
+end

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

@@ -5,43 +5,35 @@ RgGen.define_list_feature(:bit_field, :type) do
     base_feature do
       define_helpers do
         def read_write
-          @readable = true
-          @writable = true
+          accessibility[:read] = -> { true }
+          accessibility[:write] = -> { true }
         end
 
         def read_only
-          @readable = true
-          @writable = false
+          accessibility[:read] = -> { true }
+          accessibility[:write] = -> { false }
         end
 
         def write_only
-          @readable = false
-          @writable = true
+          accessibility[:read] = -> { false }
+          accessibility[:write] = -> { true }
         end
 
         def reserved
-          @readable = false
-          @writable = false
+          accessibility[:read] = -> { false }
+          accessibility[:write] = -> { false }
         end
 
-        def readable?
-          @readable.nil? || @readable
+        def readable?(&block)
+          accessibility[:read] = block
         end
 
-        def writable?
-          @writable.nil? || @writable
+        def writable?(&block)
+          accessibility[:write] = block
         end
 
-        def read_only?
-          readable? && !writable?
-        end
-
-        def write_only?
-          writable? && !readable?
-        end
-
-        def reserved?
-          !(readable? || writable?)
+        def accessibility
+          @accessibility ||= {}
         end
 
         def volatile
@@ -73,26 +65,33 @@ RgGen.define_list_feature(:bit_field, :type) do
 
       property :type
       property :settings, forward_to_helper: true
-      property :readable?, forward_to_helper: true
-      property :writable?, forward_to_helper: true
-      property :read_only?, forward_to_helper: true
-      property :write_only?, forward_to_helper: true
-      property :reserved?, forward_to_helper: true
-      property :volatile?, initial: -> { volatility }
-
-      build { |value| @type = value }
+      property :readable?, body: -> { accessibility(:read) }
+      property :writable?, body: -> { accessibility(:write) }
+      property :read_only?, body: -> { readable? && !writable? }
+      property :write_only?, body: -> { !readable? && writable? }
+      property :reserved?, body: -> { !readable? && !writable? }
+      property :volatile?, body: -> { volatility }
 
       build do |value|
         @type = value
-        helper.reserved? && bit_field.document_only
+      end
+
+      post_build do
+        reserved? && bit_field.document_only
       end
 
       printable :type
 
       private
 
+      def accessibility(access)
+        body = helper.accessibility[access]
+        body.nil? || instance_exec(&body)
+      end
+
       def volatility
-        helper.volatility.nil? || instance_exec(&helper.volatility)
+        body = helper.volatility
+        body.nil? || instance_exec(&body)
       end
     end
 
@@ -109,13 +108,15 @@ RgGen.define_list_feature(:bit_field, :type) do
     end
 
     factory do
+      allow_options
+
       convert_value do |value|
         types = target_features.keys
         types.find(&value.to_sym.method(:casecmp?)) || value
       end
 
       def target_feature_key(cell)
-        cell.value
+        cell
       end
     end
   end

data/lib/rggen/default_register_map/comment.rb

@@ -7,7 +7,7 @@ module RgGen
 
       build do |value|
         @comment =
-          (value.is_a?(Array) && value.join("\n") || value.to_s).chomp
+          (array?(value) && value.join("\n") || value.to_s).chomp
       end
 
       printable :comment do

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

@@ -4,17 +4,17 @@ RgGen.define_simple_feature(:global, :enable_wide_register) do
   configuration do
     property :enable_wide_register?, default: false
 
-    input_pattern [/true|on|yes/i, /false|off|no/i],
+    input_pattern [true => truthy_pattern, false => falsey_pattern],
                   match_automatically: false
 
     ignore_empty_value false
 
     build do |value|
       @enable_wide_register =
-        if [true, false].include?(value)
-          value
+        if [true, false].any? { |boolean| value == boolean }
+          value.value
         elsif match_pattern(value)
-          [true, false][match_index]
+          match_index
         else
           error "cannot convert #{value.inspect} into boolean"
         end

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

@@ -21,7 +21,7 @@ RgGen.define_simple_feature(:register, :offset_address) do
     verify(:feature) do
       error_condition { (offset_address % byte_width).nonzero? }
       message do
-        "offset address is not aligned with bus width(#{bus_width}): "\
+        "offset address is not aligned with bus width(#{bus_width}): " \
         "0x#{offset_address.to_s(16)}"
       end
     end

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

@@ -39,7 +39,7 @@ RgGen.define_simple_feature(:register, :size) do
 
     def parse_values(values)
       Array(
-        values.is_a?(String) && parse_string_values(values) || values
+        string?(values) && parse_string_values(values) || values
       ).map(&method(:convert_value))
     end
 

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

@@ -43,13 +43,11 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
     support_shared_address
     support_array_register
 
-    input_pattern [
-      /(#{variable_name}(?:\.#{variable_name})*)/,
-      /(#{variable_name}(?:\.#{variable_name})*):(#{integer})/
-    ], match_automatically: false
+    input_pattern /(#{variable_name}(?:\.#{variable_name})*)/,
+                  match_automatically: false
 
-    build do
-      @index_entries = parse_index_entries
+    build do |_type, options|
+      @index_entries = parse_index_entries(options)
     end
 
     verify(:component) do
@@ -173,35 +171,36 @@ RgGen.define_list_item_feature(:register, :type, :indirect) do
 
     private
 
-    def parse_index_entries
-      (!options.empty? && options.map(&method(:create_index_entry))) ||
-        (error 'no indirect indices are given')
+    def parse_index_entries(options)
+      error 'no indirect indices are given' if options.empty?
+      options.map { |option| create_index_entry(option) }
     end
 
-    def create_index_entry(value)
-      input_values = split_value(value)
-      case input_values.size
-      when 2
-        index_entry.new(input_values[0], convert_index_value(input_values[1]))
-      when 1
-        index_entry.new(input_values[0])
-      else
-        error "too many arguments for indirect index are given: #{value.inspect}"
-      end
+    def create_index_entry(option)
+      entry = array?(option) && option || [option]
+
+      field_name, index_value =
+        case entry.size
+        when 2 then [check_field_name(entry[0]), convert_index_value(entry[1])]
+        when 1 then [check_field_name(entry[0])]
+        when 0 then error 'no indirect index is given'
+        else error "too many arguments for indirect index are given: #{entry.inspect}"
+        end
+
+      index_entry.new(field_name, index_value)
     end
 
-    def split_value(value)
-      input_value = Array(value)
-      field_name = input_value.first
-      if sting_or_symbol?(field_name) && match_pattern(field_name)
-        [*match_data.captures, *input_value[1..]]
-      else
-        error "illegal input value for indirect index: #{value.inspect}"
-      end
+    def check_field_name(field_name)
+      return field_name if match_field_name?(field_name)
+      error "illegal input value for indirect index: #{field_name.inspect}"
+    end
+
+    def match_field_name?(field_name)
+      (string?(field_name) || symbol?(field_name)) && match_pattern(field_name)
     end
 
     def sting_or_symbol?(value)
-      [String, Symbol].any?(&value.method(:is_a?))
+      string?(value) || symbol?(value)
     end
 
     def convert_index_value(value)

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

@@ -43,9 +43,8 @@ RgGen.define_list_feature(:register, :type) do
       property :reserved?, initial: -> { !(writable? || readable?) }
       property :settings, forward_to_helper: true
 
-      build do |value|
-        @type = value[:type]
-        @options = value[:options]
+      build do |type, _option|
+        @type = type
         helper.need_bit_fields? || register.need_no_children
       end
 
@@ -64,8 +63,6 @@ RgGen.define_list_feature(:register, :type) do
 
       private
 
-      attr_reader :options
-
       def writability
         block = helper.writability || -> { register.bit_fields.any?(&:writable?) }
         instance_exec(&block)
@@ -87,38 +84,21 @@ RgGen.define_list_feature(:register, :type) do
     end
 
     factory do
+      allow_options
+
       convert_value do |value|
-        type, options = split_input_value(value)
-        { type: find_type(type), options: Array(options) }
+        find_type(value)
       end
 
-      def target_feature_key(cell)
-        (!cell.empty_value? && cell.value[:type]) || nil
+      def target_feature_key(value)
+        (!value.empty_value? && value) || nil
       end
 
       private
 
-      def split_input_value(value)
-        if value.is_a?(String)
-          split_string_value(value)
-        else
-          input_value = Array(value)
-          [input_value[0], input_value[1..]]
-        end
-      end
-
-      def split_string_value(value)
-        type, options = split_string(value, ':', 2)
-        [type, split_string(options, /[,\n]/, 0)]
-      end
-
-      def split_string(value, separator, limit)
-        value&.split(separator, limit)&.map(&:strip)
-      end
-
-      def find_type(type)
+      def find_type(value)
         types = target_features.keys
-        types.find(&type.to_sym.method(:casecmp?)) || type
+        types.find(&value.to_sym.method(:casecmp?)) || value
       end
     end
   end

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

@@ -15,7 +15,7 @@ RgGen.define_simple_feature(:register_file, :size) do
 
     build do |values|
       @size =
-        (values.is_a?(String) && parse_string_value(values) || Array(values))
+        (string?(values) && parse_string_value(values) || Array(values))
           .map(&method(:convert_value))
     end
 

data/lib/rggen/default_register_map/version.rb

@@ -2,6 +2,6 @@
 
 module RgGen
   module DefaultRegisterMap
-    VERSION = '0.27.0'
+    VERSION = '0.28.0'
   end
 end

data/lib/rggen/default_register_map.rb

@@ -27,10 +27,12 @@ RgGen.setup_plugin :'rggen-default-register-map' do |plugin|
     'default_register_map/bit_field/name',
     'default_register_map/bit_field/bit_assignment',
     'default_register_map/bit_field/type',
+    'default_register_map/bit_field/type/custom',
     'default_register_map/bit_field/type/rc',
     'default_register_map/bit_field/type/reserved',
     'default_register_map/bit_field/type/ro_rotrg',
     'default_register_map/bit_field/type/rof',
+    'default_register_map/bit_field/type/rol',
     'default_register_map/bit_field/type/row0trg_row1trg',
     'default_register_map/bit_field/type/rowo_rowotrg',
     'default_register_map/bit_field/type/rs',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-default-register-map
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.28.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -41,10 +41,12 @@ files:
 - lib/rggen/default_register_map/bit_field/name.rb
 - lib/rggen/default_register_map/bit_field/reference.rb
 - lib/rggen/default_register_map/bit_field/type.rb
+- lib/rggen/default_register_map/bit_field/type/custom.rb
 - lib/rggen/default_register_map/bit_field/type/rc.rb
 - lib/rggen/default_register_map/bit_field/type/reserved.rb
 - lib/rggen/default_register_map/bit_field/type/ro_rotrg.rb
 - lib/rggen/default_register_map/bit_field/type/rof.rb
+- lib/rggen/default_register_map/bit_field/type/rol.rb
 - lib/rggen/default_register_map/bit_field/type/row0trg_row1trg.rb
 - lib/rggen/default_register_map/bit_field/type/rowo_rowotrg.rb
 - lib/rggen/default_register_map/bit_field/type/rs.rb
@@ -104,8 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
-summary: rggen-default-register-map-0.27.0
+summary: rggen-default-register-map-0.28.0
 test_files: []