antelope 0.3.2 → 0.4.0

data/lib/antelope/generator/base.rb

@@ -1,264 +1,134 @@
-require 'hashie/mash'
-
-module Antelope
-  module Generator
-
-    # Generates a parser.  This is normally the parent class, and the
-    # specific implementations inherit from this.  The generated
-    # parser should, ideally, be completely independent (not requiring
-    # any external source code), as well as be under a permissive
-    # license.
-    #
-    # @abstract Subclass and redefine {#generate} to create a
-    #   generator.
-    class Base
-      Boolean = Object.new
-      # The modifiers that were applied to the grammar.
-      #
-      # @return [Hash<(Symbol, Object)>]
-      attr_reader :mods
-
-      # The file name (not including the extension) that the grammar
-      # should output to.
-      #
-      # @return [String]
-      attr_reader :file
-
-      # The grammar that the generator is for.
-      #
-      # @return [Ace::Grammar]
-      attr_reader :grammar
-
-      # The source root directory for templates.  Overwrite to change.
-      #
-      # @return [Pathname]
-      def self.source_root
-        Pathname.new("../templates").expand_path(__FILE__)
-      end
-
-      def self.register_as(*names)
-        Generator.register_generator(self, *names)
-      end
-
-      # Called by ruby on subclassing.
-      #
-      # @param subclass [Class]
-      # @return [void]
-      def self.inherited(subclass)
-        directives.each do |name, (_, type)|
-          subclass.has_directive(name, type)
-        end
-      end
-
-      # Allows a directive for this generator.  This is checked in
-      # the compiler to allow the option.  If the compiler encounters
-      # a bad directive, it'll error (to give the developer a warning).
-      #
-      # @param directive [Symbol, String]
-      # @param type [Object] used to define how the value should be
-      #   coerced.
-      # @see #directives
-      # @see #coerce_directive_value
-      # @return [void]
-      def self.has_directive(directive, type = nil)
-        directive = directive.to_s
-        directives[directive] = [self, type]
-      end
-
-      # The directives in the class.
-      #
-      # @see .has_directive
-      # @return [Hash]
-      def self.directives
-        @_directives ||= {}
-      end
-
-      class << self
-        alias_method :has_directives, :has_directive
-      end
-
-      # Initialize the generator.
-      #
-      # @param grammar [Grammar]
-      # @param mods [Hash<(Symbol, Object)>]
-      def initialize(grammar, mods)
-        @file    = grammar.name
-        @grammar = grammar
-        @mods    = mods
-      end
-
-      # Actually does the generation.  A subclass should implement this.
-      #
-      # @raise [NotImplementedError]
-      # @return [void]
-      def generate
-        raise NotImplementedError
-      end
-
-      protected
-
-      # Retrieves all directives from the grammar, and giving them the
-      # proper values for this instance.
-      #
-      # @see .has_directive
-      # @see #coerce_directive_value
-      # @return [Hash]
-      def directives
-        @_directives ||= begin
-          hash = Hashie::Mash.new
-
-          self.class.directives.each do |key, dict|
-            value = [grammar.options.key?(key), grammar.options[key]]
-            hash.deep_merge! coerce_nested_hash(key,
-              coerce_directive_value(*value, dict[1]))
-          end
-
-          hash
-        end
-      end
-
-      def coerce_nested_hash(key, value)
-        parts = key.split('.').map { |p| p.gsub(/-/, '_') }
-        top   = {}
-        hash  = top
-        parts.each_with_index do |part, _|
-          hash[part] = if parts.last == part
-                         value
-                       else
-                         {}
-                       end
-          hash = hash[part]
-        end
-
-        top[key] = value
-        top
-      end
-
-      # Coerce the given directive value to the given type.  For the
-      # type `nil`, it checks the size of the values; for no values,
-      # it returns true; for one value, it returns that one value; for
-      # any other size value, it returns the values.  For the type
-      # `Boolean`, if no values were given, or if the first value isn't
-      # "false", it returns true.  For the type `:single` (or `:one`),
-      # it returns the first value.  For the type `Array`, it returns
-      # the values.  For any other type that is a class, it tries to
-      # initialize the class with the given arguments.
-      def coerce_directive_value(defined, values, type)
-        return nil unless defined || Array === type
-        case type
-        when nil
-          case values.size
-          when 0
-            true
-          when 1
-            values[0]
-          else
-            values
-          end
-        when :single, :one
-          values[0]
-        when Boolean
-          # For bool, if there were no arguments, then return true;
-          # otherwise, if the first argument isn't "false", return
-          # true.
-
-          values[0].to_s != 'false'
-        when Array
-          values.zip(type).map do |value, t|
-            coerce_directive_value(defined, [value], t)
-          end
-        when Class
-          if type == Array
-            values
-          elsif type == String
-            values[0].to_s
-          elsif [Fixnum, Integer, Numeric].include?(type)
-            values[0].to_i
-          elsif type == Float
-            values[0].to_f
-          else
-            type.new(*values)
-          end
-        else
-          raise UnknownTypeError, "unknown type #{type}"
-        end
-      end
-
-      # Copies a template from the source, runs it through erb (in the
-      # context of this class), and then outputs it at the destination.
-      # If given a block, it will call the block after the template is
-      # run through erb with the content from erb; the result of the
-      # block is then used as the content instead.
-      #
-      # @param source [String] the source file.  This should be in
-      #   {.source_root}.
-      # @param destination [String] the destination file.  This will be
-      #   in {Ace::Grammar#output}.
-      # @yieldparam [String] content The content that ERB created.
-      # @yieldreturn [String] The new content to write to the output.
-      # @return [void]
-      def template(source, destination)
-        src  = Pathname.new("#{source}.ant").
-          expand_path(self.class.source_root)
-
-        template = Template.new(src)
-        content  = template.result(instance_eval('binding'))
-        content.gsub!(/[ \t]+\n/, "\n")
-
-        if block_given?
-          content = yield content
-        end
-
-        dest = Pathname.new(destination).
-          expand_path(grammar.output)
-
-        dest.open("w") do |file|
-          file.write(content)
-        end
-      end
-
-      # The actual table that is used for parsing.  This returns an
-      # array of hashes; the array index corresponds to the state
-      # number, and the hash keys correspond to the lookahead tokens.
-      # The hash values are an array; the first element of that array
-      # is the action to be taken, and the second element of the
-      # array is the argument for that action.  Possible actions
-      # include `:accept`, `:reduce`, and `:state`; `:accept` means
-      # to accept the string; `:reduce` means to perform the given
-      # reduction; and `:state` means to transition to the given
-      # state.
-      #
-      # @return [Array<Hash<Symbol => Array<(Symbol, Numeric)>>>]
-      def table
-        if mods[:tableizer].is_a? Generation::Tableizer
-          mods[:tableizer].table
-        else
-          []
-        end
-      end
-
-      # Returns an array of the production information of each
-      # production needed by the parser.  The first element of any
-      # element in the array is an {Ace::Token::Nonterminal} that
-      # that specific production reduces to; the second element
-      # is a number describing the number of items in the right hand
-      # side of the production; the string represents the action
-      # that should be taken on reduction.
-      #
-      # This information is used for `:reduce` actions in the parser;
-      # the value of the `:reduce` action corresponds to the array
-      # index of the production in this array.
-      #
-      # @return [Array<Array<(Ace::Token::Nonterminal, Numeric, String)>]
-      def productions
-        grammar.all_productions.map do |production|
-          [production[:label],
-           production[:items].size,
-           production[:block]]
-        end
-      end
-
-
-    end
-  end
-end
+require 'antelope/generator/base/coerce'
+require 'antelope/generator/base/extra'
+require 'hashie/mash'
+
+module Antelope
+  module Generator
+    # Generates a parser.  This is normally the parent class, and the
+    # specific implementations inherit from this.  The generated
+    # parser should, ideally, be completely independent (not requiring
+    # any external source code), as well as be under a permissive
+    # license.
+    #
+    # @abstract Subclass and redefine {#generate} to create a
+    #   generator.
+    class Base
+      include Coerce
+      include Extra
+
+      Boolean = Object.new
+      # The modifiers that were applied to the grammar.
+      #
+      # @return [Hash<(Symbol, Object)>]
+      attr_reader :mods
+
+      # The file name (not including the extension) that the grammar
+      # should output to.
+      #
+      # @return [String]
+      attr_reader :file
+
+      # The grammar that the generator is for.
+      #
+      # @return [Ace::Grammar]
+      attr_reader :grammar
+
+      # The source root directory for templates.  Overwrite to change.
+      #
+      # @return [Pathname]
+      def self.source_root
+        Pathname.new('../templates').expand_path(__FILE__)
+      end
+
+      def self.register_as(*names)
+        Generator.register_generator(self, *names)
+      end
+
+      # Called by ruby on subclassing.
+      #
+      # @param subclass [Class]
+      # @return [void]
+      def self.inherited(subclass)
+        directives.each do |name, (_, type)|
+          subclass.directive(name, type)
+        end
+      end
+
+      # Allows a directive for this generator.  This is checked in
+      # the compiler to allow the option.  If the compiler encounters
+      # a bad directive, it'll error (to give the developer a warning).
+      #
+      # @param directive [Symbol, String]
+      # @param type [Object] used to define how the value should be
+      #   coerced.
+      # @see #directives
+      # @see #coerce_directive_value
+      # @return [void]
+      def self.directive(directive, type = nil)
+        directive = directive.to_s
+        directives[directive] = [self, type]
+      end
+
+      # The directives in the class.
+      #
+      # @see .has_directive
+      # @return [Hash]
+      def self.directives
+        @_directives ||= {}
+      end
+
+      class << self
+        alias_method :has_directives, :directive
+        alias_method :has_directive,  :directive
+      end
+
+      # Initialize the generator.
+      #
+      # @param grammar [Grammar]
+      # @param mods [Hash<(Symbol, Object)>]
+      def initialize(grammar, mods)
+        @file    = grammar.name
+        @grammar = grammar
+        @mods    = mods
+      end
+
+      # Actually does the generation.  A subclass should implement
+      # this.
+      #
+      # @raise [NotImplementedError]
+      # @return [void]
+      def generate
+        raise NotImplementedError
+      end
+
+      # Copies a template from the source, runs it through mote (in the
+      # context of this class), and then outputs it at the destination.
+      # If given a block, it will call the block after the template is
+      # run through erb with the content from erb; the result of the
+      # block is then used as the content instead.
+      #
+      # @param source [String] the source file.  This should be in
+      #   {.source_root}.
+      # @param destination [String] the destination file.  This will be
+      #   in {Ace::Grammar#output}.
+      # @yieldparam [String] content The content that ERB created.
+      # @yieldreturn [String] The new content to write to the output.
+      # @return [void]
+      def template(source, destination)
+        src  = Pathname.new("#{source}.erb")
+               .expand_path(self.class.source_root)
+
+        template = ERB.new(src.read, nil, '-')
+        content  = template.result(instance_eval('binding'))
+
+        block_given? && content = yield(content)
+
+        dest = Pathname.new(destination).expand_path(grammar.output)
+
+        dest.open('w') do |file|
+          file.write(content)
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generator/c.rb

@@ -1,11 +1,11 @@
-module Antelope
-  module Generator
-    class C < Group
-      register_as "c", "C"
-
-      register_generator CHeader, "c-header"
-      register_generator CSource, "c-source"
-
-    end
-  end
-end
+module Antelope
+  module Generator
+    class C < Group
+      register_as "c", "C"
+
+      register_generator CHeader, "c-header"
+      register_generator CSource, "c-source"
+
+    end
+  end
+end

data/lib/antelope/generator/c_header.rb

@@ -1,105 +1,105 @@
-module Antelope
-  module Generator
-    class CHeader < Base
-
-      register_as "c-header", "c_header"
-
-      has_directive "union", Array[String, String]
-      has_directive "api.prefix", String
-      has_directive "api.push-pull", String
-      has_directive "api.value.type", String
-      has_directive "api.token.prefix", String
-      has_directive "parse-param", Array
-      has_directive "lex-param", Array
-      has_directive "param", Array
-
-      def push?
-        directives.api.push_pull == "push"
-      end
-
-      def define_stype?
-        !!directives.union[0] && !directives.api.value.type
-      end
-
-      def lex_params
-        params = [directives.lex_param, directives.param].compact.
-          flatten
-
-        if params.any?
-          ", " << params.join(", ")
-        else
-          ""
-        end
-      end
-
-      def parse_params
-        [directives.parse_param, directives.param].compact.flatten.
-          join(", ")
-      end
-
-      def params
-        if directives.param
-          directives.param.join(", ")
-        else
-          ""
-        end
-      end
-
-      def stype
-        prefix.upcase << if directives.api.value.type
-          directives.api.value.type
-        elsif directives.union.size > 1
-          directives.union[0]
-        else
-          "STYPE"
-        end
-      end
-
-      def union_body
-        directives.union.last
-      end
-
-      def terminal_type
-        "int" # for now
-      end
-
-      def token_prefix
-        if directives.api.token.prefix
-          directives.api.token.prefix
-        elsif directives.api.prefix
-          prefix.upcase
-        else
-          ""
-        end
-      end
-
-      def prefix
-        if directives.api.prefix
-          directives.api.prefix
-        else
-          "yy"
-        end
-      end
-
-      def upper_prefix
-        prefix.upcase
-      end
-
-      def symbols
-        @_symbols ||= begin
-          sym  = grammar.terminals.map(&:name) + grammar.nonterminals
-          nums = sym.each_with_index.map { |v, i| [v, i + 257] }
-          Hash[nums]
-        end
-      end
-
-      def guard_name
-        "#{prefix.upcase}#{file.gsub(/[\W]/, "_").upcase}"
-      end
-
-      def generate
-        template "c_header", "#{file}.h"
-      end
-    end
-  end
-end
+module Antelope
+  module Generator
+    class CHeader < Base
+
+      register_as "c-header", "c_header"
+
+      has_directive "union", Array[String, String]
+      has_directive "api.prefix", String
+      has_directive "api.push-pull", String
+      has_directive "api.value.type", String
+      has_directive "api.token.prefix", String
+      has_directive "parse-param", Array
+      has_directive "lex-param", Array
+      has_directive "param", Array
+
+      def push?
+        directives.api.push_pull == "push"
+      end
+
+      def define_stype?
+        !!directives.union[0] && !directives.api.value.type
+      end
+
+      def lex_params
+        params = [directives.lex_param, directives.param].compact.
+          flatten
+
+        if params.any?
+          ", " << params.join(", ")
+        else
+          ""
+        end
+      end
+
+      def parse_params
+        [directives.parse_param, directives.param].compact.flatten.
+          join(", ")
+      end
+
+      def params
+        if directives.param
+          directives.param.join(", ")
+        else
+          ""
+        end
+      end
+
+      def stype
+        prefix.upcase << if directives.api.value.type
+          directives.api.value.type
+        elsif directives.union.size > 1
+          directives.union[0]
+        else
+          "STYPE"
+        end
+      end
+
+      def union_body
+        directives.union.last
+      end
+
+      def terminal_type
+        "int" # for now
+      end
+
+      def token_prefix
+        if directives.api.token.prefix
+          directives.api.token.prefix
+        elsif directives.api.prefix
+          prefix.upcase
+        else
+          ""
+        end
+      end
+
+      def prefix
+        if directives.api.prefix
+          directives.api.prefix
+        else
+          "yy"
+        end
+      end
+
+      def upper_prefix
+        prefix.upcase
+      end
+
+      def symbols
+        @_symbols ||= begin
+          sym  = grammar.terminals.map(&:name) + grammar.nonterminals
+          nums = sym.each_with_index.map { |v, i| [v, i + 257] }
+          Hash[nums]
+        end
+      end
+
+      def guard_name
+        "#{prefix.upcase}#{file.gsub(/[\W]/, "_").upcase}"
+      end
+
+      def generate
+        template "c_header", "#{file}.h"
+      end
+    end
+  end
+end