rggen-default-register-map 0.13.0

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:register, :name) do
+  register_map do
+    property :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
+    end
+
+    verify(:feature) do
+      error_condition { !name }
+      message { 'no register name is given' }
+    end
+
+    verify(:feature) do
+      error_condition { duplicated_name? }
+      message { "duplicated register name: #{name}" }
+    end
+
+    printable :name
+
+    private
+
+    def duplicated_name?
+      register_block.registers.any? { |register| register.name == name }
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:register, :offset_address) do
+  register_map do
+    property :offset_address
+    property :address_range, initial: -> { start_address..end_address }
+    property :overlap?, forward_to: :overlap_address_range?
+
+    build do |value|
+      @offset_address =
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          error "cannot convert #{value.inspect} into offset address"
+        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}" }
+    end
+
+    verify(:feature) do
+      error_condition { (offset_address % byte_width).positive? }
+      message do
+        "offset address is not aligned with bus width(#{bus_width}): "\
+        "0x#{offset_address.to_s(16)}"
+      end
+    end
+
+    verify(:component) do
+      error_condition { end_address > register_block.byte_size }
+      message do
+        'offset address range exceeds byte size of register block' \
+        "(#{register_block.byte_size}): " \
+        "0x#{start_address.to_s(16)}-0x#{end_address.to_s(16)}"
+      end
+    end
+
+    verify(:component) do
+      error_condition do
+        register_block.registers.any? do |register|
+          overlap_address_range?(register) &&
+            support_unique_range_only?(register)
+        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)}"
+      end
+    end
+
+    printable(:offset_address) do
+      [start_address, end_address]
+        .map(&method(:printable_address)).join(' - ')
+    end
+
+    private
+
+    def bus_width
+      configuration.bus_width
+    end
+
+    def byte_width
+      configuration.byte_width
+    end
+
+    def start_address
+      offset_address
+    end
+
+    def end_address
+      start_address + register.byte_size - 1
+    end
+
+    def overlap_address_range?(other_register)
+      overlap_range?(other_register) && match_access?(other_register)
+    end
+
+    def overlap_range?(other_register)
+      own = address_range
+      other = other_register.address_range
+      own.include?(other.first) || other.include?(own.first)
+    end
+
+    def match_access?(other_register)
+      (register.writable? && other_register.writable?) ||
+        (register.readable? && other_register.readable?)
+    end
+
+    def support_unique_range_only?(other_register)
+      !(register.settings[:support_overlapped_address] &&
+        register.match_type?(other_register))
+    end
+
+    def printable_address(address)
+      print_width = (register_block.local_address_width + 3) / 4
+      format('0x%0*x', print_width, address)
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:register, :size) do
+  register_map do
+    property :size
+    property :width, initial: -> { calc_width }
+    property :byte_width, initial: -> { width / 8 }
+    property :byte_size, initial: -> { calc_byte_size }
+    property :array?, forward_to: :array_register?
+    property :array_size, forward_to: :array_registers
+    property :count, initial: -> { calc_count }
+
+    input_pattern [
+      /(#{integer}(:?,#{integer})*)/,
+      /\[(#{integer}(:?,#{integer})*)\]/
+    ], match_automatically: false
+
+    build do |values|
+      @size = parse_values(values)
+    end
+
+    verify(:feature) do
+      error_condition { size && !size.all?(&:positive?) }
+      message do
+        "non positive value(s) are not allowed for register size: #{size}"
+      end
+    end
+
+    printable(:array_size) do
+      (array_register? || nil) && "[#{array_registers.join(', ')}]"
+    end
+
+    private
+
+    def parse_values(values)
+      Array(
+        values.is_a?(String) && parse_string_values(values) || values
+      ).map(&method(:convert_value))
+    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}"
+      end
+    end
+
+    def split_match_data(match_data)
+      match_data.captures.first.split(',')
+    end
+
+    def convert_value(value)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      error "cannot convert #{value.inspect} into register 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
+      end
+    end
+
+    def max_msb
+      register
+        .bit_fields
+        .map { |bit_field| bit_field.msb((bit_field.sequence_size || 1) - 1) }
+        .max
+    end
+
+    def calc_byte_size
+      if register.settings[:byte_size]
+        instance_exec(&register.settings[:byte_size])
+      else
+        Array(@size).reduce(1, :*) * byte_width
+      end
+    end
+
+    def array_register?
+      register.settings[:support_array] && !@size.nil? || false
+    end
+
+    def array_registers
+      array_register? && @size || nil
+    end
+
+    def calc_count
+      Array(array_registers).reduce(1, :*)
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RgGen.define_list_feature(:register, :type) do
+  register_map do
+    base_feature do
+      define_helpers do
+        def writable?(&block)
+          @writability = block
+        end
+
+        def readable?(&block)
+          @readability = block
+        end
+
+        attr_reader :writability
+        attr_reader :readability
+
+        def no_bit_fields
+          @no_bit_fields = true
+        end
+
+        def need_bit_fields?
+          !@no_bit_fields
+        end
+
+        def settings
+          @settings ||= {}
+        end
+
+        def support_array_register
+          settings[:support_array] = true
+        end
+
+        def byte_size(&block)
+          settings[:byte_size] = block
+        end
+
+        def support_overlapped_address
+          settings[:support_overlapped_address] = true
+        end
+      end
+
+      property :type, default: :default
+      property :match_type?, body: ->(register) { register.type == type }
+      property :writable?, initial: -> { writability }
+      property :readable?, initial: -> { readability }
+      property :settings, forward_to_helper: true
+
+      build do |value|
+        @type = value[:type]
+        @options = value[:options]
+        helper.need_bit_fields? || register.need_no_children
+      end
+
+      verify(:component) do
+        error_condition do
+          helper.need_bit_fields? && register.bit_fields.empty?
+        end
+        message { 'no bit fields are given' }
+      end
+
+      private
+
+      attr_reader :options
+
+      def writability
+        instance_exec(&(helper.writability || default_writability))
+      end
+
+      def default_writability
+        -> { register.bit_fields.any?(&:writable?) }
+      end
+
+      def readability
+        instance_exec(&(helper.readability || default_readability))
+      end
+
+      def default_readability
+        lambda do
+          block = ->(bit_field) { bit_field.readable? || bit_field.reserved? }
+          register.bit_fields.any?(&block)
+        end
+      end
+    end
+
+    default_feature do
+      support_array_register
+
+      verify(:feature) do
+        error_condition { @type }
+        message { "unknown register type: #{@type.inspect}" }
+      end
+    end
+
+    factory do
+      convert_value do |value|
+        type, options = split_input_value(value)
+        { type: find_type(type), options: Array(options) }
+      end
+
+      def select_feature(cell)
+        if cell.empty_value?
+          target_feature
+        else
+          target_features[cell.value[:type]]
+        end
+      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..-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)
+        types = target_features.keys
+        types.find(&type.to_sym.method(:casecmp?)) || type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:register, :type, :external) do
+  register_map do
+    writable? { true }
+    readable? { true }
+    no_bit_fields
+
+    verify(:component) do
+      error_condition { register.size && register.size.length > 1 }
+      message do
+        'external register type supports single size definition only'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+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)
+      end
+
+      def index_verifiers
+        @index_verifiers ||= []
+      end
+    end
+
+    define_struct :index_entry, [:name, :value] do
+      def value_index?
+        !array_index?
+      end
+
+      def array_index?
+        value.nil?
+      end
+
+      def distinguishable?(other)
+        name == other.name && value != other.value &&
+          [self, other].all?(&:value_index?)
+      end
+
+      def find_index_field(bit_fields)
+        bit_fields.find { |bit_field| bit_field.full_name == name }
+      end
+    end
+
+    property :index_entries
+    property :collect_index_fields do |bit_fields|
+      index_entries.map { |entry| entry.find_index_field(bit_fields) }
+    end
+
+    byte_size { byte_width }
+    support_array_register
+    support_overlapped_address
+
+    input_pattern [
+      /(#{variable_name}\.#{variable_name})/,
+      /(#{variable_name}\.#{variable_name}):(#{integer})?/,
+      /(#{variable_name})/,
+      /(#{variable_name}):(#{integer})?/
+    ], match_automatically: false
+
+    build do
+      @index_entries = parse_index_entries
+    end
+
+    verify(:component) do
+      error_condition do
+        register.array? &&
+          register.array_size.length < array_index_fields.length
+      end
+      message { 'too many array indices are given' }
+    end
+
+    verify(:component) do
+      error_condition do
+        register.array? &&
+          register.array_size.length > array_index_fields.length
+      end
+      message { 'less array indices are given' }
+    end
+
+    verify(:all) do
+      check_error do
+        index_entries.each(&method(:verify_indirect_index))
+      end
+    end
+
+    verify_index do
+      error_condition do |index|
+        !index_entries.one? { |other| other.name == index.name }
+      end
+      message do |index|
+        "same bit field is used as indirect index more than once: #{index.name}"
+      end
+    end
+
+    verify_index do
+      error_condition { |index| !index_field(index) }
+      message do |index|
+        "no such bit field for indirect index is found: #{index.name}"
+      end
+    end
+
+    verify_index do
+      error_condition do |index|
+        index_field(index).register.name == register.name
+      end
+      message do |index|
+        "own bit field 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 ' \
+        "for indirect index: #{index.name}"
+      end
+    end
+
+    verify_index do
+      error_condition { |index| index_field(index).sequential? }
+      message do |index|
+        'sequential bit field is not allowed ' \
+        "for indirect index: #{index.name}"
+      end
+    end
+
+    verify_index do
+      error_condition { |index| index_field(index).reserved? }
+      message do |index|
+        'reserved bit field is not allowed ' \
+        "for indirect index: #{index.name}"
+      end
+    end
+
+    verify_index do
+      error_condition do |index|
+        !index.array_index? &&
+          (index.value > (2**index_field(index).width - 1))
+      end
+      message do |index|
+        'bit width of indirect index is not enough for ' \
+        "index value #{index.value}: #{index.name}"
+      end
+    end
+
+    verify_index do
+      error_condition do |index|
+        index.array_index? &&
+          (array_index_value(index) > 2**index_field(index).width)
+      end
+      message do |index|
+        'bit width of indirect index is not enough for ' \
+        "array size #{array_index_value(index)}: #{index.name}"
+      end
+    end
+
+    verify(:all) do
+      error_condition { !distinguishable? }
+      message { 'cannot be distinguished from other registers' }
+    end
+
+    private
+
+    def parse_index_entries
+      (!options.empty? && options.map(&method(:create_index_entry))) ||
+        (error 'no indirect indices are given')
+    end
+
+    def create_index_entry(value)
+      input_values = split_value(value)
+      if input_values.size == 2
+        index_entry.new(input_values[0], convert_index_value(input_values[1]))
+      elsif input_values.size == 1
+        index_entry.new(input_values[0])
+      else
+        error 'too many arguments for indirect index ' \
+              "are given: #{value.inspect}"
+      end
+    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..-1]]
+      else
+        error "illegal input value for indirect index: #{value.inspect}"
+      end
+    end
+
+    def sting_or_symbol?(value)
+      [String, Symbol].any?(&value.method(:is_a?))
+    end
+
+    def convert_index_value(value)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      error "cannot convert #{value.inspect} into indirect index value"
+    end
+
+    def verify_indirect_index(index)
+      helper.index_verifiers.each { |verifier| verifier.verify(self, index) }
+    end
+
+    def index_field(index)
+      @index_fields ||= {}
+      @index_fields[index.name] ||=
+        index.find_index_field(register_block.bit_fields)
+    end
+
+    def array_index_fields
+      @array_index_fields ||= index_entries.select(&:array_index?)
+    end
+
+    def array_index_value(index)
+      @array_index_values ||=
+        array_index_fields
+          .map.with_index { |entry, i| [entry.name, register.array_size[i]] }
+          .to_h
+      @array_index_values[index.name]
+    end
+
+    def distinguishable?
+      register_block
+        .registers.select { |other| share_same_range?(other) }
+        .all? { |other| distinguishable_indices?(other.index_entries) }
+    end
+
+    def share_same_range?(other)
+      register.name != other.name && register.overlap?(other)
+    end
+
+    def distinguishable_indices?(other_entries)
+      index_entries.any? do |entry|
+        other_entries.any?(&entry.method(:distinguishable?))
+      end
+    end
+  end
+end