antelope 0.2.4 → 0.3.0

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

@@ -1,156 +0,0 @@
-# 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?).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
-end

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

@@ -1,66 +0,0 @@
-# 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 +0,0 @@
-# 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

data/spec/antelope/constructor_spec.rb

@@ -1,133 +0,0 @@
-describe Generation::Constructor do
-  let(:grammar)  { double("grammar") }
-  let(:terminal) { token(:TERMINAL)  }
-  let(:epsilon)  { token(:epsilon) }
-
-  subject { described_class.new(grammar) }
-
-  context "#nullable?" do
-    context "when given an epsilon token" do
-      it "returns true" do
-        expect(subject.nullable?(epsilon)).to be true
-      end
-    end
-
-    context "when given a terminal" do
-      it "returns false" do
-        expect(subject.nullable?(terminal)).to be false
-      end
-    end
-
-    context "when given an array" do
-      context "with one of the elements not nullable" do
-        it "returns false" do
-          expect(subject.nullable?([terminal, epsilon])).to be false
-        end
-      end
-
-      context "with all of the elements nullable" do
-        it "returns true" do
-          expect(subject.nullable?([epsilon, epsilon])).to be true
-        end
-      end
-    end
-
-    context "when given a nonterminal" do
-      let(:grammar) { with_recognizer }
-
-      context "with no nullable productions" do
-        let(:nonterminal) { Ace::Token::Nonterminal.new(:l) }
-
-        it "returns false" do
-          expect(subject.nullable?(nonterminal)).to be false
-        end
-      end
-
-      context "with a nullable production" do
-        let(:nonterminal) { Ace::Token::Nonterminal.new(:e) }
-
-        it "returns true" do
-          expect(subject.nullable?(nonterminal)).to be true
-        end
-      end
-    end
-
-    context "when given a bad argument" do
-      it "raises an error" do
-        expect { subject.nullable?(nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "#first" do
-    context "when given an epsilon token" do
-      it "generates an empty set" do
-        expect(subject.first(epsilon)).to eq Set.new
-      end
-    end
-
-    context "when given a terminal" do
-      it "generates a set" do
-        expect(subject.first(terminal)).to eq [terminal].to_set
-      end
-    end
-
-    context "when given an array" do
-      let(:terminal2) { token(:terminal, :TERMINAL2) }
-
-      it "generates a set" do
-        expect(subject.first([epsilon, terminal])).
-          to eq [terminal].to_set
-        expect(subject.first([terminal, terminal2])).
-          to eq [terminal].to_set
-      end
-    end
-
-    context "when given a nonterminal" do
-      let(:grammar) { with_recognizer }
-      let(:nonterminal) { token(:nonterminal, :e) }
-
-      it "generates a set" do
-        expect(subject.first(nonterminal)).
-          to eq [token(:terminal, :IDENT), token(:terminal, :STAR, "*")].to_set
-      end
-    end
-
-    context "when given a bad argument" do
-      it "raises an error" do
-        expect { subject.first(nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "#follow" do
-    context "when given a bad argument" do
-      it "raises an error" do
-        expect { subject.follow(nil) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "when given a nonterminal" do
-      let(:grammar) { with_recognizer }
-      let(:nonterminal) { token(:nonterminal, :l) }
-
-      before do
-        subject.productions.merge grammar.productions.values.flatten
-      end
-
-      it "generates a set" do
-        expect(subject.follow(nonterminal)).to eq [
-          token(:terminal, :EQUALS, "="),
-          token(:terminal, :"$end")
-        ].to_set
-      end
-    end
-  end
-
-
-
-  def token(type, name = nil, value = nil, ttype = nil, id = nil)
-    type = Ace::Token.const_get(type.to_s.capitalize)
-    type.new(name, ttype, id, value)
-  end
-end