antelope 0.2.0 → 0.2.2

data/lib/antelope/ace/grammar/productions.rb

@@ -1,150 +1,156 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # Manages the productions of the grammar.
-      module Productions
-
-        # Returns a hash of all of the productions.  The result is
-        # cached.
-        #
-        # @return [Hash<(Symbol, Array<Production>)>]
-        def productions
-          @_productions || generate_productions
-        end
-
-        # Returns all productions for all nonterminals, sorted by id.
-        #
-        # @return [Array<Production>]
-        def all_productions
-          productions.values.flatten.sort_by(&:id)
-        end
-
-        # Finds a token based on its corresponding symbol.  First
-        # checks the productions, to see if it's a nonterminal; then,
-        # tries to find it in the terminals; otherwise, if the symbol
-        # is `error`, it returns a {Token::Error}; if the symbol is
-        # `nothing` or `ε`, it returns a {Token::Epsilon}; if it's
-        # none of those, it raises an {UndefinedTokenError}.
-        #
-        # @raise [UndefinedTokenError] if the token doesn't exist.
-        # @param value [String, Symbol, #intern] the token's symbol to
-        #   check.
-        # @return [Token]
-        def find_token(value)
-          value = value.intern
-
-          if productions.key?(value)
-            typed_nonterminals.find { |term| term.name == value } ||
-              Token::Nonterminal.new(value)
-          elsif terminal = terminals.
-              find { |term| term.name == value }
-            terminal
-          elsif value == :error
-            Token::Error.new
-          elsif [:nothing, :ε].include?(value)
-            Token::Epsilon.new
-          else
-            raise UndefinedTokenError, "Could not find a token " \
-              "named #{value.inspect}"
-          end
-        end
-
-        private
-
-        # Actually generates the productions.  Uses the rules from the
-        # compiler to construct the productions.  Makes two loops over
-        # the compiler's rules; the first to tell the grammar that the
-        # nonterminal does exist, and the second to actually construct
-        # the productions.  The first loop is for {#find_token},
-        # because otherwise it wouldn't be able to return a
-        # nonterminal properly.
-        #
-        # @return [Hash<(Symbol, Array<Production>)>]
-        def generate_productions
-          @_productions = {}
-
-          @compiler.rules.each do |rule|
-            productions[rule[:label]] = []
-          end.each_with_index do |rule, id|
-            productions[rule[:label]] <<
-              generate_production_for(rule, id)
-          end
-
-          productions[:$start] = [default_production]
-
-          productions
-        end
-
-        # Generates a production for a given compiler rule.  Converts
-        # the tokens in the set to their {Token} counterparts,
-        # and then sets the precedence for the production.  If the
-        # precedence declaration from the compiler rule is empty,
-        # then it'll use the last terminal from the set to check for
-        # precedence; otherwise, it'll use the precedence declaration.
-        # This is to make sure that every production has a precedence
-        # declaration.
-        #
-        # @param rule [Hash] the compiler's rule.
-        # @param id [Numeric] the id for the production.
-        # @return [Production]
-        def generate_production_for(rule, id)
-          left  = Token::Nonterminal.new(rule[:label])
-          items = rule[:set].map { |_| find_token(_[0]) }
-          prec  = if rule[:prec].empty?
-            items.select(&:terminal?).last
-          else
-            rule[:prec].intern
-          end
-
-          prec  = precedence_for(prec)
-          left.type = type_for(rule[:label])
-          left.id = rule[:label_id]
-
-          rule[:set].each_with_index do |tok, i|
-            items[i] = items[i].dup
-            items[i].id = tok[1]
-          end
-
-          Production.new(left, items, rule[:block], prec, id + 1)
-        end
-
-        # Returns the defined type for the given token name.
-        # Uses the `%type` directive to infer the corresponding types.
-        #
-        # @param token [Symbol] the token to check for
-        #   types.
-        def type_for(token)
-          token = find_token(token) unless token.is_a?(Token)
-
-          case token
-          when Token::Nonterminal
-            token.type
-          when Token::Terminal
-            token.type
-          when Token::Epsilon
-            ""
-          when Token::Error
-            ""
-          end
-        end
-
-        # Creates the default production for the grammar.  The left
-        # hand side of the production is the `:$start` symbol, with
-        # the right hand side being the first rule's left-hand side
-        # and the terminal `$`.  This production is automagically
-        # given the last precedence, and an id of 0.
-        #
-        # @return [Production]
-        def default_production
-          Production.new(Token::Nonterminal.new(:$start), [
-              Token::Nonterminal.new(@compiler.rules.first[:label]),
-              Token::Terminal.new(:$end)
-            ], "", precedence.last, 0)
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Ace
+    class Grammar
+
+      # Manages the productions of the grammar.
+      module Productions
+
+        # Returns a hash of all of the productions.  The result is
+        # cached.
+        #
+        # @return [Hash<(Symbol, Array<Production>)>]
+        def productions
+          @_productions || generate_productions
+        end
+
+        # Returns all productions for all nonterminals, sorted by id.
+        #
+        # @return [Array<Production>]
+        def all_productions
+          productions.values.flatten.sort_by(&:id)
+        end
+
+        # Finds a token based on its corresponding symbol.  First
+        # checks the productions, to see if it's a nonterminal; then,
+        # tries to find it in the terminals; otherwise, if the symbol
+        # is `error`, it returns a {Token::Error}; if the symbol is
+        # `nothing` or `ε`, it returns a {Token::Epsilon}; if it's
+        # none of those, it raises an {UndefinedTokenError}.
+        #
+        # @raise [UndefinedTokenError] if the token doesn't exist.
+        # @param value [String, Symbol, #intern] the token's symbol to
+        #   check.
+        # @return [Token]
+        def find_token(value)
+          value = value.intern
+
+          if productions.key?(value)
+            typed_nonterminals.find { |term| term.name == value } ||
+              Token::Nonterminal.new(value)
+          elsif terminal = terminals.
+              find { |term| term.name == value }
+            terminal
+          elsif value == :error
+            Token::Error.new
+          elsif [:nothing, :ε, :"%empty"].include?(value)
+            Token::Epsilon.new
+          else
+            raise UndefinedTokenError, "Could not find a token " \
+              "named #{value.inspect}"
+          end
+        end
+
+        private
+
+        # Actually generates the productions.  Uses the rules from the
+        # compiler to construct the productions.  Makes two loops over
+        # the compiler's rules; the first to tell the grammar that the
+        # nonterminal does exist, and the second to actually construct
+        # the productions.  The first loop is for {#find_token},
+        # because otherwise it wouldn't be able to return a
+        # nonterminal properly.
+        #
+        # @return [Hash<(Symbol, Array<Production>)>]
+        def generate_productions
+          @_productions = {}
+          index = 0
+
+          rules = @compiler.rules.each do |rule|
+            productions[rule[:label]] = []
+          end
+
+          while index < rules.size
+            rule = rules[index]
+            productions[rule[:label]] <<
+              generate_production_for(rule, index)
+            index += 1
+          end
+
+          productions[:$start] = [default_production]
+
+          productions
+        end
+
+        # Generates a production for a given compiler rule.  Converts
+        # the tokens in the set to their {Token} counterparts,
+        # and then sets the precedence for the production.  If the
+        # precedence declaration from the compiler rule is empty,
+        # then it'll use the last terminal from the set to check for
+        # precedence; otherwise, it'll use the precedence declaration.
+        # This is to make sure that every production has a precedence
+        # declaration.
+        #
+        # @param rule [Hash] the compiler's rule.
+        # @param id [Numeric] the id for the production.
+        # @return [Production]
+        def generate_production_for(rule, id)
+          left  = Token::Nonterminal.new(rule[:label])
+          items = rule[:set].map { |_| find_token(_[0]) }
+          prec  = if rule[:prec].empty?
+            items.select(&:terminal?).last
+          else
+            rule[:prec].intern
+          end
+
+          prec  = precedence_for(prec)
+          left.type = type_for(rule[:label])
+          left.id = rule[:label_id]
+
+          rule[:set].each_with_index do |tok, i|
+            items[i] = items[i].dup
+            items[i].id = tok[1]
+          end
+          items.delete_if(&:epsilon?)
+
+          Production.new(left, items, rule[:block], prec, id + 1)
+        end
+
+        # Returns the defined type for the given token name.
+        # Uses the `%type` directive to infer the corresponding types.
+        #
+        # @param token [Symbol] the token to check for
+        #   types.
+        def type_for(token)
+          token = find_token(token) unless token.is_a?(Token)
+
+          case token
+          when Token::Nonterminal
+            token.type
+          when Token::Terminal
+            token.type
+          when Token::Epsilon
+            ""
+          when Token::Error
+            ""
+          end
+        end
+
+        # Creates the default production for the grammar.  The left
+        # hand side of the production is the `:$start` symbol, with
+        # the right hand side being the first rule's left-hand side
+        # and the terminal `$`.  This production is automagically
+        # given the last precedence, and an id of 0.
+        #
+        # @return [Production]
+        def default_production
+          Production.new(Token::Nonterminal.new(:$start), [
+              Token::Nonterminal.new(@compiler.rules.first[:label]),
+              Token::Terminal.new(:$end)
+            ], "", precedence.last, 0)
+        end
+      end
+    end
+  end
+end

data/lib/antelope/ace/grammar/symbols.rb

@@ -1,66 +1,66 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # Manages a list of the symbols in the grammar.
-      module Symbols
-
-        # A list of all terminals in the grammar.  Checks the compiler
-        # options for terminals, and then returns an array of
-        # terminals.  Caches the result.
-        #
-        # @return [Array<Token::Terminal>]
-        def terminals
-          @_terminals ||= begin
-            @compiler.options.fetch(:terminals, []).map do |v|
-              Token::Terminal.new(*v)
-            end
-          end
-        end
-
-        # A list of all nonterminals in the grammar.
-        #
-        # @return [Array<Symbol>]
-        # @see #productions
-        def nonterminals
-          @_nonterminals ||= productions.keys
-        end
-
-        # A list of all nonterminals, with types.
-        #
-        # @return [Array<Token::Nonterminal>>]
-        def typed_nonterminals
-          @_typed_nonterminals ||= begin
-            typed = []
-            compiler.options[:nonterminals].each do |data|
-              data[1].each do |nonterm|
-                typed << Token::Nonterminal.new(nonterm, data[0])
-              end
-            end
-            typed
-          end
-        end
-
-        # A list of all symbols in the grammar; includes both
-        # terminals and nonterminals.
-        #
-        # @return [Array<Token::Terminal, Symbol>]
-        # @see #terminals
-        # @see #nonterminals
-        def symbols
-          @_symbols ||= terminals + nonterminals
-        end
-
-        # Checks to see if the grammar uses the `error` terminal
-        # anywhere.
-        #
-        # @return [Boolean]
-        def contains_error_token?
-          all_productions.any? { |_| _.items.any?(&:error?) }
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Ace
+    class Grammar
+
+      # Manages a list of the symbols in the grammar.
+      module Symbols
+
+        # A list of all terminals in the grammar.  Checks the compiler
+        # options for terminals, and then returns an array of
+        # terminals.  Caches the result.
+        #
+        # @return [Array<Token::Terminal>]
+        def terminals
+          @_terminals ||= begin
+            @compiler.options.fetch(:terminals) { [] }.map do |v|
+              Token::Terminal.new(*v)
+            end
+          end
+        end
+
+        # A list of all nonterminals in the grammar.
+        #
+        # @return [Array<Symbol>]
+        # @see #productions
+        def nonterminals
+          @_nonterminals ||= productions.keys
+        end
+
+        # A list of all nonterminals, with types.
+        #
+        # @return [Array<Token::Nonterminal>>]
+        def typed_nonterminals
+          @_typed_nonterminals ||= begin
+            typed = []
+            compiler.options[:nonterminals].each do |data|
+              data[1].each do |nonterm|
+                typed << Token::Nonterminal.new(nonterm, data[0])
+              end
+            end
+            typed
+          end
+        end
+
+        # A list of all symbols in the grammar; includes both
+        # terminals and nonterminals.
+        #
+        # @return [Array<Token::Terminal, Symbol>]
+        # @see #terminals
+        # @see #nonterminals
+        def symbols
+          @_symbols ||= terminals + nonterminals
+        end
+
+        # Checks to see if the grammar uses the `error` terminal
+        # anywhere.
+        #
+        # @return [Boolean]
+        def contains_error_token?
+          all_productions.any? { |_| _.items.any?(&:error?) }
+        end
+      end
+    end
+  end
+end

data/lib/antelope/ace/grammar.rb

@@ -1,69 +1,69 @@
-# encoding: utf-8
-
-require "hashie"
-require "antelope/ace/grammar/symbols"
-require "antelope/ace/grammar/productions"
-require "antelope/ace/grammar/precedences"
-require "antelope/ace/grammar/loading"
-require "antelope/ace/grammar/generation"
-
-module Antelope
-  module Ace
-
-    # Defines a grammar from an Ace file.  This handles setting up
-    # productions, loading from files, symbols, precedence, and
-    # generation.
-    class Grammar
-
-      include Symbols
-      include Productions
-      include Precedences
-      include Loading
-      include Grammar::Generation
-
-      # Used by a generation class; this is all the generated states
-      # of the grammar.
-      #
-      # @return [Set<Generation::Recognizer::State>]
-      # @see Generation::Recognizer
-      attr_accessor :states
-
-      # The name of the grammar.  This is normally assumed from a file
-      # name.
-      #
-      # @return [String]
-      attr_accessor :name
-
-      # The output directory for the grammar.  This is normally the
-      # same directory as the Ace file.
-      #
-      # @return [Pathname]
-      attr_accessor :output
-
-      # The compiler for the Ace file.
-      #
-      # @return [Compiler]
-      attr_reader :compiler
-
-      # Initialize.
-      #
-      # @param name [String]
-      # @param output [String] the output directory.  Automagically
-      #   turned into a Pathname.
-      # @param compiler [Compiler]
-      def initialize(name, output, compiler)
-        @name     = name
-        @output   = Pathname.new(output)
-        @compiler = compiler
-      end
-
-      # Extra options from the compiler.  This can be used by
-      # generators for output information.
-      #
-      # @return [Hash]
-      def options
-        compiler.options[:extra]
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+require "hashie"
+require "antelope/ace/grammar/symbols"
+require "antelope/ace/grammar/productions"
+require "antelope/ace/grammar/precedences"
+require "antelope/ace/grammar/loading"
+require "antelope/ace/grammar/generation"
+
+module Antelope
+  module Ace
+
+    # Defines a grammar from an Ace file.  This handles setting up
+    # productions, loading from files, symbols, precedence, and
+    # generation.
+    class Grammar
+
+      include Symbols
+      include Productions
+      include Precedences
+      include Loading
+      include Grammar::Generation
+
+      # Used by a generation class; this is all the generated states
+      # of the grammar.
+      #
+      # @return [Set<Generation::Recognizer::State>]
+      # @see Generation::Recognizer
+      attr_accessor :states
+
+      # The name of the grammar.  This is normally assumed from a file
+      # name.
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # The output directory for the grammar.  This is normally the
+      # same directory as the Ace file.
+      #
+      # @return [Pathname]
+      attr_accessor :output
+
+      # The compiler for the Ace file.
+      #
+      # @return [Compiler]
+      attr_reader :compiler
+
+      # Initialize.
+      #
+      # @param name [String]
+      # @param output [String] the output directory.  Automagically
+      #   turned into a Pathname.
+      # @param compiler [Compiler]
+      def initialize(name, output, compiler)
+        @name     = name
+        @output   = Pathname.new(output)
+        @compiler = compiler
+      end
+
+      # Extra options from the compiler.  This can be used by
+      # generators for output information.
+      #
+      # @return [Hash]
+      def options
+        compiler.options[:extra]
+      end
+    end
+  end
+end