antelope 0.0.1

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

@@ -0,0 +1,24 @@
+module Antelope
+  module Ace
+    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/ace/token/nonterminal.rb

@@ -0,0 +1,15 @@
+module Antelope
+  module Ace
+    class Token
+
+      # Defines a nonterminal token.
+      class Nonterminal < Token
+
+        # (see Token#nonterminal?)
+        def nonterminal?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Antelope
+  module Ace
+    class Token
+
+      # Defines a terminal token.
+      class Terminal < Token
+
+        # (see Token#terminal?)
+        def terminal?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/antelope/ace/token.rb

@@ -0,0 +1,171 @@
+require "antelope/ace/token/nonterminal"
+require "antelope/ace/token/terminal"
+require "antelope/ace/token/epsilon"
+require "antelope/ace/token/error"
+
+
+module Antelope
+  module Ace
+
+    # Defines a token type for productions/rules.
+    #
+    # @abstract This class should be inherited to define a real token.
+    #   A base class does not match any token; however, any token can
+    #   match the base class.
+    class Token
+
+      # The name of the token.
+      #
+      # @return [Symbol]
+      attr_reader :name
+
+      # The from state that this token is transitioned from.  This is
+      # the _source_.  This is used in the constructor in order to
+      # handle lookahead sets.
+      #
+      # @return [Recognizer::State]
+      attr_accessor :from
+
+      # The to state that this token is transitioned to.  This is the
+      # _destination_.  This is used in the constructor in order to
+      # handle lookahead sets.
+      #
+      # @return [Recognizer::State]
+      attr_accessor :to
+
+      # Initialize.
+      #
+      # @param name [Symbol] the name of the token.
+      # @param value [String?] the value of the token.  This is only
+      #   used in output representation to the developer.
+      def initialize(name, value = nil)
+        @name  = name
+        @value = value
+        @from  = nil
+        @to    = nil
+      end
+
+      include Comparable
+
+      # Whether or not the token is a terminal.
+      #
+      # @abstract
+      # @return [Boolean]
+      def terminal?
+        false
+      end
+
+      # Whether or not the token is a nonterminal.
+      #
+      # @abstract
+      # @return [Boolean]
+      def nonterminal?
+        false
+      end
+
+      # Whether or not the token is an epsilon token.
+      #
+      # @abstract
+      # @return [Boolean]
+      def epsilon?
+        false
+      end
+
+      # Whether or not the token is an error token.
+      #
+      # @abstract
+      # @return [Boolean]
+      def error?
+        false
+      end
+
+      # Gives a string representation of the token.  The output is
+      # formatted like so: `<data>["(" [<from_id>][:<to_id>] ")"]`,
+      # where `<data>` is either the value (if it's non-nil) or the
+      # name, `<from_id>` is the from state id, and `<to_id>` is the
+      # to state id.  The last part of the format is optional; if
+      # neither the from state or to state is non-nil, it's non-
+      # existant.
+      #
+      # @return [String] the string representation.
+      # @see #from
+      # @see #to
+      # @see #name
+      def to_s
+        buf = if @value
+          @value.inspect
+        else
+          @name.to_s
+        end
+
+        if from or to
+          buf << "("
+          buf << "#{from.id}" if from
+          buf << ":#{to.id}"  if to
+          buf << ")"
+        end
+
+        buf
+      end
+
+      # Compares this class to any other object.  If the other object
+      # is a token, it converts both this class and the other object
+      # to an array and compares the array.  Otherwise, it delegates
+      # the comparison.
+      #
+      # @param other [Object] the other object to compare.
+      # @return [Numeric]
+      def <=>(other)
+        if other.is_a? Token
+          to_a <=> other.to_a
+        else
+          super
+        end
+      end
+
+      # Compares this class and another object, fuzzily.  If the other
+      # object is a token, it removes the transitions (to and from)
+      # on both objects and compares them like that.  Otherwise, it
+      # delegates the comparison.
+      #
+      # @param other [Object] the other object to compare.
+      # @return [Boolean] if they are equal.
+      def ===(other)
+        if other.is_a? Token
+          without_transitions == other.without_transitions
+        else
+          super
+        end
+      end
+
+      # Creates a new token without to or from states.
+      #
+      # @return [Token]
+      def without_transitions
+        self.class.new(name, @value)
+      end
+
+      # Generates a hashs for this class.
+      #
+      # @note This is not intended for use.  It is only defined to be
+      #   compatible with Hashs (and by extension, Sets).
+      # @private
+      # @return [Object]
+      def hash
+        to_a.hash
+      end
+
+      alias_method :eql?, :==
+
+      # Creates an array representation of this class.
+      #
+      # @note This is not intended for use.  It is only defined to
+      #   make equality checking easier, and to create a hash.
+      # @private
+      # @return [Array<(Recognizer::State, Recognizer::State, Class, Symbol, String?)>]
+      def to_a
+        [to, from, self.class, name, @value]
+      end
+    end
+  end
+end

data/lib/antelope/ace.rb

@@ -0,0 +1,50 @@
+require "antelope/ace/errors"
+require "antelope/ace/scanner"
+require "antelope/ace/compiler"
+require "antelope/ace/token"
+require "antelope/ace/presidence"
+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 thid part consists of a body, which is copied directly into
+  # the output.
+  module Ace
+
+  end
+end

data/lib/antelope/automaton.rb

@@ -0,0 +1,36 @@
+module Antelope
+  class Automaton
+    attr_accessor :states
+    attr_accessor :alphabet
+    attr_accessor :start
+    attr_accessor :accept
+    attr_accessor :transitions
+    attr_accessor :stack
+
+    def initialize(states = [], alphabet = [],
+                   start = nil, accept = [], transitions = {})
+      @states      = states
+      @alphabet    = alphabet
+      @start       = start
+      @accept      = accept
+      @transitions = transitions
+      @stack       = []
+    end
+
+    def run(input, &block)
+      block = block || method(:default_transition)
+
+      @stack = [@start]
+
+      input.each do |part|
+        @stack.push(block.call(@stack.last, part))
+      end
+
+      @accept.include? @stack.last
+    end
+
+    def default_transition(state, part)
+      @transitions[state][part]
+    end
+  end
+end

data/lib/antelope/generation/conflictor/conflict.rb

@@ -0,0 +1,7 @@
+module Antelope
+  module Generation
+    class Conflictor
+      Conflict = Struct.new(:state, :type, :rules, :token)
+    end
+  end
+end

data/lib/antelope/generation/conflictor.rb

@@ -0,0 +1,45 @@
+require "antelope/generation/conflictor/conflict"
+
+module Antelope
+  module Generation
+    class Conflictor
+
+      attr_accessor :parser
+      attr_accessor :conflicts
+
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def call
+        recognize_conflicts
+      end
+
+      def recognize_conflicts
+
+        @conflicts = []
+
+        parser.states.each do |state|
+          state.rules.each do |rule|
+            if rule.lookahead.
+                any? { |tok| state.transitions.key?(tok.name) }
+              @conflicts << Conflict.new(state, :shift_reduce, [rule],
+                rule.lookahead - state.transitions.keys)
+            end
+          end
+
+          final_rules = state.rules.select(&:final?)
+
+          final_rules.each_cons(2) do |r1, r2|
+            if r1.lookahead.intersect? r2.lookahead
+              @conflicts << Conflict.new(state,
+                :reduce_reduce,
+                [r1, r2],
+                r1.lookahead.intersection(r2.lookahead))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Antelope
+  module Generation
+    class Constructor
+      module First
+
+        def initialize
+          @firstifying = []
+          super
+        end
+
+        def first(token)
+          case token
+          when Ace::Token::Nonterminal
+            firstifying(token) do
+              productions = parser.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
+
+        def first_array(token)
+          token.dup.delete_if { |tok| @firstifying.include?(tok) }.
+          each_with_index.take_while do |tok, i|
+            if i.zero?
+              true
+            else
+              nullable?(token[i - 1])
+            end
+          end.map(&:first).map { |tok| first(tok) }.inject(Set.new, :+)
+        end
+
+        def firstifying(tok)
+          @firstifying << tok
+          out = yield
+          @firstifying.delete tok
+          out
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Antelope
+  module Generation
+    class Constructor
+      module Follow
+
+        def initialize
+          @follows = {}
+          super
+        end
+
+        def follow(token)
+
+          if token.nonterminal?
+            token = token.name
+          elsif token.is_a? Symbol
+          else
+            incorrect_argument! token, Ace::Token::Nonterminal, Symbol
+          end
+
+          @follows.fetch(token) do
+            @follows[token] = Set.new
+            set = Set.new
+
+            parser.productions.each do |key, value|
+              value.each do |production|
+                items = production[:items]
+                positions = items.each_with_index.
+                  find_all { |t, _| t.name == token }.
+                  map(&:last).map(&:succ)
+                positions.map { |pos| first(items[pos..-1]) }.
+                  inject(set, :merge)
+                positions.each do |pos|
+                  if pos == items.size || nullable?(items[pos..-1])
+                    set.merge follow(Ace::Token::Nonterminal.new(key))
+                  end
+                end
+              end
+            end
+
+            @follows[token] = set
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Antelope
+  module Generation
+    class Constructor
+      module Lookahead
+
+        def initialize
+          @lookaheads = {}
+          super
+        end
+
+        def lookahead(left, right = nil)
+          @lookaheads.fetch([left, right]) do
+            if right
+              set = Set.new
+
+              set += if nullable?(right)
+                first(right) + follow(left)
+              else
+                first(right)
+              end
+            else
+              set = lookahead_nonterminal(left)
+            end
+
+            @lookaheads[[left, right]] = set
+          end
+        end
+
+        private
+
+        def lookahead_nonterminal(left)
+          set = Set.new
+          parser.productions[left].each do |production|
+            set += lookahead(left, production[:items])
+          end
+
+          set
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Antelope
+  module Generation
+    class Constructor
+      module Nullable
+
+        def initialize
+          @nullifying = []
+        end
+
+        def nullable?(token)
+          case token
+          when Ace::Token::Nonterminal
+            nullifying(token) do
+              productions = parser.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
+
+        def nullifying(tok)
+          @nullifying << tok
+          out = yield
+          @nullifying.delete tok
+          out
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generation/constructor.rb

@@ -0,0 +1,81 @@
+require "set"
+require "antelope/generation/constructor/nullable"
+require "antelope/generation/constructor/first"
+require "antelope/generation/constructor/follow"
+require "antelope/generation/constructor/lookahead"
+
+module Antelope
+  module Generation
+    class Constructor
+
+      include Nullable
+      include First
+      include Follow
+      include Lookahead
+
+      attr_reader :parser
+      attr_reader :productions
+
+      def initialize(parser)
+        @parser      = parser
+        @productions = []
+        super()
+      end
+
+      def call
+        parser.states.each do |state|
+          augment_state(state)
+        end.each do |state|
+          augment_rules(state)
+        end
+
+        @productions
+      end
+
+      def augment_state(state)
+        state.rules.select { |x| x.position.zero? }.each do |rule|
+          current_state = state
+
+          rule.left.from = state
+          rule.left.to   = state.transitions[rule.left.name]
+
+          states = [state]
+
+          rule.right.each_with_index do |part, pos|
+            transition = current_state.transitions[part.name]
+            if part.nonterminal?
+              part.from = current_state
+              part.to   = transition
+            end
+
+            states.push(transition)
+            current_state = transition
+          end
+
+          productions << rule unless productions.include?(rule)
+        end
+      end
+
+      def augment_rules(state)
+        state.rules.select { |x| x.position.zero? }.each do |rule|
+          current_state = state
+
+          rule.right.each do |part|
+            transition = current_state.transitions[part.name]
+            current_state = transition
+          end
+
+          final = current_state.rule_for(rule)
+
+          final.lookahead = follow(rule.left)
+        end
+      end
+
+      private
+
+      def incorrect_argument!(arg, *types)
+        raise ArgumentError, "Expected one of #{types.join(", ")}, got #{arg.class}"
+      end
+    end
+  end
+end