rggen 0.4.4 → 0.5.1

data/lib/rggen/core_components/verilog_utility/subroutine_definition.rb

@@ -0,0 +1,41 @@
+module RgGen
+  module VerilogUtility
+    class SubroutineDefinition < StructureDefinition
+      def initialize(type, name, &body)
+        @type = type
+        super(name, &body)
+      end
+
+      def return_type(data_type_and_width)
+        if [Symbol, String].any?(&data_type_and_width.method(:is_a?))
+          @return_type  = data_type_and_width
+        else
+          data_type     = data_type_and_width[:data_type]
+          width         = data_type_and_width[:width    ] || 1
+          @return_type  =
+            ((width > 1) && "#{data_type} [#{width - 1}:0]") || data_type
+        end
+      end
+
+      attr_setter :arguments
+
+      private
+
+      def function?
+        @type == :function
+      end
+
+      def header_code
+        [
+          (function? && :function   ) || :task,
+          (function? && @return_type) || nil,
+          "#{@name}(#{Array(@arguments).join(', ')});"
+        ].compact.join(' ')
+      end
+
+      def footer_code
+        (function? && :endfunction) || :endtask
+      end
+    end
+  end
+end

data/lib/rggen/core_extensions/facets.rb

@@ -1,4 +1,5 @@
 require 'facets/enumerable/exclude'
+require 'facets/enumerable/find_yield'
 require 'facets/enumerable/sum'
 require 'facets/file/ext'
 require 'facets/hash/symbolize_keys'
@@ -6,9 +7,13 @@ require 'facets/integer/multiple'
 require 'facets/kernel/attr_singleton'
 require 'facets/kernel/not'
 require 'facets/kernel/not_nil'
+require 'facets/method/curry' unless Method.public_method_defined?(:curry)
+require 'facets/module/attr_class_accessor'
 require 'facets/module/attr_setter'
 require 'facets/numeric/positive'
 require 'facets/object/itself' unless Object.public_method_defined?(:itself)
+require 'facets/pathname/to_path'
+require 'facets/pathname/to_str'
 require 'facets/range/overlap'
 require 'facets/regexp/op_add'
 require 'facets/regexp/op_or'

data/lib/rggen/generator.rb

@@ -20,7 +20,7 @@ module RgGen
       attr_writer   :body
 
       def on(parser, options)
-        options[@kind]  = @default if @default
+        options[@kind]  = default_value if default_value
         parser.on(*args) do |value|
           parser.instance_exec(value, options, @kind, &body)
         end
@@ -31,10 +31,10 @@ module RgGen
       end
 
       def description
-        return nil unless @description || @default
+        return nil unless @description || default_value
         d = ''
         d << @description.to_s
-        d << "(default: #{@default})" if @default
+        d << "(default: #{default_value})" if default_value
         d
       end
 
@@ -47,6 +47,16 @@ module RgGen
           options[kind] = value
         end
       end
+
+      def default_value
+        return unless @default
+        case @default
+        when Proc
+          @default.call
+        else
+          @default
+        end
+      end
     end
 
     class << self
@@ -64,13 +74,17 @@ module RgGen
 
     add_option :setup do |option|
       option.long         = '--setup FILE'
-      option.default      = File.join(RGGEN_HOME, 'setup', 'default.rb')
+      option.default      = proc do
+        ENV['RGGEN_DEFAULT_SETUP_FILE'] ||
+        File.join(RGGEN_HOME, 'setup', 'default.rb')
+      end
       option.description  = 'Specify a setup file to set up RgGen tool'
     end
 
     add_option :configuration do |option|
       option.short        = '-c'
       option.long         = '--configuration FILE'
+      option.default      = proc { ENV['RGGEN_DEFAULT_CONFIGURATION_FILE'] }
       option.description  = 'Specify a configuration file ' \
                             'for generated source code'
     end
@@ -78,7 +92,7 @@ module RgGen
     add_option :output do |option|
       option.short        = '-o'
       option.long         = '--output DIR'
-      option.default      = './'
+      option.default      = '.'
       option.description  = 'Specify output directory'
     end
 

data/lib/rggen/input_base/item.rb

@@ -53,8 +53,8 @@ module RgGen
         def field(field_name, options = {}, &body)
           return if fields.include?(field_name)
 
-          define_method(field_name) do
-            field_method(field_name, options, body)
+          define_method(field_name) do |*args, &block|
+            field_method(field_name, options, body, args, block)
           end
 
           fields  << field_name
@@ -139,14 +139,14 @@ module RgGen
         input_matcher && input_matcher.match_automatically?
       end
 
-      def field_method(field_name, options, body)
+      def field_method(field_name, options, body, args, block)
         validate if options[:need_validation]
         if body
-          instance_exec(&body)
+          instance_exec(*args, &body)
         elsif options[:forward_to_helper]
-          self.class.__send__(field_name)
+          self.class.__send__(field_name, *args, &block)
         elsif options.key?(:forward_to)
-          __send__(options[:forward_to])
+          __send__(options[:forward_to], *args, &block)
         else
           default_field_method(field_name, options[:default])
         end

data/lib/rggen/output_base/code_generator.rb

@@ -0,0 +1,36 @@
+module RgGen
+  module OutputBase
+    class CodeGenerator
+      def []=(kind, body)
+        (@bodies ||= {})[kind]  = body
+      end
+
+      def generate_code(context, kind, code)
+        return code unless body?(kind)
+        (code || context.create_blank_code).tap do |c|
+          execute_body(context, kind, c)
+        end
+      end
+
+      def copy
+        CodeGenerator.new.tap do |g|
+          g.instance_variable_set(:@bodies, Hash[@bodies]) if @bodies
+        end
+      end
+
+      private
+
+      def body?(kind)
+        @bodies && @bodies.key?(kind)
+      end
+
+      def execute_body(context, kind, code)
+        if @bodies[kind].arity.zero?
+          code << context.instance_exec(&@bodies[kind])
+        else
+          context.instance_exec(code, &@bodies[kind])
+        end
+      end
+    end
+  end
+end

data/lib/rggen/output_base/component.rb

@@ -26,64 +26,50 @@ module RgGen
         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
+      def generate_code(kind, mode, code = nil)
+        [
+          pre_code_generator, *main_code_generator(mode), post_code_generator
+        ].inject(code) { |c, g| g.call(kind, mode, c) }
       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)
+      def write_file(output_directory)
+        directoris  = [*Array(output_directory), @output_directory].compact
+        [*items, *children].each do |item_or_child|
+          item_or_child.write_file(directoris)
         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)
+      def generate_item_code(method_name, kind, _, code)
+        items.inject(code) do |c, item|
+          item.send(method_name, kind, c)
         end
       end
 
-      def generate_child_code(kind, mode, buffer)
-        children.each do |child|
-          child.generate_code(kind, mode, buffer)
+      def generate_child_code(kind, mode, code)
+        children.inject(code) do |c, child|
+          child.generate_code(kind, mode, code)
         end
       end
 
-      def generate_item_code(kind, buffer)
-        items.each do |item|
-          item.generate_code(kind, buffer)
-        end
+      def pre_code_generator
+        method(:generate_item_code).curry[:generate_pre_code]
       end
 
-      def generate_post_code(kind, buffer)
-        items.reverse_each do |item|
-          item.generate_post_code(kind, buffer)
-        end
+      def main_code_generator(mode)
+        return [
+          method(:generate_item_code ).curry[:generate_code],
+          method(:generate_child_code)
+        ] if mode == :top_down
+        return [
+          method(:generate_child_code),
+          method(:generate_item_code ).curry[:generate_code]
+        ] if mode == :bottom_up
       end
 
-      def output_directory(root_directory)
-        File.join([root_directory, @output_directory.to_s].reject(&:empty?))
+      def post_code_generator
+        method(:generate_item_code).curry[:generate_post_code]
       end
     end
   end

data/lib/rggen/output_base/file_writer.rb

@@ -0,0 +1,36 @@
+module RgGen
+  module OutputBase
+    class FileWriter
+      def initialize(pattern, body)
+        @pattern  = BabyErubis::Text.new.from_str(pattern)
+        @body     = body
+      end
+
+      def write_file(context, output_directory = nil)
+        path  = generate_path(context, output_directory)
+        code  = generate_code(context, path)
+        create_output_directory(path)
+        File.binwrite(path, code)
+      end
+
+      private
+
+      def generate_path(context, output_directory)
+        [
+          *Array(output_directory), @pattern.render(context)
+        ].map(&:to_s).reject(&:empty?).to_path
+      end
+
+      def generate_code(context, path)
+        context.create_blank_file(path).tap do |file|
+          context.instance_exec(file, &@body)
+        end
+      end
+
+      def create_output_directory(path)
+        dirname = path.dirname
+        dirname.directory? || dirname.mkpath
+      end
+    end
+  end
+end

data/lib/rggen/output_base/item.rb

@@ -2,100 +2,41 @@ 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
+      CODE_GENERATION_METHODS = {
+        pre:  :generate_pre_code,
+        main: :generate_code,
+        post: :generate_post_code
+      }
 
       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
+        def template_engine(engine)
+          define_method(:template_engine) { engine.instance }
         end
 
-        def generate_code(kind, &body)
-          @code_generator ||= CodeGenerator.new
-          @code_generator[kind] = body
+        def code_generators
+          @code_generators ||= {}
         end
 
-        def generate_code_from_template(kind, path = nil)
-          path  ||= File.ext(caller.first[/^(.+?):\d/, 1], 'erb')
-          generate_code(kind) { process_template(path) }
+        CODE_GENERATION_METHODS.each do |type, method_name|
+          define_method(method_name) do |kind, &body|
+            (code_generators[type] ||= CodeGenerator.new)[kind] = body
+          end
         end
 
-        def generate_post_code(kind, &body)
-          @post_code_generator  ||= CodeGenerator.new
-          @post_code_generator[kind]  = body
+        def generate_code_from_template(kind, path = nil)
+          call_info = caller.first
+          generate_code(kind) do
+            template_engine.process_template(self, path, call_info)
+          end
         end
 
         def write_file(name_pattern, &body)
@@ -118,12 +59,11 @@ module RgGen
         [:@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)
+        if @code_generators && @code_generators.size > 0
+          subclass.instance_variable_set(
+            :@code_generators,
+            Hash[*@code_generators.flat_map { |k, g| [k, g.copy] }]
+          )
         end
       end
 
@@ -133,10 +73,8 @@ module RgGen
       end
 
       class_delegator :builders
-      class_delegator :pre_code_generator
-      class_delegator :code_generator
+      class_delegator :code_generators
       class_delegator :file_writer
-      class_delegator :post_code_generator
       class_delegator :exported_methods
 
       def build
@@ -146,28 +84,24 @@ module RgGen
         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)
+      CODE_GENERATION_METHODS.each do |type, method_name|
+        define_method(method_name) do |kind, code|
+          return code unless code_generators.key?(type)
+          code_generators[type].generate_code(self, kind, code)
+        end
       end
 
-      def write_file(output_directory = '')
+      def write_file(output_directory = nil)
         return if file_writer.nil?
         file_writer.write_file(self, output_directory)
       end
 
       private
 
+      def process_template(path = nil)
+        template_engine.process_template(self, path, caller.first)
+      end
+
       def configuration
         @owner.configuration
       end