antelope 0.2.0 → 0.2.2

data/lib/antelope/generator/base.rb

@@ -1,264 +1,264 @@
-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, i|
-          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 '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, i|
+          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

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