rggen-core 0.9.0

data/lib/rggen/core/input_base/property.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class Property
+        def self.define(feature, name, **options, &body)
+          new(name, options, body).define(feature)
+        end
+
+        def initialize(name, options, body)
+          @name = name
+          @options = options
+          @costom_property = create_costom_property(@options[:body] || body)
+        end
+
+        attr_reader :name
+
+        def define(feature)
+          feature.class_exec(self) do |property|
+            define_method(property.name) do |*args, &block|
+              property.evaluate(self, args, block)
+            end
+          end
+        end
+
+        def evaluate(feature, args, block)
+          feature.verify(@options[:verify]) if @options.key?(:verify)
+          if proxy_property?
+            proxy_property(feature, args, block)
+          else
+            default_property(feature)
+          end
+        end
+
+        private
+
+        def create_costom_property(body)
+          body && Module.new.module_eval do
+            define_method(:__costom_property__, &body)
+            instance_method(:__costom_property__)
+          end
+        end
+
+        def proxy_property?
+          [
+            @costom_property,
+            @options[:forward_to_helper],
+            @options[:forward_to]
+          ].any?
+        end
+
+        def proxy_property(feature, args, block)
+          receiver, method =
+            if @costom_property
+              [@costom_property.bind(feature), :call]
+            elsif @options[:forward_to_helper]
+              [feature.class, @name]
+            else
+              [feature, @options[:forward_to]]
+            end
+          receiver.__send__(method, *args, &block)
+        end
+
+        def default_property(feature)
+          varible_name = "@#{@name[-1] == '?' ? @name[0..-2] : @name}"
+          if feature.instance_variable_defined?(varible_name)
+            feature.instance_variable_get(varible_name)
+          else
+            @options[:default]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/input_base/verifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class Verifier
+        def initialize(&block)
+          instance_eval(&block)
+        end
+
+        def check_error(&block)
+          @error_checker = block
+        end
+
+        def error_condition(&block)
+          @condition = block
+        end
+
+        def message(&block)
+          @message = block
+        end
+
+        def verify(feature)
+          if @error_checker
+            feature.instance_eval(&@error_checker)
+          else
+            default_error_check(feature)
+          end
+        end
+
+        private
+
+        def default_error_check(feature)
+          feature.instance_exec(@condition, @message) do |condition, message|
+            instance_eval(&condition) && error(instance_eval(&message))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      module YAMLLoader
+        private
+
+        def load_yaml(file)
+          yaml = File.binread(file)
+          result =
+            if Psych::VERSION >= '3.1.0'
+              YAML.safe_load(yaml, aliases: true, filename: file)
+            else
+              YAML.safe_load(yaml, [], [], true, file)
+            end
+          symbolize_key(result)
+        end
+
+        def symbolize_key(result)
+          case result
+          when Hash
+            result.keys.each do |key|
+              result[key.to_sym] = symbolize_key(result.delete(key))
+            end
+          when Array
+            result.map! { |value| symbolize_key(value) }
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/rggen/core/options.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    class Options
+      extend ::Forwardable
+
+      class Option
+        def initialize(option_name)
+          @option_name = option_name
+          block_given? && yield(self)
+        end
+
+        def enable(parser, options)
+          options[@option_name] ||= default
+          parser.on(*args) { |value| handler(value, options, parser) }
+        end
+
+        attr_setter :short_option
+        attr_setter :long_option
+        attr_setter :option_class
+
+        def default(value = nil, &block)
+          if block_given?
+            @default = block
+          elsif !value.nil?
+            @default = -> { value }
+          elsif @default
+            instance_exec(&@default)
+          end
+        end
+
+        def description(value = nil)
+          if value
+            @description = value
+          else
+            @description
+          end
+        end
+
+        def action(&block)
+          if block_given?
+            @action = block
+          else
+            @action || default_action
+          end
+        end
+
+        private
+
+        def args
+          [@short_option, @long_option, @option_class, description].compact
+        end
+
+        def default_action
+          proc do |value, options, option_name, _parser|
+            options[option_name] = value
+          end
+        end
+
+        def handler(value, options, parser)
+          instance_exec(value, options, @option_name, parser, &action)
+        end
+      end
+
+      def self.options
+        @options ||= {}
+      end
+
+      def self.add_option(option_name, &body)
+        options[option_name] = Option.new(option_name, &body)
+      end
+
+      def initialize
+        @options = {}
+      end
+
+      attr_reader :original_args
+      attr_reader :register_map_files
+
+      def_delegator :@options, :[]
+
+      def parse(args)
+        @original_args = args
+        @register_map_files = option_parser.parse(args)
+      end
+
+      private
+
+      def option_parser
+        OptionParser.new do |parser|
+          parser.program_name = 'rggen'
+          parser.version = RgGen::Core::VERSION
+          parser.banner = 'Usage: rggen [options] register_map_files'
+          define_options(parser)
+        end
+      end
+
+      def define_options(parser)
+        self.class.options.each_value { |o| o.enable(parser, @options) }
+      end
+    end
+
+    Options.add_option(:setup) do |option|
+      option.long_option '--setup FILE'
+      option.default { default_steup_file }
+      option.description 'Specify a Ruby file to set up RgGen tool'
+
+      def option.default_steup_file
+        ENV['RGGEN_DEFAULT_SETUP_FILE'] || define_setup_file_from_const
+      end
+
+      def option.define_setup_file_from_const
+        require 'rggen/default_setup_file'
+        RgGen::DEFAULT_SETUP_FILE
+      rescue ::LoadError
+        nil
+      end
+    end
+
+    Options.add_option(:configuration) do |option|
+      option.short_option '-c'
+      option.long_option '--configuration FILE'
+      option.default { ENV['RGGEN_DEFAULT_CONFIGURATION_FILE'] }
+      option.description 'Specify a configuration file'
+    end
+
+    Options.add_option(:output) do |option|
+      option.short_option '-o'
+      option.long_option '--output DIRECTORY'
+      option.default { '.' }
+      option.description 'Specify the directory where ' \
+                         'generated file(s) will be written'
+    end
+
+    Options.add_option(:load_only) do |option|
+      option.long_option '--load-only'
+      option.default false
+      option.description 'Load setup, configuration and register map ' \
+                         'files only; write no files'
+    end
+
+    Options.add_option(:enable) do |option|
+      option.long_option '--enable WRITER1[,WRITER2,...]'
+      option.option_class Array
+      option.default { [] }
+      option.action { |v, o, n| merge_enabled_writers(v, o, n) }
+      option.description 'Enable only the given writer(s) to write files'
+
+      def option.merge_enabled_writers(value, options, option_name)
+        options[option_name].concat(value.map(&:to_sym))
+      end
+    end
+
+    Options.add_option(:version) do |option|
+      option.short_option '-v'
+      option.long_option '--version'
+      option.action do |_value, options|
+        options[:runner] = VersionPrinter.new(false)
+      end
+      option.description 'Display version'
+    end
+
+    Options.add_option(:verbose_version) do |option|
+      option.long_option '--verbose-version'
+      option.action do |_value, options|
+        options[:runner] = VersionPrinter.new(true)
+      end
+      option.description 'Load a setup Ruby file and display verbose version'
+    end
+
+    Options.add_option(:help) do |option|
+      option.short_option '-h'
+      option.long_option '--help'
+      option.action do |_value, options, _name, parser|
+        options[:runner] = HelpPrinter.new(parser)
+      end
+      option.description 'Display this message'
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class CodeGenerator
+        def register(kind, block)
+          return unless block
+          code_blocks[kind] << block
+        end
+
+        def generate(context, kind, code)
+          return code unless generatable?(kind)
+          execute_code_blocks(
+            context, kind, code || context.create_blank_code
+          )
+        end
+
+        def copy
+          generator = CodeGenerator.new
+          generator.copy_code_blocks(@code_blocks) if @code_blocks
+          generator
+        end
+
+        private
+
+        def code_blocks
+          @code_blocks ||= Hash.new { |blocks, kind| blocks[kind] = [] }
+        end
+
+        def generatable?(kind)
+          @code_blocks&.key?(kind)
+        end
+
+        def execute_code_blocks(context, kind, code)
+          code_blocks[kind].each(&code_block_executor(context, code))
+          code
+        end
+
+        def code_block_executor(context, code)
+          lambda do |block|
+            if block.arity.zero?
+              code << context.instance_exec(&block)
+            else
+              context.instance_exec(code, &block)
+            end
+          end
+        end
+
+        protected
+
+        def copy_code_blocks(original_blocks)
+          original_blocks
+            .each { |kind, blocks| code_blocks[kind] = blocks.dup }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class Component < Base::Component
+        include Base::HierarchicalAccessors
+
+        attr_reader :configuration
+        attr_reader :source
+
+        def post_initialize(_paren, configuration, source)
+          @configuration = configuration
+          @source = source
+          @need_children = source.need_children?
+          define_hierarchical_accessors
+          define_property_accessors
+          define_children_presense_indicator
+        end
+
+        def children?
+          !source.children.empty?
+        end
+
+        def add_feature(feature)
+          super
+          import_feature_methods(feature, :class)
+        end
+
+        def pre_build
+          @features.each_value(&:pre_build)
+        end
+
+        def build
+          @features.each_value(&method(:build_feature))
+          @children.each(&:build)
+        end
+
+        def generate_code(kind, mode, code = nil)
+          code_generators(kind, mode).inject(code) { |c, g| g[c] }
+        end
+
+        def write_file(directory = nil)
+          @features.each_value { |feature| feature.write_file(directory) }
+          @children.each { |component| component.write_file(directory) }
+        end
+
+        private
+
+        def define_property_accessors
+          def_delegators(:@source, *@source.properties)
+        end
+
+        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)
+        end
+
+        def import_feature_methods(feature, scope)
+          receiver = "@features[:#{feature.feature_name}]"
+          methods = feature.exported_methods(scope)
+          def_delegators(receiver, *methods)
+        end
+
+        def code_generators(kind, mode)
+          [
+            [@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
+          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
+        end
+      end
+    end
+  end
+end