antelope 0.1.4 → 0.1.5

data/examples/simple.output

@@ -1,10 +1,19 @@
 Productions:
-  e → l "=" r 
-  e → r 
-  l → IDENT 
-  l → "*" r 
-  r → l 
-  $start → e $ 
+  0 $start(0) → e(0:1) $ 
+  1 e(0:1) → l(0:2) "=" r(7:10) 
+  2 e(0:1) → r(0:3) 
+  3 l(0:2) → IDENT 
+  4 l(0:2) → "*" r(5:8) 
+  5 r(0:3) → l(0:2) 
+  5 r(5:8) → l(5:9) 
+  3 l(5:9) → IDENT 
+  4 l(5:9) → "*" r(5:8) 
+  5 r(7:10) → l(7:9) 
+  3 l(7:9) → IDENT 
+  4 l(7:9) → "*" r(5:8) 
+
+Nontemrinals:
+["$start(0)", "e(0:1)", "l(0:2)", "r(0:3)", "r(5:8)", "l(5:9)", "r(7:10)", "l(7:9)"]
 
 Precedence:
   --- highest
@@ -15,18 +24,18 @@ Precedence:
   --- lowest
 
   State 0:
-    0/n0: $start(0) →  • e(0:1) $
-      {}
-    1/n1: e(0:1) →  • l(0:2) "=" r(8:10)
-      {}
-    2/n1: e(0:1) →  • r(0:3)
-      {}
-    3/n1: l(0:2) →  • IDENT
-      {}
-    4/n1: l(0:2) →  • "*" r(5:9)
-      {}
-    5/n1: r(0:3) →  • l(0:2)
-      {}
+    0/n0: $start →  • e $
+      {} ($start)
+    1/n1: e →  • l "=" r
+      {} (e)
+    2/n1: e →  • r
+      {} (e)
+    3/n1: l →  • IDENT
+      {} (l)
+    4/n1: l →  • "*" r
+      {} (l)
+    5/n1: r →  • l
+      {} (r)
     transitions:
       e: State 1
       l: State 2
@@ -36,83 +45,86 @@ Precedence:
 
   State 1:
     6/n0: $start → e • $
-      {}
+      {} ($start)
     transitions:
-      $: State 7
+      $: State 6
 
   State 2:
     7/n1: e → l • "=" r
-      {}
-    15/n1: r → l • 
-      {$}
+      {} (e)
+    8/n1: r → l • 
+      {$} (r)
     transitions:
-      EQUALS: State 8
+      EQUALS: State 7
     reductions:
       $: Rule 5
 
   State 3:
     9/n1: e → r • 
-      {$}
+      {$} (e)
     reductions:
       $: Rule 2
 
   State 4:
     10/n1: l → IDENT • 
-      {$}
+      {"=", $} (l)
     reductions:
+      EQUALS: Rule 3
       $: Rule 3
 
   State 5:
     11/n1: l → "*" • r
-      {}
-    12/n1: r(5:9) →  • l(5:6)
-      {}
-    13/n1: l(5:6) →  • IDENT
-      {}
-    14/n1: l(5:6) →  • "*" r(5:9)
-      {}
+      {} (l)
+    12/n1: r →  • l
+      {} (r)
+    13/n1: l →  • IDENT
+      {} (l)
+    14/n1: l →  • "*" r
+      {} (l)
     transitions:
-      r: State 9
-      l: State 6
+      r: State 8
+      l: State 9
       IDENT: State 4
       STAR: State 5
 
   State 6:
-    15/n1: r → l • 
-      {$}
-    reductions:
-      $: Rule 5
-
-  State 7:
-    16/n0: $start → e $ • 
-      {}
+    15/n0: $start → e $ • 
+      {} ($start)
     accepting:
       $: Rule 0
 
-  State 8:
-    17/n1: e → l "=" • r
-      {}
-    18/n1: r(8:10) →  • l(8:6)
-      {}
-    19/n1: l(8:6) →  • IDENT
-      {}
-    20/n1: l(8:6) →  • "*" r(5:9)
-      {}
+  State 7:
+    16/n1: e → l "=" • r
+      {} (e)
+    17/n1: r →  • l
+      {} (r)
+    18/n1: l →  • IDENT
+      {} (l)
+    19/n1: l →  • "*" r
+      {} (l)
     transitions:
       r: State 10
-      l: State 6
+      l: State 9
       IDENT: State 4
       STAR: State 5
 
-  State 9:
-    21/n1: l → "*" r • 
-      {$}
+  State 8:
+    20/n1: l → "*" r • 
+      {"=", $} (l)
     reductions:
+      EQUALS: Rule 4
       $: Rule 4
 
+  State 9:
+    21/n1: r → l • 
+      {"=", $} (r)
+    reductions:
+      EQUALS: Rule 5
+      $: Rule 5
+
   State 10:
     22/n1: e → l "=" r • 
-      {$}
+      {$} (e)
     reductions:
       $: Rule 1
 

data/lib/antelope/ace/grammar.rb

@@ -5,7 +5,6 @@ require "antelope/ace/grammar/productions"
 require "antelope/ace/grammar/precedences"
 require "antelope/ace/grammar/loading"
 require "antelope/ace/grammar/generation"
-require "antelope/ace/grammar/production"
 
 module Antelope
   module Ace

data/lib/antelope/ace/production.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Antelope
+  module Ace
+
+    # Defines a production.
+    class Production < Struct.new(:label, :items, :block, :prec, :id)
+      # @!attribute [rw] label
+      #   The label (or left-hand side) of the production.  This
+      #   should be a nonterminal.
+      #
+      #   @return [Symbol]
+      # @!attribute [rw] items
+      #   The body (or right-hand side) of the production.  This can
+      #   be array of terminals and nonterminals.
+      #
+      #   @return [Array<Token>]
+      # @!attribute [rw] block
+      #   The block of code to be executed when the production's right
+      #   hand side is reduced.
+      #
+      #   @return [String]
+      # @!attribute [rw] prec
+      #   The precedence declaration for the production.
+      #
+      #   @return [Ace::Precedence]
+      # @!attribute [rw] id
+      #   The ID of the production.  The starting production always
+      #   has an ID of 0.
+      #
+      #   @return [Numeric]
+
+      # Creates a new production from a hash.  The hash's keys
+      # correspond to the attributes on this class.
+      #
+      # @param hash [Hash<(Symbol, Object)>]
+      def self.from_hash(hash)
+        new(hash[:label] || hash["label"],
+            hash[:items] || hash["items"],
+            hash[:block] || hash["block"],
+            hash[:prec]  || hash["prec"],
+            hash[:id]    || hash["id"])
+      end
+
+      # Create a new version of the production with duplicated values.
+      #
+      # @return [Production]
+      def clone
+        Production.new(label.dup,
+            items.map(&:dup),
+            block.dup,
+            prec.dup,
+            id)
+      end
+    end
+  end
+end

data/lib/antelope/ace/token.rb

@@ -110,6 +110,11 @@ module Antelope
         buf
       end
 
+      def inspect
+        "#<#{self.class} from=#{from.id if from} to=#{to.id if to} " \
+          "name=#{name.inspect} value=#{@value.inspect}>"
+      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

data/lib/antelope/ace.rb

@@ -5,6 +5,7 @@ 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

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

@@ -68,16 +68,10 @@ module Antelope
         # @see Nullable#nullable?
         def generate_follow_set(token)
           # Set it to the empty set so we don't end up recursing.
-          @follows[token] = Set.new
-
-          # This is going to be the output set.
-          set = Set.new
-
-          productions = grammar.states.map(&:rules).flatten.
-            inject(Set.new, :merge)
+          set = @follows[token] = Set.new
 
           productions.each do |rule|
-            items = rule.right
+            items = rule.items
 
             # Find all of the positions within the rule that our token
             # occurs, and then increment that position by one.
@@ -95,7 +89,7 @@ module Antelope
               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.left)
+                set.merge follow(rule.label)
               end
             end
           end

data/lib/antelope/generation/constructor.rb

@@ -21,6 +21,9 @@ module Antelope
       # @return [Ace::Grammar]
       attr_reader :grammar
 
+      # The augmented productions generated by the constructor.
+      #
+      # @return [Set<Ace::Production>]
       attr_reader :productions
 
       # Initialize.
@@ -56,22 +59,29 @@ module Antelope
       # @return [void]
       def augment_state(state)
         state.rules.select { |x| x.position.zero? }.each do |rule|
+          production = rule.production.clone
+          production.items = []
+
           current_state = state
 
-          rule.left.from = state
-          rule.left.to   = state.transitions[rule.left.name]
+          production.label.from = state
+          production.label.to   = state.transitions[rule.left.name]
 
           rule.right.each_with_index do |part, pos|
             transition = current_state.transitions[part.name]
+            new_item = part.dup
+
             if part.nonterminal?
-              part.from = current_state
-              part.to   = transition
+              new_item.from = current_state
+              new_item.to   = transition
             end
 
+            production.items << new_item
+
             current_state = transition
           end
 
-          productions << rule
+          productions << production
         end
       end
 
@@ -88,6 +98,10 @@ module Antelope
         state.rules.select { |x| x.position.zero? }.each do |rule|
           current_state = state
 
+          label = rule.left.dup
+          label.from = state
+          label.to = state.transitions[label.name]
+
           rule.right.each do |part|
             transition = current_state.transitions[part.name]
             current_state = transition
@@ -95,7 +109,8 @@ module Antelope
 
           final = current_state.rule_for(rule)
 
-          final.lookahead = follow(rule.left)
+          final.lookahead = Set.new unless final.lookahead
+          final.lookahead.merge follow(label)
         end
       end
 

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

@@ -18,8 +18,8 @@ module Antelope
 
         # The right-hand side of the rule.
         #
-        # @return [Ace::Token]
-        attr_reader :right
+        # @return [Array<Ace::Token>]
+        attr_accessor :right
 
         # The current position inside of the rule.
         #
@@ -28,7 +28,7 @@ module Antelope
 
         # The block to be executed on production match.
         #
-        # @deprecated Use {Ace::Grammar::Production#block} instead.
+        # @deprecated Use {Ace::Production#block} instead.
         # @return [String]
         attr_reader :block
 
@@ -52,14 +52,14 @@ module Antelope
 
         # The associated production.
         #
-        # @return [Ace::Grammar::Production]
+        # @return [Ace::Production]
         attr_reader :production
 
         include Comparable
 
         # Initialize the rule.
         #
-        # @param production [Ace::Grammar::Production] the production
+        # @param production [Ace::Production] the production
         #   that this rule is based off of.
         # @param position [Numeric] the position that this rule is in
         #   the production.
@@ -74,9 +74,9 @@ module Antelope
           @id         = SecureRandom.hex
 
           if inherited
-            @right = inherited
+            @left, @right = inherited
           else
-            @right = production.items.map(&:dup).freeze
+            @right = production.items.map(&:dup)
           end
         end
 
@@ -115,7 +115,7 @@ module Antelope
         #
         # @return [Rule]
         def succ
-          Rule.new(production, position + 1)
+          Rule.new(production, position + 1, [left, right])
         end
 
         # Checks to see if a rule can exist after this one; i.e. the
@@ -175,6 +175,15 @@ module Antelope
           end
         end
 
+        # Produces a clone of the rule; any modifications made to the
+        # contents of that rule do not reflect the contents of this
+        # rule.
+        #
+        # @return [Rule]
+        def clone
+          Rule.new(production, position)
+        end
+
         # Generates a hash for this class.
         #
         # @note This is not intended for use.  It is only defined to be
@@ -194,7 +203,7 @@ module Antelope
         # @private
         # @return [Array<(Ace::Token::Nonterminal, Array<Ace::Token>, Numeric)>]
         def to_a
-          [left, right, position]
+          [left, right, position].flatten
         end
       end
     end

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

@@ -87,7 +87,7 @@ module Antelope
         # @return [self]
         def <<(rule)
           if rule.is_a? State
-            rule.rules.each { |r| self << r }
+            rule.rules.map(&:clone).each { |r| self << r }
           elsif rule.is_a? Rule
             rules << rule unless rules.include? rule
           else
@@ -100,6 +100,15 @@ module Antelope
 
         alias_method :push, :<<
 
+        def ===(other)
+          return super unless other.is_a? State
+
+          other_rules = other.rules.to_a
+          other.transitions == transitions and
+            rules.each_with_index.
+            all? { |rule, i| rule === other_rules[i] }
+        end
+
       end
     end
   end

data/lib/antelope/generation/recognizer.rb

@@ -93,17 +93,15 @@ module Antelope
             state.rules.each do |rule|
               next unless rule.succ?
               transitional = find_state_for(rule.succ) do |succ|
-                ns = State.new
-                ns << succ
+                ns = State.new << succ
                 compute_closure(ns)
-                states << ns
                 @map[succ] = ns
-                ns
               end
 
               if state.transitions[rule.active.name]
                 state.transitions[rule.active.name].merge! transitional
               else
+                states << transitional
                 state.transitions[rule.active.name] = transitional
               end
             end

data/lib/antelope/version.rb

@@ -2,5 +2,5 @@
 
 module Antelope
   # The current running version of antelope.
-  VERSION = "0.1.4".freeze
+  VERSION = "0.1.5".freeze
 end

data/spec/antelope/constructor_spec.rb

@@ -111,6 +111,10 @@ describe Generation::Constructor do
       let(:grammar) { with_recognizer }
       let(:nonterminal) { token(:l, nil, :nonterminal) }
 
+      before do
+        subject.productions.merge grammar.productions.values.flatten
+      end
+
       it "generates a set" do
         expect(subject.follow(nonterminal)).to eq [
           token(:EQUALS, "="),

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: antelope
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-23 00:00:00.000000000 Z
+date: 2014-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -126,10 +126,10 @@ files:
 - lib/antelope/ace/grammar/generation.rb
 - lib/antelope/ace/grammar/loading.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/precedence.rb
+- lib/antelope/ace/production.rb
 - lib/antelope/ace/scanner.rb
 - lib/antelope/ace/scanner/first.rb
 - lib/antelope/ace/scanner/second.rb

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

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # Defines a production.
-      class Production < Struct.new(:label, :items, :block, :prec, :id)
-        # @!attribute [rw] label
-        #   The label (or left-hand side) of the production.  This
-        #   should be a nonterminal.
-        #
-        #   @return [Symbol]
-        # @!attribute [rw] items
-        #   The body (or right-hand side) of the production.  This can
-        #   be array of terminals and nonterminals.
-        #
-        #   @return [Array<Token>]
-        # @!attribute [rw] block
-        #   The block of code to be executed when the production's right
-        #   hand side is reduced.
-        #
-        #   @return [String]
-        # @!attribute [rw] prec
-        #   The precedence declaration for the production.
-        #
-        #   @return [Ace::Precedence]
-        # @!attribute [rw] id
-        #   The ID of the production.  The starting production always
-        #   has an ID of 0.
-        #
-        #   @return [Numeric]
-
-        # Creates a new production from a hash.  The hash's keys
-        # correspond to the attributes on this class.
-        #
-        # @param hash [Hash<(Symbol, Object)>]
-        def self.from_hash(hash)
-          new(hash[:label] || hash["label"],
-              hash[:items] || hash["items"],
-              hash[:block] || hash["block"],
-              hash[:prec]  || hash["prec"],
-              hash[:id]    || hash["id"])
-        end
-      end
-    end
-  end
-end