rggen 0.8.2 → 0.9.0

data/bin/rggen

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-$LOAD_PATH.unshift(File.join(__dir__, '../lib'))
-
-require 'rggen'
-RgGen::Generator.new.run(ARGV)

data/c_header/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Taichi Ishitani
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/c_header/rggen.h

@@ -1,17 +0,0 @@
-#ifndef RGGEN_H
-#define RGGEN_H
-
-#include <stdint.h>
-
-typedef uint8_t   rggen_uint8;
-typedef uint16_t  rggen_uint16;
-typedef uint32_t  rggen_uint32;
-typedef uint64_t  rggen_uint64;
-
-#define RGGEN_EXTERNAL_REGISTERS(SIZE, TYPE) \
-union { \
-  rggen_uint8 array[SIZE]; \
-  TYPE        body; \
-}
-
-#endif

data/lib/rggen/base/component.rb

@@ -1,31 +0,0 @@
-module RgGen
-  module Base
-    class Component
-      include SingleForwardable
-
-      def initialize(parent)
-        @parent   = parent
-        @children = []
-        @level    = (parent && parent.level + 1) || 0
-        @items    = []
-      end
-
-      attr_reader :parent
-      attr_reader :children
-      attr_reader :level
-      attr_reader :items
-
-      def need_children?
-        @need_children
-      end
-
-      def add_child(child)
-        @children << child if need_children?
-      end
-
-      def add_item(item)
-        items << item
-      end
-    end
-  end
-end

data/lib/rggen/base/component_factory.rb

@@ -1,53 +0,0 @@
-module RgGen
-  module Base
-    class ComponentFactory
-      def initialize
-        @root_factory = false
-      end
-
-      attr_writer :target_component
-      attr_writer :item_factories
-      attr_writer :child_factory
-
-      def create(*args)
-        parent  = (child_factory? && args.shift) || nil
-        sources = args
-        create_component(parent, *sources).tap do |component|
-          create_items(component, *sources) if create_items?
-          parent.add_child(component) if child_factory?
-          create_children(component, *sources) if create_children?(component)
-        end
-      end
-
-      def root_factory
-        @root_factory = true
-      end
-
-      private
-
-      def child_factory?
-        !@root_factory
-      end
-
-      def create_items?
-        @item_factories.not_nil?
-      end
-
-      def create_children?(component)
-        @child_factory.not_nil? && component.need_children?
-      end
-
-      def create_component(parent, *_sources)
-        @target_component.new(parent)
-      end
-
-      def create_item(item_factory, component, *sources)
-        item_factory.create(component, *sources)
-      end
-
-      def create_child(component, *sources)
-        @child_factory.create(component, *sources)
-      end
-    end
-  end
-end

data/lib/rggen/base/hierarchical_accessors.rb

@@ -1,87 +0,0 @@
-module RgGen
-  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
-
-      EXTENSIONS  = [
-        RegisterMap, RegisterBlock, Register, BitField
-      ].freeze
-
-      def define_hierarchical_accessors
-        extend EXTENSIONS[level]
-      end
-    end
-  end
-end

data/lib/rggen/base/hierarchical_item_accessors.rb

@@ -1,79 +0,0 @@
-module RgGen
-  module Base
-    module HierarchicalItemAccessors
-      module RegisterMap
-        def hierarchy
-          :register_map
-        end
-
-        def register_map
-          @owner
-        end
-      end
-
-      module RegisterBlock
-        def hierarchy
-          :register_block
-        end
-
-        def register_map
-          register_block.parent
-        end
-
-        def register_block
-          @owner
-        end
-      end
-
-      module Register
-        def hierarchy
-          :register
-        end
-
-        def register_map
-          register_block.parent
-        end
-
-        def register_block
-          register.parent
-        end
-
-        def register
-          @owner
-        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
-          @owner
-        end
-      end
-
-      private
-
-      EXTENSIONS  = [
-        RegisterMap, RegisterBlock, Register, BitField
-      ].freeze
-
-      def define_hierarchical_item_accessors
-        extend EXTENSIONS[@owner.level]
-      end
-    end
-  end
-end

data/lib/rggen/base/internal_struct.rb

@@ -1,28 +0,0 @@
-module RgGen
-  module Base
-    module InternalStruct
-      private
-
-      def internal_structs
-        @internal_structs ||= {}
-      end
-
-      def define_struct(struct_name, members, &body)
-        return if internal_structs.key?(struct_name)
-        internal_structs[struct_name] = Struct.new(*members, &body)
-        define_method(struct_name) do
-          self.class.send(:internal_structs)[struct_name]
-        end
-        private(struct_name)
-      end
-
-      def inherited(subclass)
-        super(subclass)
-        return unless instance_variable_defined?(:@internal_structs)
-        subclass.instance_variable_set(
-          :@internal_structs, Hash[@internal_structs]
-        )
-      end
-    end
-  end
-end

data/lib/rggen/base/item.rb

@@ -1,35 +0,0 @@
-module RgGen
-  module Base
-    class Item
-      extend Forwardable
-      extend InternalStruct
-
-      class << self
-        def define_helpers(&body)
-          singleton_class.class_exec(&body) if block_given?
-        end
-
-        def available?(&body)
-          define_method(:available?, &body)
-        end
-
-        def inherit_class_instance_variable(variable_name, klass)
-          return unless klass.instance_variable_defined?(variable_name)
-          v = klass.instance_variable_get(variable_name)
-          v = yield(v) if block_given?
-          instance_variable_set(variable_name, v)
-        end
-      end
-
-      def initialize(owner)
-        @owner  = owner
-      end
-
-      attr_reader :owner
-
-      def available?
-        true
-      end
-    end
-  end
-end

data/lib/rggen/base/item_factory.rb

@@ -1,25 +0,0 @@
-module RgGen
-  module Base
-    class ItemFactory
-      extend InternalStruct
-
-      attr_writer :target_items
-      attr_writer :target_item
-
-      private
-
-      def create_item(owner, *args)
-        item  = create_item_object(owner, *args)
-        return unless item.available?
-        yield item if block_given?
-        owner.add_item(item)
-      end
-
-      def create_item_object(owner, *args)
-        klass ||= @target_items && select_target_item(*args)
-        klass ||= @target_item
-        klass.new(owner)
-      end
-    end
-  end
-end

data/lib/rggen/builder/builder.rb

@@ -1,69 +0,0 @@
-module RgGen
-  module Builder
-    class Builder
-      INITIAL_CATEGORIES  = [
-        :global,
-        :register_block,
-        :register,
-        :bit_field
-      ].freeze
-
-      def initialize
-        @stores = Hash.new do |_, component_name|
-          raise RgGen::BuilderError, "unknown component: #{component_name}"
-        end
-        @categories = Hash.new do |_, category_name|
-          raise RgGen::BuilderError, "unknown category: #{category_name}"
-        end
-        INITIAL_CATEGORIES.each do |category_name|
-          @categories[category_name]  = Category.new
-        end
-      end
-
-      attr_reader :categories
-
-      def input_component_store(component_name, &body)
-        component_store(InputComponentStore, component_name, body)
-      end
-
-      def output_component_store(component_name, &body)
-        component_store(OutputComponentStore, component_name, body)
-      end
-
-      def stored_output_components
-        @stores.keys.select do |component_name|
-          @stores[component_name].is_a?(OutputComponentStore)
-        end
-      end
-
-      def define_loader(component_name, type_or_types, &body)
-        @stores[component_name].define_loader(type_or_types, &body)
-      end
-
-      def build_factory(component_name)
-        @stores[component_name].build_factory
-      end
-
-      def define_simple_item(category_name, item_name, &body)
-        @categories[category_name].define_simple_item(item_name, &body)
-      end
-
-      def define_list_item(category_name, list_name, item_name = nil, &body)
-        @categories[category_name].define_list_item(list_name, item_name, &body)
-      end
-
-      def enable(category_name, *args)
-        @categories[category_name].enable(*args)
-      end
-
-      private
-
-      def component_store(klass, component_name, body)
-        unless @stores.key?(component_name)
-          @stores[component_name] = klass.new(self, component_name)
-        end
-        @stores[component_name].instance_exec(&body)
-      end
-    end
-  end
-end