rggen 0.3.0

data/lib/rggen/builder/component_store.rb

@@ -0,0 +1,42 @@
+module RgGen
+  module Builder
+    class ComponentStore
+      def initialize(builder, component_name)
+        @builder        = builder
+        @component_name = component_name
+        @entries        = []
+      end
+
+      def entry(associated_category_or_categories = nil, &body)
+        if associated_category_or_categories.nil?
+          @entries << create_new_entry(nil, body)
+        else
+          Array(associated_category_or_categories).each do |category|
+            @entries << create_new_entry(category, body)
+          end
+        end
+      end
+
+      def build_factory
+        factories = @entries.map(&:build_factory)
+        factories.each_cons(2) do |factory_pair|
+          factory_pair[0].child_factory = factory_pair[1]
+        end
+        factories.first.root_factory
+        factories.first
+      end
+
+      private
+
+      def create_new_entry(associated_category, body)
+        ComponentEntry.new.tap do |new_entry|
+          new_entry.instance_exec(&body)
+          @builder.categories.each do |name, category|
+            next if associated_category && name != associated_category
+            category.add_item_store(@component_name, new_entry.item_store)
+          end if new_entry.item_store
+        end
+      end
+    end
+  end
+end

data/lib/rggen/builder/input_component_store.rb

@@ -0,0 +1,25 @@
+module RgGen
+  module Builder
+    class InputComponentStore < ComponentStore
+      def initialize(builder, component_name)
+        super(builder, component_name)
+        @loaders  = []
+      end
+
+      attr_setter :loader_base
+
+      def define_loader(type_or_types, &body)
+        return unless loader_base
+        @loaders  << Class.new(loader_base, &body).tap do |l|
+          l.supported_types = Array(type_or_types)
+        end
+      end
+
+      def build_factory
+        super.tap do |f|
+          f.loaders = @loaders
+        end
+      end
+    end
+  end
+end

data/lib/rggen/builder/item_store.rb

@@ -0,0 +1,89 @@
+module RgGen
+  module Builder
+    class ItemStore
+      def initialize(base, factory)
+        @base                 = base
+        @factory              = factory
+        @simple_item_entries  = {}
+        @list_item_entries    = {}
+        @enabled_entries      = []
+      end
+
+      attr_reader :base
+      attr_reader :factory
+
+      def define_simple_item(context, item_name, &body)
+        create_item_entry(:simple, item_name, context, body)
+      end
+
+      def define_list_item(context, list_name, item_name = nil, &body)
+        if item_name.nil?
+          create_item_entry(:list, list_name, context, body)
+        else
+          define_list_item_class(list_name, item_name, context, body)
+        end
+      end
+
+      def enable(*args)
+        case args.size
+        when 1
+          enable_item_entries(args[0])
+        when 2
+          enable_list_item(args[0], args[1])
+        else
+          message = "wrong number of arguments (#{args.size} for 1..2)"
+          fail ArgumentError, message
+        end
+      end
+
+      def build_factories
+        @enabled_entries.each_with_object({}) do |entry_name, factories|
+          factories[entry_name] = (
+            @simple_item_entries[entry_name] || @list_item_entries[entry_name]
+          ).build_factory
+        end
+      end
+
+      private
+
+      def create_item_entry(entry_type, entry_name, context, body)
+        klass = { simple: SimpleItemEntry, list: ListItemEntry }[entry_type]
+        entry = klass.new(base, factory, context, &body)
+        update_entries(entry_type, entry_name, entry)
+      end
+
+      def update_entries(entry_type, entry_name, entry)
+        if entry_type == :simple
+          @list_item_entries.delete(entry_name)
+          @simple_item_entries[entry_name] = entry
+        else
+          @simple_item_entries.delete(entry_name)
+          @list_item_entries[entry_name]  = entry
+        end
+      end
+
+      def define_list_item_class(list_name, item_name, context, body)
+        unless @list_item_entries.key?(list_name)
+          message = "undefined list item entry: #{list_name}"
+          fail RgGen::BuilderError, message
+        end
+        entry = @list_item_entries[list_name]
+        entry.define_list_item(item_name, context, &body)
+      end
+
+      def enable_item_entries(entry_name_or_names)
+        Array(entry_name_or_names).each do |entry_name|
+          next if @enabled_entries.include?(entry_name)
+          next unless @simple_item_entries.key?(entry_name) ||
+                      @list_item_entries.key?(entry_name)
+          @enabled_entries  << entry_name
+        end
+      end
+
+      def enable_list_item(list_name, item_name_or_names)
+        return unless @list_item_entries.key?(list_name)
+        @list_item_entries[list_name].enable(item_name_or_names)
+      end
+    end
+  end
+end

data/lib/rggen/builder/list_item_entry.rb

@@ -0,0 +1,81 @@
+module RgGen
+  module Builder
+    class ListItemEntry
+      def initialize(item_base, factory_base, context, &body)
+        @item_base      = Class.new(item_base)
+        @factory        = Class.new(factory_base)
+        @items          = {}
+        @enabled_items  = []
+        unless context.nil?
+          set_context(@item_base     , context)
+          set_context(@factory       , context)
+          set_context(singleton_class, context)
+        end
+        instance_exec(&body) if block_given?
+      end
+
+      def item_base(&body)
+        @item_base.class_exec(&body) if block_given?
+        @item_base
+      end
+
+      def item_class(&body)
+        @item_class ||= Class.new(@item_base)
+        @item_class.class_exec(&body) if block_given?
+        @item_class
+      end
+
+      alias_method :default_item, :item_class
+
+      def factory(&body)
+        @factory.class_exec(&body) if block_given?
+        @factory
+      end
+
+      def define_list_item(item_name, context, &body)
+        klass = Class.new(item_base)
+        unless context.nil?
+          if item_base.private_method_defined?(:shared_context)
+            fail BuilderError, 'base class already has #shared_context'
+          end
+          set_context(klass, context)
+        end
+        klass.class_exec(&body)
+        @items[item_name] = klass
+      end
+
+      def enable(item_or_items)
+        Array(item_or_items).each do |item|
+          next unless @items.key?(item)
+          next if @enabled_items.include?(item)
+          @enabled_items  << item
+        end
+      end
+
+      def build_factory
+        @factory.new.tap do |f|
+          f.target_items  = target_items
+          f.target_item   = @item_class unless @item_class.nil?
+        end
+      end
+
+      private
+
+      def target_items
+        return nil if @enabled_items.empty?
+        @enabled_items.each_with_object({}) do |item_name, items|
+          items[item_name]  = @items[item_name]
+        end
+      end
+
+      def set_context(klass, context)
+        klass.class_exec do
+          define_method(:shared_context) do
+            context
+          end
+          private :shared_context
+        end
+      end
+    end
+  end
+end

data/lib/rggen/builder/output_component_store.rb

@@ -0,0 +1,13 @@
+module RgGen
+  module Builder
+    class OutputComponentStore < ComponentStore
+      attr_setter :output_directory
+
+      def build_factory
+        super.tap do |f|
+          f.output_directory  = @output_directory
+        end
+      end
+    end
+  end
+end

data/lib/rggen/builder/simple_item_entry.rb

@@ -0,0 +1,33 @@
+module RgGen
+  module Builder
+    class SimpleItemEntry
+      def initialize(base, factory, context, &body)
+        @item_class = define_item_class(base, context, body)
+        @factory    = factory
+      end
+
+      attr_reader :item_class
+      attr_reader :factory
+
+      def build_factory
+        @factory.new.tap do |f|
+          f.target_item = @item_class
+        end
+      end
+
+      private
+
+      def define_item_class(base, context, body)
+        klass = Class.new(base)
+        klass.class_exec do
+          define_method(:shared_context) do
+            context
+          end
+          private :shared_context
+        end unless context.nil?
+        klass.class_exec(&body) unless body.nil?
+        klass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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_creation.rb

@@ -0,0 +1,25 @@
+simple_item :bit_field, :field_model_creation do
+  ral do
+    delegate [:name, :width, :lsb, :access] => :bit_field
+
+    generate_code :field_model_creation do
+      "`rggen_ral_create_field_model(#{arguments.join(', ')})\n"
+    end
+
+    def arguments
+      [name, string(name), width, lsb, access, volatile, reset, has_reset]
+    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
+  end
+end

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

@@ -0,0 +1,9 @@
+simple_item :bit_field, :field_model_declaration do
+  ral do
+    delegate [:name] => :bit_field
+
+    generate_code :field_model_declaration do |buffer|
+      buffer << model_declaration(:rggen_ral_field, name) << semicolon << nl
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,42 @@
+simple_item :bit_field, :reference do
+  register_map do
+    field :reference, need_validation: true, forward_to: :find_reference
+    field :has_reference? do
+      @reference.not.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 do |bit_field|
+        bit_field.name == @reference
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+list_item :bit_field, :type, :reserved  do
+  register_map do
+    reserved
+  end
+
+  ral do
+    access :ro
+  end
+end

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

@@ -0,0 +1,19 @@
+list_item :bit_field, :type, :ro do
+  register_map do
+    read_only
+  end
+
+  rtl do
+    build do
+      input :value_in, name: port_name, width: width, dimensions: dimensions
+    end
+
+    generate_code :module_item do |buffer|
+      buffer << assign(value[loop_variables], value_in[loop_variables]) << nl
+    end
+
+    def port_name
+      "i_#{bit_field.name}"
+    end
+  end
+end

data/lib/rggen/builtins/bit_field/rw.erb

@@ -0,0 +1,13 @@
+rggen_bit_field_rw #(
+  .WIDTH          (<%= bit_field.width %>),
+  .INITIAL_VALUE  (<%= initial_value %>)
+) u_<%= bit_field.name %> (
+  .clk              (<%= register_block.clock %>),
+  .rst_n            (<%= register_block.reset %>),
+  .i_command_valid  (<%= register_block.host_if.command_valid %>),
+  .i_select         (<%= register_block.register_select[index] %>),
+  .i_write          (<%= register_block.host_if.write %>),
+  .i_write_data     (<%= register_block.host_if.write_data[bit_field.msb, bit_field.lsb] %>),
+  .i_write_mask     (<%= register_block.host_if.write_mask[bit_field.msb, bit_field.lsb] %>),
+  .o_value          (<%= value[loop_variables] %>)
+);

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

@@ -0,0 +1,25 @@
+list_item :bit_field, :type, :rw do
+  register_map do
+    read_write
+    need_initial_value
+  end
+
+  rtl do
+    build do
+      output :value_out, name: port_name, width: width, dimensions: dimensions
+    end
+
+    generate_code :module_item do |buffer|
+      buffer << assign(value_out[loop_variables], value[loop_variables]) << nl
+      buffer << process_template
+    end
+
+    def port_name
+      "o_#{bit_field.name}"
+    end
+
+    def initial_value
+      hex(bit_field.initial_value, bit_field.width)
+    end
+  end
+end