rggen 0.4.4 → 0.5.1

data/lib/rggen/builtins/register/read_data.rb

@@ -1,6 +1,6 @@
 simple_item :register, :read_data do
   rtl do
-    available? { register.internal? }
+    available? { !register.type?(:external) }
 
     generate_code :module_item do |buffer|
       buffer  << assign(register_read_data, read_data) << nl

data/lib/rggen/builtins/register/reg_model.rb

@@ -4,9 +4,9 @@ simple_item :register, :reg_model do
 
     delegate [:byte_width] => :configuration
     delegate [:local_address_width] => :register_block
-    delegate [:name, :dimensions, :array?, :shadow?] => :register
+    delegate [:name, :dimensions, :array?, :type?] => :register
 
-    available? { register.internal? }
+    available? { !type?(:external) }
 
     build do
       variable :block_model, :reg_model,
@@ -62,7 +62,7 @@ simple_item :register, :reg_model do
 
     def offset_address
       base  = hex(register.start_address, local_address_width)
-      if !array? || shadow?
+      if !array? || type?(:indirect)
         base
       else
         "#{base} + #{byte_width} * #{loop_varibles.first}"
@@ -76,7 +76,7 @@ simple_item :register, :reg_model do
     end
 
     def unmapped
-      (shadow? && 1) || 0
+      (type?(:indirect) && 1) || 0
     end
 
     def hdl_path
@@ -97,7 +97,7 @@ simple_item :register, :reg_model do
     end
 
     def base_model
-      (register.shadow? && :rggen_ral_shadow_reg) || :rggen_ral_reg
+      (type?(:indirect) && :rggen_ral_indirect_reg) || :rggen_ral_reg
     end
 
     def body_code(code)

data/lib/rggen/builtins/register/sub_block_model.rb

@@ -2,7 +2,7 @@ simple_item :register, :sub_block_model do
   ral do
     export :model_creation
 
-    available? { register.external? }
+    available? { register.type?(:external) }
 
     build do
       parameter :block_model, :model_type,

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

@@ -0,0 +1,207 @@
+list_item :register, :type do
+  register_map do
+    item_base do
+      define_helpers do
+        def readable?(&evaluator)
+          @readability_evaluator  = evaluator
+        end
+
+        def writable?(&evaluator)
+          @writability_evaluator  = evaluator
+        end
+
+        {
+          read_write: [true , true ],
+          read_only:  [true , false],
+          write_only: [false, true ],
+          reserved:   [false, false]
+        }.each do |access_type, accessibility|
+          define_method(access_type) do
+            readable? { accessibility[0] }
+            writable? { accessibility[1] }
+          end
+        end
+
+        def need_options
+          @need_options = true
+        end
+
+        def need_options?
+          @need_options
+        end
+
+        def support_array_register(options = {})
+          @support_array_register = true
+          @array_options          = options
+        end
+
+        def support_array_register?
+          @support_array_register
+        end
+
+        def array_options
+          @array_options || {}
+        end
+
+        attr_setter :required_byte_size
+
+        [:amount_of_registers, :data_width, :any_size].each do |width_type|
+          define_method(width_type) { width_type }
+        end
+
+        def need_no_bit_fields
+          @no_bit_fields  = true
+        end
+
+        def need_no_bit_fields?
+          @no_bit_fields
+        end
+      end
+
+      attr_class_reader :writability_evaluator
+      attr_class_reader :readability_evaluator
+      class_delegator   :need_options?
+      class_delegator   :support_array_register?
+      class_delegator   :array_options
+      class_delegator   :required_byte_size
+      class_delegator   :need_no_bit_fields?
+
+      field :type
+
+      field :type? do |other|
+        other == type
+      end
+
+      field :readable? do
+        next true if readability_evaluator.nil?
+        instance_exec(&readability_evaluator)
+      end
+
+      field :writable? do
+        next true if writability_evaluator.nil?
+        instance_exec(&writability_evaluator)
+      end
+
+      field :read_only? do
+        readable? && !writable?
+      end
+
+      field :write_only? do
+        !readable? && writable?
+      end
+
+      field :reserved? do
+        !(readable? || writable?)
+      end
+
+      build do |cell|
+        @type = cell.type
+        error 'no options are specified' if need_options? && cell.options.nil?
+        register.need_no_children if need_no_bit_fields?
+      end
+
+      validate do
+        check_array_register_usage
+        check_array_demension
+        check_byte_size
+      end
+
+      def check_array_register_usage
+        return unless register.array?
+        return if support_array_register?
+        error 'array register is not allowed'
+      end
+
+      def check_array_demension
+        return unless register.array?
+        return if register.dimensions.size == 1
+        return if array_options[:support_multiple_dimensions]
+        error 'multiple dimensions array register is not allowed'
+      end
+
+      def check_byte_size
+        return if required_byte_size == :any_size
+        return if register.byte_size == required_byte_size_value
+        error "byte size(#{register.byte_size}) is not matched with " \
+              "required size(#{required_byte_size_value})"
+      end
+
+      def required_byte_size_value
+        return configuration.byte_width if required_byte_size == :data_width
+        register.count * configuration.byte_width
+      end
+    end
+
+    default_item do
+      readable? { register.bit_fields.any?(&:readable?) }
+      writable? { register.bit_fields.any?(&:writable?) }
+      support_array_register
+      build { @type = :default }
+    end
+
+    factory do
+      define_struct :cell_value, [:type, :options] do
+        def empty?
+          self.type.nil?
+        end
+      end
+
+      def select_target_item(cell)
+        @target_items.fetch(cell.value.type) do
+          next if cell.value.type == :default
+          error "unknown register type: #{cell.value.type}", cell
+        end unless cell.empty?
+      end
+
+      def convert_cell_value(cell)
+        cell.value  =
+          if cell.empty?
+            cell_value.new(nil, nil)
+          else
+            convert(cell.value)
+          end
+      end
+
+      def convert(cell)
+        [:default, *@target_items.keys].find_yield do |t|
+          case cell
+          when /\A#{t}(?::(.+))?\Z/im
+            cell_value.new(t, Regexp.last_match.captures[0])
+          end
+        end || cell_value.new(cell, nil)
+      end
+    end
+  end
+
+  c_header do
+    item_base do
+      define_helpers do
+        def address_struct_member(&body)
+          define_method(:address_struct_member, &body)
+        end
+      end
+
+      export :address_struct_member
+
+      def data_type
+        "rggen_uint#{configuration.data_width}"
+      end
+    end
+
+    default_item do
+      delegate [:name, :dimensions] => :register
+
+      address_struct_member do
+        variable_declaration(
+          name: name, data_type: data_type, dimensions: dimensions
+        )
+      end
+    end
+
+    factory do
+      def select_target_item(_, register)
+        @target_items[register.type]
+      end
+    end
+  end
+end

data/lib/rggen/builtins/register/types/external.rb

@@ -0,0 +1,15 @@
+list_item :register, :type, :external do
+  register_map do
+    read_write
+    required_byte_size any_size
+    need_no_bit_fields
+  end
+
+  c_header do
+    delegate [:name, :byte_size] => :register
+
+    address_struct_member do
+      "RGGEN_EXTERNAL_REGISTERS(#{byte_size}, #{name.upcase}) #{name}"
+    end
+  end
+end

data/lib/rggen/builtins/register/types/indirect.rb

@@ -0,0 +1,134 @@
+list_item :register, :type, :indirect do
+  register_map do
+    field :indexes
+
+    readable? { register.bit_fields.any?(&:readable?) }
+    writable? { register.bit_fields.any?(&:writable?) }
+
+    need_options
+    support_array_register support_multiple_dimensions: true
+    required_byte_size data_width
+
+    input_pattern %r{(#{variable_name})(?::(#{number}))?}
+
+    define_struct :index_entry, [:name, :value] do
+      def initialize(name, value)
+        self.name   = name
+        self.value  = value && Integer(value)
+      end
+
+      def ==(other)
+        return false unless name == other.name
+        return true if [value, other.value].any?(&:nil?)
+        value == other.value
+      end
+    end
+
+    build do |cell|
+      @indexes  = parse_indexes(cell.options.strip)
+    end
+
+    def parse_indexes(options)
+      options.split(/[,\n]/).map do |entry|
+        if pattern_match(entry)
+          index_entry.new(captures[0], captures[1])
+        else
+          error "invalid value for index: #{options.inspect}"
+        end
+      end
+    end
+
+    validate do
+      check_index_entries
+      check_number_of_array_indexes
+      check_array_index_values
+      check_fixed_value_index_values
+    end
+
+    def check_index_entries
+      indexes.each(&method(:check_index_entry))
+    end
+
+    def check_index_entry(entry)
+      [
+        :check_using_same_index_more_than_once,
+        :check_using_non_existing_index,
+        :check_using_own_bit_field_for_index,
+        :check_using_arrayed_bit_field_for_index
+      ].each do |checker|
+        send(checker, entry)
+      end
+    end
+
+    def check_using_same_index_more_than_once(entry)
+      return if indexes.one? { |index| index.name == entry.name }
+      error "not use the same index field more than once: #{entry.name}"
+    end
+
+    def check_using_non_existing_index(entry)
+      return unless index_bit_fields[entry.name].nil?
+      error "no such index field: #{entry.name}"
+    end
+
+    def check_using_own_bit_field_for_index(entry)
+      return unless register.bit_fields.find_by(name: entry.name)
+      error "not use own bit field for index field: #{entry.name}"
+    end
+
+    def check_using_arrayed_bit_field_for_index(entry)
+      return unless index_bit_fields[entry.name].register.array?
+      error "not use arrayed bit field for index field: #{entry.name}"
+    end
+
+    def check_number_of_array_indexes
+      return if array_indexes.size == size_of_dimensions
+      error "not match size of array dimensions and number of array indexes"
+    end
+
+    def check_array_index_values
+      array_indexes.each_with_index do |entry, i|
+        next if register.dimensions[i] <= (max_value(entry.name) + 1)
+        error "array size(#{register.dimensions[i]}) is greater than " \
+              "maximum value of #{entry.name}(#{max_value(entry.name)})"
+      end
+    end
+
+    def check_fixed_value_index_values
+      fixed_value_indexes.each_with_index do |entry, i|
+        next if entry.value <= max_value(entry.name)
+        error "index value(#{entry.value}) is greater thatn " \
+              "maximum value of #{entry.name}(#{max_value(entry.name)})"
+      end
+    end
+
+    def index_bit_fields
+      @index_bit_fields ||= Hash.new do |h, name|
+        h[name] = register_block.bit_fields.find_by(
+          name: name, reserved?: false
+        )
+      end
+    end
+
+    def array_indexes
+      indexes.select { |entry| entry.value.nil? }
+    end
+
+    def fixed_value_indexes
+      indexes.select { |entry| entry.value }
+    end
+
+    def size_of_dimensions
+      (register.array? && register.dimensions.size) || 0
+    end
+
+    def max_value(index_name)
+      2**index_bit_fields[index_name].width - 1
+    end
+  end
+
+  c_header do
+    address_struct_member do
+      variable_declaration(name: register.name, data_type: data_type)
+    end
+  end
+end

data/lib/rggen/builtins/register/uniqueness_validator.rb

@@ -11,16 +11,15 @@ simple_item :register, :uniqueness_validator do
     end
 
     def validate_uniqueness(previous_register)
-      case
-      when overlap_offset_address?(previous_register)
+      if overlap_offset_address?(previous_register)
         error 'offset address is not unique', error_position(:start_address)
-      when overlap_shadow_indexes?(previous_register)
-        error 'shadow indexes is not unique', error_position(:shadow_indexes)
+      elsif overlap_indirect_indexes?(previous_register)
+        error 'indirect indexes is not unique', error_position(:indexes)
       end
     end
 
     def overlap_offset_address?(previous_register)
-      return false if [previous_register, register].all?(&:shadow?)
+      return false if both_register_indirect?(previous_register)
       overlap_address_range?(register, previous_register)
     end
 
@@ -30,15 +29,19 @@ simple_item :register, :uniqueness_validator do
       lhs_range.overlap?(rhs_range)
     end
 
-    def overlap_shadow_indexes?(previous_register)
+    def overlap_indirect_indexes?(previous_register)
       return false unless overlap_address_range?(register, previous_register)
       return true  unless unique_shadw_indexes?(register, previous_register)
       return true  unless unique_shadw_indexes?(previous_register, register)
       false
     end
 
+    def both_register_indirect?(previous_register)
+      [register, previous_register].all? { |r| r.type?(:indirect) }
+    end
+
     def unique_shadw_indexes?(lhs, rhs)
-      lhs.shadow_indexes.any?(&rhs.shadow_indexes.method(:exclude?))
+      lhs.indexes.any?(&rhs.indexes.method(:exclude?))
     end
 
     def error_position(field)