rggen 0.3.0

data/lib/rggen/core_components/rtl/item.rb

@@ -0,0 +1,83 @@
+module RgGen
+  module RTL
+    class Item < OutputBase::Item
+      use_verilog_utility
+
+      def initialize(owner)
+        super(owner)
+        @identifiers              = []
+        @signal_declarations      = []
+        @port_declarations        = []
+        @parameter_declarations   = []
+        @localparam_declarations  = []
+      end
+
+      attr_reader :identifiers
+      attr_reader :signal_declarations
+      attr_reader :port_declarations
+      attr_reader :parameter_declarations
+      attr_reader :localparam_declarations
+
+      private
+
+      class << self
+        private
+
+        def define_declaration_method(method_name)
+          define_method(method_name) do |handle_name, attributes = {}|
+            attributes[:name] ||= handle_name.to_s
+            add_identifier(handle_name, attributes[:name])
+            add_declaration(method_name, attributes)
+          end
+          private method_name
+        end
+      end
+
+      define_declaration_method :wire
+      define_declaration_method :reg
+      define_declaration_method :logic
+      define_declaration_method :input
+      define_declaration_method :output
+      define_declaration_method :parameter
+      define_declaration_method :localparam
+
+      def group(group_name, &body)
+        create_group(group_name)
+        instance_exec(&body)
+        @group  = nil
+      end
+
+      def add_declaration(type, attributes)
+        attribute_key, declaration_type, declarations =
+          case type
+          when :wire, :reg, :logic
+            [:data_type, :variable, signal_declarations]
+          when :input, :output
+            [:direction, :port, port_declarations]
+          when :parameter
+            [:parameter_type, :parameter, parameter_declarations]
+          when :localparam
+            [:parameter_type, :parameter, localparam_declarations]
+          end
+        attributes[attribute_key] = type
+        declarations << create_declaration(declaration_type, attributes)
+      end
+
+      def add_identifier(handle_name, name)
+        identifier  = create_identifier(name)
+        (@group || self).instance_exec do
+          instance_variable_set(handle_name.variablize, identifier)
+          attr_singleton_reader(handle_name)
+        end
+        identifiers << handle_name if @group.nil?
+      end
+
+      def create_group(group_name)
+        instance_variable_set(group_name.variablize, Object.new)
+        attr_singleton_reader(group_name)
+        identifiers << group_name
+        @group      = __send__(group_name)
+      end
+    end
+  end
+end

data/lib/rggen/core_components/rtl/setup.rb

@@ -0,0 +1,19 @@
+module RgGen
+  module RTL
+    output_component_store :rtl do
+      entry do
+        component_class   OutputBase::Component
+        component_factory OutputBase::ComponentFactory
+      end
+
+      entry [:register_block, :register, :bit_field] do
+        component_class   Component
+        component_factory OutputBase::ComponentFactory
+        item_base         Item
+        item_factory      OutputBase::ItemFactory
+      end
+
+      output_directory  'rtl'
+    end
+  end
+end

data/lib/rggen/core_components.rb

@@ -0,0 +1,23 @@
+require_relative 'core_components/configuration/raise_error'
+require_relative 'core_components/configuration/configuration_factory'
+require_relative 'core_components/configuration/item_factory'
+require_relative 'core_components/configuration/setup'
+
+require_relative 'core_components/register_map/generic_map'
+require_relative 'core_components/register_map/loader'
+require_relative 'core_components/register_map/raise_error'
+require_relative 'core_components/register_map/component'
+require_relative 'core_components/register_map/item'
+require_relative 'core_components/register_map/register_map_factory'
+require_relative 'core_components/register_map/register_block_factory'
+require_relative 'core_components/register_map/register_factory'
+require_relative 'core_components/register_map/bit_field_factory'
+require_relative 'core_components/register_map/item_factory'
+require_relative 'core_components/register_map/setup'
+
+require_relative 'core_components/rtl/component'
+require_relative 'core_components/rtl/item'
+require_relative 'core_components/rtl/setup'
+
+require_relative 'core_components/ral/item'
+require_relative 'core_components/ral/setup'

data/lib/rggen/core_extensions/facets.rb

@@ -0,0 +1,17 @@
+require 'facets/enumerable/exclude'
+require 'facets/enumerable/sum'
+require 'facets/file/ext'
+require 'facets/hash/symbolize_keys'
+require 'facets/integer/multiple'
+require 'facets/kernel/attr_singleton'
+require 'facets/kernel/not'
+require 'facets/kernel/not_nil'
+require 'facets/module/attr_setter'
+require 'facets/numeric/positive'
+require 'facets/range/overlap'
+require 'facets/regexp/op_add'
+require 'facets/regexp/op_or'
+require 'facets/string/indent'
+require 'facets/string/quote'
+require 'facets/string/variablize'
+require 'facets/symbol/variablize'

data/lib/rggen/core_extensions/forwardable.rb

@@ -0,0 +1,26 @@
+module Forwardable
+  def def_class_delegator(method, ali = method)
+    def_delegator('self.class', method, ali)
+  end
+
+  def def_class_delegators(*methods)
+    def_instance_delegators('self.class', *methods)
+  end
+
+  alias_method :class_delegator , :def_class_delegator
+  alias_method :class_delegators, :def_class_delegators
+end
+
+module SingleForwardable
+  def def_object_delegator(target, method, ali = method)
+    define_singleton_method(ali) do |*args, &block|
+      target.__send__(method, *args, &block)
+    end
+  end
+
+  def def_object_delegators(target, *methods)
+    methods.each do |method|
+      def_object_delegator(target, method)
+    end
+  end
+end

data/lib/rggen/core_extensions/integer.rb

@@ -0,0 +1,5 @@
+class Integer
+  def pow2?
+    positive? && (ord & pred).zero?
+  end
+end

data/lib/rggen/core_extensions/math.rb

@@ -0,0 +1,7 @@
+module Math
+  module_function
+
+  def clog2(value)
+    Math.log2(value).ceil
+  end
+end

data/lib/rggen/exceptions.rb

@@ -0,0 +1,22 @@
+module RgGen
+  class RgGenError < StandardError
+  end
+
+  class BuilderError < RgGenError
+  end
+
+  class LoadError < RgGenError
+  end
+
+  class ConfigurationError < RgGenError
+  end
+
+  class RegisterMapError < RgGenError
+    def initialize(message, position)
+      super(message)
+      @position = position
+    end
+
+    attr_reader :position
+  end
+end

data/lib/rggen/generator.rb

@@ -0,0 +1,185 @@
+module RgGen
+  class Generator
+    Context = Struct.new(:options, :configuration, :register_map) do
+      def initialize
+        super
+        self.options  = {}
+      end
+    end
+
+    class Option
+      def initialize(kind)
+        @kind = kind
+      end
+
+      attr_accessor :short
+      attr_accessor :long
+      attr_accessor :class
+      attr_writer   :default
+      attr_writer   :description
+      attr_writer   :body
+
+      def on(parser, options)
+        options[@kind]  = @default if @default
+        parser.on(*args) do |value|
+          parser.instance_exec(value, options, @kind, &body)
+        end
+      end
+
+      def args
+        [@short, @long, @class, description].compact
+      end
+
+      def description
+        return nil unless @description || @default
+        d = ''
+        d << @description.to_s
+        d << "(default: #{@default})" if @default
+        d
+      end
+
+      def body
+        @body || default_body
+      end
+
+      def default_body
+        proc do |value, options, kind|
+          options[kind] = value
+        end
+      end
+    end
+
+    class << self
+      def options
+        @options  ||= []
+      end
+
+      private
+
+      def add_option(kind, &body)
+        options << Option.new(kind)
+        body.call(options.last)
+      end
+    end
+
+    add_option :setup do |option|
+      option.long         = '--setup FILE'
+      option.default      = File.join(RGGEN_HOME, 'setup', 'default.rb')
+      option.description  = 'Specify a setup file to set up RgGen tool'
+    end
+
+    add_option :configuration do |option|
+      option.short        = '-c'
+      option.long         = '--configuration FILE'
+      option.description  = 'Specify a configuration file ' \
+                            'for generated source code'
+    end
+
+    add_option :output do |option|
+      option.short        = '-o'
+      option.long         = '--output DIR'
+      option.default      = './'
+      option.description  = 'Specify output directory'
+    end
+
+    add_option :except do |option|
+      option.long         = '--except [TYPE1,TYPE2,...]'
+      option.class        = Array
+      option.description  = 'Disable the given output file type(s)'
+      option.body         = proc do |value, options, kind|
+        options[kind] ||= []
+        options[kind].concat(value.map(&:to_sym))
+      end
+    end
+
+    add_option :version do |option|
+      option.short        = '-v'
+      option.long         = '--version'
+      option.description  = 'Display the version'
+      option.body         = proc do
+        puts ver
+        exit
+      end
+    end
+
+    add_option :help do |option|
+      option.short        = '-h'
+      option.long         = '--help'
+      option.description  = 'Display this message'
+      option.body         = proc do
+        puts help
+        exit
+      end
+    end
+
+    def run(argv)
+      Context.new.tap do |context|
+        parse_options(argv, context)
+        load_setup(context)
+        load_configuration(context)
+        load_register_map(context, argv.first)
+        write_files(context)
+      end
+    end
+
+    private
+
+    def parse_options(argv, context)
+      option_parser(context.options).parse!(argv)
+    end
+
+    def option_parser(options)
+      OptionParser.new do |parser|
+        parser.version      = RgGen::VERSION
+        parser.program_name = 'rggen'
+        parser.banner       = 'Usage: rggen [options] REGISTER_MAP'
+        add_option_switches(parser, options)
+      end
+    end
+
+    def add_option_switches(parser, options)
+      self.class.options.each do |option|
+        option.on(parser, options)
+      end
+    end
+
+    def load_setup(context)
+      load(context.options[:setup])
+    end
+
+    def build_factory(component_name)
+      RgGen.builder.build_factory(component_name)
+    end
+
+    def load_configuration(context)
+      context.configuration =
+        build_factory(:configuration).create(context.options[:configuration])
+    end
+
+    def load_register_map(context, file)
+      context.register_map  =
+        build_factory(:register_map).create(context.configuration, file)
+    end
+
+    def write_files(context)
+      file_generators(context).each do |generator|
+        generator.write_file(context.options[:output])
+      end
+    end
+
+    def file_generators(context)
+      available_output_components(context).map do |component|
+        build_factory(component).create(
+          context.configuration, context.register_map
+        )
+      end
+    end
+
+    def available_output_components(context)
+      except  = context.options[:except]
+      RgGen.builder.stored_output_components.select do |component|
+        except.nil? || except.exclude?(component)
+      end
+    end
+  end
+end

data/lib/rggen/input_base/component.rb

@@ -0,0 +1,19 @@
+module RgGen
+  module InputBase
+    class Component < Base::Component
+      def add_item(item)
+        super(item)
+        def_object_delegators(@items.last, *item.fields)
+      end
+
+      def fields
+        items.flat_map(&:fields)
+      end
+
+      def validate
+        items.each(&:validate)
+        children.each(&:validate)
+      end
+    end
+  end
+end

data/lib/rggen/input_base/component_factory.rb

@@ -0,0 +1,58 @@
+module RgGen
+  module InputBase
+    class ComponentFactory < Base::ComponentFactory
+      attr_writer :loaders
+
+      def create(*args)
+        if @root_factory
+          file    = args.pop
+          source  = load(file)
+          args    << source
+
+          component = super(*args)
+          component.validate
+        else
+          component = super(*args)
+        end
+        component
+      end
+
+      private
+
+      def create_items(component, *sources)
+        create_active_items(component, *sources)
+        create_passive_items(component, *sources[0..-2])
+      end
+
+      def create_passive_items(component, *sources)
+        passive_item_factories.each do |factory|
+          create_item(factory, component, *sources)
+        end
+      end
+
+      def active_item_factories
+        @item_factories.each_with_object({}) do |(name, factory), factories|
+          factories[name] = factory if factory.active_item_factory?
+        end
+      end
+
+      def passive_item_factories
+        @item_factories.each_value.select(&:passive_item_factory?)
+      end
+
+      def load(file)
+        load_file(file)
+      end
+
+      def load_file(file)
+        find_loader(file).load_file(file)
+      end
+
+      def find_loader(file)
+        loader  = @loaders && @loaders.find { |l| l.acceptable?(file) }
+        return loader.new unless loader.nil?
+        fail RgGen::LoadError, "unsupported file type: #{File.ext(file)}"
+      end
+    end
+  end
+end

data/lib/rggen/input_base/item.rb

@@ -0,0 +1,170 @@
+module RgGen
+  module InputBase
+    class Item < Base::Item
+      include RegxpPatterns
+
+      class InputMatcher
+        def initialize(pattern, options)
+          @options  = options
+          @pattern  =
+            if @options.fetch(:match_wholly, true)
+              /\A#{pattern}\z/
+            else
+              pattern
+            end
+        end
+
+        attr_reader :match_data
+
+        def match_automatically?
+          @options.fetch(:match_automatically, true)
+        end
+
+        def match(rhs)
+          rhs = rhs.to_s if @options[:convert_to_string]
+          rhs = delete_blanks(rhs) if @options.fetch(:ignore_blank, true)
+          @match_data =
+            case rhs
+            when @pattern
+              Regexp.last_match
+            end
+        end
+
+        private
+
+        BLANK_REGEXP  = [
+          /\A[ \t]+/,
+          /(?<=\w)[ \t]+(?=[[:punct:]])/,
+          /(?<=[[:punct:]])[ \t]+(?=\w)/,
+          /[ \t]+\z/
+        ].inject(&:|).freeze
+
+        def delete_blanks(rhs)
+          return rhs unless rhs.respond_to?(:gsub)
+          rhs.gsub(BLANK_REGEXP, '')
+        end
+      end
+
+      define_helpers do
+        attr_reader :builders
+        attr_reader :validators
+        attr_reader :input_matcher
+
+        def field(field_name, options = {}, &body)
+          return if fields.include?(field_name)
+
+          define_method(field_name) do
+            field_method(field_name, options, body)
+          end
+
+          fields  << field_name
+        end
+
+        def fields
+          @fields ||= []
+        end
+
+        def build(&body)
+          @builders ||= []
+          @builders << body
+        end
+
+        def validate(&body)
+          @validators ||= []
+          @validators << body
+        end
+
+        def input_pattern(pattern, options = {})
+          @input_matcher  = InputMatcher.new(pattern, options)
+        end
+
+        def active_item?
+          !passive_item?
+        end
+
+        def passive_item?
+          @builders.nil? || @builders.empty?
+        end
+      end
+
+      def self.inherited(subclass)
+        [:@fields, :@builders, :@validators].each do |v|
+          subclass.inherit_class_instance_variable(v, self, &:dup)
+        end
+        subclass.inherit_class_instance_variable(:@input_matcher, self)
+      end
+
+      class_delegator :fields
+      class_delegator :builders
+      class_delegator :validators
+      class_delegator :input_matcher
+
+      def build(*sources)
+        return unless builders
+        pattern_match(sources.last) if match_automatically?
+        builders.each do |builder|
+          instance_exec(*sources, &builder)
+        end
+      end
+
+      def validate
+        return if @validated
+        return unless validators
+        validators.each do |validator|
+          instance_exec(&validator)
+        end
+        @validated  = true
+      end
+
+      private
+
+      def pattern_match(rhs)
+        input_matcher && input_matcher.match(rhs)
+      end
+
+      def match_data
+        input_matcher && input_matcher.match_data
+      end
+
+      def pattern_matched?
+        match_data.not_nil?
+      end
+
+      def captures
+        match_data && match_data.captures
+      end
+
+      def match_automatically?
+        input_matcher && input_matcher.match_automatically?
+      end
+
+      def field_method(field_name, options, body)
+        validate if options[:need_validation]
+        if body
+          instance_exec(&body)
+        elsif options[:forward_to_helper]
+          self.class.__send__(field_name)
+        elsif options.key?(:forward_to)
+          __send__(options[:forward_to])
+        else
+          default_field_method(field_name, options[:default])
+        end
+      end
+
+      def default_field_method(field_name, default_value)
+        variable_name =
+          if field_name =~ /\A([a-zA-Z0-9]\w*)\?\z/
+            Regexp.last_match[1].variablize
+          else
+            field_name.variablize
+          end
+
+        if instance_variable_defined?(variable_name)
+          instance_variable_get(variable_name)
+        else
+          default_value
+        end
+      end
+    end
+  end
+end

data/lib/rggen/input_base/item_factory.rb

@@ -0,0 +1,13 @@
+module RgGen
+  module InputBase
+    class ItemFactory < Base::ItemFactory
+      def active_item_factory?
+        !passive_item_factory?
+      end
+
+      def passive_item_factory?
+        @target_items.nil? && @target_item.passive_item?
+      end
+    end
+  end
+end

data/lib/rggen/input_base/loader.rb

@@ -0,0 +1,14 @@
+module RgGen
+  module InputBase
+    class Loader
+      class << self
+        attr_writer :supported_types
+
+        def acceptable?(file_name)
+          ext = File.ext(file_name).to_sym
+          @supported_types.any? { |type| type.casecmp(ext) == 0 }
+        end
+      end
+    end
+  end
+end

data/lib/rggen/input_base/regexp_patterns.rb

@@ -0,0 +1,29 @@
+module RgGen
+  module InputBase
+    module RegxpPatterns
+      BIN_REGEXP  = /0b(?:[01][01_]*)?[01]/i
+      OCT_REGEXP  = /0o(?:[0-7][0-7_]*)?[0-7]/i
+      DEC_REGEXP  = /(?:[1-9][\d_]*)?\d/
+      HEX_REGEXP  = /0x(?:\h[\h_]*)?\h/i
+
+      UNSIGNED_NUMBER_REGEXP  = (
+        /\b/ + (BIN_REGEXP | OCT_REGEXP | DEC_REGEXP | HEX_REGEXP) + /\b/
+      ).freeze
+      VARIABLE_NAME_REGEXP    = /\b[a-z_][a-z0-9_]*\b/i
+
+      def self.included(klass)
+        klass.extend(self)
+      end
+
+      private
+
+      def number
+        UNSIGNED_NUMBER_REGEXP
+      end
+
+      def variable_name
+        VARIABLE_NAME_REGEXP
+      end
+    end
+  end
+end