antelope 0.3.2 → 0.4.0

data/lib/antelope/grammar/productions.rb

@@ -1,154 +1,154 @@
-# encoding: utf-8
-
-module Antelope
-  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 || 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?).first
-        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
+# encoding: utf-8
+
+module Antelope
+  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 || 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?).first
+        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

data/lib/antelope/grammar/symbols.rb

@@ -1,64 +1,64 @@
-# encoding: utf-8
-
-module Antelope
-  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
+# encoding: utf-8
+
+module Antelope
+  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

data/lib/antelope/grammar/token/epsilon.rb

@@ -1,23 +1,23 @@
-# encoding: utf-8
-
-module Antelope
-  class Grammar
-    class Token
-      # Defines an epsilon token.  An epsilon token represents
-      # nothing.  This is used to say that a nonterminal can
-      # reduce to nothing.
-      class Epsilon < Token
-        # Initialize.  Technically takes no arguments.  Sets
-        # the name of the token to be `:$empty`.
-        def initialize(*)
-          super :"$empty"
-        end
-
-        # (see Token#epsilon?)
-        def epsilon?
-          true
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  class Grammar
+    class Token
+      # Defines an epsilon token.  An epsilon token represents
+      # nothing.  This is used to say that a nonterminal can
+      # reduce to nothing.
+      class Epsilon < Token
+        # Initialize.  Technically takes no arguments.  Sets
+        # the name of the token to be `:$empty`.
+        def initialize(*)
+          super :"$empty"
+        end
+
+        # (see Token#epsilon?)
+        def epsilon?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/antelope/grammar/token/error.rb

@@ -1,24 +1,24 @@
-# encoding: utf-8
-
-module Antelope
-  class Grammar
-    class Token
-      # Defines an error token.  This may be used internally by the
-      # parser when it enters panic mode; any tokens following this
-      # are the synchronisation tokens.  This is considered a terminal
-      # for the purposes of rule definitions.
-      class Error < Terminal
-        # Initialize the error token.  Technically takes no arguments.
-        # Sets the name to be `:$error`.
-        def initialize(*)
-          super :$error
-        end
-
-        # (see Token#error?)
-        def error?
-          true
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  class Grammar
+    class Token
+      # Defines an error token.  This may be used internally by the
+      # parser when it enters panic mode; any tokens following this
+      # are the synchronisation tokens.  This is considered a terminal
+      # for the purposes of rule definitions.
+      class Error < Terminal
+        # Initialize the error token.  Technically takes no arguments.
+        # Sets the name to be `:$error`.
+        def initialize(*)
+          super :$error
+        end
+
+        # (see Token#error?)
+        def error?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/antelope/grammar/token/nonterminal.rb

@@ -1,15 +1,15 @@
-# encoding: utf-8
-
-module Antelope
-  class Grammar
-    class Token
-      # Defines a nonterminal token.
-      class Nonterminal < Token
-        # (see Token#nonterminal?)
-        def nonterminal?
-          true
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  class Grammar
+    class Token
+      # Defines a nonterminal token.
+      class Nonterminal < Token
+        # (see Token#nonterminal?)
+        def nonterminal?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/antelope/grammar/token/terminal.rb

@@ -1,15 +1,15 @@
-# encoding: utf-8
-
-module Antelope
-  class Grammar
-    class Token
-      # Defines a terminal token.
-      class Terminal < Token
-        # (see Token#terminal?)
-        def terminal?
-          true
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  class Grammar
+    class Token
+      # Defines a terminal token.
+      class Terminal < Token
+        # (see Token#terminal?)
+        def terminal?
+          true
+        end
+      end
+    end
+  end
+end