rggen-systemverilog 0.11.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72d85079f6fe1425ce8227634c0a0d4d2e3b2c24f72b9befc1ab6faddbb498d1
-  data.tar.gz: '0483e8644334c77814b245d8644041041089f237f045e5c2eff0f011329fe20f'
+  metadata.gz: 8a3623823355599396aefd51ff1e23199edeadb01ec6a9c5a41e4c96795bd415
+  data.tar.gz: 9d64e7ed55d00af43bec20af3277fbc4236bb8c3a4839291de9c2e4ded5657ba
 SHA512:
-  metadata.gz: 749d5f74f72fe9d683bc29179d4c0ef2262025d71388e75da9eed675714d0819a092385e46be9c3180103c70bcb0e05fd815ff5b05ab35874cdcb2e57ab9930c
-  data.tar.gz: dcbba23df7e2674578f010c0dc6db7ca0f84c9cf1d3c3b54ae4d036bc40660564084265fcae382e5cdca94890fba6ede3fd737828b724f9d89b513d422e08bea
+  metadata.gz: c4c9f664b3d0232e088126bc6d5a564cae08526960fa0c2ce53fea558487695e0585d9339548c22a2842d14b1caf1148f8a99c2bc069e1ffa0a817b81adaa765
+  data.tar.gz: aab9d80c62650db7bbae7ffe799aa3330cae974be7adecad9615e400576d472aa9e89ba043c653baa5c1d4aceb4d38b5677d8f996adbd6d1b191956f282ede6c

data/README.md

@@ -1,5 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/rggen-systemverilog.svg)](https://badge.fury.io/rb/rggen-systemverilog)
-[![Build Status](https://travis-ci.org/rggen/rggen-systemverilog.svg?branch=master)](https://travis-ci.org/rggen/rggen-systemverilog)
+[![Build Status](https://travis-ci.com/rggen/rggen-systemverilog.svg?branch=master)](https://travis-ci.com/rggen/rggen-systemverilog)
 [![Maintainability](https://api.codeclimate.com/v1/badges/88086c5be538a1564a35/maintainability)](https://codeclimate.com/github/rggen/rggen-systemverilog/maintainability)
 [![codecov](https://codecov.io/gh/rggen/rggen-systemverilog/branch/master/graph/badge.svg)](https://codecov.io/gh/rggen/rggen-systemverilog)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=rggen_rggen-systemverilog&metric=alert_status)](https://sonarcloud.io/dashboard?id=rggen_rggen-systemverilog)
@@ -7,13 +7,7 @@
 
 # RgGen::SystemVerilog
 
-RgGen::SystemVerilog provides features listed below:
-
-* Structure for defining SystemVerilog RTL and UVM RAL model writers
-* Convenience APIs for SystemVerilog code
-    * Declaring signals, ports and variables
-    * Generating code to define module, class and package
-    * Etc.
+RgGen::SystemVerilog privides SystemVerilog RTL generator and UVM RAL model generator for RgGen.
 
 ## Installation
 

data/lib/rggen/systemverilog.rb

@@ -1,49 +1,5 @@
 # frozen_string_literal: true
 
-require 'docile'
-require 'facets/kernel/attr_singleton'
-
-require_relative 'systemverilog/version'
-
-require_relative 'systemverilog/utility/identifier'
-require_relative 'systemverilog/utility/data_object'
-require_relative 'systemverilog/utility/interface_port'
-require_relative 'systemverilog/utility/interface_instance'
-require_relative 'systemverilog/utility/structure_definition'
-require_relative 'systemverilog/utility/class_definition'
-require_relative 'systemverilog/utility/function_definition'
-require_relative 'systemverilog/utility/local_scope'
-require_relative 'systemverilog/utility/module_definition'
-require_relative 'systemverilog/utility/package_definition'
-require_relative 'systemverilog/utility/source_file'
-require_relative 'systemverilog/utility'
-
-require_relative 'systemverilog/component'
-require_relative 'systemverilog/feature'
-require_relative 'systemverilog/feature_rtl'
-require_relative 'systemverilog/feature_ral'
-require_relative 'systemverilog/factories'
-
-module RgGen
-  module SystemVerilog
-    class << self
-      def setup_sv_component(builder, name, sv_feature)
-        builder.output_component_registry(name) do
-          register_component [
-            :register_map, :register_block, :register, :bit_field
-          ] do |category|
-            component Component, ComponentFactory
-            feature sv_feature, FeatureFactory if category != :register_map
-          end
-        end
-      end
-
-      def setup(builder)
-        setup_sv_component(builder, :sv_rtl, FeatureRTL)
-        setup_sv_component(builder, :sv_ral, FeatureRAL)
-      end
-    end
-  end
-
-  setup :systemverilog, SystemVerilog
-end
+require_relative 'systemverilog/common'
+require_relative 'systemverilog/rtl'
+require_relative 'systemverilog/ral'

data/lib/rggen/systemverilog/common.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'docile'
+require 'facets/kernel/attr_singleton'
+
+require_relative 'version'
+
+require_relative 'common/utility/identifier'
+require_relative 'common/utility/data_object'
+require_relative 'common/utility/interface_instance'
+require_relative 'common/utility/interface_port'
+require_relative 'common/utility/structure_definition'
+require_relative 'common/utility/class_definition'
+require_relative 'common/utility/function_definition'
+require_relative 'common/utility/local_scope'
+require_relative 'common/utility/module_definition'
+require_relative 'common/utility/package_definition'
+require_relative 'common/utility/source_file'
+require_relative 'common/utility'
+
+require_relative 'common/component'
+require_relative 'common/feature'
+require_relative 'common/factories'
+
+module RgGen
+  module SystemVerilog
+    module Common
+      def self.register_component(builder, name, feature_class)
+        builder.output_component_registry(name) do
+          register_component [
+            :register_map, :register_block, :register, :bit_field
+          ] do |category|
+            component Component, ComponentFactory
+            feature feature_class, FeatureFactory if category != :register_map
+          end
+        end
+      end
+
+      def self.load_features(features, root)
+        features.each { |feature| require File.join(root, feature) }
+      end
+    end
+  end
+end

data/lib/rggen/systemverilog/common/component.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      class Component < Core::OutputBase::Component
+        def declarations(domain, type)
+          body = ->(r) { r.declarations(domain, type) }
+          [
+            @features.each_value.map(&body),
+            @children.map(&body)
+          ].flatten
+        end
+
+        def package_imports(domain)
+          body = ->(r) { r.package_imports(domain) }
+          [
+            @features.each_value.map(&body),
+            @children.map(&body)
+          ].flatten.uniq
+        end
+      end
+    end
+  end
+end

data/lib/rggen/systemverilog/common/factories.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      class ComponentFactory < Core::OutputBase::ComponentFactory
+      end
+
+      class FeatureFactory < Core::OutputBase::FeatureFactory
+      end
+    end
+  end
+end

data/lib/rggen/systemverilog/common/feature.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      class Feature < Core::OutputBase::Feature
+        include Common::Utility
+        template_engine Core::OutputBase::ERBEngine
+
+        EntityContext =
+          Struct.new(:entity_type, :creation_method, :declaration_type)
+
+        class << self
+          private
+
+          def define_entity(entity_type, creation_method, declaration_type)
+            context =
+              EntityContext.new(entity_type, creation_method, declaration_type)
+            define_method(entity_type) do |domain, name, **attributes, &block|
+              entity =
+                create_entity(context, { name: name }.merge(attributes), block)
+              add_entity(entity, context, domain, name)
+            end
+          end
+        end
+
+        def declarations(domain, type)
+          @declarations[domain][type]
+        end
+
+        def package_imports(domain)
+          @package_imports[domain]
+        end
+
+        private
+
+        def post_initialize
+          super
+          @declarations = Hash.new do |h0, k0|
+            h0[k0] = Hash.new { |h1, k1| h1[k1] = [] }
+          end
+          @package_imports = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def create_entity(context, attributes, block)
+          creation_method = context.creation_method
+          entity_type = context.entity_type
+          __send__(creation_method, entity_type, attributes, block)
+        end
+
+        def add_entity(entity, context, domain, name)
+          add_declaration(context, domain, entity.declaration)
+          add_identifier(name, entity.identifier)
+        end
+
+        def add_declaration(context, domain, declaration)
+          declaration_type = context.declaration_type
+          @declarations[domain][declaration_type] << declaration
+        end
+
+        def add_identifier(name, identifier)
+          instance_variable_set("@#{name}", identifier)
+          attr_singleton_reader(name)
+          export(name)
+        end
+
+        def import_package(domain, package)
+          @package_imports[domain].include?(package) ||
+            (@package_imports[domain] << package)
+        end
+
+        def import_packages(domain, packages)
+          Array(packages).each { |package| import_package(domain, package) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemVerilog
+    module Common
+      module Utility
+        include Core::Utility::CodeUtility
+
+        def create_blank_file(path)
+          SourceFile.new(path)
+        end
+
+        private
+
+        def create_identifier(name)
+          Identifier.new(name)
+        end
+
+        def assign(lhs, rhs)
+          "assign #{lhs} = #{rhs};"
+        end
+
+        def concat(expressions)
+          "{#{Array(expressions).join(', ')}}"
+        end
+
+        def array(expressions)
+          "'#{concat(expressions)}"
+        end
+
+        def function_call(name, expressions = nil)
+          "#{name}(#{Array(expressions).join(', ')})"
+        end
+
+        def macro_call(name, expressions = nil)
+          if (expression_array = Array(expressions)).empty?
+            "`#{name}"
+          else
+            "`#{name}(#{expression_array.join(', ')})"
+          end
+        end
+
+        def bin(value, width = nil)
+          if width
+            width = bit_width(value, width)
+            format("%d'b%0*b", width, width, value)
+          else
+            format("'b%b", value)
+          end
+        end
+
+        def dec(value, width = nil)
+          if width
+            width = bit_width(value, width)
+            format("%0d'd%d", width, value)
+          else
+            format("'d%d", value)
+          end
+        end
+
+        def hex(value, width = nil)
+          if width
+            width = bit_width(value, width)
+            print_width = (width + 3) / 4
+            format("%0d'h%0*x", width, print_width, value)
+          else
+            format("'h%x", value)
+          end
+        end
+
+        def bit_width(value, width)
+          bit_length = value.bit_length
+          bit_length = 1 if bit_length.zero?
+          [width, bit_length].max
+        end
+
+        def argument(name, **attribute)
+          DataObject.new(:argument, attribute.merge(name: name)).declaration
+        end
+
+        {
+          class_definition: ClassDefinition,
+          function_definition: FunctionDefinition,
+          local_scope: LocalScope,
+          module_definition: ModuleDefinition,
+          package_definition: PackageDefinition
+        }.each do |method_name, definition|
+          define_method(method_name) do |name, **attributes, &block|
+            definition.new(attributes.merge(name: name), &block).to_code
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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