rggen 0.12.0 → 0.13.0

data/lib/rggen/built_in/global/array_port_format.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:global, :array_port_format) do
-  configuration do
-    property :array_port_format, default: :packed
-
-    input_pattern /(packed|unpacked|serialized)/i
-    ignore_empty_value false
-
-    build do |value|
-      @array_port_format =
-        if pattern_matched?
-          match_data[1].downcase.to_sym
-        else
-          error "illegal input value for array port format: #{value.inspect}"
-        end
-    end
-  end
-end

data/lib/rggen/built_in/global/bus_width.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:global, :bus_width) do
-  configuration do
-    property :bus_width, default: 32
-    property :byte_width, body: -> { bus_width / 8 }
-
-    build do |value|
-      @bus_width =
-        begin
-          Integer(value)
-        rescue ArgumentError, TypeError
-          error "cannot convert #{value.inspect} into bus width"
-        end
-    end
-
-    verify(:feature) do
-      error_condition { bus_width < 8 }
-      message { "input bus width is less than 8: #{bus_width}" }
-    end
-
-    verify(:feature) do
-      error_condition { !power_of_2?(bus_width) }
-      message { "input bus width is not power of 2: #{bus_width}" }
-    end
-
-    printable :bus_width
-
-    private
-
-    def power_of_2?(value)
-      value.positive? && (value & value.pred).zero?
-    end
-  end
-end

data/lib/rggen/built_in/global/fold_sv_interface_port.rb

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

data/lib/rggen/built_in/register/markdown.erb

@@ -1,11 +0,0 @@
-
-### <%= anchor(anchor_id) %><%= register.name %>
-
-<% register.printables.each do |name, printable| %>
-* <%= name %>
-    * <%= printable || 'NA' %>
-<% end %>
-<% if register.bit_fields? %>
-
-<%= bit_field_table %>
-<% end%>

data/lib/rggen/built_in/register/markdown.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:register, :markdown) do
-  markdown do
-    export def anchor_id
-      [register_block.anchor_id, register.name].join('-')
-    end
-
-    main_code :markdown, from_template: true
-
-    private
-
-    def bit_field_table
-      column_names = bit_field_printables.first.keys
-      rows =
-        bit_field_printables
-          .map(&:values)
-          .map { |row| row.map { |cell| Array(cell).join("\n") } }
-      table(column_names, rows)
-    end
-
-    def bit_field_printables
-      @bit_field_printables ||= register.bit_fields.map(&:printables)
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# 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/built_in/register/offset_address.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:register, :offset_address) do
-  register_map do
-    property :offset_address
-    property :address_range, body: -> { 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/built_in/register/size.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:register, :size) do
-  register_map do
-    property :size
-    property :width, body: -> { @width ||= calc_width }
-    property :byte_width, body: -> { width / 8 }
-    property :byte_size, body: -> { @byte_size ||= calc_byte_size }
-    property :array?, forward_to: :array_register?
-    property :array_size, forward_to: :array_registers
-    property :count, body: -> { @count ||= 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/built_in/register/sv_rtl_top.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-RgGen.define_simple_feature(:register, :sv_rtl_top) do
-  sv_rtl do
-    export :index
-    export :local_index
-    export :loop_variables
-
-    pre_build do
-      @base_index =
-        register_block.registers.map(&:count).inject(0, :+)
-    end
-
-    build do
-      if register.bit_fields?
-        interface :register, :bit_field_if, {
-          name: 'bit_field_if',
-          interface_type: 'rggen_bit_field_if',
-          parameter_values: [register.width]
-        }
-      end
-    end
-
-    main_code :register_block do
-      local_scope("g_#{register.name}") do |scope|
-        scope.top_scope
-        scope.loop_size loop_size
-        scope.variables variables
-        scope.body(&method(:body_code))
-      end
-    end
-
-    def index(offset = nil)
-      operands =
-        register.array? ? [@base_index, offset || local_index] : [@base_index]
-      if operands.all? { |operand| operand.is_a?(Integer) }
-        operands.inject(:+)
-      else
-        operands.join('+')
-      end
-    end
-
-    def local_index
-      (register.array? || nil) &&
-        loop_variables
-          .zip(local_index_coefficients)
-          .map { |v, c| [c, v].compact.join('*') }
-          .join('+')
-    end
-
-    def loop_variables
-      (register.array? || nil) &&
-        register.array_size.map.with_index(1) do |_size, i|
-          create_identifier(loop_index(i))
-        end
-    end
-
-    private
-
-    def local_index_coefficients
-      coefficients = []
-      register.array_size.reverse.inject(1) do |total, size|
-        coefficients.unshift(coefficients.size.zero? ? nil : total)
-        total * size
-      end
-      coefficients
-    end
-
-    def loop_size
-      (register.array? || nil) &&
-        loop_variables.zip(register.array_size).to_h
-    end
-
-    def variables
-      register.declarations(:register, :variable)
-    end
-
-    def body_code(code)
-      register.generate_code(:register, :top_down, code)
-    end
-  end
-end

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

@@ -1,344 +0,0 @@
-# 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, body: -> { @type || :default }
-      property :match_type?, body: ->(register) { register.type == type }
-      property :writable?, forward_to: :writability
-      property :readable?, forward_to: :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
-        if @writability.nil?
-          block = helper.writability || default_writability
-          @writability = instance_exec(&block)
-        end
-        @writability
-      end
-
-      def default_writability
-        -> { register.bit_fields.any?(&:writable?) }
-      end
-
-      def readability
-        if @readability.nil?
-          block = helper.readability || default_readability
-          @readability = instance_exec(&block)
-        end
-        @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
-
-  sv_rtl do
-    base_feature do
-      private
-
-      def readable
-        register.readable? && 1 || 0
-      end
-
-      def writable
-        register.writable? && 1 || 0
-      end
-
-      def bus_width
-        configuration.bus_width
-      end
-
-      def address_width
-        register_block.local_address_width
-      end
-
-      def offset_address
-        hex(register.offset_address, address_width)
-      end
-
-      def width
-        register.width
-      end
-
-      def valid_bits
-        bits = register.bit_fields.map(&:bit_map).inject(:|)
-        hex(bits, register.width)
-      end
-
-      def register_index
-        register.local_index || 0
-      end
-
-      def register_if
-        register_block.register_if[register.index]
-      end
-
-      def bit_field_if
-        register.bit_field_if
-      end
-    end
-
-    default_feature do
-      template_path = File.join(__dir__, 'type', 'default_sv_rtl.erb')
-      main_code :register, from_template: template_path
-    end
-
-    factory do
-      def select_feature(_configuration, register)
-        target_features[register.type]
-      end
-    end
-  end
-
-  sv_ral do
-    base_feature do
-      define_helpers do
-        def model_name(&body)
-          @model_name = body if block_given?
-          @model_name
-        end
-
-        def offset_address(&body)
-          @offset_address = body if block_given?
-          @offset_address
-        end
-
-        def unmapped
-          @unmapped = true
-        end
-
-        def unmapped?
-          !@unmapped.nil?
-        end
-
-        def constructor(&body)
-          @constructor = body if block_given?
-          @constructor
-        end
-      end
-
-      export :constructors
-
-      build do
-        variable :register_block, :ral_model, {
-          name: register.name,
-          data_type: model_name,
-          array_size: register.array_size,
-          random: true
-        }
-      end
-
-      def constructors
-        (array_index_list || [nil]).map.with_index do |array_index, i|
-          constructor_code(array_index, i)
-        end
-      end
-
-      private
-
-      def model_name
-        if helper.model_name
-          instance_eval(&helper.model_name)
-        else
-          "#{register.name}_reg_model"
-        end
-      end
-
-      def array_index_list
-        (register.array? || nil) &&
-          begin
-            index_table = register.array_size.map { |size| (0...size).to_a }
-            index_table[0].product(*index_table[1..-1])
-          end
-      end
-
-      def constructor_code(array_index, index)
-        if helper.constructor
-          instance_exec(array_index, index, &helper.constructor)
-        else
-          macro_call(
-            :rggen_ral_create_reg_model, arguments(array_index, index)
-          )
-        end
-      end
-
-      def arguments(array_index, index)
-        [
-          ral_model[array_index], array(array_index), offset_address(index),
-          access_rights, unmapped, hdl_path(array_index)
-        ]
-      end
-
-      def offset_address(index = 0)
-        address =
-          if helper.offset_address
-            instance_exec(index, &helper.offset_address)
-          else
-            register.offset_address + register.byte_width * index
-          end
-        hex(address, register_block.local_address_width)
-      end
-
-      def access_rights
-        if register.writable? && register.readable?
-          'RW'
-        elsif register.writable?
-          'WO'
-        else
-          'RO'
-        end
-      end
-
-      def unmapped
-        helper.unmapped? && 1 || 0
-      end
-
-      def hdl_path(array_index)
-        [
-          "g_#{register.name}",
-          *Array(array_index).map { |i| "g[#{i}]" },
-          'u_register'
-        ].join('.')
-      end
-
-      def variables
-        register.declarations(:register, :variable)
-      end
-
-      def field_model_constructors
-        register.bit_fields.flat_map(&:constructors)
-      end
-    end
-
-    default_feature do
-      main_code :ral_package do
-        class_definition(model_name) do |sv_class|
-          sv_class.base 'rggen_ral_reg'
-          sv_class.variables variables
-          sv_class.body { model_body }
-        end
-      end
-
-      private
-
-      def model_body
-        process_template(File.join(__dir__, 'type', 'default_sv_ral.erb'))
-      end
-    end
-
-    factory do
-      def select_feature(_configuration, register)
-        target_features[register.type]
-      end
-    end
-  end
-end