antelope 0.2.0 → 0.2.2

data/lib/antelope/generation/constructor/nullable.rb

@@ -1,64 +1,64 @@
-# encoding: utf-8
-
-module Antelope
-  module Generation
-    class Constructor
-
-      # Contains the methods to determine if an object is nullable.
-      module Nullable
-
-        # Initialize.
-        def initialize
-          @nullifying = Set.new
-        end
-
-        # Determine if a given token is nullable.  This is how the
-        # method should behave:
-        #
-        #     nullable?(ϵ) == true  # if ϵ is the epsilon token
-        #     nullable?(x) == false # if x is a terminal
-        #     nullable?(αβ) == nullable?(α) && nullable?(β)
-        #     nullable?(A) == nullable?(a_1) || nullable?(a_2) || ... nullable?(a_n)
-        #       # if A is a nonterminal and a_1, a_2, ..., a_n are all
-        #       # of the right-hand sides of its productions
-        #
-        # @param token [Ace::Token, Array<Ace::Token>] the token to
-        #    check.
-        # @return [Boolean] if the token can reduce to ϵ.
-        def nullable?(token)
-          case token
-          when Ace::Token::Nonterminal
-            nullifying(token) do
-              productions = grammar.productions[token.name]
-              !!productions.any? { |prod| nullable?(prod[:items]) }
-            end
-          when Array
-            token.dup.delete_if { |tok|
-              @nullifying.include?(tok) }.all? { |tok| nullable?(tok) }
-          when Ace::Token::Epsilon
-            true
-          when Ace::Token::Terminal
-            false
-          else
-            incorrect_argument! token, Ace::Token, Array
-          end
-        end
-
-        private
-
-        # Helps keep track of the nonterminals we're checking for
-        # nullability.  This helps prevent recursion.
-        #
-        # @param tok [Ace::Token::Nonterminal]
-        # @yield once.
-        # @return [Boolean]
-        def nullifying(tok)
-          @nullifying << tok
-          out = yield
-          @nullifying.delete tok
-          out
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Generation
+    class Constructor
+
+      # Contains the methods to determine if an object is nullable.
+      module Nullable
+
+        # Initialize.
+        def initialize
+          @nullifying = Set.new
+        end
+
+        # Determine if a given token is nullable.  This is how the
+        # method should behave:
+        #
+        #     nullable?(ϵ) == true  # if ϵ is the epsilon token
+        #     nullable?(x) == false # if x is a terminal
+        #     nullable?(αβ) == nullable?(α) && nullable?(β)
+        #     nullable?(A) == nullable?(a_1) || nullable?(a_2) || ... nullable?(a_n)
+        #       # if A is a nonterminal and a_1, a_2, ..., a_n are all
+        #       # of the right-hand sides of its productions
+        #
+        # @param token [Ace::Token, Array<Ace::Token>] the token to
+        #    check.
+        # @return [Boolean] if the token can reduce to ϵ.
+        def nullable?(token)
+          case token
+          when Ace::Token::Nonterminal
+            nullifying(token) do
+              productions = grammar.productions[token.name]
+              !!productions.any? { |prod| nullable?(prod[:items]) }
+            end
+          when Array
+            token.dup.delete_if { |tok|
+              @nullifying.include?(tok) }.all? { |tok| nullable?(tok) }
+          when Ace::Token::Epsilon
+            true
+          when Ace::Token::Terminal
+            false
+          else
+            incorrect_argument! token, Ace::Token, Array
+          end
+        end
+
+        private
+
+        # Helps keep track of the nonterminals we're checking for
+        # nullability.  This helps prevent recursion.
+        #
+        # @param tok [Ace::Token::Nonterminal]
+        # @yield once.
+        # @return [Boolean]
+        def nullifying(tok)
+          @nullifying << tok
+          out = yield
+          @nullifying.delete tok
+          out
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generation/constructor.rb

@@ -1,126 +1,126 @@
-# encoding: utf-8
-
-require "set"
-require "antelope/generation/constructor/nullable"
-require "antelope/generation/constructor/first"
-require "antelope/generation/constructor/follow"
-
-module Antelope
-  module Generation
-
-    # Constructs the lookahead sets for all of the rules in the
-    # grammar.
-    class Constructor
-
-      include Nullable
-      include First
-      include Follow
-
-      # The grammar.
-      #
-      # @return [Ace::Grammar]
-      attr_reader :grammar
-
-      # The augmented productions generated by the constructor.
-      #
-      # @return [Set<Ace::Production>]
-      attr_reader :productions
-
-      # Initialize.
-      #
-      # @param grammar [Ace::Grammar] the grammar.
-      def initialize(grammar)
-        @productions = Set.new
-        @grammar = grammar
-        super()
-      end
-
-      # Performs the construction.  First, it goes through every state
-      # and augments the state.  It then goes through every rule and
-      # augments it.
-      #
-      # @return [void]
-      # @see #augment_state
-      # @see #augment_rule
-      def call
-        grammar.states.each do |state|
-          augment_state(state)
-        end.each do |state|
-          augment_rules(state)
-        end
-      end
-
-      # Augments the given state.  On every rule within that state
-      # that has a position of zero, it follows the rule throughout
-      # the DFA until the end; it marks every nonterminal it
-      # encounters with the transitions it took on that nonterminal.
-      #
-      # @param state [Recognizer::State] the state to augment.
-      # @return [void]
-      def augment_state(state)
-        state.rules.select { |x| x.position.zero? }.each do |rule|
-          production = rule.production.clone
-          production.items = []
-
-          current_state = state
-          old_state = state
-
-          production.label.from = state
-          production.label.to   = state.transitions[rule.left.name]
-
-          rule.right.each_with_index do |part, pos|
-            transition = current_state.transitions[part.name]
-            new_item = part.dup
-
-            if part.nonterminal?
-              new_item.from = current_state
-              new_item.to   = transition
-            end
-
-            production.items << new_item
-
-            old_state = current_state
-            current_state = transition
-          end
-
-          productions << production
-        end
-      end
-
-      # Augments every final rule.  For every rule in the current
-      # state that has a position of zero, it follows the rule through
-      # the DFA until the ending state; it then modifies the ending
-      # state's lookahead set to be the FOLLOW set of the nonterminal
-      # it reduces to.
-      #
-      # @param state [Recognizer::State]
-      # @return [void]
-      # @see Follow#follow
-      def augment_rules(state)
-        state.rules.select { |x| x.position.zero? }.each do |rule|
-          current_state = state
-
-          label = rule.left.dup
-          label.from = state
-          label.to = state.transitions[label.name]
-
-          rule.right.each do |part|
-            transition = current_state.transitions[part.name]
-            current_state = transition
-          end
-
-          final = current_state.rule_for(rule)
-
-          final.lookahead = Set.new unless final.lookahead
-          final.lookahead.merge follow(label)
-        end
-      end
-
-      private
-
-      def incorrect_argument!(arg, *types)
-        raise ArgumentError, "Expected one of #{types.join(", ")}, got #{arg.class}"
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+require "set"
+require "antelope/generation/constructor/nullable"
+require "antelope/generation/constructor/first"
+require "antelope/generation/constructor/follow"
+
+module Antelope
+  module Generation
+
+    # Constructs the lookahead sets for all of the rules in the
+    # grammar.
+    class Constructor
+
+      include Nullable
+      include First
+      include Follow
+
+      # The grammar.
+      #
+      # @return [Ace::Grammar]
+      attr_reader :grammar
+
+      # The augmented productions generated by the constructor.
+      #
+      # @return [Set<Ace::Production>]
+      attr_reader :productions
+
+      # Initialize.
+      #
+      # @param grammar [Ace::Grammar] the grammar.
+      def initialize(grammar)
+        @productions = Set.new
+        @grammar = grammar
+        super()
+      end
+
+      # Performs the construction.  First, it goes through every state
+      # and augments the state.  It then goes through every rule and
+      # augments it.
+      #
+      # @return [void]
+      # @see #augment_state
+      # @see #augment_rule
+      def call
+        grammar.states.each do |state|
+          augment_state(state)
+        end.each do |state|
+          augment_rules(state)
+        end
+      end
+
+      # Augments the given state.  On every rule within that state
+      # that has a position of zero, it follows the rule throughout
+      # the DFA until the end; it marks every nonterminal it
+      # encounters with the transitions it took on that nonterminal.
+      #
+      # @param state [Recognizer::State] the state to augment.
+      # @return [void]
+      def augment_state(state)
+        state.rules.select { |x| x.position.zero? }.each do |rule|
+          production = rule.production.clone
+          production.items = []
+
+          current_state = state
+          old_state = state
+
+          production.label.from = state
+          production.label.to   = state.transitions[rule.left.name]
+
+          rule.right.each_with_index do |part, pos|
+            transition = current_state.transitions[part.name]
+            new_item = part.dup
+
+            if part.nonterminal?
+              new_item.from = current_state
+              new_item.to   = transition
+            end
+
+            production.items << new_item
+
+            old_state = current_state
+            current_state = transition
+          end
+
+          productions << production
+        end
+      end
+
+      # Augments every final rule.  For every rule in the current
+      # state that has a position of zero, it follows the rule through
+      # the DFA until the ending state; it then modifies the ending
+      # state's lookahead set to be the FOLLOW set of the nonterminal
+      # it reduces to.
+      #
+      # @param state [Recognizer::State]
+      # @return [void]
+      # @see Follow#follow
+      def augment_rules(state)
+        state.rules.select { |x| x.position.zero? }.each do |rule|
+          current_state = state
+
+          label = rule.left.dup
+          label.from = state
+          label.to = state.transitions[label.name]
+
+          rule.right.each do |part|
+            transition = current_state.transitions[part.name]
+            current_state = transition
+          end
+
+          final = current_state.rule_for(rule)
+
+          final.lookahead = Set.new unless final.lookahead
+          final.lookahead.merge follow(label)
+        end
+      end
+
+      private
+
+      def incorrect_argument!(arg, *types)
+        raise ArgumentError, "Expected one of #{types.join(", ")}, got #{arg.class}"
+      end
+    end
+  end
+end

data/lib/antelope/generation/errors.rb

@@ -1,17 +1,17 @@
-# encoding: utf-8
-
-module Antelope
-  module Generation
-
-    # Defines an error that can occur within the Generation module.
-    # All errors that are raised within the Generation module are
-    # subclasses of this.
-    class Error < Antelope::Error
-    end
-
-    # Used mainly in the {Tableizer}, this is raised when a conflict
-    # could not be resolved.
-    class UnresolvableConflictError < Error
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Generation
+
+    # Defines an error that can occur within the Generation module.
+    # All errors that are raised within the Generation module are
+    # subclasses of this.
+    class Error < Antelope::Error
+    end
+
+    # Used mainly in the {Tableizer}, this is raised when a conflict
+    # could not be resolved.
+    class UnresolvableConflictError < Error
+    end
+  end
+end

data/lib/antelope/generation/null.rb

@@ -1,13 +1,13 @@
-module Antelope
-  module Generation
-    class Null
-
-
-      def initialize(*)
-      end
-
-      def call(*)
-      end
-    end
-  end
-end
+module Antelope
+  module Generation
+    class Null
+
+
+      def initialize(*)
+      end
+
+      def call(*)
+      end
+    end
+  end
+end