rggen 0.3.0

data/lib/rggen/output_base/code_block.rb

@@ -0,0 +1,72 @@
+module RgGen
+  module OutputBase
+    class CodeBlock
+      def initialize
+        @lines  = []
+        @indent = 0
+        add_newline
+      end
+
+      attr_reader :indent
+
+      def indent=(value)
+        @indent             = value
+        @lines.last.indent  = @indent
+      end
+
+      def <<(other)
+        case other
+        when CodeBlock
+          merge_code_block(other)
+        when /\n/
+          add_multiple_lines_string(other)
+        when :newline
+          add_newline
+        else
+          @lines.last << other
+        end
+        self
+      end
+
+      def last_line_empty?
+        lines.empty? || lines.last.empty?
+      end
+
+      def to_s
+        @lines.map(&:to_s).each(&:rstrip!).join("\n")
+      end
+
+      private
+
+      def add_newline
+        line        = Line.new
+        line.indent = @indent
+        @lines << line
+      end
+
+      def merge_code_block(other_block)
+        other_block.lines.each_with_index do |line, i|
+          line.indent += @indent
+          if i == 0
+            @lines.last.indent  = line.indent if last_line_empty?
+            @lines.last.words.concat(line.words)
+          else
+            @lines << line
+          end
+        end
+        @lines.last.indent  = @indent if other_block.last_line_empty?
+      end
+
+      def add_multiple_lines_string(other_string)
+        other_string.each_line.with_index do |line, i|
+          add_newline if i > 0
+          @lines.last << line
+        end
+        add_newline if other_string.end_with?("\n")
+      end
+
+      attr_reader :lines
+      protected :lines
+    end
+  end
+end

data/lib/rggen/output_base/code_utility.rb

@@ -0,0 +1,44 @@
+module RgGen
+  module OutputBase
+    module CodeUtility
+      private
+
+      def newline
+        :newline
+      end
+
+      alias_method :nl, :newline
+
+      def comma
+        ','
+      end
+
+      def semicolon
+        ';'
+      end
+
+      def space(size = 1)
+        ' ' * size
+      end
+
+      def code_block(indent_size = 0, &block)
+        CodeBlock.new.tap do |code|
+          code.indent = indent_size
+          block.call(code) if block_given?
+        end
+      end
+
+      def indent(code_block, indent_size, &indent_block)
+        code_block << nl unless code_block.last_line_empty?
+        code_block.indent += indent_size
+        indent_block.call if block_given?
+        code_block << nl unless code_block.last_line_empty?
+        code_block.indent -= indent_size
+      end
+
+      def loop_index(level)
+        level.times.with_object('i') { |_, index| index.next! }
+      end
+    end
+  end
+end

data/lib/rggen/output_base/component.rb

@@ -0,0 +1,88 @@
+module RgGen
+  module OutputBase
+    class Component < Base::Component
+      include Base::HierarchicalAccessors
+
+      def initialize(parent, configuration, register_map)
+        super(parent)
+        define_hierarchical_accessors
+        @configuration  = configuration
+        @register_map   = register_map
+        def_delegators(:@register_map, *@register_map.fields)
+      end
+
+      attr_reader :configuration
+      attr_writer :output_directory
+
+      def add_item(item)
+        super(item)
+        def_object_delegators(@items.last, *item.exported_methods)
+      end
+
+      def build
+        items.each(&:build)
+        children.each(&:build)
+      end
+
+      def generate_code(kind, mode, buffer = nil)
+        buffer  ||= CodeBlock.new
+        generate_pre_code(kind, buffer)
+        generate_main_code(kind, mode, buffer)
+        generate_post_code(kind, buffer)
+        buffer
+      end
+
+      def write_file(root_directory)
+        directory = output_directory(root_directory)
+        FileUtils.mkpath(directory) unless Dir.exist?(directory)
+        items.each do |item|
+          item.write_file(directory)
+        end
+        children.each do |child|
+          child.write_file(directory)
+        end
+      end
+
+      private
+
+      def generate_pre_code(kind, buffer)
+        items.each do |item|
+          item.generate_pre_code(kind, buffer)
+        end
+      end
+
+      def generate_main_code(kind, mode, buffer)
+        case mode
+        when :top_down
+          generate_item_code(kind, buffer)
+          generate_child_code(kind, mode, buffer)
+        when :bottom_up
+          generate_child_code(kind, mode, buffer)
+          generate_item_code(kind, buffer)
+        end
+      end
+
+      def generate_child_code(kind, mode, buffer)
+        children.each do |child|
+          child.generate_code(kind, mode, buffer)
+        end
+      end
+
+      def generate_item_code(kind, buffer)
+        items.each do |item|
+          item.generate_code(kind, buffer)
+        end
+      end
+
+      def generate_post_code(kind, buffer)
+        items.reverse_each do |item|
+          item.generate_post_code(kind, buffer)
+        end
+      end
+
+      def output_directory(root_directory)
+        File.join([root_directory, @output_directory.to_s].reject(&:empty?))
+      end
+    end
+  end
+end

data/lib/rggen/output_base/component_factory.rb

@@ -0,0 +1,32 @@
+module RgGen
+  module OutputBase
+    class ComponentFactory < Base::ComponentFactory
+      attr_writer :output_directory
+
+      def create(*args)
+        component = super(*args)
+        if @root_factory
+          component.build
+          component.output_directory  = @output_directory
+        end
+        component
+      end
+
+      def create_component(parent, configuration, register_map)
+        @target_component.new(parent, configuration, register_map)
+      end
+
+      def create_items(generator, configuration, soruce)
+        @item_factories.each_value do |item_factory|
+          create_item(item_factory, generator, configuration, soruce)
+        end
+      end
+
+      def create_children(generator, configuration, source)
+        source.children.each do |child_source|
+          create_child(generator, configuration, child_source)
+        end
+      end
+    end
+  end
+end

data/lib/rggen/output_base/item.rb

@@ -0,0 +1,175 @@
+module RgGen
+  module OutputBase
+    class Item < Base::Item
+      include Base::HierarchicalItemAccessors
+      include CodeUtility
+      include TemplateUtility
+
+      class CodeGenerator
+        def []=(kind, body)
+          @bodies ||= {}
+          @bodies[kind] = body
+        end
+
+        def generate_code(item, kind, buffer)
+          return unless @bodies && @bodies.key?(kind)
+          if @bodies[kind].arity.zero?
+            buffer << item.instance_exec(&@bodies[kind])
+          else
+            item.instance_exec(buffer, &@bodies[kind])
+          end
+        end
+
+        def copy
+          CodeGenerator.new.tap do |g|
+            g.instance_variable_set(:@bodies, Hash[@bodies]) if @bodies
+          end
+        end
+      end
+
+      class FileWriter
+        def initialize(name_pattern, body)
+          @name_pattern = BabyErubis::Text.new.from_str(name_pattern)
+          @body         = body
+        end
+
+        def write_file(item, outptu_directory)
+          code  = generate_code(item)
+          path  = file_path(item, outptu_directory)
+          File.write(path, code, nil, binmode: true)
+        end
+
+        private
+
+        def generate_code(item)
+          code  = CodeBlock.new.tap do |c|
+            if @body.arity.zero?
+              c << item.instance_exec(&@body)
+            else
+              item.instance_exec(c, &@body)
+            end
+          end
+          code.to_s
+        end
+
+        def file_path(item, outptu_directory)
+          path  = [outptu_directory, file_name(item)].reject(&:empty?)
+          File.join(*path)
+        end
+
+        def file_name(item)
+          @name_pattern.render(item)
+        end
+      end
+
+      define_helpers do
+        attr_reader :builders
+        attr_reader :pre_code_generator
+        attr_reader :code_generator
+        attr_reader :post_code_generator
+        attr_reader :file_writer
+
+        def use_verilog_utility
+          include VerilogUtility
+        end
+
+        def build(&body)
+          @builders ||= []
+          @builders << body
+        end
+
+        def generate_pre_code(kind, &body)
+          @pre_code_generator ||= CodeGenerator.new
+          @pre_code_generator[kind] = body
+        end
+
+        def generate_code(kind, &body)
+          @code_generator ||= CodeGenerator.new
+          @code_generator[kind] = body
+        end
+
+        def generate_code_from_template(kind, path = nil)
+          path  ||= File.ext(caller.first[/^(.+?):\d/, 1], 'erb')
+          generate_code(kind) { process_template(path) }
+        end
+
+        def generate_post_code(kind, &body)
+          @post_code_generator  ||= CodeGenerator.new
+          @post_code_generator[kind]  = body
+        end
+
+        def write_file(name_pattern, &body)
+          @file_writer  ||= FileWriter.new(name_pattern, body)
+        end
+
+        def export(*exporting_methods)
+          exported_methods.concat(
+            exporting_methods.reject(&exported_methods.method(:include?))
+          )
+        end
+
+        def exported_methods
+          @exported_methods ||= []
+        end
+      end
+
+      def self.inherited(subclass)
+        [:@builders, :@exported_methods].each do |v|
+          subclass.inherit_class_instance_variable(v, self, &:dup)
+        end
+        [
+          :@pre_code_generator,
+          :@code_generator,
+          :@post_code_generator
+        ].each do |v|
+          subclass.inherit_class_instance_variable(v, self, &:copy)
+        end
+      end
+
+      def initialize(owner)
+        super(owner)
+        define_hierarchical_item_accessors
+      end
+
+      class_delegator :builders
+      class_delegator :pre_code_generator
+      class_delegator :code_generator
+      class_delegator :file_writer
+      class_delegator :post_code_generator
+      class_delegator :exported_methods
+
+      def build
+        return if builders.nil?
+        builders.each do |builder|
+          instance_exec(&builder)
+        end
+      end
+
+      def generate_pre_code(kind, buffer)
+        return if pre_code_generator.nil?
+        pre_code_generator.generate_code(self, kind, buffer)
+      end
+
+      def generate_code(kind, buffer)
+        return if code_generator.nil?
+        code_generator.generate_code(self, kind, buffer)
+      end
+
+      def generate_post_code(kind, buffer)
+        return if post_code_generator.nil?
+        post_code_generator.generate_code(self, kind, buffer)
+      end
+
+      def write_file(output_directory = '')
+        return if file_writer.nil?
+        file_writer.write_file(self, output_directory)
+      end
+
+      private
+
+      def configuration
+        @owner.configuration
+      end
+    end
+  end
+end

data/lib/rggen/output_base/item_factory.rb

@@ -0,0 +1,6 @@
+module RgGen
+  module OutputBase
+    class ItemFactory < Base::ItemFactory
+    end
+  end
+end

data/lib/rggen/output_base/line.rb

@@ -0,0 +1,28 @@
+module RgGen
+  module OutputBase
+    class Line
+      def initialize
+        @words      = []
+        @not_empty  = false
+        @indent     = 0
+      end
+
+      attr_reader   :words
+      attr_accessor :indent
+
+      def <<(word)
+        @words << word.to_s
+        self
+      end
+
+      def empty?
+        @words.all?(&:empty?)
+      end
+
+      def to_s
+        return '' if @words.empty?
+        @words.join.indent(@indent)
+      end
+    end
+  end
+end

data/lib/rggen/output_base/template_utility.rb

@@ -0,0 +1,29 @@
+module RgGen
+  module OutputBase
+    module TemplateUtility
+      module Extensions
+        def template_engines
+          @template_engines ||= Hash.new do |engines, path|
+            engines[path] = create_engine(path)
+          end
+        end
+
+        private
+
+        def create_engine(path)
+          template  = File.read(path)
+          BabyErubis::Text.new.from_str(template, path)
+        end
+      end
+
+      def self.included(klass)
+        klass.extend(Extensions)
+      end
+
+      def process_template(path = nil)
+        path  ||= File.ext(caller.first[/^(.+?):\d/, 1], 'erb')
+        self.class.template_engines[path].render(self)
+      end
+    end
+  end
+end

data/lib/rggen/output_base/verilog_utility/class_definition.rb

@@ -0,0 +1,23 @@
+module RgGen
+  module OutputBase
+    module VerilogUtility
+      class ClassDefinition < StructureDefinition
+        attr_setter :base
+
+        private
+
+        def header_code
+          code_block do |code|
+            code << :class << space   << @name
+            code << space  <<:extends << space << @base unless @base.nil?
+            code << semicolon
+          end
+        end
+
+        def footer_code
+          :endclass
+        end
+      end
+    end
+  end
+end

data/lib/rggen/output_base/verilog_utility/declaration.rb

@@ -0,0 +1,70 @@
+module RgGen
+  module OutputBase
+    module VerilogUtility
+      class Declaration
+        def initialize(declation_type, attributes)
+          @declation_type = declation_type
+          @attributes     = attributes
+        end
+
+        def to_s
+          code_snippets.join(' ')
+        end
+
+        private
+
+        def code_snippets
+          [
+            random_or_direction_or_parameter_type,
+            data_type,
+            width,
+            identifier,
+            default_value_assignment
+          ].reject(&:empty?)
+        end
+
+        def random_or_direction_or_parameter_type
+          case @declation_type
+          when :variable
+            (@attributes[:random] && 'rand') || ''
+          when :port
+            @attributes[:direction] || ''
+          when :parameter
+            @attributes[:parameter_type]
+          end
+        end
+
+        def data_type
+          @attributes[:data_type] || ''
+        end
+
+        def width
+          return '' if @attributes[:width].nil?
+          return '' if (variable? || port?) && @attributes[:width] == 1
+          "[#{@attributes[:width] - 1}:0]"
+        end
+
+        def identifier
+          "#{@attributes[:name]}#{dimensions}"
+        end
+
+        def dimensions
+          return '' if @attributes[:dimensions].nil?
+          @attributes[:dimensions].map { |dimension| "[#{dimension}]" }.join
+        end
+
+        def default_value_assignment
+          (@attributes[:default].nil? && '') || "= #{@attributes[:default]}"
+        end
+
+        def variable?
+          @declation_type == :variable
+        end
+
+        def port?
+          @declation_type == :port
+        end
+      end
+    end
+  end
+end

data/lib/rggen/output_base/verilog_utility/identifier.rb

@@ -0,0 +1,29 @@
+module RgGen
+  module OutputBase
+    module VerilogUtility
+      class Identifier
+        def initialize(name)
+          @name = name
+        end
+
+        def to_s
+          @name
+        end
+
+        def [](indexes_or_msb, lsb = indexes_or_msb)
+          if indexes_or_msb.nil?
+            self
+          elsif indexes_or_msb.is_a?(Array)
+            indexes_or_msb.inject(self) do |identifer, index|
+              identifer[index]
+            end
+          elsif indexes_or_msb == lsb
+            Identifier.new("#{@name}[#{indexes_or_msb}]")
+          else
+            Identifier.new("#{@name}[#{indexes_or_msb}:#{lsb}]")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rggen/output_base/verilog_utility/module_definition.rb

@@ -0,0 +1,47 @@
+module RgGen
+  module OutputBase
+    module VerilogUtility
+      class ModuleDefinition < StructureDefinition
+        attr_setter :parameters
+        attr_setter :ports
+
+        private
+
+        def header_code
+          code_block do |code|
+            code << :module << space << @name << space
+            parameter_declarations(code)
+            port_declarations(code)
+            code << semicolon
+          end
+        end
+
+        def footer_code
+          :endmodule
+        end
+
+        def parameter_declarations(code)
+          return if @parameters.nil? || @parameters.empty?
+          code << '#('
+          declarations(@parameters, code)
+          code << ')'
+        end
+
+        def port_declarations(code)
+          code << '('
+          declarations(@ports, code) if @ports && @ports.size > 0
+          code << ')'
+        end
+
+        def declarations(list, code)
+          indent(code, 2) do
+            list.each_with_index do |d, i|
+              code << comma << nl if i > 0
+              code << d
+            end
+          end
+        end
+      end
+    end
+  end
+end