rggen 0.12.0 → 0.13.0

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:bit_field, :initial_value) do
-  register_map do
-    property :initial_value, default: 0
-    property :initial_value?, body: -> { !@initial_value.nil? }
-
-    build do |value|
-      @initial_value =
-        begin
-          Integer(value)
-        rescue ArgumentError, TypeError
-          error "cannot convert #{value.inspect} into initial value"
-        end
-    end
-
-    verify(:component) do
-      error_condition { settings[:require] && !initial_value? }
-      message { 'no initial value is given' }
-    end
-
-    verify(:component) do
-      error_condition { initial_value? && initial_value < min_initial_value }
-      message do
-        'input initial value is less than minimum initial value: ' \
-        "initial value #{initial_value} " \
-        "minimum initial value #{min_initial_value}"
-      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}"
-      end
-    end
-
-    verify(:component) do
-      error_condition { initial_value? && !match_valid_condition? }
-      message do
-        "does not match the valid initial value condition: #{initial_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
-    end
-
-    private
-
-    def settings
-      @settings ||=
-        (bit_field.settings && bit_field.settings[:initial_value]) || {}
-    end
-
-    def min_initial_value
-      bit_field.width == 1 ? 0 : -(2**(bit_field.width - 1))
-    end
-
-    def max_initial_value
-      2**bit_field.width - 1
-    end
-
-    def match_valid_condition?
-      !settings.key?(:valid_condition) ||
-        instance_exec(@initial_value, &settings[:valid_condition])
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:bit_field, :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 bit field name: #{value.inspect}"
-        end
-    end
-
-    verify(:feature) do
-      error_condition { !name }
-      message { 'no bit field name is given' }
-    end
-
-    verify(:feature) do
-      error_condition { duplicated_name? }
-      message { "duplicated bit field name: #{name}" }
-    end
-
-    printable :name
-
-    private
-
-    def get_full_name(separator = '.')
-      [register.name, name].join(separator)
-    end
-
-    def duplicated_name?
-      register.bit_fields.any? { |bit_field| bit_field.name == name }
-    end
-  end
-end

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

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:bit_field, :reference) do
-  register_map do
-    property :reference, forward_to: :reference_bit_field, verify: :all
-    property :reference?, body: -> { use_reference? && !no_reference? }
-    property :reference_width, forward_to: :required_width
-    property :find_reference, forward_to: :find_reference_bit_field
-
-    input_pattern /(#{variable_name})\.(#{variable_name})/
-
-    build do |value|
-      @input_reference =
-        if pattern_matched?
-          "#{match_data[1]}.#{match_data[2]}"
-        else
-          error "illegal input value for reference: #{value.inspect}"
-        end
-    end
-
-    verify(:component) do
-      error_condition { require_reference? && no_reference? }
-      message { 'no reference bit field is given' }
-    end
-
-    verify(:component) do
-      error_condition { reference? && @input_reference == bit_field.full_name }
-      message { "self reference: #{@input_reference}" }
-    end
-
-    verify(:all) do
-      error_condition { reference? && !reference_bit_field }
-      message { "no such bit field found: #{@input_reference}" }
-    end
-
-    verify(:all) do
-      error_condition do
-        reference? && !register.array? && reference_bit_field.register.array?
-      end
-      message do
-        'bit field of array register is not allowed for ' \
-        "reference bit field: #{@input_reference}"
-      end
-    end
-
-    verify(:all) do
-      error_condition { reference? && !match_array_size? }
-      message do
-        'array size is not matched: ' \
-        "own #{register.array_size} " \
-        "reference #{reference_bit_field.register.array_size}"
-      end
-    end
-
-    verify(:all) do
-      error_condition do
-        reference? && !bit_field.sequential? && reference_bit_field.sequential?
-      end
-      message do
-        'sequential bit field is not allowed for ' \
-        "reference bit field: #{@input_reference}"
-      end
-    end
-
-    verify(:all) do
-      error_condition { reference? && !match_sequence_size? }
-      message do
-        'sequence size is not matched: ' \
-        "own #{bit_field.sequence_size} " \
-        "reference #{reference_bit_field.sequence_size}"
-      end
-    end
-
-    verify(:all) do
-      error_condition { reference? && reference_bit_field.reserved? }
-      message { "refer to reserved bit field: #{@input_reference}" }
-    end
-
-    verify(:all) do
-      error_condition { reference? && !match_width? }
-      message do
-        "#{required_width} bits reference bit field is required: " \
-        "#{reference_bit_field.width} bit(s) width"
-      end
-    end
-
-    private
-
-    def settings
-      @settings ||=
-        (bit_field.settings && bit_field.settings[:reference]) || {}
-    end
-
-    def use_reference?
-      settings.fetch(:use, false)
-    end
-
-    def require_reference?
-      use_reference? && settings[:require]
-    end
-
-    def no_reference?
-      @input_reference.nil?
-    end
-
-    def reference_bit_field
-      (reference? || nil) &&
-        (@reference_bit_field ||= lookup_reference)
-    end
-
-    def find_reference_bit_field(bit_fields)
-      (reference? || nil) &&
-        bit_fields
-          .find { |bit_field| bit_field.full_name == @input_reference }
-    end
-
-    def lookup_reference
-      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
-    end
-
-    def match_sequence_size?
-      !(bit_field.sequential? && reference_bit_field.sequential?) ||
-        bit_field.sequence_size == reference_bit_field.sequence_size
-    end
-
-    def required_width
-      settings[:width] || bit_field.width
-    end
-
-    def match_width?
-      reference_bit_field.width >= required_width
-    end
-  end
-end

data/lib/rggen/built_in/bit_field/sv_rtl_top.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:bit_field, :sv_rtl_top) do
-  sv_rtl do
-    export :local_index
-    export :loop_variables
-    export :array_size
-    export :value
-
-    build do
-      interface :bit_field, :bit_field_sub_if, {
-        name: 'bit_field_sub_if',
-        interface_type: 'rggen_bit_field_if',
-        parameter_values: [bit_field.width]
-      }
-    end
-
-    main_code :register do
-      local_scope("g_#{bit_field.name}") do |scope|
-        scope.loop_size loop_size
-        scope.variables variables
-        scope.body(&method(:body_code))
-      end
-    end
-
-    pre_code :bit_field do |code|
-      code << bit_field_if_connection << nl
-    end
-
-    def local_index
-      (bit_field.sequential? || nil) &&
-        create_identifier(index_name)
-    end
-
-    def index_name
-      depth = (register.loop_variables&.size || 0) + 1
-      loop_index(depth)
-    end
-
-    def loop_variables
-      (inside_loop? || nil) &&
-        [*register.loop_variables, local_index].compact
-    end
-
-    def array_size
-      (inside_loop? || nil) &&
-        [*register.array_size, bit_field.sequence_size].compact
-    end
-
-    def value(register_offset = nil, bit_field_offset = nil, width = nil)
-      bit_field_offset ||= local_index
-      width ||= bit_field.width
-      register_block
-        .register_if[register.index(register_offset)]
-        .value[bit_field.lsb(bit_field_offset), width]
-    end
-
-    private
-
-    def inside_loop?
-      register.array? || bit_field.sequential?
-    end
-
-    def loop_size
-      (bit_field.sequential? || nil) &&
-        { index_name => bit_field.sequence_size }
-    end
-
-    def variables
-      bit_field.declarations(:bit_field, :variable)
-    end
-
-    def body_code(code)
-      bit_field.generate_code(:bit_field, :top_down, code)
-    end
-
-    def bit_field_if_connection
-      macro_call(
-        :rggen_connect_bit_field_if,
-        [
-          register.bit_field_if,
-          bit_field.bit_field_sub_if,
-          bit_field.lsb(local_index),
-          bit_field.width
-        ]
-      )
-    end
-  end
-end

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

@@ -1,245 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_list_feature(:bit_field, :type) do
-  register_map do
-    base_feature do
-      define_helpers do
-        def read_write
-          @readable = true
-          @writable = true
-        end
-
-        def read_only
-          @readable = true
-          @writable = false
-        end
-
-        def write_only
-          @readable = false
-          @writable = true
-        end
-
-        def reserved
-          @readable = false
-          @writable = false
-        end
-
-        def readable?
-          @readable.nil? || @readable
-        end
-
-        def writable?
-          @writable.nil? || @writable
-        end
-
-        def volatile
-          @volatility = -> { true }
-        end
-
-        def non_volatile
-          @volatility = -> { false }
-        end
-
-        def volatile?(&block)
-          @volatility = block
-        end
-
-        attr_reader :volatility
-
-        def settings
-          @settings ||= {}
-        end
-
-        def initial_value(**setting)
-          settings[:initial_value] = setting
-        end
-
-        def reference(**setting)
-          settings[:reference] = setting
-        end
-      end
-
-      property :type
-      property :readable?, forward_to_helper: true
-      property :writable?, forward_to_helper: true
-      property :read_only?, body: -> { readable? && !writable? }
-      property :write_only?, body: -> { writable? && !readable? }
-      property :reserved?, body: -> { !(readable? || writable?) }
-      property :volatile?, forward_to: :volatility
-      property :settings, forward_to_helper: true
-
-      build { |value| @type = value }
-
-      printable :type
-
-      private
-
-      def volatility
-        if @volatility.nil?
-          @volatility =
-            helper.volatility.nil? || instance_exec(&helper.volatility)
-        end
-        @volatility
-      end
-    end
-
-    default_feature do
-      verify(:feature) do
-        error_condition { !type }
-        message { 'no bit field type is given' }
-      end
-
-      verify(:feature) do
-        error_condition { type }
-        message { "unknown bit field type: #{type.inspect}" }
-      end
-    end
-
-    factory do
-      convert_value do |value|
-        types = target_features.keys
-        types.find(&value.to_sym.method(:casecmp?)) || value
-      end
-
-      def select_feature(cell)
-        target_features[cell.value]
-      end
-    end
-  end
-
-  sv_rtl do
-    base_feature do
-      private
-
-      def array_port_format
-        configuration.array_port_format
-      end
-
-      def full_name
-        bit_field.full_name('_')
-      end
-
-      def width
-        bit_field.width
-      end
-
-      def array_size
-        bit_field.array_size
-      end
-
-      def initial_value
-        hex(bit_field.initial_value, bit_field.width)
-      end
-
-      def mask
-        reference_bit_field ||
-          hex(2**bit_field.width - 1, bit_field.width)
-      end
-
-      def reference_bit_field
-        bit_field.reference? &&
-          bit_field
-            .find_reference(register_block.bit_fields)
-            .value(
-              register.local_index,
-              bit_field.local_index,
-              bit_field.reference_width
-            )
-      end
-
-      def bit_field_if
-        bit_field.bit_field_sub_if
-      end
-
-      def loop_variables
-        bit_field.loop_variables
-      end
-    end
-
-    factory do
-      def select_feature(_configuration, bit_field)
-        target_features[bit_field.type]
-      end
-    end
-  end
-
-  sv_ral do
-    base_feature do
-      define_helpers do
-        attr_setter :access
-
-        def model_name(name = nil, &block)
-          @model_name = name || block || @model_name
-          @model_name
-        end
-      end
-
-      export :access
-      export :model_name
-      export :constructors
-
-      build do
-        variable :register, :ral_model, {
-          name: bit_field.name,
-          data_type: model_name,
-          array_size: array_size,
-          random: true
-        }
-      end
-
-      def access
-        (helper.access || bit_field.type).to_s.upcase
-      end
-
-      def model_name
-        if helper.model_name&.is_a?(Proc)
-          instance_eval(&helper.model_name)
-        else
-          helper.model_name || :rggen_ral_field
-        end
-      end
-
-      def constructors
-        (bit_field.sequence_size&.times || [nil]).map do |index|
-          macro_call(
-            :rggen_ral_create_field_model, arguments(index)
-          )
-        end
-      end
-
-      private
-
-      def array_size
-        Array(bit_field.sequence_size)
-      end
-
-      def arguments(index)
-        [
-          ral_model[index], bit_field.lsb(index), bit_field.width,
-          access, volatile, reset_value, valid_reset
-        ]
-      end
-
-      def volatile
-        bit_field.volatile? && 1 || 0
-      end
-
-      def reset_value
-        hex(bit_field.initial_value, bit_field.width)
-      end
-
-      def valid_reset
-        bit_field.initial_value? && 1 || 0
-      end
-    end
-
-    default_feature do
-    end
-
-    factory do
-      def select_feature(_configuration, bit_field)
-        target_features[bit_field.type]
-      end
-    end
-  end
-end