llip 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,13 @@
+== 0.2.0 / 2007-07-17
+
+* 2 major enhacement
+  * added the '[a-Z]' syntax to regular expression support
+  * added the possibility to define two token in which final states of the first are internal states of the second
+* 1 minor enhacement
+  * spec loading fixed
+  * added a simple REPL based on Ariteval
+  * aliased :recursive with :iterative because it's more intuitive
+
 == 0.1.0 / 2007-06-09
 
 * 1 major enhancement

data/Manifest.txt

@@ -5,6 +5,7 @@ README.txt
 Rakefile
 examples/ariteval
 examples/ariteval/ariteval.rb
+examples/ariteval/ariteval_repl.rb
 examples/ariteval/evaluator.rb
 examples/ariteval/exp.rb
 lib/llip

data/examples/ariteval/ariteval.rb

@@ -1,5 +1,5 @@
-require 'parser'
-require 'evaluator'
+require File.dirname(__FILE__) + '/evaluator'
+require File.dirname(__FILE__) + '/exp'
 
 # It's a simple arithmetical evaluator. It's able to parse expressions like these: 
 # * ( a = 3 * 2 ) - ( 24 + a ),
@@ -25,7 +25,7 @@ require 'evaluator'
 #   FACTOR ::= ( EXP )
 # }
 #
-class Ariteval < Parser
+class Ariteval < LLIP::Parser
 	
   def initialize
     super
@@ -39,8 +39,7 @@ class Ariteval < Parser
 
   # tokens definitions
 	
-  numbers = ("0".."9").to_a.join("|")
-  token :number, "(#{numbers})+ *"
+  token :number, "[0-9]+ *"
 
   token :plus, '\+ *'
 	
@@ -54,19 +53,27 @@ class Ariteval < Parser
 	
   token ")".to_sym, '\) *'
 
-  identifiers = (("a".."z").to_a + ("A".."Z").to_a).join("|")
-  token :ident, "(#{identifiers}) *"
+  token :ident, "[a-Z] *"
 
   token :assign, "= *" 
 	
+  token :space, " "
+  
   # production definitions
 	
   lookahead(true)
 	
   scope :exp
 
-  production(:exp,:recursive) do |prod|
-    prod.default { |scanner,parser| parser.parse_term }
+  production(:exp,:iterative) do |prod|
+    prod.default do |scanner,parser| 
+      #this is needed to trim spaces from the beginning of the string to parse
+      while scanner.current == :space
+        scanner.next
+      end
+      
+      parser.parse_term
+    end
 
     prod.token(:plus) do |term_seq,scanner,parser|
       scanner.next
@@ -79,10 +86,9 @@ class Ariteval < Parser
       next_term = parser.parse_term
       MinusExp.new(term_seq,next_term)
     end
-	
   end
 
-  production(:term,:recursive) do |prod|
+  production(:term,:iterative) do |prod|
     prod.default { |scanner,parser| parser.parse_factor }
 
     prod.token(:mul) do |factor_seq,scanner,parser|
@@ -129,4 +135,4 @@ class Ariteval < Parser
 
   end
 
-end
+end

data/examples/ariteval/ariteval_repl.rb

@@ -0,0 +1,24 @@
+#! /usr/bin/ruby
+
+unless Object.const_defined? :LLIP
+  require File.join(File.dirname(__FILE__), "/../../lib/llip")
+end
+
+require File.dirname(__FILE__) + "/ariteval"
+
+Signal.trap("INT") do
+  puts "Goodbye!"
+  exit(0)
+end
+  
+parser = Ariteval.new
+  
+loop do
+  print "> "
+  string = readline.strip
+  begin
+    puts "=> " + parser.evaluate(string).to_s
+  rescue Exception => er
+    puts "Exception raised: \"#{er.message}\""
+  end
+end

data/examples/ariteval/evaluator.rb

@@ -39,6 +39,7 @@ class Evaluator
   end
 
   def visit_ident_exp(exp)
+    raise "Unknown variable \"#{exp.value}\"" unless ident_table.has_key?(exp.value)
     @result = ident_table[exp.value]
   end
 

data/examples/ariteval/exp.rb

@@ -1,8 +1,6 @@
-require 'visitable'
-
 class NumExp
 
-  include Visitable
+  include LLIP::Visitable
   
   attr_reader :value
 
@@ -16,7 +14,7 @@ class NumExp
 end
 
 class IdentExp
-  include Visitable
+  include LLIP::Visitable
   
   attr_reader :value
 
@@ -31,7 +29,7 @@ end
 
 class AssignIdentExp
 	
-  include Visitable
+  include LLIP::Visitable
 
   attr_reader :name
   attr_reader :value
@@ -49,7 +47,7 @@ end
 
 class OpExp
 
-  include Visitable
+  include LLIP::Visitable
 
   attr_reader :op
   attr_reader :left

data/lib/llip.rb

@@ -1,6 +1,7 @@
 # :include: README.txt
 module LLIP
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end
 
 require File.dirname(__FILE__) + '/llip/parser'
+require File.dirname(__FILE__) + '/llip/visitable'

data/lib/llip/parser.rb

@@ -83,7 +83,7 @@ module LLIP
         @parser = Class.new(AbstractParser)
         @scanner = Class.new(RegexpAbstractScanner)
         
-        @regexp_scanner = RegexpScanner.new
+        @regexp_scanner = Buffer.new(RegexpScanner.new)
         @regexp_parser = RegexpParser.new
         
         @lookahead = false

data/lib/llip/production_specification.rb

@@ -27,8 +27,8 @@ module LLIP
     # They are specified through ProductionSpecification#token.
     attr_reader :tokens
     
-    # The mode of the production. It can be :single or :recursive.
-    attr_accessor :mode
+    # The mode of the production. It can be :single or :recursive (:iterative is just an alias for :recursive).
+    attr_reader :mode
     
     # This attribute specifies if the production should raise an exception if the current token hasn't been recognized.
     # It's important only for :single productions.
@@ -75,5 +75,13 @@ module LLIP
       @default
     end
     
+    # see ProductionSpecification#mode
+    def mode=(value)
+      if value == :iterative
+        value = :recursive
+      end
+      @mode = value
+    end
+    
   end
 end

data/lib/llip/regexp_parser.rb

@@ -6,11 +6,11 @@ module LLIP
   #
   # === Grammar
   #	
-  # VN = { EXP , ELEMENT}
+  # VN = { EXP , ELEMENT , META}
   #
   # char = every charachter
   #	
-  # symb = { ( , ) , . , * , + , \ , |}
+  # symb = { ( , ) , . , * , + , \ , | , [ , ] }
   #	
   # VT = char U symb
   #
@@ -24,7 +24,12 @@ module LLIP
   #   META -> ELEMENT+
   #   META -> ELEMENT
   #   ELEMENT -> char or . or \symb
+  #   ELEMENT -> [CLASS]
   #   ELEMENT -> (EXP)
+  #   CLASS -> char
+  #   CLASS -> char CLASS
+  #   CLASS -> char - char
+  #   CLASS -> char - char CLASS
   # }
   #
   # or in EBNF format
@@ -32,7 +37,8 @@ module LLIP
   # P' = {
   #   EXP ::= META{[|]EXP}
   #   META ::= ELEMENT[* or  +]
-  #   ELEMENT ::= char or . or \symb or (EXP)
+  #   ELEMENT ::= char or . or \symb or (EXP) or [CLASS]
+  #   CLASS ::= char{ - char or - char char or char}
   # }
   #
   class LLIP::RegexpParser < LLIP::AbstractParser
@@ -67,7 +73,6 @@ module LLIP
       end
       
       p.token("|") do |result,scanner,parser|
-        result 
         scanner.next
         parser[:last] = result
         parser.parse_meta.last
@@ -88,6 +93,11 @@ module LLIP
         result
       end
       
+      p.token("[") do |result,scanner,parser|
+        parser.parse_meta
+        result
+      end
+      
       p.token("\\") do |result,scanner,parser|
         parser.parse_meta
         result
@@ -171,6 +181,55 @@ module LLIP
         parser[:last] = first_state.last
         first_state.keys
       end
+      
+      p.token("[") do |result, scanner, parser|
+        scanner.next
+        
+        chars = parser.parse_class
+        unless scanner.current == "]"
+          raise "Every '[' must be followed by a ']'"
+        end
+        scanner.next
+        
+        state = parser[:regexp].add_state
+        chars.each do |char|
+          parser[:last].each { |s| s[char] = state }
+        end
+ 
+        parser[:last] = [state]
+        chars
+      end
+    end
+    
+    production :class, :recursive do |prod|
+      prod.default do |scanner,parser| 
+        []
+      end
+      
+      prod.token(:char) do |result, scanner, parser|
+        result << scanner.current.value
+        scanner.next
+        result
+      end
+      
+      prod.token(:char,"-",:char) do |result, scanner, parser|
+        first_char = scanner.current.value
+        scanner.next
+        last_char = scanner.next.value
+        
+        block = lambda do |char|
+            result << char
+          end
+        
+        if first_char =~ /[a-z]/ and last_char =~ /[A-Z]/
+          (first_char.."z").to_a.each(&block)
+          ("A"..last_char).to_a.each(&block)
+        else
+          (first_char..last_char).to_a.each(&block)
+        end
+        scanner.next
+        result
+      end
     end
     
     def add_char(parser, scanner, char=scanner.current.value)

data/lib/llip/regexp_scanner.rb

@@ -15,7 +15,7 @@ module LLIP
     
     add_regexp(CHAR)
     
-    # It represents the regular expression '(.|*|+|\(|\)|\\|\|)' so it matches the chars: . * + ( ) \ |
+    # It represents the regular expression '(.|*|+|\(|\)|\\|\|\[|\]-)' so it matches the chars: . * + ( ) \ | [ ] -
     SYMBOL = LLIP::RegexpSpecification.new(:symbol)
     
     SYMBOL.add_state
@@ -27,6 +27,8 @@ module LLIP
     SYMBOL.init[')'] = final
     SYMBOL.init['\\'] = final
     SYMBOL.init['|'] = final
+    SYMBOL.init['['] = final
+    SYMBOL.init[']'] = final
     
     add_regexp(SYMBOL)
   end

data/lib/llip/regexp_specification.rb

@@ -177,8 +177,14 @@ module LLIP
         examined[new_first] ||= state
         examined[new_second] ||= state
         
-        if new_first.final? or new_second.final?
+        if new_first.final? and new_second.final?
           raise "It's impossible to mix two regexp with final states in common."
+        elsif new_first.final?
+          state.regexp = new_first.regexp
+          state.final = true
+        elsif new_second.final?
+          state.regexp = new_second.regexp
+          state.final = true
         end
         mix_accessor(new_first,new_second,regexp,state,examined)
       end

data/spec/ariteval/ariteval_spec.rb

@@ -80,6 +80,10 @@ describe "An Ariteval should be able to parse" do
   it "'( a = 3 * 2 ) - ( 24 + a )'" do
     @parser.parse('( a = 3 * 2 ) - ( 24 + a )').to_s.should == "( ( a = ( 3 * 2 ) ) - ( 24 + a ) )"
   end
+  
+  it "' 3 + 2'" do
+    @parser.parse(' 3 + 2').to_s.should == "( 3 + 2 )"
+  end
 end
 
 describe "An Ariteval shouldn't be able to parse" do

data/spec/ariteval/evaluator_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require 'ariteval'
 require 'evaluator'
-require 'buffer'
 
 
 describe 'An Evaluator' do
@@ -61,26 +61,26 @@ describe "An Evaluator should be able to eval" do
     expression = "3 * (4 - 2) + 5*(4/2)/(3-2)"
 		
     exp = PlusExp.new(
-    MulExp.new(
-    NumExp.new(3),
-    MinusExp.new(
-    NumExp.new(4),
-    NumExp.new(2)
-    )
-    ),
-    DivExp.new(
-    MulExp.new(
-    NumExp.new(5),
-    DivExp.new(
-    NumExp.new(4),
-    NumExp.new(2)
-    )
-    ),
-    DivExp.new(
-    NumExp.new(3),
-    NumExp.new(2)
-    )
-    )
+      MulExp.new(
+        NumExp.new(3),
+        MinusExp.new(
+          NumExp.new(4),
+          NumExp.new(2)
+        )
+      ),
+      DivExp.new(
+        MulExp.new(
+          NumExp.new(5),
+          DivExp.new(
+            NumExp.new(4),
+            NumExp.new(2)
+          )
+        ),
+        DivExp.new(
+          NumExp.new(3),
+          NumExp.new(2)
+        )
+      )
     )
 		
     exp.accept(@eval)
@@ -103,4 +103,8 @@ describe "An Evaluator should be able to eval" do
     @parser.parse("a").accept(@eval)
     @eval.result.should == @eval.ident_table["a"]
   end
+  
+  it "an IdentExp with an unknown name" do
+    lambda { @parser.parse("a").accept(@eval) }.should raise_error
+  end
 end

data/spec/llip/abstract_parser_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'abstract_parser'
 
 describe "A class descending from AbstractParser" do
 

data/spec/llip/abstract_scanner_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'abstract_scanner'
 require 'stringio'
 
 describe "An AbstractScanner" do

data/spec/llip/llip_error_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'llip_error'
 
 describe "An LLIPError" do
 

data/spec/llip/parser_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'parser'
 require 'stringio'
 
 describe "A class that descend from Parser" do
@@ -38,7 +37,8 @@ describe "A class that descend from Parser" do
     @class.should respond_to(:regexp_scanner)
 
     @class.regexp_parser.should be_kind_of(RegexpParser)
-    @class.regexp_scanner.should be_kind_of(RegexpScanner)
+    @class.regexp_scanner.should be_kind_of(Buffer)
+    @class.regexp_scanner.scanner.should be_kind_of(RegexpScanner)
   end
 
   it "should have a token method which parse a regexp and calls :add_regexp to the scanner" do
@@ -135,7 +135,7 @@ describe "The instance of a class descending from Parser with a simple grammar s
     @instance = @class.new
 
     @class.token(:plus,"\\+")
-    @class.token(:number,("0".."9").to_a.join("|"))
+    @class.token(:number,"[0-9]")
 	
     @class.scope(:exp)
 

data/spec/llip/production_compiler_spec.rb

@@ -137,12 +137,13 @@ describe "A ProductionCompiler" do
 
     @production = mock "Production"
     @production.should_receive(:name).and_return(:fake)
-    @production.should_receive(:tokens).and_return({ [:look,"3"] => nil, [:look,"1"] => nil, :look => nil})
+    @production.should_receive(:tokens).and_return({[:look,"3","2"] => nil, :look => nil, [:look,"1"] => nil, [:look, "2"] => nil })
     @production.should_receive(:raise_on_error).and_return(true)
 
     @compiler.should_receive(:start).with(:fake)
-    @compiler.should_receive(:token).with([:look,"3"])	
+    @compiler.should_receive(:token).with([:look,"3","2"])	
     @compiler.should_receive(:token).with([:look,"1"])
+    @compiler.should_receive(:token).with([:look,"2"])
     @compiler.should_receive(:token).with(:look)	
     @compiler.should_receive(:end).with(true)
 
@@ -156,6 +157,14 @@ describe "A ProductionCompiler" do
     @production.should_receive(:tokens).and_return({ [:look,"1"] => nil, [:look,"3","2"] => nil, :everything => nil, :look => nil})
 		
     @compiler.sort_production(@production).should == [[:look,"3","2"],[:look,"1"], :look, :everything]
+    
+    @production = mock "Production"
+    tokens = mock "Tokens"
+    tokens.should_receive(:keys).twice.and_return([[:look,"3","2"],[:look,"1"]])
+    tokens.should_receive(:has_key?).twice.with(:look).and_return(false)
+    @production.should_receive(:tokens).and_return(tokens)
+		
+    @compiler.sort_production(@production).should == [[:look,"3","2"],[:look,"1"]]
   end
 end
 

data/spec/llip/production_specification_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'production_specification'
 
 describe "A ProductionSpecification" do
   
@@ -72,4 +71,9 @@ describe "A ProductionSpecification" do
     @production.raise_on_error=false
     @production.raise_on_error.should == false
   end
+  
+  it "should alias :recursive with :iterative" do
+    @production.mode = :iterative
+    @production.mode.should == :recursive
+  end
 end

data/spec/llip/regexp_abstract_scanner_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'regexp_abstract_scanner'
 
 describe "A class descending from RegexpAbstractScanner" do
 

data/spec/llip/regexp_parser_spec.rb

@@ -1,14 +1,11 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'regexp_parser'
-require 'regexp_specification'
-require 'token'
 
 module RegexpMockScannerBuilder
 
   def mock_scanner(*tokens)
     @scanner = mock "Scanner"
     tokens.map! do |t|
-      if t =~ /[\.\+\*\|\(\)\\]/
+      if t =~ /[\.\+\*\|\(\)\\\-\[\]]/
         Token.new(:symbol,t)
       else
         Token.new(:char,t)
@@ -19,7 +16,7 @@ module RegexpMockScannerBuilder
     t = nil
     @scanner.should_receive(:next).exactly(tokens.size).and_return { t = @tokens.shift }
     @scanner.should_receive(:current).any_number_of_times.and_return { t }
-    @scanner
+    Buffer.new(@scanner)
   end
 
 end
@@ -245,6 +242,85 @@ describe "A RegexpParser should parse" do
     regexp.init['a']['c'].final?.should == false
     regexp.init['a']['c']['e'].final?.should == false
   end
+  
+  it "[a-zD]" do
+    @scanner = mock_scanner("[","a","-","z","D","]")
+    regexp = @parser.parse(@scanner)
+    
+    keys = regexp.init.keys
+    expected_keys = ("a".."z").to_a + ["D"]
+    keys.sort!
+    expected_keys.sort!
+    keys.should == expected_keys
+    keys.each do |key|
+      regexp[key].should be_final
+    end
+  end
+  
+  it "[a-Z]" do
+    @scanner = mock_scanner("[","a","-","Z","]")
+    regexp = @parser.parse(@scanner)
+    
+    keys = regexp.init.keys
+    expected_keys = ("a".."z").to_a + ("A".."Z").to_a
+    keys.sort!
+    expected_keys.sort!
+    keys.should == expected_keys
+    keys.each do |key|
+      regexp[key].should be_final
+    end
+  end
+  
+  
+  it "a[bc]+d" do
+    @scanner = mock_scanner("a","[","b","c","]","+","d")
+    regexp = @parser.parse(@scanner)
+
+    regexp.init['a'].keys.should == ['b','c']
+		
+    regexp['a']['b'].keys.should == ['b','c','d']
+    regexp['a']['c'].keys.should == ['b','c','d']
+		
+    regexp.init['a']['b']['d'].should be_final
+    regexp.init['a']['c']['d'].should be_final
+	
+    regexp.init['a'].should_not == regexp.init['a']['b']
+    regexp.init['a'].should_not == regexp.init['a']['c']
+		
+    regexp.init['a']['b']['b'].should == regexp.init['a']['b']
+    regexp.init['a']['c']['b'].should == regexp.init['a']['b']
+    regexp.init['a']['b']['c'].should == regexp['a']['c']
+
+    regexp['a']['b'].final?.should == false
+    regexp.init['a']['c'].final?.should == false
+    regexp.init['a']['c'].final?.should == false
+  end
+  
+    
+  it "a[bc]*d" do
+    @scanner = mock_scanner("a","[","b","c","]","*","d")
+    regexp = @parser.parse(@scanner)
+
+    regexp.init['a'].keys.should == ['b','c','d']
+    regexp['a']['d'].should be_final
+		
+    regexp['a']['b'].keys.should == ['b','c','d']
+    regexp['a']['c'].keys.should == ['b','c','d']
+		
+    regexp.init['a']['b']['d'].should be_final
+    regexp.init['a']['c']['d'].should be_final
+	
+    regexp.init['a'].should == regexp.init['a']['b']
+    regexp.init['a'].should == regexp.init['a']['c']
+		
+    regexp.init['a']['b']['b'].should == regexp.init['a']['b']
+    regexp.init['a']['c']['b'].should == regexp.init['a']['b']
+    regexp.init['a']['b']['c'].should == regexp['a']['c']
+
+    regexp['a']['b'].final?.should == false
+    regexp.init['a']['c'].final?.should == false
+    regexp.init['a']['c'].final?.should == false
+  end
 
 end
 
@@ -261,5 +337,10 @@ describe "A RegexpParser should not parse" do
     @scanner = mock_scanner("a","(","b","c","d","e","f")
     lambda { @parser.parse(@scanner) }.should raise_error(RuntimeError)
   end
+  
+  it "a[cdef" do
+    @scanner = mock_scanner("a","[","b","c","d","e","f")
+    lambda { @parser.parse(@scanner) }.should raise_error(RuntimeError)
+  end
 
 end

data/spec/llip/regexp_scanner_spec.rb

@@ -1,6 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'regexp_scanner'
-require 'token'
 require 'stringio'
 
 describe "A RegexpScanner should scan" do
@@ -37,4 +35,16 @@ describe "A RegexpScanner should scan" do
     @scanner.next.should == :symbol
     @scanner.next.should be_nil
   end
+  
+  it "'[a-zA-Z]'" do
+    @scanner.scan('[a-zA-Z]')
+    @scanner.next.should == :symbol
+    @scanner.next.should == 'a'
+    @scanner.next.should == '-'
+    @scanner.next.should == 'z'
+    @scanner.next.should == 'A'
+    @scanner.next.should == '-'
+    @scanner.next.should == 'Z'
+    @scanner.next.should == :symbol
+  end
 end

data/spec/llip/regexp_specification_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require 'regexp_specification'
 
 describe "A RegexpSpecification" do
 
@@ -637,7 +636,7 @@ describe "The :mix method of the RegexpSpecification class" do
     second['a'].error.should == s3
   end
 
-  it "should raise if trying to mix: 'ab' and 'abc'" do
+  it "should be able to mix: 'ab' and 'abc'" do
     r1 = RegexpSpecification.new("first")
     r2 = RegexpSpecification.new("second")
 		
@@ -654,8 +653,13 @@ describe "The :mix method of the RegexpSpecification class" do
     s4['a'] = s5
     s5['b'] = s6
     s6['c'] = s7
-		
-    lambda { RegexpSpecification.mix(r1,r2) }.should raise_error(RuntimeError)
+	
+    result = RegexpSpecification.mix(r1,r2)
+    result.name.should == :"mix between 'first' and 'second'"
+    result['a']['b'].should be_final
+    result['a']['b'].regexp.should == r1
+    result['a']['b']['c'].should be_final
+    result['a']['b']['c'].regexp.should == r2
   end
 
   it "should be able to mix: '(a|b)c' and '(b|e)d'" do

data/spec/spec_helper.rb

@@ -1,10 +1,12 @@
-require 'rubygems'
-require 'spec'
+unless Object.const_defined? :LLIP
+  $:.unshift(File.join(File.dirname(__FILE__), "/../lib/llip"))
 
-$:.unshift(File.join(File.dirname(__FILE__), "/../lib/llip"))
+  require File.join(File.dirname(__FILE__), "/../lib/llip")
 
-require 'llip'
+  include LLIP
 
-include LLIP
+  require 'rubygems'
+  require 'spec'
 
-$: << File.dirname(__FILE__) + "/../examples/ariteval"
+  $: << File.dirname(__FILE__) + "/../examples/ariteval"
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.4
 specification_version: 1
 name: llip
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-06-09 00:00:00 +02:00
+  version: 0.2.0
+date: 2007-07-17 00:00:00 +02:00
 summary: LLIP is a tool to geneate a LL(k) parser.
 require_paths: 
 - lib
@@ -36,6 +36,7 @@ files:
 - Rakefile
 - examples/ariteval
 - examples/ariteval/ariteval.rb
+- examples/ariteval/ariteval_repl.rb
 - examples/ariteval/evaluator.rb
 - examples/ariteval/exp.rb
 - lib/llip