rggen-core 0.15.0 → 0.20.0

data/lib/rggen/core/output_base/component.rb

@@ -4,22 +4,21 @@ module RgGen
   module Core
     module OutputBase
       class Component < Base::Component
-        include Base::HierarchicalAccessors
+        include Base::ComponentLayerExtension
 
         attr_reader :configuration
-        attr_reader :source
+        attr_reader :register_map
 
-        def post_initialize(_paren, configuration, source)
+        def post_initialize(configuration, register_map)
           @configuration = configuration
-          @source = source
-          @need_children = source.need_children?
-          define_hierarchical_accessors
-          define_children_presense_indicator
-          define_proxy_calls(@source, @source.properties)
+          @register_map = register_map
+          @need_children = register_map.need_children?
+          define_layer_methods
+          define_proxy_calls(@register_map, @register_map.properties)
         end
 
         def children?
-          !source.children.empty?
+          !register_map.children.empty?
         end
 
         def add_feature(feature)
@@ -28,7 +27,7 @@ module RgGen
         end
 
         def printables
-          @source.printables
+          register_map.printables
         end
 
         def pre_build
@@ -40,8 +39,9 @@ module RgGen
           @children.each(&:build)
         end
 
-        def generate_code(kind, mode, code = nil)
-          code_generators(kind, mode).inject(code) { |c, g| g[c] }
+        def generate_code(code, kind, mode, target_or_range = nil, depth = 0)
+          code_generator_contexts(kind, mode, target_or_range, depth)
+            .each { |context| context.generate(code) }
         end
 
         def write_file(directory = nil)
@@ -51,18 +51,6 @@ module RgGen
 
         private
 
-        INDICATOR_NAMES = {
-          register_map: :register_blocks?,
-          register_block: :registers?,
-          register: :bit_fields?
-        }.freeze
-
-        def define_children_presense_indicator
-          indicator_name = INDICATOR_NAMES[hierarchy]
-          indicator_name &&
-            singleton_exec { alias_method indicator_name, :children? }
-        end
-
         def build_feature(feature)
           feature.build
           import_feature_methods(feature, :object)
@@ -73,25 +61,40 @@ module RgGen
           define_proxy_calls(feature, methods)
         end
 
-        def code_generators(kind, mode)
+        CodeGeneratorContext = Struct.new(:receivers, :args) do
+          def generate(code)
+            receivers.each { |receiver| receiver.generate_code(code, *args) }
+          end
+        end
+
+        def code_generator_contexts(kind, mode, target_or_range, depth)
           [
-            [@features.each_value, [:pre_code, kind]],
-            *main_code_contexts(kind, mode),
-            [@features.each_value, [:post_code, kind]]
-          ].map do |receivers, args|
-            lambda do |code|
-              receivers.inject(code) { |c, r| r.generate_code(*args, c) }
-            end
+            feature_code_generator_context(:pre_code, kind, target_or_range, depth),
+            *main_code_generator_contexts(kind, mode, target_or_range, depth),
+            feature_code_generator_context(:post_code, kind, target_or_range, depth)
+          ].compact
+        end
+
+        def feature_code_generator_context(phase, kind, target_or_range, depth)
+          (target_depth?(depth, target_or_range) || nil) &&
+            CodeGeneratorContext.new(@features.each_value, [phase, kind])
+        end
+
+        def target_depth?(depth, target_or_range)
+          if target_or_range.nil?
+            true
+          elsif target_or_range.respond_to?(:include?)
+            target_or_range.include?(depth)
+          else
+            depth == target_or_range
           end
         end
 
-        def main_code_contexts(kind, mode)
-          contexts = [
-            [@features.each_value, [:main_code, kind]],
-            [@children, [kind, mode]]
-          ]
-          contexts.reverse! if mode == :bottom_up
-          contexts
+        def main_code_generator_contexts(kind, mode, target_or_range, depth)
+          [
+            feature_code_generator_context(:main_code, kind, target_or_range, depth),
+            CodeGeneratorContext.new(@children, [kind, mode, target_or_range, depth + 1])
+          ].tap { |contexts| mode == :bottom_up && contexts.reverse! }
         end
       end
     end

data/lib/rggen/core/output_base/component_factory.rb

@@ -6,8 +6,8 @@ module RgGen
       class ComponentFactory < Base::ComponentFactory
         private
 
-        def create_component(parent, configuration, register_map, &block)
-          target_component.new(parent, configuration, register_map, &block)
+        def select_actual_sources(configuration, register_map)
+          [configuration, register_map]
         end
 
         def create_features(component, configuration, register_map)
@@ -22,6 +22,10 @@ module RgGen
           end
         end
 
+        def find_child_factory(_configuration, register_map)
+          component_factories[register_map.layer]
+        end
+
         def post_build(component)
           component.pre_build
         end

data/lib/rggen/core/output_base/feature.rb

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module OutputBase
       class Feature < Base::Feature
-        include Base::HierarchicalFeatureAccessors
+        include Base::FeatureLayerExtension
         include RaiseError
 
         class << self
@@ -64,9 +64,8 @@ module RgGen
 
           def export(*methods)
             methods.each do |method|
-              exported_methods.include?(method) || (
-                exported_methods << method
-              )
+              exported_methods.include?(method) ||
+                (exported_methods << method)
             end
           end
         end
@@ -90,7 +89,7 @@ module RgGen
         end
 
         def post_initialize
-          define_hierarchical_accessors
+          define_layer_methods
         end
 
         def pre_build
@@ -122,9 +121,9 @@ module RgGen
           end
         end
 
-        def generate_code(phase, kind, code = nil)
+        def generate_code(code, phase, kind)
           generator = self.class.code_generators[phase]
-          (generator&.generate(self, kind, code)) || code
+          generator&.generate(self, code, kind)
         end
 
         def write_file(directory = nil)

data/lib/rggen/core/printers.rb

@@ -19,7 +19,7 @@ module RgGen
 
       def run(builder, options)
         verbose? && load_setup_file(builder, options[:setup])
-        puts help_message(builder)
+        puts version_message(builder)
       end
 
       private
@@ -32,7 +32,7 @@ module RgGen
         file.nil? || file.empty? || builder.load_setup_file(file, false)
       end
 
-      def help_message(builder)
+      def version_message(builder)
         [
           simple_version,
           *(verbose? && verbose_version(builder) || nil)

data/lib/rggen/core/register_map.rb

@@ -6,10 +6,10 @@ module RgGen
       def self.setup(builder)
         builder.input_component_registry(:register_map) do
           register_component [
-            :register_map, :register_block, :register, :bit_field
-          ] do |category|
+            :root, :register_block, :register_file, :register, :bit_field
+          ] do |layer|
             component Component, ComponentFactory
-            feature Feature, FeatureFactory if category != :register_map
+            feature Feature, FeatureFactory if layer != :root
           end
 
           base_loader Loader

data/lib/rggen/core/register_map/component.rb

@@ -4,15 +4,16 @@ module RgGen
   module Core
     module RegisterMap
       class Component < InputBase::Component
-        include Base::HierarchicalAccessors
+        include Base::ComponentLayerExtension
 
         attr_reader :configuration
 
         private
 
-        def post_initialize(_parent, configuration)
+        def post_initialize(configuration)
           @configuration = configuration
-          define_hierarchical_accessors
+          define_layer_methods
+          layer == :bit_field && need_no_children
         end
       end
     end

data/lib/rggen/core/register_map/component_factory.rb

@@ -4,14 +4,31 @@ module RgGen
   module Core
     module RegisterMap
       class ComponentFactory < InputBase::ComponentFactory
+        include RaiseError
+
         private
 
-        def create_component(parent, configuration, _, &block)
-          @target_component.new(parent, configuration, &block)
+        def select_actual_sources(configuration, *_)
+          configuration
         end
 
         def create_input_data(&block)
-          RegisterMapData.new(valid_value_lists, &block)
+          InputData.new(:root, valid_value_lists, &block)
+        end
+
+        def find_child_factory(_configuration, register_map)
+          component_factories[register_map.layer]
+        end
+
+        NO_CHILDREN_ERROR_MESSAGES = {
+          root: 'no register blocks are given',
+          register_block: 'neither register files nor registers are given',
+          register_file: 'neither register files nor registers are given',
+          register: 'no bit fields are given'
+        }.freeze
+
+        def raise_no_children_error(comoponent)
+          error(NO_CHILDREN_ERROR_MESSAGES[comoponent.layer])
         end
       end
     end

data/lib/rggen/core/register_map/feature.rb

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module RegisterMap
       class Feature < InputBase::Feature
-        include Base::HierarchicalFeatureAccessors
+        include Base::FeatureLayerExtension
         include RaiseError
 
         private
@@ -14,7 +14,7 @@ module RgGen
         end
 
         def post_initialize
-          define_hierarchical_accessors
+          define_layer_methods
         end
       end
     end

data/lib/rggen/core/register_map/hash_loader.rb

@@ -5,41 +5,34 @@ module RgGen
     module RegisterMap
       module HashLoader
         def format(read_data, file)
-          format_data(:register_map, register_map, read_data, file)
+          format_data(:root, root, read_data, file)
         rescue TypeError => e
           raise Core::LoadError.new(e.message, file)
         end
 
         private
 
-        CHILD_HIERARCHY = {
-          register_map: :register_block,
-          register_block: :register,
-          register: :bit_field
+        LAYER_MAP = {
+          root: { register_blocks: :register_block },
+          register_block: { register_files: :register_file, registers: :register },
+          register_file: { register_files: :register_file, registers: :register },
+          register: { bit_fields: :bit_field }
         }.freeze
 
-        CHILD_HIERARCHY_KEY = {
-          register_map: :register_blocks,
-          register_block: :registers,
-          register: :bit_fields
-        }.freeze
-
-        def format_data(hierarchy, input_data, read_data, file)
+        def format_data(layer, input_data, read_data, file)
           read_data = Hash(read_data)
           input_data.values(read_data, file)
-          read_data_for_child(hierarchy, read_data).each do |data|
-            format_data(
-              CHILD_HIERARCHY[hierarchy],
-              input_data.child,
-              data,
-              file
-            )
-          end
+          format_next_layer_data(layer, input_data, read_data, file)
         end
 
-        def read_data_for_child(hierarchy, read_data)
-          key = CHILD_HIERARCHY_KEY[hierarchy]
-          Array(key && read_data[key])
+        def format_next_layer_data(layer, input_data, read_data, file)
+          LAYER_MAP[layer]&.each do |key, next_layer|
+            Array(read_data[key]).each do |data|
+              format_data(
+                next_layer, input_data.child(next_layer), data, file
+              )
+            end
+          end
         end
       end
     end

data/lib/rggen/core/register_map/input_data.rb

@@ -3,30 +3,44 @@
 module RgGen
   module Core
     module RegisterMap
-      class BitFieldData < InputBase::InputData
-      end
+      class InputData < InputBase::InputData
+        module Root
+          def register_block(value_list = nil, &block)
+            child(:register_block, value_list, &block)
+          end
+        end
 
-      class RegisterData < InputBase::InputData
-        alias_method :bit_field, :child
+        module RegisterBlockRegisterFile
+          def register_file(value_list = nil, &block)
+            child(:register_file, value_list, &block)
+          end
 
-        def child_data_class
-          BitFieldData
+          def register(value_list = nil, &block)
+            child(:register, value_list, &block)
+          end
         end
-      end
 
-      class RegisterBlockData < InputBase::InputData
-        alias_method :register, :child
+        module Register
+          def bit_field(value_list = nil, &block)
+            child(:bit_field, value_list, &block)
+          end
+        end
 
-        def child_data_class
-          RegisterData
+        module BitField
+          def self.extended(object)
+            object.singleton_exec { undef_method :child }
+          end
         end
-      end
 
-      class RegisterMapData < InputBase::InputData
-        alias_method :register_block, :child
+        LAYER_EXTENSIONS = {
+          root: Root, register_block: RegisterBlockRegisterFile,
+          register_file: RegisterBlockRegisterFile, register: Register,
+          bit_field: BitField
+        }.freeze
 
-        def child_data_class
-          RegisterBlockData
+        def initialize(layer, valid_value_list)
+          extend(LAYER_EXTENSIONS[layer])
+          super
         end
       end
     end

data/lib/rggen/core/register_map/loader.rb

@@ -6,7 +6,7 @@ module RgGen
       class Loader < InputBase::Loader
         private
 
-        def register_map
+        def root
           input_data
         end
       end

data/lib/rggen/core/register_map/ruby_loader.rb

@@ -7,7 +7,7 @@ module RgGen
         support_types [:rb]
 
         def read_file(file)
-          register_map.load_file(file)
+          root.load_file(file)
         end
       end
     end

data/lib/rggen/core/utility/code_utility.rb

@@ -8,13 +8,15 @@ module RgGen
           code_block
         end
 
-        private
+        module_function
 
         def newline
           "\n"
         end
 
-        alias_method :nl, :newline
+        def nl
+          newline
+        end
 
         def comma
           ','
@@ -36,6 +38,10 @@ module RgGen
           "\"#{expression}\""
         end
 
+        def array_name(name, size)
+          [name, *size&.map { |s| "[#{s}]" }].join
+        end
+
         def code_block(indent = 0, &body)
           CodeBlock.new(indent, &body)
         end