rggen 0.8.2 → 0.9.0

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

@@ -1,17 +0,0 @@
-simple_item :register, :constructor do
-  ral do
-    generate_code :reg_model_item do
-      function_definition :new do |f|
-        f.arguments [
-          argument(:name, data_type: :string, default: string(register.name))
-        ]
-        f.body { "super.new(name, #{bits}, 0);" }
-      end
-    end
-
-    def bits
-      max_msb = register.bit_fields.map(&:msb).max
-      ((max_msb + 8) / 8) * 8
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-simple_item :register, :field_model_creator do
-  ral do
-    generate_code :reg_model_item do
-      function_definition :create_fields do |f|
-        f.return_type :void
-        f.body { |code| body_code(code) }
-      end
-    end
-
-    def body_code(code)
-      register.bit_fields.each { |b| b.model_creation(code) }
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-simple_item :register, :indirect_index_configurator do
-  ral do
-    available? { register.type?(:indirect) }
-
-    generate_code :reg_model_item do
-      function_definition :configure_indirect_indexes do |f|
-        f.return_type :void
-        f.body { |code| function_body(code) }
-      end
-    end
-
-    def function_body(code)
-      register.indexes.each do |index|
-        code << subroutine_call(:set_indirect_index, arguments(index))
-        code << semicolon
-        code << nl
-      end
-    end
-
-    def arguments(indirect_index)
-      [
-        parent_name(indirect_index),
-        index_name(indirect_index),
-        index_value(indirect_index)
-      ]
-    end
-
-    def parent_name(indirect_index)
-      parent_register = fild_parent_register(indirect_index.name)
-      string(parent_register.name)
-    end
-
-    def fild_parent_register(index_name)
-      register_block.bit_fields.find_by(name: index_name).register
-    end
-
-    def index_name(indirect_index)
-      string(indirect_index.name)
-    end
-
-    def index_value(indirect_index)
-      if indirect_index.value
-        indirect_index.value
-      else
-        "indexes[#{array_index}]"
-      end
-    end
-
-    def array_index
-      @array_index  ||= -1
-      @array_index  += 1
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-simple_item :register, :name do
-  register_map do
-    field :name
-
-    input_pattern %r{(#{variable_name})}
-
-    build do |cell|
-      @name = parse_name(cell)
-      error "repeated register name: #{@name}" if repeated_name?
-    end
-
-    def parse_name(cell)
-      if pattern_matched?
-        captures.first
-      else
-        error "invalid value for register name: #{cell.inspect}"
-      end
-    end
-
-    def repeated_name?
-      register_block.registers.any? do |register|
-        @name == register.name
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-simple_item :register, :offset_address do
-  register_map do
-    field :start_address
-    field :end_address
-    field :byte_size do
-      end_address - start_address + 1
-    end
-    field :single? do
-      byte_size == configuration.byte_width
-    end
-    field :multiple? do
-      byte_size > configuration.byte_width
-    end
-
-    input_pattern %r{(#{number})(?:-(#{number}))?}
-
-    build do |cell|
-      @start_address, @end_address  = parse_address(cell)
-      check_start_end_adderss_relation(cell)
-      check_address_align(cell)
-      check_address_range(cell)
-    end
-
-    def parse_address(cell)
-      if pattern_matched?
-        addresses = captures.compact.map(&method(:Integer))
-        if addresses.size == 2
-          addresses
-        else
-          [addresses[0], addresses[0] + configuration.byte_width - 1]
-        end
-      else
-        error "invalid value for offset address: #{cell.inspect}"
-      end
-    end
-
-    def check_start_end_adderss_relation(cell)
-      return if start_address < end_address
-      return if [configuration.byte_width, byte_size].all? { |v| v == 1 }
-      error "start address is equal to or greater than end address: #{cell}"
-    end
-
-    def check_address_align(cell)
-      return if [start_address, end_address + 1].all? do |a|
-        a.multiple?(configuration.byte_width)
-      end
-      error 'not aligned with data width' \
-            "(#{configuration.data_width}): #{cell}"
-    end
-
-    def check_address_range(cell)
-      return if end_address <= max_address
-      error 'exceeds the maximum offset address' \
-            "(0x#{max_address.to_s(16)}): #{cell}"
-    end
-
-    def max_address
-      register_block.byte_size - 1
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-simple_item :register, :reg_model do
-  ral do
-    export :model_creation
-
-    delegate [:byte_width] => :configuration
-    delegate [:local_address_width] => :register_block
-    delegate [:name, :dimensions, :array?, :type?] => :register
-
-    available? { !type?(:external) }
-
-    build do
-      variable :block_model, :reg_model,
-               data_type:  model_name,
-               name:       name,
-               dimensions: dimensions,
-               random:     true
-    end
-
-    generate_code :package_item do
-      class_definition model_name do |c|
-        c.base      base_model
-        c.variables register.variable_declarations(:reg_model)
-        c.body { |code| body_code(code) }
-      end
-    end
-
-    def model_creation(code)
-      foreach_header(code) if array?
-      code << subroutine_call('`rggen_ral_create_reg_model', arguments) << nl
-      foreach_footer(code) if array?
-    end
-
-    def foreach_header(code)
-      code << "foreach (#{name}[#{loop_varibles.join(', ')}]) begin" << nl
-      code.indent += 2
-    end
-
-    def foreach_footer(code)
-      code.indent -= 2
-      code << :end << nl
-    end
-
-    def arguments
-      [handle, instance_name, array_index, offset_address, rights, unmapped, hdl_path]
-    end
-
-    def handle
-      create_identifier(name)[loop_varibles]
-    end
-
-    def instance_name
-      return string(name) unless array?
-      subroutine_call '$sformatf', [
-        string(name + '[%0d]' * loop_varibles.size),
-        *loop_varibles
-      ]
-    end
-
-    def array_index
-      array((array? && loop_varibles) || [])
-    end
-
-    def offset_address
-      base  = hex(register.start_address, local_address_width)
-      if !array? || type?(:indirect)
-        base
-      else
-        "#{base} + #{byte_width} * #{loop_varibles.first}"
-      end
-    end
-
-    def rights
-      return string(:RO) if register.read_only?
-      return string(:WO) if register.write_only?
-      string(:RW)
-    end
-
-    def unmapped
-      (type?(:indirect) && 1) || 0
-    end
-
-    def hdl_path
-      return string("g_#{name}") unless array?
-      subroutine_call '$sformatf', [
-        string("g_#{name}" + '.g[%0d]' * loop_varibles.size),
-        *loop_varibles
-      ]
-    end
-
-    def loop_varibles
-      return nil unless array?
-      @loop_varibles ||= Array.new(dimensions.size, &method(:loop_index))
-    end
-
-    def model_name
-      "#{name}_reg_model"
-    end
-
-    def base_model
-      (type?(:indirect) && :rggen_ral_indirect_reg) || :rggen_ral_reg
-    end
-
-    def body_code(code)
-      register.generate_code(:reg_model_item, :top_down, code)
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-simple_item :register, :rtl_top do
-  rtl do
-    export :index
-    export :local_index
-    export :loop_variables
-    export :loop_variable
-
-    delegate [:array?, :dimensions] => :register
-
-    generate_code :register_block do
-      local_scope "g_#{register.name}" do |s|
-        s.signals register.signal_declarations(:register)
-        s.loops loops
-        s.body { |c| register.generate_code(:register, :top_down, c) }
-      end
-    end
-
-    def index
-      return base_index unless array?
-      "#{base_index}+#{local_index}"
-    end
-
-    def local_index
-      return nil unless array?
-      local_index_terms(0).join('+')
-    end
-
-    def loop_variables
-      return nil unless array?
-      Array.new(dimensions.size, &method(:loop_variable))
-    end
-
-    def loop_variable(level)
-      return nil unless array?
-      return nil if level >= dimensions.size
-      @loop_variables ||= Hash.new do |h, l|
-        h[l]  = create_identifier("g_#{loop_index(l)}")
-      end
-      @loop_variables[level]
-    end
-
-    private
-
-    def base_index
-      former_registers.sum(0, &:count)
-    end
-
-    def former_registers
-      register_block.registers.take_while { |r| !register.equal?(r) }
-    end
-
-    def local_index_terms(level)
-      if level < (dimensions.size - 1)
-        partial_count = dimensions[(level + 1)..-1].inject(&:*)
-        local_index_terms(level + 1).unshift(
-          [partial_count, :'*', loop_variable(level)].join
-        )
-      else
-        [loop_variable(level)]
-      end
-    end
-
-    def loops
-      return nil unless array?
-      Hash[*loop_variables.zip(dimensions).flatten]
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-simple_item :register, :sub_block_model do
-  ral do
-    export :model_creation
-
-    available? { register.type?(:external) }
-
-    build do
-      parameter :block_model, :model_type,
-                data_type: :type,
-                name:      type_name,
-                default:   :rggen_ral_block
-      variable  :block_model, :sub_block_model,
-                data_type: type_name,
-                name:      register.name,
-                random:    true
-    end
-
-    def type_name
-      register.name.upcase
-    end
-
-    def model_creation(code)
-      code << subroutine_call('`rggen_ral_create_block_model', arguments) << nl
-    end
-
-    def arguments
-      [register.name, string(register.name), offset_addess]
-    end
-
-    def offset_addess
-      hex(register.start_address, register_block.local_address_width)
-    end
-  end
-end

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

@@ -1,283 +0,0 @@
-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?
-          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
-
-  rtl do
-    item_base do
-      export :register_if
-
-      delegate [:data_width, :byte_width] => :configuration
-      delegate [:local_address_width] => :register_block
-      delegate [:loop_variables, :local_index, :dimensions] => :register
-
-      build do
-        interface :register, :bit_field_if,
-                  type:       :rggen_bit_field_if,
-                  name:       :bit_field_if,
-                  parameters: [data_width] if total_bit_fields > 0
-      end
-
-      def register_if
-        register_block.register_if[register.index]
-      end
-
-      private
-
-      def total_bit_fields
-        register.bit_fields.size
-      end
-
-      def address_range
-        @address_range ||=
-          if register.array?
-            register.start_address..(register.start_address + byte_width - 1)
-          else
-            register.start_address..register.end_address
-          end
-      end
-
-      def start_address
-        address_code(register.start_address)
-      end
-
-      def end_address
-        address_code(address_range.last)
-      end
-
-      def address_code(address)
-        base  = hex(address, local_address_width)
-        if register.array? && register.multiple?
-          increment_value = hex(byte_width, local_address_width)
-          "#{base} + #{increment_value} * #{local_index}"
-        else
-          base
-        end
-      end
-
-      def valid_bits
-        hex(valid_bits_value, data_width)
-      end
-
-      def valid_bits_value
-        register.bit_fields.inject(0) do |bits, bit_field|
-          bits | (((1 << bit_field.width) - 1) << bit_field.lsb)
-        end
-      end
-    end
-
-    default_item do
-      generate_code :register do
-        process_template File.join(__dir__, 'types', 'default.erb')
-      end
-    end
-
-    factory do
-      def select_target_item(_, register)
-        @target_items[register.type]
-      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