rggen-core 0.9.0

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class FeatureFactory < InputBase::FeatureFactory
+        include RaiseError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      module HashLoader
+        def format(read_data, file)
+          format_data(:register_map, register_map, 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
+        }.freeze
+
+        CHILD_HIERARCHY_KEY = {
+          register_map: :register_blocks,
+          register_block: :registers,
+          register: :bit_fields
+        }.freeze
+
+        def format_data(hierarchy, 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
+        end
+
+        def read_data_for_child(hierarchy, read_data)
+          key = CHILD_HIERARCHY_KEY[hierarchy]
+          Array(key && read_data[key])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class BitFieldData < InputBase::InputData
+      end
+
+      class RegisterData < InputBase::InputData
+        alias_method :bit_field, :child
+
+        def child_data_class
+          BitFieldData
+        end
+      end
+
+      class RegisterBlockData < InputBase::InputData
+        alias_method :register, :child
+
+        def child_data_class
+          RegisterData
+        end
+      end
+
+      class RegisterMapData < InputBase::InputData
+        alias_method :register_block, :child
+
+        def child_data_class
+          RegisterBlockData
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class JSONLoader < Loader
+        include HashLoader
+        include InputBase::JSONLoader
+
+        support_types [:json]
+
+        def read_file(file)
+          load_json(file)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class Loader < InputBase::Loader
+        private
+
+        def register_map
+          input_data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class RubyLoader < Loader
+        support_types [:rb]
+
+        def read_file(file)
+          register_map.load_file(file)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class YAMLLoader < Loader
+        include HashLoader
+        include InputBase::YAMLLoader
+
+        support_types [:yaml, :yml]
+
+        def read_file(file)
+          load_yaml(file)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Utility
+      module AttributeSetter
+        module Extension
+          def attributes
+            @attributes ||= []
+          end
+
+          private
+
+          DEFAULT_VALUE = Object.new.freeze
+
+          def define_attribute(name, default_value = nil)
+            attributes << name.to_sym
+            variable_name = "@#{name}"
+            define_method(name) do |value = DEFAULT_VALUE|
+              if value.equal?(DEFAULT_VALUE)
+                attribute_value_get(variable_name, default_value)
+              else
+                instance_variable_set(variable_name, value)
+              end
+            end
+          end
+        end
+
+        def self.included(class_or_module)
+          class_or_module.extend(Extension)
+        end
+
+        def apply_attributes(**attributes)
+          attributes.each do |name, value|
+            __send__(name, value) if self.class.attributes.include?(name)
+          end
+        end
+
+        private
+
+        def attribute_value_get(variable_name, default_value)
+          if instance_variable_defined?(variable_name)
+            instance_variable_get(variable_name)
+          elsif default_value.is_a?(Proc)
+            instance_exec(&default_value)
+          else
+            default_value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Utility
+      module CodeUtility
+        def create_blank_code
+          code_block
+        end
+
+        private
+
+        def newline
+          "\n"
+        end
+
+        alias_method :nl, :newline
+
+        def comma
+          ','
+        end
+
+        def colon
+          ':'
+        end
+
+        def semicolon
+          ';'
+        end
+
+        def space(size = 1)
+          ' ' * size
+        end
+
+        def string(expression)
+          "\"#{expression}\""
+        end
+
+        def code_block(indent = 0, &body)
+          CodeBlock.new(indent, &body)
+        end
+
+        def indent(code, indent_size)
+          code << nl unless code.last_line_empty?
+          code.indent += indent_size
+          block_given? && yield(code)
+          code << nl unless code.last_line_empty?
+          code.indent -= indent_size
+        end
+
+        def wrap(code, head, tail)
+          code << head
+          block_given? && yield(code)
+          code << tail
+        end
+
+        def loop_index(level = 1)
+          return '' unless level.positive?
+          (1...level).inject(+'i') { |index, _| index.next! }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Utility
+      module CodeUtility
+        class CodeBlock
+          def initialize(indent = 0)
+            @indent = indent
+            @lines = []
+            add_line
+            block_given? && yield(self)
+          end
+
+          attr_reader :indent
+
+          def <<(rhs)
+            return push_string(rhs) if rhs.is_a?(String)
+            return push_code_block(rhs) if rhs.is_a?(CodeBlock)
+            return rhs.inject(self, :<<) if rhs.is_a?(Array)
+            return self << rhs.to_code if rhs.respond_to?(:to_code)
+            push_word(rhs)
+          end
+
+          def indent=(indent)
+            @indent = indent
+            last_line.indent = indent
+          end
+
+          def last_line_empty?
+            last_line.empty?
+          end
+
+          def to_s
+            @lines.map(&:to_s).each(&:rstrip!).join(newline)
+          end
+
+          def eval_block(&block)
+            return unless block_given?
+            block.arity.zero? ? self << yield : yield(self)
+          end
+
+          private
+
+          def add_line
+            line = Line.new(@indent)
+            @lines << line
+          end
+
+          def push_string(rhs)
+            rhs += newline if rhs.end_with?(newline)
+            rhs.each_line.with_index do |line, i|
+              i.positive? && add_line
+              push_word(line.chomp)
+            end
+            self
+          end
+
+          def push_code_block(rhs)
+            rhs.lines.each_with_index do |line, i|
+              i.positive? && add_line
+              line.empty? || (last_line.indent += line.indent)
+              last_line.concat(line)
+            end
+            self
+          end
+
+          def last_line
+            @lines.last
+          end
+
+          def push_word(word)
+            last_line << word
+            self
+          end
+
+          def newline
+            "\n"
+          end
+
+          protected
+
+          attr_reader :lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Utility
+      module CodeUtility
+        class Line
+          def initialize(indent = 0)
+            @indent = indent
+            @words = []
+          end
+
+          attr_reader :indent
+
+          def indent=(indent)
+            empty? && (@indent = indent)
+          end
+
+          def <<(word)
+            @words << word
+            self
+          end
+
+          def concat(line)
+            @words.concat(line.words)
+          end
+
+          def empty?
+            @words.all?(&method(:empty_word?))
+          end
+
+          def to_s
+            [' ' * (@indent || 0), *@words].join
+          end
+
+          private
+
+          def empty_word?(word)
+            return true if word.nil?
+            return false unless word.respond_to?(:empty?)
+            word.empty?
+          end
+
+          protected
+
+          attr_reader :words
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Utility
+      module CodeUtility
+        class SourceFile
+          include CodeUtility
+
+          class << self
+            attr_setter :ifndef_keyword
+            attr_setter :endif_keyword
+            attr_setter :define_keyword
+            attr_setter :include_keyword
+          end
+
+          def initialize(file_path)
+            @file_path = file_path
+            block_given? && yield(self)
+          end
+
+          attr_reader :file_path
+
+          def header(&block)
+            @file_header = -> { block.call(@file_path) }
+          end
+
+          def include_guard
+            @guard_macro =
+              if block_given?
+                yield(default_guard_macro)
+              else
+                default_guard_macro
+              end
+          end
+
+          def include_files(files)
+            @include_files ||= []
+            @include_files.concat(Array(files))
+          end
+
+          def include_file(file)
+            include_files([file])
+          end
+
+          def body(&block)
+            @bodies ||= []
+            @bodies << block
+          end
+
+          def to_code
+            CodeBlock.new do |code|
+              code_blocks.each { |block| execute_code_block(code, block, true) }
+            end
+          end
+
+          def to_s
+            to_code.to_s
+          end
+
+          private
+
+          def code_blocks
+            [
+              @file_header,
+              include_guard_header,
+              include_file_block,
+              *Array(@bodies),
+              include_guard_footer
+            ].compact
+          end
+
+          def execute_code_block(code, code_block, insert_newline)
+            code.eval_block(&code_block)
+            code << nl if insert_newline && !code.last_line_empty?
+          end
+
+          def default_guard_macro
+            File.basename(file_path).upcase.gsub(/\W/, '_')
+          end
+
+          def include_guard_header
+            @guard_macro && lambda do
+              [self.class.ifndef_keyword, self.class.define_keyword]
+                .flat_map { |keyword| [keyword, space, @guard_macro, nl] }
+            end
+          end
+
+          def include_file_block
+            @include_files && lambda do
+              keyword = self.class.include_keyword
+              @include_files
+                .flat_map { |file| [keyword, space, string(file), nl] }
+            end
+          end
+
+          def include_guard_footer
+            @guard_macro && (-> { self.class.endif_keyword })
+          end
+        end
+      end
+    end
+  end
+end