rggen-core 0.9.0

data/lib/rggen/core/base/hierarchical_accessors.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Base
+      module HierarchicalAccessors
+        module RegisterMap
+          def hierarchy
+            :register_map
+          end
+
+          def register_blocks
+            children
+          end
+
+          def registers
+            register_blocks.flat_map(&:children)
+          end
+
+          def bit_fields
+            registers.flat_map(&:children)
+          end
+        end
+
+        module RegisterBlock
+          def hierarchy
+            :register_block
+          end
+
+          def register_map
+            parent
+          end
+
+          def registers
+            children
+          end
+
+          def bit_fields
+            registers.flat_map(&:children)
+          end
+        end
+
+        module Register
+          def hierarchy
+            :register
+          end
+
+          def register_map
+            register_block.parent
+          end
+
+          def register_block
+            parent
+          end
+
+          def bit_fields
+            children
+          end
+        end
+
+        module BitField
+          def hierarchy
+            :bit_field
+          end
+
+          def register_map
+            register_block.parent
+          end
+
+          def register_block
+            register.parent
+          end
+
+          def register
+            parent
+          end
+        end
+
+        private
+
+        ACCESSOR_EXTENSIONS = [
+          RegisterMap, RegisterBlock, Register, BitField
+        ].freeze
+
+        def define_hierarchical_accessors
+          extend ACCESSOR_EXTENSIONS[level]
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/base/hierarchical_feature_accessors.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Base
+      module HierarchicalFeatureAccessors
+        module RegisterMap
+          def hierarchy
+            :register_map
+          end
+
+          def register_map
+            @component
+          end
+        end
+
+        module RegisterBlock
+          def hierarchy
+            :register_block
+          end
+
+          def register_map
+            register_block.parent
+          end
+
+          def register_block
+            @component
+          end
+        end
+
+        module Register
+          def hierarchy
+            :register
+          end
+
+          def register_map
+            register_block.parent
+          end
+
+          def register_block
+            register.parent
+          end
+
+          def register
+            @component
+          end
+        end
+
+        module BitField
+          def hierarchy
+            :bit_field
+          end
+
+          def register_map
+            register_block.parent
+          end
+
+          def register_block
+            register.parent
+          end
+
+          def register
+            bit_field.parent
+          end
+
+          def bit_field
+            @component
+          end
+        end
+
+        private
+
+        ACCESSOR_EXTENSIONS = [
+          RegisterMap, RegisterBlock, Register, BitField
+        ].freeze
+
+        def define_hierarchical_accessors
+          extend ACCESSOR_EXTENSIONS[@component.level]
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/base/internal_struct.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Base
+      module InternalStruct
+        def self.included(klass)
+          klass.extend(self)
+        end
+
+        private
+
+        def define_struct(name, members, &body)
+          struct = Struct.new(*members, &body)
+          define_method(name) { struct }
+          private name
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/base/shared_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Base
+      module SharedContext
+        def attach_context(context)
+          if is_a?(Module)
+            define_method(:shared_context) { context }
+          else
+            instance_variable_set(:@shared_context, context)
+            singleton_exec { attr_reader :shared_context }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      def self.create
+        builder = Builder.new
+        builder.register_input_components
+        builder
+      end
+    end
+  end
+end

data/lib/rggen/core/builder/builder.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class Builder
+        def initialize
+          initialize_component_registries
+          initialize_categories
+        end
+
+        def input_component_registry(name, &body)
+          component_registry(:input, name, body)
+        end
+
+        def output_component_registry(name, &body)
+          component_registry(:output, name, body)
+        end
+
+        def register_loader(component, loader)
+          @component_registries[:input][component].register_loader(loader)
+        end
+
+        def register_loaders(component, loaders)
+          @component_registries[:input][component].register_loaders(loaders)
+        end
+
+        def define_loader(component, &body)
+          @component_registries[:input][component].define_loader(&body)
+        end
+
+        def add_feature_registry(name, target_category, registry)
+          target_categories =
+            if target_category
+              Array(@categories[target_category])
+            else
+              @categories.values
+            end
+          target_categories.each do |category|
+            category.add_feature_registry(name, registry)
+          end
+        end
+
+        [
+          :define_simple_feature,
+          :define_list_feature,
+          :define_list_item_feature
+        ].each do |method_name|
+          define_method(method_name) do |category, *args, &body|
+            @categories[category].__send__(__method__, *args, &body)
+          end
+        end
+
+        def enable(category, *args)
+          @categories[category].enable(*args)
+        end
+
+        def disable_all
+          @categories.each_value(&:disable)
+        end
+
+        def disable(category, *args)
+          @categories.key?(category) && @categories[category].disable(*args)
+        end
+
+        def build_factory(type, component)
+          @component_registries[type][component].build_factory
+        end
+
+        def build_factories(type, targets)
+          registries =
+            if targets.empty?
+              @component_registries[type]
+            else
+              @component_registries[type]
+                .select { |name, _| targets.include?(name) }
+            end
+          registries.each_value.map(&:build_factory)
+        end
+
+        def delete(category, *args)
+          @categories.key?(category) && @categories[category].delete(*args)
+        end
+
+        def register_input_components
+          Configuration.setup(self)
+          RegisterMap.setup(self)
+        end
+
+        def setup(library_name, library_module)
+          library_versions[library_name] =
+            if library_module.const_defined?(:VERSION)
+              library_module.const_get(:VERSION)
+            elsif library_module.respond_to?(:version)
+              library_module.version
+            else
+              '0.0.0'
+            end
+          library_module.setup(self)
+        end
+
+        def library_versions
+          @library_versions ||= {}
+        end
+
+        def load_setup_file(file)
+          (file.nil? || file.empty?) &&
+            (raise Core::LoadError.new('no setup file is given'))
+          File.readable?(file) ||
+            (raise Core::LoadError.new("cannot load such setup file: #{file}"))
+          RgGen.builder(self)
+          load(file)
+        end
+
+        private
+
+        def initialize_component_registries
+          @component_registries = {}
+          [:input, :output].each do |type|
+            @component_registries[type] = Hash.new do |_, component_name|
+              raise BuilderError.new("unknown component: #{component_name}")
+            end
+          end
+        end
+
+        def initialize_categories
+          @categories = Hash.new do |_, category_name|
+            raise BuilderError.new("unknown category: #{category_name}")
+          end
+          [
+            :global, :register_map, :register_block, :register, :bit_field
+          ].each do |category|
+            @categories[category] = Category.new(category)
+          end
+        end
+
+        COMPONENT_REGISTRIES = {
+          input: InputComponentRegistry, output: OutputComponentRegistry
+        }
+
+        def component_registry(type, name, body)
+          registries = @component_registries[type]
+          klass = COMPONENT_REGISTRIES[type]
+          registries.key?(name) || (registries[name] = klass.new(name, self))
+          Docile.dsl_eval(registries[name], &body)
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/builder/category.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class Category
+        class Proxy
+          def initialize(body)
+            body.call(self)
+          end
+
+          attr_setter :method
+          attr_setter :list_names
+          attr_setter :feature_names
+
+          def shared_context(&body)
+            if block_given?
+              @shared_context ||= Object.new
+              @shared_context.instance_eval(&body)
+            end
+            @shared_context
+          end
+
+          def register_execution(registry, args, body)
+            @executions ||= []
+            @executions << { registry: registry, args: args, body: body }
+          end
+
+          def execute(category, body)
+            Docile.dsl_eval(category, &body)
+            Array(@executions).each { |execution| call_execution(execution) }
+          end
+
+          private
+
+          def call_execution(execution)
+            send_args = [
+              list_names, feature_names, shared_context, *execution[:args]
+            ].compact
+            execution[:registry].__send__(
+              method, *send_args, &execution[:body]
+            )
+          end
+        end
+
+        def initialize(name)
+          @name = name
+          @feature_registries = {}
+        end
+
+        def add_feature_registry(name, registry)
+          @feature_registries[name] = registry
+          define_proxy_call(name)
+        end
+
+        def shared_context(&body)
+          block_given? && @proxy&.shared_context(&body)
+        end
+
+        def define_simple_feature(feature_names, &body)
+          do_proxy_call(body) do |proxy|
+            proxy.method(__method__)
+            proxy.feature_names(feature_names)
+          end
+        end
+
+        def define_list_feature(list_names, &body)
+          do_proxy_call(body) do |proxy|
+            proxy.method(__method__)
+            proxy.list_names(list_names)
+          end
+        end
+
+        def define_list_item_feature(list_name, feature_names, &body)
+          do_proxy_call(body) do |proxy|
+            proxy.method(__method__)
+            proxy.list_names(list_name)
+            proxy.feature_names(feature_names)
+          end
+        end
+
+        def enable(feature_or_list_names, feature_names = nil)
+          @feature_registries.each_value do |registry|
+            registry.enable(feature_or_list_names, feature_names)
+          end
+        end
+
+        def disable(feature_or_list_names = nil, feature_names = nil)
+          @feature_registries.each_value do |registry|
+            registry.disable(*[feature_or_list_names, feature_names].compact)
+          end
+        end
+
+        def delete(feature_or_list_names = nil, feature_names = nil)
+          @feature_registries.each_value do |registry|
+            registry.delete(*[feature_or_list_names, feature_names].compact)
+          end
+        end
+
+        private
+
+        def define_proxy_call(name)
+          define_singleton_method(name) do |*args, &body|
+            @proxy.register_execution(@feature_registries[name], args, body)
+          end
+        end
+
+        def do_proxy_call(body, &proxy_block)
+          @proxy = Proxy.new(proxy_block)
+          @proxy.execute(self, body)
+          remove_instance_variable(:@proxy)
+        end
+      end
+    end
+  end
+end