rggen-systemverilog 0.11.1 → 0.13.0

data/lib/rggen/systemverilog/utility/class_definition.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class ClassDefinition < StructureDefinition
-        define_attribute :name
-        define_attribute :base
-        define_attribute :parameters
-        define_attribute :variables
-
-        private
-
-        def header_code(code)
-          code << [:class, space, name]
-          parameter_declarations(code)
-          class_inheritance(code)
-          code << semicolon
-        end
-
-        def parameter_declarations(code)
-          declarations = Array(parameters)
-          declarations.empty? || wrap(code << space, '#(', ')') do
-            add_declarations_to_header(code, declarations)
-          end
-        end
-
-        def class_inheritance(code)
-          return unless base
-          code << [space, :extends, space, base]
-        end
-
-        def pre_body_code(code)
-          add_declarations_to_body(code, Array(variables))
-        end
-
-        def footer_code
-          :endclass
-        end
-      end
-    end
-  end
-end

data/lib/rggen/systemverilog/utility/data_object.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class DataObject
-        include Core::Utility::AttributeSetter
-
-        def initialize(object_type, **default_attributes)
-          @object_type = object_type
-          apply_attributes(default_attributes)
-          block_given? && yield(self)
-        end
-
-        define_attribute :name
-        define_attribute :direction
-        define_attribute :parameter_type
-        define_attribute :data_type
-        define_attribute :width
-        define_attribute :array_size
-        define_attribute :array_format, :packed
-        define_attribute :random
-        define_attribute :default
-
-        def declaration
-          declaration_snippets
-            .select(&:itself)
-            .reject(&:empty?)
-            .join(' ')
-        end
-
-        def identifier
-          Identifier.new(name) do |identifier|
-            identifier.__width__(width)
-            identifier.__array_size__(array_size)
-            identifier.__array_format__(array_format)
-          end
-        end
-
-        private
-
-        def declaration_snippets
-          [
-            rand_keyword,
-            argument_direction,
-            paraemter_keyword,
-            data_type,
-            packed_dimensions,
-            object_identifier,
-            default_value
-          ]
-        end
-
-        def rand_keyword
-          return unless @object_type == :variable
-          return unless random
-          return :rand if random.equal?(true)
-          random
-        end
-
-        def argument_direction
-          @object_type == :argument && direction
-        end
-
-        def paraemter_keyword
-          @object_type == :parameter && parameter_type
-        end
-
-        def packed_dimensions
-          (serialized? ? serialized_array_size : packed_array_size)
-            .map { |size| "[#{msb(size)}:0]" }
-            .join
-        end
-
-        def msb(size)
-          (size.is_a?(Integer) && size - 1) || "#{size}-1"
-        end
-
-        def array?
-          return false unless array_size
-          !array_size.empty?
-        end
-
-        def serialized?
-          array? && array_format == :serialized
-        end
-
-        def serialized_array_size
-          size = [(width || 1), *array_size]
-          if size.all? { |s| s.is_a?(Integer) }
-            [size.inject(&:*)]
-          else
-            [size.join('*')]
-          end
-        end
-
-        def packed_array_size
-          size = []
-          size.concat(Array(array_size)) if array_format == :packed
-          size << width if valid_width?
-          size
-        end
-
-        def valid_width?
-          return false unless width
-          return true unless width.is_a?(Integer)
-          width > 1
-        end
-
-        def object_identifier
-          "#{name}#{unpacked_dimensions}"
-        end
-
-        def unpacked_array?
-          array? && array_format == :unpacked
-        end
-
-        def unpacked_dimensions
-          return unless unpacked_array?
-          array_size.map { |size| "[#{size}]" }.join
-        end
-
-        def default_value
-          default && "= #{default}"
-        end
-      end
-    end
-  end
-end

data/lib/rggen/systemverilog/utility/function_definition.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class FunctionDefinition < StructureDefinition
-        define_attribute :name
-        define_attribute :return_type
-        define_attribute :arguments
-
-        def return_type(**attributes)
-          attributes.size.zero? || (
-            @return_type = DataObject.new(:variable, **attributes)
-          )
-          @return_type
-        end
-
-        private
-
-        def header_code(code)
-          code << :function
-          return_type_declaration(code)
-          code << [space, name]
-          argument_declarations(code)
-          code << semicolon
-        end
-
-        def return_type_declaration(code)
-          return unless @return_type
-          code << [space, return_type.declaration]
-        end
-
-        def argument_declarations(code)
-          wrap(code, '(', ')') do
-            add_declarations_to_header(code, Array(arguments))
-          end
-        end
-
-        def footer_code
-          :endfunction
-        end
-      end
-    end
-  end
-end

data/lib/rggen/systemverilog/utility/identifier.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class Identifier
-        def initialize(name)
-          @name = name
-          block_given? && yield(self)
-        end
-
-        def __width__(width)
-          @width = width
-        end
-
-        def __array_size__(array_size)
-          @array_size = array_size
-        end
-
-        def __array_format__(array_format)
-          @array_format = array_format
-        end
-
-        def __sub_identifiers__(sub_identifiers)
-          Array(sub_identifiers).each do |sub_identifier|
-            (@sub_identifiers ||= []) << sub_identifier
-            define_singleton_method(sub_identifier) do
-              Identifier.new("#{@name}.#{__method__}")
-            end
-          end
-        end
-
-        def to_s
-          @name.to_s
-        end
-
-        def [](array_index_or_lsb, width = nil)
-          if array_index_or_lsb
-            __create_new_identifier__(array_index_or_lsb, width)
-          else
-            self
-          end
-        end
-
-        private
-
-        def __create_new_identifier__(array_index_or_lsb, width)
-          select = __create_select__(array_index_or_lsb, width)
-          Identifier.new("#{@name}#{select}") do |identifier|
-            identifier.__sub_identifiers__(@sub_identifiers)
-          end
-        end
-
-        def __create_select__(array_index_or_lsb, width)
-          if array_index_or_lsb.is_a?(::Array)
-            __array_select__(array_index_or_lsb)
-          elsif width
-            "[#{array_index_or_lsb}+:#{width}]"
-          else
-            "[#{array_index_or_lsb}]"
-          end
-        end
-
-        def __array_select__(array_index)
-          if @array_format == :serialized
-            "[#{__serialized_lsb__(array_index)}+:#{@width}]"
-          else
-            array_index
-              .map { |index| "[#{index}]" }
-              .join
-          end
-        end
-
-        def __serialized_lsb__(array_index)
-          __reduce_array__([@width, __serialized_index__(array_index)], :*, 1)
-        end
-
-        def __serialized_index__(array_index)
-          index_values =
-            array_index
-              .reverse
-              .zip(__index_factors__)
-              .map { |i, f| __calc_index_value__(i, f) }
-          index = __reduce_array__(index_values.reverse, :+, 0)
-          integer?(index) ? index : "(#{index})"
-        end
-
-        def __index_factors__
-          Array.new(@array_size.size) do |i|
-            i.zero? ? nil : __reduce_array__(@array_size[-i..-1], :*, 1)
-          end
-        end
-
-        def __calc_index_value__(index, factor)
-          __reduce_array__([factor, index].compact, :*, 1)
-        end
-
-        def __reduce_array__(array, operator, initial_value)
-          if array.all?(&method(:integer?))
-            array.reduce(initial_value, &operator)
-          else
-            array.join(operator.to_s)
-          end
-        end
-
-        def integer?(value)
-          value.is_a?(Integer)
-        end
-      end
-    end
-  end
-end

data/lib/rggen/systemverilog/utility/interface_instance.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class InterfaceInstance
-        include Core::Utility::AttributeSetter
-
-        def initialize(**default_attributes)
-          apply_attributes(default_attributes)
-          block_given? && yield(self)
-        end
-
-        define_attribute :name
-        define_attribute :interface_type
-        define_attribute :parameter_values
-        define_attribute :port_connections
-        define_attribute :array_size
-        define_attribute :variables
-
-        def instantiation
-          [
-            interface_type,
-            parameter_value_assignments,
-            instance_identifier
-          ].select(&:itself).join(' ')
-        end
-
-        alias_method :declaration, :instantiation
-
-        def identifier
-          Identifier.new(name) do |identifier|
-            identifier.__array_size__(array_size)
-            identifier.__sub_identifiers__(variables)
-          end
-        end
-
-        private
-
-        def parameter_value_assignments
-          values = Array(parameter_values)
-          values.size.positive? && "#(#{values.join(', ')})"
-        end
-
-        def instance_identifier
-          [
-            name,
-            *Array(array_size).map { |size| "[#{size}]" },
-            "(#{Array(port_connections).join(', ')})"
-          ].join
-        end
-      end
-    end
-  end
-end

data/lib/rggen/systemverilog/utility/interface_port.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class InterfacePort
-        include Core::Utility::AttributeSetter
-
-        def initialize(**default_attributes)
-          apply_attributes(default_attributes)
-          block_given? && yield(self)
-        end
-
-        define_attribute :name
-        define_attribute :interface_type
-        define_attribute :modport
-        define_attribute :array_size
-
-        def modport(name, ports = nil)
-          @modport_name = name
-          @modport_ports = ports
-        end
-
-        def declaration
-          "#{port_type} #{port_identifier}"
-        end
-
-        def identifier
-          Identifier.new(name) do |identifier|
-            identifier.__array_size__(array_size)
-            identifier.__sub_identifiers__(@modport_ports)
-          end
-        end
-
-        private
-
-        def port_type
-          [@interface_type, @modport_name].compact.join('.')
-        end
-
-        def port_identifier
-          [
-            name, *Array(array_size).map { |size| "[#{size}]" }
-          ].join
-        end
-      end
-    end
-  end
-end

data/lib/rggen/systemverilog/utility/local_scope.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module SystemVerilog
-    module Utility
-      class LocalScope < StructureDefinition
-        define_attribute :name
-        define_attribute :variables
-        define_attribute :loop_size
-
-        def top_scope
-          @top_scope = true
-        end
-
-        private
-
-        def header_code(code)
-          code << [:generate, space] if @top_scope
-          code << "if (1) begin : #{name}" << nl
-        end
-
-        def footer_code(code)
-          code << :end
-          code << [space, :endgenerate] if @top_scope
-        end
-
-        def pre_body_code(code)
-          genvar_declarations(code)
-          generate_for_header(code)
-          variable_declarations(code)
-        end
-
-        def genvar_declarations(code)
-          genvars = Array(loop_size&.keys).map { |genvar| "genvar #{genvar}" }
-          add_declarations_to_body(code, genvars)
-        end
-
-        def generate_for_header(code)
-          loop_size&.each do |genvar, size|
-            code << generate_for(genvar, size) << nl
-            code.indent += 2
-          end
-        end
-
-        def generate_for(genvar, size)
-          "for (#{genvar} = 0;#{genvar} < #{size};++#{genvar}) begin : g"
-        end
-
-        def variable_declarations(code)
-          add_declarations_to_body(code, Array(variables))
-        end
-
-        def post_body_code(code)
-          (loop_size&.size || 0).times do
-            code.indent -= 2
-            code << :end << nl
-          end
-        end
-      end
-    end
-  end
-end