rggen 0.8.2 → 0.9.0

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

@@ -1,37 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class InterfaceInstance
-      def initialize(attributes)
-        @attributes = attributes
-      end
-
-      def to_s
-        "#{interface_type} #{instance_identifier}()"
-      end
-
-      def identifier
-        Identifier.new(@attributes[:name], nil, nil, nil)
-      end
-
-      private
-
-      def interface_type
-        return @attributes[:type] unless @attributes[:parameters]
-        "#{@attributes[:type]} #{parameters}"
-      end
-
-      def parameters
-        "#(#{@attributes[:parameters].join(', ')})"
-      end
-
-      def instance_identifier
-        "#{@attributes[:name]}#{dimensions}"
-      end
-
-      def dimensions
-        return unless @attributes[:dimensions]
-        @attributes[:dimensions].map { |d| "[#{d}]" }.join
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class InterfacePort
-      def initialize(attributes)
-        @attributes = attributes
-      end
-
-      def to_s
-        "#{interface_type} #{port_identifier}"
-      end
-
-      def identifier
-        Identifier.new(@attributes[:name], nil, nil, nil)
-      end
-
-      private
-
-      def interface_type
-        return @attributes[:type] unless @attributes[:modport]
-        "#{@attributes[:type]}.#{@attributes[:modport]}"
-      end
-
-      def port_identifier
-        "#{@attributes[:name]}#{dimensions}"
-      end
-
-      def dimensions
-        return unless @attributes[:dimensions]
-        @attributes[:dimensions].map { |d| "[#{d}]" }.join
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class LocalScope < StructureDefinition
-      attr_setter :signals
-      attr_setter :loops
-
-      def without_generate_keyword
-        @without_generate_keyword = true
-      end
-
-      def to_code
-        code_block do |c|
-          header_code(c)
-          body_code(c)
-          footer_code(c)
-        end
-      end
-
-      private
-
-      def header_code(code)
-        code << :generate << space unless @without_generate_keyword
-        code << :'if (1) begin : ' << @name << nl
-        loops? && generate_for_header(code)
-      end
-
-      def body_code_blocks
-        blocks = []
-        signals? && (blocks << signal_declarations)
-        blocks.concat(super)
-        blocks
-      end
-
-      def footer_code(code)
-        loops? && generate_for_footer(code)
-        code << :end
-        code << space << :endgenerate unless @without_generate_keyword
-        code << nl
-      end
-
-      def loops?
-        !(@loops.nil? || @loops.empty?)
-      end
-
-      def generate_for_header(code)
-        loops.each do |genvar, size|
-          code.indent += 2
-          code << "genvar #{genvar}" << semicolon << nl
-          code << generate_for(genvar, size) << nl
-        end
-      end
-
-      def generate_for(genvar, size)
-        "for (#{genvar} = 0;#{genvar} < #{size};++#{genvar}) begin : g"
-      end
-
-      def generate_for_footer(code)
-        loops.size.times do
-          code << :end << nl
-          code.indent -= 2
-        end
-      end
-
-      def signals?
-        !(@signals.nil? || @signals.empty?)
-      end
-
-      def signal_declarations
-        lambda do |code|
-          signals.each { |signal| code << signal << semicolon << nl }
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class ModuleDefinition < StructureDefinition
-      attr_setter :parameters
-      attr_setter :ports
-      attr_setter :signals
-
-      def include_file(file)
-        @include_files ||= []
-        @include_files << "`include #{file.to_s.quote}"
-      end
-
-      private
-
-      def header_code
-        code_block do |code|
-          code << :module << space << @name << space
-          parameters? && parameter_declarations(code)
-          port_declarations(code)
-          code << semicolon
-        end
-      end
-
-      def body_code_blocks
-        blocks = []
-        @include_files && (blocks << include_files_code)
-        signals? && (blocks << signal_declarations)
-        blocks.concat(super)
-        blocks
-      end
-
-      def footer_code
-        :endmodule
-      end
-
-      def parameters?
-        !(@parameters.nil? || @parameters.empty?)
-      end
-
-      def ports?
-        !(@ports.nil? || @ports.empty?)
-      end
-
-      def signals?
-        !(@signals.nil? || @signals.empty?)
-      end
-
-      def parameter_declarations(code)
-        wrap(code, '#(', ')') do
-          declarations(@parameters, code)
-        end
-      end
-
-      def port_declarations(code)
-        wrap(code, '(', ')') do
-          ports? && declarations(@ports, code)
-        end
-      end
-
-      def include_files_code
-        lambda do |code|
-          @include_files.each { |file| code << file << nl }
-        end
-      end
-
-      def signal_declarations
-        lambda do |code|
-          signals.each { |signal| code << signal << semicolon << nl }
-        end
-      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

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

@@ -1,57 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class PackageDefinition < StructureDefinition
-      ImportedPackage = Struct.new(:name, :items) do
-        def to_s
-          "import #{import_items.join(', ')};"
-        end
-
-        def import_items
-          (((items.nil? || items.empty?) && [:*]) || items).map do |item|
-            "#{name}::#{item}"
-          end
-        end
-      end
-
-      def import_package(name, items = nil)
-        @import_packages ||= []
-        @import_packages << ImportedPackage.new(name, items)
-      end
-
-      def include_file(name)
-        @include_files ||= []
-        @include_files << "`include #{name.to_s.quote}"
-      end
-
-      private
-
-      def header_code
-        "package #{@name};"
-      end
-
-      def body_code_blocks
-        blocks = []
-        @import_packages && (blocks << import_packges_code)
-        @include_files && (blocks << include_files_code)
-        blocks.concat(super)
-        blocks
-      end
-
-      def footer_code
-        :endpackage
-      end
-
-      def import_packges_code
-        lambda do |code|
-          @import_packages.each { |package| code << package << nl }
-        end
-      end
-
-      def include_files_code
-        lambda do |code|
-          @include_files.each { |file| code << file << nl }
-        end
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class SourceFile < CodeUtility::SourceFile
-      ifndef_keyword  :'`ifndef'
-      endif_keyword   :'`endif'
-      define_keyword  :'`define'
-      include_keyword :'`include'
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class StructureDefinition
-      include CodeUtility
-
-      def initialize(name)
-        @name = name
-        yield(self) if block_given?
-      end
-
-      def body(&block)
-        @bodies ||= []
-        @bodies << block if block_given?
-      end
-
-      def to_code
-        code_block do |code|
-          code << header_code << nl
-          body_code(code) if body_code?
-          code << footer_code << nl
-        end
-      end
-
-      private
-
-      def body_code(code)
-        body_code_blocks.each do |body|
-          generate_body_code(code, body)
-        end
-      end
-
-      def body_code_blocks
-        @bodies || []
-      end
-
-      def generate_body_code(code, body)
-        indent(code, 2) do
-          if body.arity.zero?
-            code << body.call
-          else
-            body.call(code)
-          end
-        end
-      end
-
-      def body_code?
-        !(@bodies.nil? || @bodies.empty?)
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-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_components/verilog_utility/variable.rb

@@ -1,115 +0,0 @@
-module RgGen
-  module VerilogUtility
-    class Variable
-      def initialize(variable_type, attributes)
-        @variable_type  = variable_type
-        @attributes     = attributes
-      end
-
-      def to_s
-        code_snippets.join(' ')
-      end
-
-      def identifier
-        name          = @attributes[:name]
-        width         = @attributes[:width] || 1
-        dimensions    = @attributes[:dimensions]
-        array_fomrat  = @attributes[:array_format] || :unpacked
-        Identifier.new(name, width, dimensions, array_fomrat)
-      end
-
-      private
-
-      def code_snippets
-        [
-          rand_keyword,
-          port_direction,
-          parameter_keyword,
-          data_type,
-          width,
-          variable_identifier,
-          default_value_assignment
-        ].select(&:itself)
-      end
-
-      def rand_keyword
-        @variable_type == :variable && @attributes[:random] && :rand
-      end
-
-      def port_direction
-        @variable_type == :port && @attributes[:direction]
-      end
-
-      def parameter_keyword
-        @variable_type == :parameter && @attributes[:parameter_type]
-      end
-
-      def data_type
-        @attributes[:data_type]
-      end
-
-      def width
-        vector? || return
-        msb =
-          if numerical_width?
-            vectored_array_size * (@attributes[:width] || 1) - 1
-          elsif vectored_array?
-            "#{vectored_array_size}*#{@attributes[:width]}-1"
-          else
-            "#{@attributes[:width]}-1"
-          end
-        "[#{msb}:0]"
-      end
-
-      def vectored_array_size
-        vectored_array? || (return 1)
-        @attributes[:dimensions].inject(&:*)
-      end
-
-      def variable_identifier
-        "#{@attributes[:name]}#{dimensions}"
-      end
-
-      def dimensions
-        unpacked_array? || return
-        @attributes[:dimensions].map { |dimension| "[#{dimension}]" }.join
-      end
-
-      def default_value_assignment
-        @attributes[:default] || return
-        "= #{@attributes[:default]}"
-      end
-
-      def parameter?
-        @variable_type == :parameter
-      end
-
-      def vector?
-        @attributes[:vector] && (return true)
-        vectored_array? && (return true)
-        @attributes[:width] || (return false)
-        numerical_width? || (return true)
-        parameter? && (return true)
-        @attributes[:width] > 1
-      end
-
-      def numerical_width?
-        @attributes[:width] || (return true)
-        @attributes[:width].is_a?(Integer) && (return true)
-        false
-      end
-
-      def unpacked_array?
-        @attributes[:dimensions] || (return false)
-        @attributes[:array_format] == :vectored && (return false)
-        true
-      end
-
-      def vectored_array?
-        @attributes[:dimensions] || (return false)
-        @attributes[:array_format] == :vectored && (return true)
-        false
-      end
-    end
-  end
-end