antelope 0.3.2 → 0.4.0

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

@@ -1,86 +1,86 @@
-# encoding: utf-8
-
-module Antelope
-  module Generation
-    class Constructor
-      # Contains the methods to construct first sets for tokens.
-      module First
-        # Initialize.
-        def initialize
-          @firstifying = []
-          super
-        end
-
-        # Constructs the first set for a given token.  This is how
-        # the method should behave:
-        #
-        #     FIRST(ε)  == []  # if ε is the epsilon token
-        #     FIRST(x)  == [x] # if x is a terminal
-        #     FIRST(αβ) == if nullable?(α)
-        #       FIRST(α) U FIRST(β)
-        #     else
-        #       FIRST(α)
-        #     end
-        #     FIRST(A)  == FIRST(a_1) U FIRST(a_2) U ... U FIRST(a_n)
-        #       # if A is a nonterminal and a_1, a_2, ..., a_3 are all
-        #       # of the right-hand sides of its productions.
-        #
-        # @param token [Grammar::Token, Array<Grammar::Token>]
-        # @return [Set<Grammar::Token::Terminal>]
-        # @see #first_array
-        def first(token)
-          case token
-          when Grammar::Token::Nonterminal
-            firstifying(token) do
-              productions = grammar.productions[token.name]
-              productions.map { |prod|
-                first(prod[:items]) }.inject(Set.new, :+)
-            end
-          when Array
-            first_array(token)
-          when Grammar::Token::Epsilon
-            Set.new
-          when Grammar::Token::Terminal
-            Set.new([token])
-          else
-            incorrect_argument! token, Grammar::Token, Array
-          end
-        end
-
-        private
-
-        # Determines the FIRST set of an array of tokens.  First, it
-        # removes any terminals we are finding the FIRST set for;
-        # then, it determines which tokens we have to find the FIRST
-        # sets for (since some tokens may be nullable).  We then add
-        # those sets to our set.
-        #
-        # @param tokens [Array<Grammar::Token>]
-        # @return [Set<Grammar::Token>]
-        def first_array(tokens)
-          tokens.dup.delete_if { |_| @firstifying.include?(_) }.
-          each_with_index.take_while do |token, i|
-            if i.zero?
-              true
-            else
-              nullable?(tokens[i - 1])
-            end
-          end.map(&:first).map { |_| first(_) }.inject(Set.new, :+)
-        end
-
-        # Helps keep track of the nonterminals we're finding FIRST
-        # sets for. This helps prevent recursion.
-        #
-        # @param tok [Grammar::Token::Nonterminal]
-        # @yield once.
-        # @return [Set<Grammar::Token>]
-        def firstifying(tok)
-          @firstifying << tok
-          out = yield
-          @firstifying.delete tok
-          out
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Generation
+    class Constructor
+      # Contains the methods to construct first sets for tokens.
+      module First
+        # Initialize.
+        def initialize
+          @firstifying = []
+          super
+        end
+
+        # Constructs the first set for a given token.  This is how
+        # the method should behave:
+        #
+        #     FIRST(ε)  == []  # if ε is the epsilon token
+        #     FIRST(x)  == [x] # if x is a terminal
+        #     FIRST(αβ) == if nullable?(α)
+        #       FIRST(α) U FIRST(β)
+        #     else
+        #       FIRST(α)
+        #     end
+        #     FIRST(A)  == FIRST(a_1) U FIRST(a_2) U ... U FIRST(a_n)
+        #       # if A is a nonterminal and a_1, a_2, ..., a_3 are all
+        #       # of the right-hand sides of its productions.
+        #
+        # @param token [Grammar::Token, Array<Grammar::Token>]
+        # @return [Set<Grammar::Token::Terminal>]
+        # @see #first_array
+        def first(token)
+          case token
+          when Grammar::Token::Nonterminal
+            firstifying(token) do
+              productions = grammar.productions[token.name]
+              productions.map { |prod|
+                first(prod[:items]) }.inject(Set.new, :+)
+            end
+          when Array
+            first_array(token)
+          when Grammar::Token::Epsilon
+            Set.new
+          when Grammar::Token::Terminal
+            Set.new([token])
+          else
+            incorrect_argument! token, Grammar::Token, Array
+          end
+        end
+
+        private
+
+        # Determines the FIRST set of an array of tokens.  First, it
+        # removes any terminals we are finding the FIRST set for;
+        # then, it determines which tokens we have to find the FIRST
+        # sets for (since some tokens may be nullable).  We then add
+        # those sets to our set.
+        #
+        # @param tokens [Array<Grammar::Token>]
+        # @return [Set<Grammar::Token>]
+        def first_array(tokens)
+          tokens.dup.delete_if { |_| @firstifying.include?(_) }.
+          each_with_index.take_while do |token, i|
+            if i.zero?
+              true
+            else
+              nullable?(tokens[i - 1])
+            end
+          end.map(&:first).map { |_| first(_) }.inject(Set.new, :+)
+        end
+
+        # Helps keep track of the nonterminals we're finding FIRST
+        # sets for. This helps prevent recursion.
+        #
+        # @param tok [Grammar::Token::Nonterminal]
+        # @yield once.
+        # @return [Set<Grammar::Token>]
+        def firstifying(tok)
+          @firstifying << tok
+          out = yield
+          @firstifying.delete tok
+          out
+        end
+      end
+    end
+  end
+end

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

@@ -1,105 +1,105 @@
-# encoding: utf-8
-
-module Antelope
-  module Generation
-    class Constructor
-
-      # Contains the methods to find the FOLLOW sets of nonterminals.
-      module Follow
-
-        # Initialize.
-        def initialize
-          @follows = {}
-          super
-        end
-
-        # Returns the FOLLOW set of the given token.  If the given
-        # token isn't a nonterminal, it raises an error.  It then
-        # generates the FOLLOW set for the given token, and then
-        # caches it.
-        #
-        # @return [Set<Grammar::Token>]
-        # @see Constructor#incorrect_argument!
-        # @see #generate_follow_set
-        def follow(token)
-          unless token.is_a? Grammar::Token::Nonterminal
-            incorrect_argument! token, Grammar::Token::Nonterminal
-          end
-
-          @follows.fetch(token) { generate_follow_set(token) }
-        end
-
-        private
-
-        # Generates the FOLLOW set for the given token.  It finds the
-        # positions at which the token appears in the grammar, and
-        # sees what could possibly follow it.  For example, given the
-        # following production:
-        #
-        #     A -> aBz
-        #
-        # With `a` and `z` being any combination of terminals and
-        # nonterminals, and we're trying to find the FOLLOW set of
-        # `B` we add the FIRST set of `z` to the FOLLOW set of `B`:
-        #
-        #     FOLLOW(B) = FOLLOW(B) ∪ FIRST(z)
-        #
-        # In the case that `B` is at the end of a production, like so:
-        #
-        #     A -> aB
-        #
-        # or
-        #
-        #     A -> aBw
-        #
-        # (with `w` being nullable) We also add the FOLLOW set of `A`
-        # to `B`:
-        #
-        #     FOLLOW(B) = FOLLOW(B) ∪ FOLLOW(A)
-        #
-        # In case this operation is potentially recursive, we make
-        # sure to set the FOLLOW set of `B` to an empty set (since we
-        # cache the result of a FOLLOW set, the empty set will be
-        # returned).
-        #
-        # @param token [Grammar::Token::Nonterminal]
-        # @return [Set<Grammar::Token>]
-        # @see First#first
-        # @see Nullable#nullable?
-        def generate_follow_set(token)
-          # Set it to the empty set so we don't end up recursing.
-          @follows[token] = Set.new
-          set = Set.new
-
-          productions.each do |rule|
-            items = rule.items
-            i = 0
-
-            # Find all of the positions within the rule that our token
-            # occurs, and then increment that position by one.
-            while i < items.size
-              next i += 1 unless items[i] == token
-              position = i.succ
-
-              # Find the FIRST set of every item after our token, and
-              # put that in our set.
-              set.merge first(items[position..-1])
-
-              # If we're at the end of the rule...
-              if position == items.size || nullable?(items[position..-1])
-                # Then add the FOLLOW set of the left-hand side to our
-                # set.
-                set.merge follow(rule.label)
-              end
-
-              i += 1
-            end
-          end
-
-          # ReplGrammar the cached empty set with our filled set.
-          @follows[token] = set
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Generation
+    class Constructor
+
+      # Contains the methods to find the FOLLOW sets of nonterminals.
+      module Follow
+
+        # Initialize.
+        def initialize
+          @follows = {}
+          super
+        end
+
+        # Returns the FOLLOW set of the given token.  If the given
+        # token isn't a nonterminal, it raises an error.  It then
+        # generates the FOLLOW set for the given token, and then
+        # caches it.
+        #
+        # @return [Set<Grammar::Token>]
+        # @see Constructor#incorrect_argument!
+        # @see #generate_follow_set
+        def follow(token)
+          unless token.is_a? Grammar::Token::Nonterminal
+            incorrect_argument! token, Grammar::Token::Nonterminal
+          end
+
+          @follows.fetch(token) { generate_follow_set(token) }
+        end
+
+        private
+
+        # Generates the FOLLOW set for the given token.  It finds the
+        # positions at which the token appears in the grammar, and
+        # sees what could possibly follow it.  For example, given the
+        # following production:
+        #
+        #     A -> aBz
+        #
+        # With `a` and `z` being any combination of terminals and
+        # nonterminals, and we're trying to find the FOLLOW set of
+        # `B` we add the FIRST set of `z` to the FOLLOW set of `B`:
+        #
+        #     FOLLOW(B) = FOLLOW(B) ∪ FIRST(z)
+        #
+        # In the case that `B` is at the end of a production, like so:
+        #
+        #     A -> aB
+        #
+        # or
+        #
+        #     A -> aBw
+        #
+        # (with `w` being nullable) We also add the FOLLOW set of `A`
+        # to `B`:
+        #
+        #     FOLLOW(B) = FOLLOW(B) ∪ FOLLOW(A)
+        #
+        # In case this operation is potentially recursive, we make
+        # sure to set the FOLLOW set of `B` to an empty set (since we
+        # cache the result of a FOLLOW set, the empty set will be
+        # returned).
+        #
+        # @param token [Grammar::Token::Nonterminal]
+        # @return [Set<Grammar::Token>]
+        # @see First#first
+        # @see Nullable#nullable?
+        def generate_follow_set(token)
+          # Set it to the empty set so we don't end up recursing.
+          @follows[token] = Set.new
+          set = Set.new
+
+          productions.each do |rule|
+            items = rule.items
+            i = 0
+
+            # Find all of the positions within the rule that our token
+            # occurs, and then increment that position by one.
+            while i < items.size
+              next i += 1 unless items[i] == token
+              position = i.succ
+
+              # Find the FIRST set of every item after our token, and
+              # put that in our set.
+              set.merge first(items[position..-1])
+
+              # If we're at the end of the rule...
+              if position == items.size || nullable?(items[position..-1])
+                # Then add the FOLLOW set of the left-hand side to our
+                # set.
+                set.merge follow(rule.label)
+              end
+
+              i += 1
+            end
+          end
+
+          # ReplGrammar the cached empty set with our filled set.
+          @follows[token] = set
+        end
+      end
+    end
+  end
+end

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 [Grammar::Token, Array<Grammar::Token>] the token to
-        #    check.
-        # @return [Boolean] if the token can reduce to ϵ.
-        def nullable?(token)
-          case token
-          when Grammar::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 Grammar::Token::Epsilon
-            true
-          when Grammar::Token::Terminal
-            false
-          else
-            incorrect_argument! token, Grammar::Token, Array
-          end
-        end
-
-        private
-
-        # Helps keep track of the nonterminals we're checking for
-        # nullability.  This helps prevent recursion.
-        #
-        # @param tok [Grammar::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 [Grammar::Token, Array<Grammar::Token>] the token to
+        #    check.
+        # @return [Boolean] if the token can reduce to ϵ.
+        def nullable?(token)
+          case token
+          when Grammar::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 Grammar::Token::Epsilon
+            true
+          when Grammar::Token::Terminal
+            false
+          else
+            incorrect_argument! token, Grammar::Token, Array
+          end
+        end
+
+        private
+
+        # Helps keep track of the nonterminals we're checking for
+        # nullability.  This helps prevent recursion.
+        #
+        # @param tok [Grammar::Token::Nonterminal]
+        # @yield once.
+        # @return [Boolean]
+        def nullifying(tok)
+          @nullifying << tok
+          out = yield
+          @nullifying.delete tok
+          out
+        end
+      end
+    end
+  end
+end