antelope 0.2.0 → 0.2.2

data/lib/antelope/ace.rb

@@ -1,53 +1,53 @@
-# encoding: utf-8
-
-require "antelope/ace/errors"
-require "antelope/ace/scanner"
-require "antelope/ace/compiler"
-require "antelope/ace/token"
-require "antelope/ace/precedence"
-require "antelope/ace/production"
-require "antelope/ace/grammar"
-
-module Antelope
-
-  # Defines the Ace file.  The Ace file format works similarly to
-  # bison's y file format.  The Ace file is seperated into three
-  # parts:
-  #
-  #      <first>
-  #      %%
-  #      <second>
-  #      %%
-  #      <third>
-  #
-  # All parts may be empty; thus, the minimal file that Ace will
-  # accept would be
-  #
-  #     %%
-  #     %%
-  #
-  # The first part consists of _directives_ and _blocks_; directives
-  # look something like `"%" <directive>[ <argument>]*\n`, with
-  # `<directive>` being any alphanumerical character, including
-  # underscores and dashes, and `<argument>` being any word character
-  # or a quote-delimited string.  Blocks consist of
-  # `"%{" <content> "\n" "\s"* "%}"`, with `<content>` being any
-  # characters.  The content is copied directly into the body of the
-  # output.
-  #
-  # The second part consists of rules.  Rules look something like
-  # this:
-  #
-  #     <nonterminal>: (<nonterminal> | <terminal>)* ["{" <content> "}"] ["|" (<nonterminal> | <terminal>)* ["{" <content> "}"]]* [;]
-  #
-  # Where `<nonterminal>` is any lowercase alphabetical cahracter,
-  # `<terminal>` is any uppercase alphabetical character, and
-  # `<content>` is code to be used in the output file upon matching
-  # the specific rule.
-  #
-  # The third part consists of a body, which is copied directly into
-  # the output.
-  module Ace
-
-  end
-end
+# encoding: utf-8
+
+require "antelope/ace/errors"
+require "antelope/ace/scanner"
+require "antelope/ace/compiler"
+require "antelope/ace/token"
+require "antelope/ace/precedence"
+require "antelope/ace/production"
+require "antelope/ace/grammar"
+
+module Antelope
+
+  # Defines the Ace file.  The Ace file format works similarly to
+  # bison's y file format.  The Ace file is seperated into three
+  # parts:
+  #
+  #      <first>
+  #      %%
+  #      <second>
+  #      %%
+  #      <third>
+  #
+  # All parts may be empty; thus, the minimal file that Ace will
+  # accept would be
+  #
+  #     %%
+  #     %%
+  #
+  # The first part consists of _directives_ and _blocks_; directives
+  # look something like `"%" <directive>[ <argument>]*\n`, with
+  # `<directive>` being any alphanumerical character, including
+  # underscores and dashes, and `<argument>` being any word character
+  # or a quote-delimited string.  Blocks consist of
+  # `"%{" <content> "\n" "\s"* "%}"`, with `<content>` being any
+  # characters.  The content is copied directly into the body of the
+  # output.
+  #
+  # The second part consists of rules.  Rules look something like
+  # this:
+  #
+  #     <nonterminal>: (<nonterminal> | <terminal>)* ["{" <content> "}"] ["|" (<nonterminal> | <terminal>)* ["{" <content> "}"]]* [;]
+  #
+  # Where `<nonterminal>` is any lowercase alphabetical cahracter,
+  # `<terminal>` is any uppercase alphabetical character, and
+  # `<content>` is code to be used in the output file upon matching
+  # the specific rule.
+  #
+  # The third part consists of a body, which is copied directly into
+  # the output.
+  module Ace
+
+  end
+end

data/lib/antelope/cli.rb

@@ -1,55 +1,55 @@
-# encoding: utf-8
-
-require "thor"
-
-module Antelope
-
-  # Handles the command line interface.
-  class CLI < Thor
-
-    class_option :verbose, default: false, type: :boolean
-
-    option :type, default: nil, type: :string,
-      desc: "The type of generator to use"
-    desc "compile FILE [FILE]*", "compile the given files"
-
-    # Compile.
-    def compile(*files)
-      files.each do |file|
-        compile_file(file)
-      end
-    end
-
-    desc "check FILE [FILE]*", "check the syntax of the given files"
-
-    # Check.
-    def check(*files)
-      files.each do |file|
-        compile_file(file, [Generator::Null])
-      end
-    end
-
-    private
-
-    # Compiles the given file, and then generates.  If an error
-    # occurs, it prints it out to stderr, along with a backtrace if
-    # the verbose flag was set.
-    #
-    # @param file [String] the file to compile.
-    # @param gen [Array, Symbol] the generator to use.
-    # @return [void]
-    def compile_file(file, gen = :guess)
-      puts "Compiling #{file}... "
-
-      grammar = Ace::Grammar.from_file(file)
-      grammar.generate(options, gen)
-
-    rescue => e
-      $stderr.puts "Error while compiling: #{e.class}: #{e.message}"
-
-      if options[:verbose]
-        $stderr.puts e.backtrace[0..10].map { |_| "\t#{_}" }
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+require "thor"
+
+module Antelope
+
+  # Handles the command line interface.
+  class CLI < Thor
+
+    class_option :verbose, default: false, type: :boolean
+
+    option :type, default: nil, type: :string,
+      desc: "The type of generator to use"
+    desc "compile FILE [FILE]*", "compile the given files"
+
+    # Compile.
+    def compile(*files)
+      files.each do |file|
+        compile_file(file)
+      end
+    end
+
+    desc "check FILE [FILE]*", "check the syntax of the given files"
+
+    # Check.
+    def check(*files)
+      files.each do |file|
+        compile_file(file, [Generator::Null])
+      end
+    end
+
+    private
+
+    # Compiles the given file, and then generates.  If an error
+    # occurs, it prints it out to stderr, along with a backtrace if
+    # the verbose flag was set.
+    #
+    # @param file [String] the file to compile.
+    # @param gen [Array, Symbol] the generator to use.
+    # @return [void]
+    def compile_file(file, gen = :guess)
+      puts "Compiling #{file}... "
+
+      grammar = Ace::Grammar.from_file(file)
+      grammar.generate(options, gen)
+
+    rescue => e
+      $stderr.puts "Error while compiling: #{e.class}: #{e.message}"
+
+      if options[:verbose]
+        $stderr.puts e.backtrace[0..10].map { |_| "\t#{_}" }
+      end
+    end
+  end
+end

data/lib/antelope/errors.rb

@@ -1,8 +1,8 @@
-# encoding: utf-8
-
-module Antelope
-
-  # Every error in antelope inherits this error class.
-  class Error < StandardError
-  end
-end
+# encoding: utf-8
+
+module Antelope
+
+  # Every error in antelope inherits this error class.
+  class Error < StandardError
+  end
+end

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

@@ -1,88 +1,88 @@
-# 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 [Ace::Token, Array<Ace::Token>]
-        # @return [Set<Ace::Token::Terminal>]
-        # @see #first_array
-        def first(token)
-          case token
-          when Ace::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 Ace::Token::Epsilon
-            Set.new
-          when Ace::Token::Terminal
-            Set.new([token])
-          else
-            incorrect_argument! token, Ace::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<Ace::Token>]
-        # @return [Set<Ace::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 [Ace::Token::Nonterminal]
-        # @yield once.
-        # @return [Set<Ace::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 [Ace::Token, Array<Ace::Token>]
+        # @return [Set<Ace::Token::Terminal>]
+        # @see #first_array
+        def first(token)
+          case token
+          when Ace::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 Ace::Token::Epsilon
+            Set.new
+          when Ace::Token::Terminal
+            Set.new([token])
+          else
+            incorrect_argument! token, Ace::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<Ace::Token>]
+        # @return [Set<Ace::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 [Ace::Token::Nonterminal]
+        # @yield once.
+        # @return [Set<Ace::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,103 +1,103 @@
-# 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<Ace::Token>]
-        # @see Constructor#incorrect_argument!
-        # @see #generate_follow_set
-        def follow(token)
-          unless token.is_a? Ace::Token::Nonterminal
-            incorrect_argument! token, Ace::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 [Ace::Token::Nonterminal]
-        # @return [Set<Ace::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.
-          set = @follows[token] = Set.new
-
-          productions.each do |rule|
-            items = rule.items
-
-            # Find all of the positions within the rule that our token
-            # occurs, and then increment that position by one.
-            positions = items.each_with_index.
-              find_all { |t, _| t == token }.
-              map(&:last).map(&:succ)
-
-            # Find the FIRST set of every item after our token, and
-            # put that in our set.
-            positions.map { |pos| first(items[pos..-1]) }.
-              inject(set, :merge)
-
-            positions.each do |pos|
-              # If we're at the end of the rule...
-              if pos == items.size || nullable?(items[pos..-1])
-                # Then add the FOLLOW set of the left-hand side to our
-                # set.
-                set.merge follow(rule.label)
-              end
-            end
-          end
-
-          # Replace 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<Ace::Token>]
+        # @see Constructor#incorrect_argument!
+        # @see #generate_follow_set
+        def follow(token)
+          unless token.is_a? Ace::Token::Nonterminal
+            incorrect_argument! token, Ace::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 [Ace::Token::Nonterminal]
+        # @return [Set<Ace::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.
+          set = @follows[token] = Set.new
+
+          productions.each do |rule|
+            items = rule.items
+
+            # Find all of the positions within the rule that our token
+            # occurs, and then increment that position by one.
+            positions = items.each_with_index.
+              find_all { |t, _| t == token }.
+              map(&:last).map(&:succ)
+
+            # Find the FIRST set of every item after our token, and
+            # put that in our set.
+            positions.map { |pos| first(items[pos..-1]) }.
+              inject(set, :merge)
+
+            positions.each do |pos|
+              # If we're at the end of the rule...
+              if pos == items.size || nullable?(items[pos..-1])
+                # Then add the FOLLOW set of the left-hand side to our
+                # set.
+                set.merge follow(rule.label)
+              end
+            end
+          end
+
+          # Replace the cached empty set with our filled set.
+          @follows[token] = set
+        end
+      end
+    end
+  end
+end