antelope 0.0.1 → 0.1.0

data/lib/antelope/generation/recognizer/state.rb

@@ -4,10 +4,26 @@ require "securerandom"
 module Antelope
   module Generation
     class Recognizer
+
+      # A state within the parser.  A state has a set of rules, as
+      # well as transitions on those rules.
       class State
 
+        # All of the rules in this state.
+        #
+        # @return [Set<Rule>]
         attr_reader :rules
+
+        # All of the transitions that can be made on this state.
+        #
+        # @return [Hash<(Symbol, State)>]
         attr_reader :transitions
+
+        # The id of this state.  This starts off as a string of
+        # hexadecmial characters, but after all of the states are
+        # finalized, this becomes a numeric.
+        #
+        # @return [String, Numeric]
         attr_accessor :id
 
         include Enumerable
@@ -15,19 +31,31 @@ module Antelope
 
         def_delegator :@rules, :each
 
+        # Initialize the state.
         def initialize
           @rules = Set.new
-          @transitions = {} #Hash.new { |hash, key| hash[key] = State.new }
+          @transitions = {}
           @id = SecureRandom.hex
         end
 
+        # Gives a nice string representation of the state.
+        #
+        # @return [String]
         def inspect
-          "#<#{self.class} id=#{id} transitions=[#{transitions.keys.join(", ")}] rules=[{#{rules.to_a.join("} {")}}]>"
+          "#<#{self.class} id=#{id} " \
+            "transitions=[#{transitions.keys.join(", ")}] " \
+            "rules=[{#{rules.to_a.join("} {")}}]>"
         end
 
+        # Merges another state with this state.  It copies all of the
+        # rules into this state, and then merges the transitions on
+        # the given state to this state.  It then returns self.
+        #
+        # @raise [ArgumentError] if the given argument is not a state.
+        # @param other [State] the state to merge.
+        # @return [self]
         def merge!(other)
-          return if other == :_ignore
-          raise ArgumentError, "Expected #{self.class}, " +
+          raise ArgumentError, "Expected #{self.class}, " \
             "got #{other.class}" unless other.is_a? State
 
           self << other
@@ -36,16 +64,36 @@ module Antelope
           self
         end
 
+        # Finds the rule that match the given production.  It
+        # uses fuzzy equality checking.  It returns the first rule
+        # that matches.
+        #
+        # @param production [Rule] the rule to compare.
+        # @return [Rule?]
         def rule_for(production)
           rules.find { |rule| production === rule }
         end
 
+        # Appends the given object to this state.  The given object
+        # must be a state or a rule.  If it's a state, it appends all
+        # of the rules in the state to this state.  If it's a rule, it
+        # adds the rule to our rules.
+        #
+        # @raise [ArgumentError] if the argument isn't a {State} or a
+        #   {Rule}.
+        # @param rule [State, Rule] the object to append.
+        # @return [self]
         def <<(rule)
           if rule.is_a? State
             rule.rules.each { |r| self << r }
-          else
+          elsif rule.is_a? Rule
             rules << rule unless rules.include? rule
+          else
+            raise ArgumentError, "Expected #{State} or #{Rule}, " \
+              "got #{rule.class}"
           end
+
+          self
         end
 
         alias_method :push, :<<

data/lib/antelope/generation/recognizer.rb

@@ -80,7 +80,10 @@ module Antelope
       # Computes all states.  Uses a fix point iteration to determine
       # when no states have been added.  Loops through every state and
       # every rule, looking for rules that have an active nonterminal
-      # and computing
+      # and computing the closure for said rule.
+      #
+      # @return [void]
+      # @see #compute_closure
       def compute_states
         fixed_point(states) do
           states.dup.each do |state|
@@ -104,6 +107,11 @@ module Antelope
         end
       end
 
+      # Given a state, it does a fixed point iteration on the rules of
+      # the state that have an active nonterminal, and add the
+      # corresponding production rules to the state.
+      #
+      # @return [void]
       def compute_closure(state)
         fixed_point(state.rules) do
           state.rules.select { |_| _.active.nonterminal? }.each do |rule|
@@ -116,16 +124,29 @@ module Antelope
 
       private
 
+      # Find a state that include a specific rule, or yields the rule.
+      #
+      # @param rule [Rule]
+      # @yield [rule]
+      # @return [State]
       def find_state_for(rule)
         states.find { |state| state.include?(rule) } or yield(rule)
       end
 
+      # Changes the IDs of the states into a more friendly format.
+      #
+      # @return [void]
       def redefine_state_ids
         states.each_with_index do |state, i|
           state.id = i
         end
       end
 
+      # Redefines all of the rule ids to make them more friendly.
+      # Every rule in every state is given a unique ID, reguardless if
+      # the rules are equivalent.
+      #
+      # @return [void]
       def redefine_rule_ids
         start = 0
 
@@ -137,6 +158,15 @@ module Antelope
         end
       end
 
+      # Begins a fixed point iteration on the given enumerable.  It
+      # initializes the added elements to one; then, while the number
+      # of added elements is not zero, it yields and checks for added
+      # elements.
+      #
+      # @param enum [Enumerable]
+      # @yield for every iteration.  Guarenteed to do so at least
+      #   once.
+      # @return [void]
       def fixed_point(enum)
         added = 1
 

data/lib/antelope/generation/tableizer.rb

@@ -1,30 +1,55 @@
 module Antelope
   module Generation
 
-    class UnresolvableConflictError < StandardError; end
-
+    # Constructs the table required for the parser.
     class Tableizer
 
-      attr_accessor :parser
+      # The grammar that the table is based off of.
+      #
+      # @return [Ace::Grammar]
+      attr_accessor :grammar
+
+      # The table itself.
+      #
+      # @return [Array<Hash<(Symbol, Array<(Symbol, Numeric)>)>>]
       attr_accessor :table
+
+      # All rules in the grammar.
+      #
+      # @return [Hash<(Numeric, Recognizer::Rule)>]
       attr_accessor :rules
 
-      def initialize(parser)
-        @parser = parser
+      # Initialize.
+      #
+      # @param grammar [Ace::Grammar]
+      def initialize(grammar)
+        @grammar = grammar
       end
 
+      # Construct the table, and then check the table for conflicts.
+      #
+      # @return [void]
+      # @see #tablize
+      # @see #conflictize
       def call
         tablize
         conflictize
       end
 
+      # Construct a table based on the grammar.  The table itself is
+      # an array whose elements are hashes; the index of the array
+      # corresponds to the state ID, and the keys of the hashes
+      # correspond to acceptable tokens.  The values of the hashes
+      # should be an array of arrays (at this point).
+      #
+      # @return [void]
       def tablize
-        @table = Array.new(parser.states.size) do
+        @table = Array.new(grammar.states.size) do
           Hash.new { |h, k| h[k] = [] }
         end
         @rules = []
 
-        parser.states.each do |state|
+        grammar.states.each do |state|
           state.transitions.each do |on, to|
             table[state.id][on] << [:state, to.id]
           end
@@ -47,6 +72,13 @@ module Antelope
         table
       end
 
+      # Resolve any conflicts through precedence, if we can.  If we
+      # can't, let the user know.  This makes sure that every value
+      # of the hashes is a single array.
+      #
+      # @raise [UnresolvableConflictError] if a conflict could not be
+      #   resolved using precedence rules.
+      # @return [void]
       def conflictize
         @table.each_with_index do |v, state|
           v.each do |on, data|
@@ -55,16 +87,16 @@ module Antelope
               next
             end
 
-            terminal = parser.presidence_for(on)
+            terminal = grammar.precedence_for(on)
 
             state_part = data.select { |(t, d)| t == :state }.first
             rule_part  = data.select { |(t, d)| t == :reduce}.first
 
-            result = @rules[rule_part[1]].presidence <=> terminal
+            result = @rules[rule_part[1]].precedence <=> terminal
 
             case result
             when 0
-              p v, terminal, @rules[rule_part[1]].presidence
+              p v, terminal, @rules[rule_part[1]].precedence
               raise UnresolvableConflictError,
                 "Could not determine move for #{on} in state #{state}"
             when 1

data/lib/antelope/generation.rb

@@ -1,4 +1,4 @@
-require "antelope/generation/conflictor"
+require "antelope/generation/errors"
 require "antelope/generation/constructor"
 require "antelope/generation/recognizer"
 require "antelope/generation/tableizer"

data/lib/antelope/generator/templates/output.erb

@@ -1,36 +1,37 @@
 Productions:
-% constructor.productions.each do |production|
-    <%= production.to_s(false) %>
-% end
-
-Original Productions:
 % grammar.productions.each do |k, v|
 %  v.each do |prod|
-  <%= k %> → <%= prod[:items].join(" ") %>
-    <%= prod[:block] %>
+  <%= k %> → <%= prod[:items].join(" ") %> <%= prod[:block] %>
 %  end
 % end
 
-Conflicts:
-% conflictor.conflicts.each do |conflict|
-  State <%= conflict.state.id %>:
-    rules : <%= conflict.rules.map(&:id).join(", ") %>
-    type  : <%= conflict.type %>
-    tokens: {<%= conflict.token.to_a.join(", ") %>}
+Productions, Again:
+% constructor.productions.each do |production|
+  <%= production.to_s(false) %>
 % end
 
-Presidence:
+FOLLOW:
+% constructor.instance_variable_get(:@follows).each do |k, v|
+  <%= k %>: {<%= v.map(&:to_s).join(", ") %>}
+% end
+
+Precedence:
   --- highest
-% grammar.presidence.each do |pr|
+% grammar.precedence.each do |pr|
   <%= "%-8s" % pr.type %> <%= pr.level %>:
     {<%= pr.tokens.to_a.join(", ") %>}
 % end
   --- lowest
 
 Table:
-% PP.pp(Hash[tableizer.table.each_with_index.to_a.map(&:reverse)], _erbout)
-
-% PP.pp(tableizer.rules, _erbout)
+% len = tableizer.table.flatten.map(&:keys).flatten.map(&:size).max
+% tableizer.table.each_with_index do |v, i|
+  State <%= i %>:
+%   v.each do |token, action|
+    <%= "%-#{len}s" % token %>: <%= action[0] %> (<%= action[1] %>)
+%   end
+% end
+  <%# PP.pp(Hash[tableizer.table.each_with_index.to_a.map(&:reverse)], _erbout) %>
 
 % grammar.states.each do |state|
 State <%= state.id %>:

data/lib/antelope/version.rb

@@ -1,4 +1,4 @@
 module Antelope
   # The current running version of antelope.
-  VERSION = "0.0.1".freeze
+  VERSION = "0.1.0".freeze
 end

data/lib/antelope.rb

@@ -1,9 +1,10 @@
-require "antelope/automaton"
+require "antelope/errors"
 require "antelope/generation"
 require "antelope/generator"
 require "antelope/version"
 require "antelope/ace"
 
+# Antelope, the compiler compiler.
 module Antelope
-  # Your code goes here...
+
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: antelope
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2014-06-18 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: liquid
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.6'
-- !ruby/object:Gem::Dependency
-  name: sourcify
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -152,11 +124,11 @@ files:
 - lib/antelope/ace/grammar.rb
 - lib/antelope/ace/grammar/generation.rb
 - lib/antelope/ace/grammar/loading.rb
-- lib/antelope/ace/grammar/presidence.rb
+- lib/antelope/ace/grammar/precedences.rb
 - lib/antelope/ace/grammar/production.rb
 - lib/antelope/ace/grammar/productions.rb
 - lib/antelope/ace/grammar/terminals.rb
-- lib/antelope/ace/presidence.rb
+- lib/antelope/ace/precedence.rb
 - lib/antelope/ace/scanner.rb
 - lib/antelope/ace/scanner/first.rb
 - lib/antelope/ace/scanner/second.rb
@@ -166,15 +138,14 @@ files:
 - lib/antelope/ace/token/error.rb
 - lib/antelope/ace/token/nonterminal.rb
 - lib/antelope/ace/token/terminal.rb
-- lib/antelope/automaton.rb
+- lib/antelope/cli.rb
+- lib/antelope/errors.rb
 - lib/antelope/generation.rb
-- lib/antelope/generation/conflictor.rb
-- lib/antelope/generation/conflictor/conflict.rb
 - lib/antelope/generation/constructor.rb
 - lib/antelope/generation/constructor/first.rb
 - lib/antelope/generation/constructor/follow.rb
-- lib/antelope/generation/constructor/lookahead.rb
 - lib/antelope/generation/constructor/nullable.rb
+- lib/antelope/generation/errors.rb
 - lib/antelope/generation/recognizer.rb
 - lib/antelope/generation/recognizer/rule.rb
 - lib/antelope/generation/recognizer/state.rb

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

@@ -1,59 +0,0 @@
-require "set"
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # Manages presidence for tokens.
-      module Presidence
-
-        # Accesses the generated presidence list.  Lazily generates
-        # the presidence rules on the go, and then caches it.
-        #
-        # @return [Array<Ace::Presidence>]
-        def presidence
-          @_presidence ||= generate_presidence
-        end
-
-        # Finds a presidence rule for a given token.  If no direct
-        # rule is defined for that token, it will check for a rule
-        # defined for the special symbol, `:_`.  By default, there
-        # is always a rule defined for `:_`.
-        #
-        # @param token [Ace::Token, Symbol]
-        # @return [Ace::Presidence]
-        def presidence_for(token)
-          token = token.name if token.is_a?(Token)
-
-          set = Set.new([token, :_])
-
-          presidence.
-            select { |pr| set.intersect?(pr.tokens) }.
-            first
-        end
-
-        private
-
-        # Generates the presidence rules.  Loops through the compiler
-        # given presidence settings, and then adds two default
-        # presidence rules; one for `:$` (level 0, nonassoc), and one
-        # for `:_` (level 1, nonassoc).
-        #
-        # @return [Array<Ace::Presidence>]
-        def generate_presidence
-          size = @compiler.options[:prec].size + 1
-          presidence = @compiler.options[:prec].
-            each_with_index.map do |prec, i|
-            Ace::Presidence.new(prec[0], prec[1..-1].to_set, size - i)
-          end
-
-          presidence <<
-            Ace::Presidence.new(:nonassoc, [:"$"].to_set, 0) <<
-            Ace::Presidence.new(:nonassoc, [:_].to_set, 1)
-          presidence.sort_by { |_| _.level }.reverse
-        end
-
-      end
-    end
-  end
-end

data/lib/antelope/automaton.rb

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

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

data/lib/antelope/generation/conflictor.rb

@@ -1,45 +0,0 @@
-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/lookahead.rb

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