rggen-systemverilog 0.11.1 → 0.13.0

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      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
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      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
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      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
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      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
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      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
+end

data/lib/rggen/systemverilog/common/utility/module_definition.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      module Utility
+        class ModuleDefinition < StructureDefinition
+          define_attribute :name
+          define_attribute :package_imports
+          define_attribute :parameters
+          define_attribute :ports
+          define_attribute :variables
+
+          def package_imports(packages)
+            @package_imports ||= []
+            @package_imports.concat(Array(packages))
+          end
+
+          def package_import(package)
+            package_imports([package])
+          end
+
+          private
+
+          def header_code(code)
+            code << [:module, space, name]
+            package_import_declaration(code)
+            parameter_declarations(code)
+            port_declarations(code)
+            code << semicolon
+          end
+
+          def package_import_declaration(code)
+            if (items = pacakge_import_items).empty?
+              code << space
+              return
+            end
+            add_declarations_to_header(code, items, semicolon)
+          end
+
+          def pacakge_import_items
+            Array(@package_imports).map.with_index do |package, i|
+              if i.zero?
+                [:import, "#{package}::*"].join(space)
+              else
+                [space(6), "#{package}::*"].join(space)
+              end
+            end
+          end
+
+          def parameter_declarations(code)
+            declarations = Array(parameters)
+            declarations.empty? || wrap(code, '#(', ')') do
+              add_declarations_to_header(code, declarations)
+            end
+          end
+
+          def port_declarations(code)
+            declarations = Array(ports)
+            wrap(code, '(', ')') do
+              add_declarations_to_header(code, declarations)
+            end
+          end
+
+          def pre_body_code(code)
+            add_declarations_to_body(code, Array(variables))
+          end
+
+          def footer_code
+            :endmodule
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rggen/systemverilog/common/utility/package_definition.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      module Utility
+        class PackageDefinition < StructureDefinition
+          define_attribute :name
+          define_attribute :package_imports
+          define_attribute :include_files
+
+          def package_imports(packages)
+            @package_imports ||= []
+            @package_imports.concat(Array(packages))
+          end
+
+          def package_import(package)
+            package_imports([package])
+          end
+
+          def include_files(files)
+            @include_files ||= []
+            @include_files.concat(Array(files))
+          end
+
+          def include_file(file)
+            include_files([file])
+          end
+
+          private
+
+          def header_code(code)
+            code << [:package, space, name, semicolon]
+          end
+
+          def pre_body_code(code)
+            package_import_declaration(code)
+            file_include_directives(code)
+          end
+
+          def package_import_declaration(code)
+            declarations =
+              Array(@package_imports)
+                .map { |package| [:import, space, package, '::*'] }
+            add_declarations_to_body(code, declarations)
+          end
+
+          def file_include_directives(code)
+            Array(@include_files).each do |file|
+              code << [:'`include', space, string(file), nl]
+            end
+          end
+
+          def footer_code
+            :endpackage
+          end
+        end
+      end
+    end
+  end
+end