rggen 0.8.2 → 0.9.0

data/lib/rggen/builtins/bit_field/bit_assignment.rb

@@ -1,39 +0,0 @@
-simple_item :bit_field, :bit_assignment do
-  register_map do
-    field :msb
-    field :lsb
-    field :width do
-      msb - lsb + 1
-    end
-
-    input_pattern %r{\[(#{number})(?::(#{number}))?\]}
-
-    build do |cell|
-      parse_bit_assignment(cell)
-      case
-      when @lsb > @msb
-        error "lsb is larger than msb: #{cell}"
-      when @msb >= configuration.data_width
-        error "exceeds the data width(#{configuration.data_width}): #{cell}"
-      when overlapped_bit_assignment?
-        error "overlapped bit assignment: #{cell}"
-      end
-    end
-
-    def parse_bit_assignment(cell)
-      if pattern_matched?
-        @msb, @lsb  = captures.compact.map(&method(:Integer))
-        @lsb ||= @msb
-      else
-        error "invalid value for bit assignment: #{cell.inspect}"
-      end
-    end
-
-    def overlapped_bit_assignment?
-      own_range = @lsb..@msb
-      register.bit_fields.any? do |bit_field|
-        own_range.overlap?(bit_field.lsb..bit_field.msb)
-      end
-    end
-  end
-end

data/lib/rggen/builtins/bit_field/field_model.rb

@@ -1,38 +0,0 @@
-simple_item :bit_field, :field_model do
-  ral do
-    export :model_creation
-
-    delegate [:name, :width, :lsb, :access, :model_name] => :bit_field
-
-    build do
-      variable :reg_model, :field_model,
-               data_type: model_name,
-               name:      name,
-               random:    true
-    end
-
-    def model_creation(code)
-      code << subroutine_call('`rggen_ral_create_field_model', arguments) << nl
-    end
-
-    def arguments
-      [name, string(name), width, lsb, access, volatile, reset, has_reset, hdl_path]
-    end
-
-    def volatile
-      0
-    end
-
-    def reset
-      hex(bit_field.initial_value || 0, width)
-    end
-
-    def has_reset
-      (bit_field.initial_value? && 1) || 0
-    end
-
-    def hdl_path
-      string(bit_field.hdl_path)
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-simple_item :bit_field, :initial_value do
-  register_map do
-    field :initial_value
-    field :initial_value? do
-      @initial_value.not_nil?
-    end
-
-    build do |cell|
-      @initial_value  = parse_initial_value(cell)
-    end
-
-    validate do
-      if initial_value? && valid_range.exclude?(@initial_value)
-        error "out of valid initial value range(#{valid_range}):" \
-              " #{@initial_value}"
-      end
-    end
-
-    def parse_initial_value(cell)
-      return if empty?(cell)
-      Integer(cell)
-    rescue
-      error "invalid value for initial value: #{cell.inspect}"
-    end
-
-    def empty?(cell)
-      cell.to_s.strip.empty?
-    end
-
-    def valid_range
-      min_value = -1 * (2**bit_field.width) / 2
-      max_value = 2**bit_field.width - 1
-      (min_value..max_value)
-    end
-  end
-end

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

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

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

@@ -1,40 +0,0 @@
-simple_item :bit_field, :reference do
-  register_map do
-    field :reference, need_validation: true, forward_to: :find_reference
-    field :has_reference? do
-      !(@reference.nil? || @reference.empty?)
-    end
-
-    build do |cell|
-      @reference  = cell.to_s
-    end
-
-    validate do
-      case
-      when @reference == bit_field.name
-        error "self reference: #{@reference}"
-      when not_find_reference?
-        error "no such reference bit field: #{@reference}"
-      when refer_reserved_bit_field?
-        error "reserved bit field is refered: #{@reference}"
-      end
-    end
-
-    def not_find_reference?
-      return false unless has_reference?
-      find_reference.nil?
-    end
-
-    def refer_reserved_bit_field?
-      return false unless has_reference?
-      find_reference.reserved?
-    end
-
-    private
-
-    def find_reference
-      return nil unless has_reference?
-      @found_reference ||= register_block.bit_fields.find_by(name: @reference)
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-simple_item :bit_field, :rtl_top do
-  rtl do
-    generate_code :register do
-      local_scope "g_#{bit_field.name}" do |s|
-        s.signals bit_field.signal_declarations(:bit_field)
-        s.without_generate_keyword
-        s.body { |c| bit_field.generate_code(:bit_field, :top_down, c) }
-      end
-    end
-  end
-end

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

@@ -1,244 +0,0 @@
-list_item :bit_field, :type do
-  register_map do
-    item_base 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 read_only?
-          readable? && !writable?
-        end
-
-        def write_only?
-          writable? && !readable?
-        end
-
-        def reserved?
-          !(readable? || writable?)
-        end
-
-        attr_setter :required_width
-
-        def full_width
-          :full_width
-        end
-
-        def need_initial_value
-          @need_initial_value = true
-        end
-
-        def need_initial_value?
-          @need_initial_value || false
-        end
-
-        def use_reference(options = {})
-          @use_reference      = true
-          @reference_options  = options
-        end
-
-        attr_reader :reference_options
-
-        def use_reference?
-          @use_reference || false
-        end
-
-        def same_width
-          :same_width
-        end
-      end
-
-      field :type
-      field :readable?  , forward_to_helper: true
-      field :writable?  , forward_to_helper: true
-      field :read_only? , forward_to_helper: true
-      field :write_only?, forward_to_helper: true
-      field :reserved?  , forward_to_helper: true
-
-      class_delegator :full_width
-      class_delegator :need_initial_value?
-      class_delegator :use_reference?
-      class_delegator :reference_options
-      class_delegator :same_width
-
-      build do |cell|
-        @type = cell
-      end
-
-      validate do
-        case
-        when width_mismatch?
-          error "#{required_width} bit(s) width required:" \
-                " #{bit_field.width} bit(s)"
-        when need_initial_value? && no_initial_value?
-          error 'no initial value'
-        when required_refercne_not_exist?
-          error 'reference bit field required'
-        when reference_width_mismatch?
-          error "#{required_reference_width} bit(s) reference bit field" \
-                " required: #{bit_field.reference.width}"
-        end
-      end
-
-      def width_mismatch?
-        return false if required_width.nil?
-        if required_width.respond_to?(:include?)
-          required_width.not.include?(bit_field.width)
-        else
-          bit_field.width != required_width
-        end
-      end
-
-      def required_width
-        width = self.class.required_width
-        return nil if width.nil?
-        return configuration.data_width if width == full_width
-        width
-      end
-
-      def no_initial_value?
-        !bit_field.initial_value?
-      end
-
-      def required_refercne_not_exist?
-        return false unless use_reference?
-        return false unless reference_options[:required]
-        return false if bit_field.has_reference?
-        true
-      end
-
-      def reference_width_mismatch?
-        return false unless use_reference?
-        return false unless bit_field.has_reference?
-        bit_field.reference.width != required_reference_width
-      end
-
-      def required_reference_width
-        return 1 unless reference_options[:width]
-        return bit_field.width if reference_options[:width] == same_width
-        reference_options[:width]
-      end
-    end
-
-    factory do
-      def select_target_item(cell)
-        @target_items.fetch(cell.value) do
-          error "unknown bit field type: #{cell.value}", cell
-        end
-      end
-
-      def convert(cell)
-        @target_items.keys.find(proc { cell }) do |type|
-          type.to_sym.casecmp(cell.to_sym).zero?
-        end
-      end
-    end
-  end
-
-  rtl do
-    item_base do
-      export :value
-
-      delegate [
-        :name, :width, :msb, :lsb, :type, :reserved?
-      ] => :bit_field
-      delegate [
-        :dimensions, :index, :local_index, :loop_variables
-      ] => :register
-      delegate [
-        :array_port_format
-      ] => :configuration
-
-      build do
-        interface :bit_field, :bit_field_sub_if,
-                  type:       :rggen_bit_field_if,
-                  name:       :bit_field_sub_if,
-                  parameters: [width]
-      end
-
-      generate_pre_code :bit_field do |c|
-        c << subroutine_call(:'`rggen_connect_bit_field_if', [
-          register.bit_field_if, bit_field_sub_if, msb, lsb
-        ]) << nl
-      end
-
-      def value
-        register.register_if.value[msb, lsb]
-      end
-    end
-
-    default_item do
-    end
-
-    factory do
-      def select_target_item(_, bit_field)
-        @target_items[bit_field.type]
-      end
-    end
-  end
-
-  ral do
-    item_base do
-      export :access
-      export :model_name
-      export :hdl_path
-
-      define_helpers do
-        attr_setter :access
-
-        def model_name(&body)
-          define_method(:model_name, &body)
-        end
-
-        def hdl_path(&body)
-          define_method(:hdl_path, &body)
-        end
-      end
-
-      def access
-        string((self.class.access || bit_field.type).to_s.upcase)
-      end
-
-      def model_name
-        :rggen_ral_field
-      end
-
-      def hdl_path
-        "g_#{bit_field.name}.u_bit_field.value"
-      end
-    end
-
-    default_item do
-    end
-
-    factory do
-      def select_target_item(_, bit_field)
-        @target_items[bit_field.type]
-      end
-    end
-  end
-end

data/lib/rggen/builtins/bit_field/types/reserved.erb

@@ -1,6 +0,0 @@
-rggen_bit_field_ro #(
-  .WIDTH  (<%= width %>)
-) u_bit_field (
-  .bit_field_if (<%= bit_field_sub_if %>),
-  .i_value      (<%= default_value %>)
-);