llip 0.1.0

data/lib/llip/regexp_scanner.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/regexp_abstract_scanner'
+require File.dirname(__FILE__) + '/regexp_specification'
+
+module LLIP
+  # It's a scanner for the parser RegexpParser. It has two kind of token: :char and :symbol.
+  # * char: every character.
+  # * symbol: . * + ( ) \ |
+  class RegexpScanner < RegexpAbstractScanner
+    
+    # It represents the regular expression '.'
+    CHAR = LLIP::RegexpSpecification.new(:char)
+    
+    CHAR.add_state
+    CHAR.init.error = CHAR.add_state(:final => true)
+    
+    add_regexp(CHAR)
+    
+    # It represents the regular expression '(.|*|+|\(|\)|\\|\|)' so it matches the chars: . * + ( ) \ |
+    SYMBOL = LLIP::RegexpSpecification.new(:symbol)
+    
+    SYMBOL.add_state
+    final = SYMBOL.add_state(:final => true)
+    SYMBOL.init['.'] = final
+    SYMBOL.init['*'] = final
+    SYMBOL.init['+'] = final
+    SYMBOL.init['('] = final
+    SYMBOL.init[')'] = final
+    SYMBOL.init['\\'] = final
+    SYMBOL.init['|'] = final
+    
+    add_regexp(SYMBOL)
+  end
+end

data/lib/llip/regexp_specification.rb

@@ -0,0 +1,210 @@
+require 'forwardable'
+
+module LLIP
+  # This class represents a specification for a Regexp as an Hash of State because of the equivalence between finite state machines and regular expressions.
+  class RegexpSpecification
+    
+    extend Forwardable
+    
+    def_delegators :@init, :[], :[]=, :keys, :values, :each, :error, :error=, :final?, :final=, :regexp, :regexp=
+    
+    # The name of the RegexpSpecification. Its default is nil
+    attr_accessor :name
+    
+    # The first value inserted in the RegexpSpecification
+    attr_reader :init
+    
+    # It's an hash containing all the states that compose this RegexpSpecification
+    attr_reader :states
+    
+    # The +name+ is stored in the attribute name.
+    def initialize(name=nil)
+      @states = Hash.new { |hash,key| raise "Unknown RegexpSpecification::State #{key}" }
+      @name = name.to_sym if name
+    end
+    
+    # :call-seq:
+    # 	add_state(RegexpSpecification::State) => RegexpSpecification::State
+    #		add_state({}) => RegexpSpecification::State
+    #		add_state => RegexpSpecification::State
+    #
+    # Adds a State to the RegexpSpecification with the name as a key. 
+    # If an hash is passed, it will create a State with that hash as a parameter. 
+    # If nothing is passed, an empty Hash is taken as the default.
+    def add_state(arg={})
+      unless arg.kind_of? State or arg.kind_of? RegexpSpecification
+        arg = State.new(arg)
+      end
+      @init ||= arg
+      arg.regexp = self
+      @states[arg.name]=arg
+    end
+    
+    # Returns :everything if the init State has an error which is not a State. Returns the init State keys otherwise.
+    def starting_chars
+      if self.init
+        if self.init.error.kind_of? State
+          :everything
+        else
+          self.init.keys
+        end
+      else
+        []
+      end	
+    end
+    
+    # Calls init.last
+    # 
+    # See State#last	
+    def last
+      return [] unless @init
+      @init.last
+    end
+    
+    public
+    class State < Hash
+      
+      # It's a Numeric and it globally identifies a State.	
+      attr_reader :name
+      
+      # see State#final?
+      attr_writer :final
+      
+      # The RegexpSpecification of this state
+      attr_accessor :regexp
+      
+      @@next_name = 0
+      
+      # The defaults are:
+      # 	* :final => false
+      # 	* :error => :error
+      #
+      # If :error is set to :self, the error code it's set to the name of the State, i.e. state[:unknown_key] == state.name => true. This is used to have a everything-like behaviour.
+      def initialize(hash = {})
+        @name = (@@next_name += 1)
+        
+        if hash[:error] == :self
+          super self
+        elsif hash[:error].nil?
+          super :error
+        else
+          hash[:error] = hash[:error].to_sym if hash[:error].respond_to? :to_sym
+          super hash[:error]
+        end
+        
+        @final = hash[:final] || false
+        
+        self
+      end
+      
+      # :call-seq:
+      # 	final? => true
+      # 	final? => false
+      #
+      # It identifies if a State is final or not.
+      def final?
+        @final
+      end
+      
+      # As a State is globally identified by it's name so it's valid to use it as the hash code.
+      def hash
+        @name.hash
+      end
+      
+      alias :error :default
+      alias :error= :default=
+      
+      def ==(other)
+        if other.respond_to? :error
+          return false unless other.error === error
+        end
+        super
+      end
+      
+      # Return an Array which contains all the last states reachable starting from this state, those which must be marked as final.
+      #
+      # It internally calls RegexpSpecification.last_accessor	
+      def last
+        RegexpSpecification.last_accessor(self).uniq	
+      end
+      
+    end
+    
+    # :call-seq:
+    # 	RegexpSpecification.last_accessor(RegexpSpecification::State) => Array
+    #
+    # Returns an Array which contains all the last states reachable starting from _state_. The states in the array may be duplicated.
+    def self.last_accessor(state,last=[],examined={},prev=nil)
+      
+      future_states = state.values.uniq
+      
+      future_states << state.error if ( state.error.kind_of? RegexpSpecification::State or state.error.kind_of? RegexpSpecification ) and state.error != state 
+      
+      unless examined.has_key? state
+        examined[state] = {}
+        examined[state][prev] = true	
+        
+        if future_states.size == 0
+          last << state
+        else
+          future_states.each do |s|
+            last_accessor(s,last,examined,state)
+          end
+        end
+      else
+        future_state_unvisited = future_states.select { |s| not examined[s] }
+        last << state if future_state_unvisited.size == 0 and ( examined[state][prev] or examined[state][state] or prev == state )
+        examined[state][prev] = true
+      end
+      last
+    end
+    
+    # This method is used by RegexpAbstractScanner to mix two different RegexpSpecification which have starting chars in common.
+    # It raises an exception if the two regexp have some common chars marked as final.
+    def self.mix(first,second)
+      regexp = self.new("mix between '#{first.name}' and '#{second.name}'") 
+      mix_accessor(first.init,second.init,regexp,regexp.add_state)
+      regexp
+    end
+    
+    private
+    def self.mix_accessor(first, second, regexp, last,examined={first => last , second => last}) # :nodoc:
+      first_keys = first.keys - second.keys
+      common_keys = first.keys - first_keys
+      second_keys = second.keys - common_keys
+      
+      accessor = lambda do |new_first,new_second,state|
+        examined[new_first] ||= state
+        examined[new_second] ||= state
+        
+        if new_first.final? or new_second.final?
+          raise "It's impossible to mix two regexp with final states in common."
+        end
+        mix_accessor(new_first,new_second,regexp,state,examined)
+      end
+      
+      common_keys.each do |key|
+        unless examined.has_key? first[key] and examined.has_key? second[key]
+          state = regexp.add_state
+          last[key] = state
+          accessor.call(first[key],second[key],state)
+        else
+          last[key] = examined[first[key]] # because examined[first[key]] and examined[second[key]] are the same
+        end	
+      end
+      
+      if first.error.kind_of? State and second.error.kind_of? State
+        state = regexp.add_state
+        last.error = state
+        accessor.call(first.error,second.error,state)
+      elsif first.error.kind_of? State
+        last.error = first.error
+      elsif second.error.kind_of? State
+        last.error = second.error
+      end
+      
+      first_keys.each  { |key| last[key] = first[key] }
+      second_keys.each { |key| last[key] = second[key] }
+    end
+  end
+end

data/lib/llip/token.rb

@@ -0,0 +1,47 @@
+module LLIP
+  class Token
+    
+    # The name of the Regexp that generated this token
+    attr_reader :name
+    
+    # The matched String
+    attr_reader :value
+    
+    # The line at which this token was matched
+    attr_reader :line
+    
+    # The position of the first char in the token
+    attr_reader :char
+    
+    alias :to_s :value
+    alias :to_str :value
+    
+    def initialize(name=:nil,value=nil,line=-1,char = -1)
+      @name = name
+      @value = value
+      @line = line
+      @char = char
+    end
+    
+    def nil?
+      value.nil?
+    end
+    
+    def ==(other)
+      if other.respond_to? :name
+        other.name == @name
+      elsif other.respond_to? :to_str
+        @value == other.to_str
+      elsif other.respond_to? :to_sym	
+        return true if other == :everything
+        other.to_sym == @name
+      else
+        nil
+      end
+    end
+    
+    def =~(regexp)
+      @value =~ regexp
+    end
+  end
+end

data/lib/llip/visitable.rb

@@ -0,0 +1,37 @@
+
+module LLIP
+  
+  # It makes a class visitable like it's defined in the Visitor pattern, using the
+  # double dispatch tecnique.
+  #
+  # It adds the accept method so for every instance of a class, ie TempClass, including it,
+  # it's possible to call instance.accept(visitor) and the visitor will receive
+  # a :visit_temp_class message.
+  #
+  # It passes this ability to its subclasses, so if the subclass is TempClassChild the visitor
+  # method which will be called is :visit_temp_class_child.
+  module Visitable
+    def self.included(other)
+      add_accept(other)
+      other.extend(ClassMethods)
+    end
+
+    # It adds the accept method following the visitor pattern and the double dispatch tecnique.
+    def self.add_accept(klass)
+      name = klass.name.gsub(/[A-Z]+/) { |s| " " + s.downcase}.strip.gsub(" ","_")
+      klass.class_eval <<-CODE
+			def accept(visitor)
+				visitor.visit_#{name}(self)
+			end
+		CODE
+    end
+    
+    module ClassMethods
+      def inherited(other)
+        Visitable.add_accept(other)
+        other.extend(Visitable::ClassMethods)
+      end
+    end
+  end
+end
+

data/spec/ariteval/ariteval_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'ariteval'
+
+describe "An Ariteval should evaluate" do
+	
+  before(:each) do
+    @ariteval = Ariteval.new
+  end
+
+  it "a single complex expression" do
+    expression = "3 * (4 - 2) + 5*(4/2)/(3-2)"
+    @ariteval.evaluate(expression).should == eval(expression)
+  end
+
+  it "two different expressions" do
+    exp1 = "5 - 32"
+    exp2 = "3*(2-4)"
+
+    @ariteval.evaluate(exp1).should == eval(exp1)
+    @ariteval.evaluate(exp2).should == eval(exp2)
+  end
+end
+
+describe "An Ariteval should be able to parse" do
+
+  before(:each) do
+    @parser = Ariteval.new
+    @parser.should respond_to(:parse)
+    @parser.scanner.should be_kind_of(Buffer)
+  end
+	
+  it "'1 + 1 + 1'" do
+    result = @parser.parse('1+ 1 + 1')
+
+    result.to_s.should == "( ( 1 + 1 ) + 1 )"
+  end
+
+  it "'5 - 1 - 2'" do
+    result = @parser.parse('5 - 1 - 2')
+
+    result.to_s.should == "( ( 5 - 1 ) - 2 )"
+  end
+
+  it "'1 + 5 * 3'" do
+    @parser.parse('1 + 5 * 3').to_s.should == "( 1 + ( 5 * 3 ) )"
+  end
+
+  it "'5 * 3 / 2'" do
+    @parser.parse('5 * 3 / 2').to_s.should == "( ( 5 * 3 ) / 2 )"
+  end
+
+  it "'5 * ( 4 + 1 )'" do
+    @parser.parse('5 * ( 4 + 1 )').to_s.should == "( 5 * ( 4 + 1 ) )"
+  end
+
+  it "'( 3 - 4 ) * ( 3 + 2 )'" do
+    @parser.parse('( 3 - 4 ) * ( 3 + 2 )').to_s.should == '( ( 3 - 4 ) * ( 3 + 2 ) )' 
+  end
+
+  it "twice" do
+    result = @parser.parse("1+1+1")
+
+    result.to_s.should == "( ( 1 + 1 ) + 1 )"
+	
+    result = @parser.parse("5-1-2")
+
+    result.to_s.should == "( ( 5 - 1 ) - 2 )"
+  end
+
+  it "a = 5" do
+    Ariteval.parser.productions[:factor].tokens[[:ident,:assign]].should_not be_nil
+    @parser.scanner.should respond_to(:lookahead)
+    @parser.parse("a = 5").to_s.should == "( a = 5 )"
+  end
+	
+  it "a + 5" do
+    @parser.parse("a + 5").to_s.should == "( a + 5 )"
+  end
+
+  it "'( a = 3 * 2 ) - ( 24 + a )'" do
+    @parser.parse('( a = 3 * 2 ) - ( 24 + a )').to_s.should == "( ( a = ( 3 * 2 ) ) - ( 24 + a ) )"
+  end
+end
+
+describe "An Ariteval shouldn't be able to parse" do
+	
+  before(:each) do
+    @parser = Ariteval.new
+  end
+
+  it "'1 + +'" do
+    lambda { @parser.parse('1 + +') }.should raise_error(ParserError)
+  end
+
+  it "'- 1'" do
+    lambda { @parser.parse('- 1') }.should raise_error(ParserError)
+  end
+
+  it "'* 2'" do
+    lambda { @parser.parse('* 2') }.should raise_error(ParserError)
+  end
+	
+  it "'2 /'" do
+    lambda { @parser.parse('2 /') }.should raise_error(ParserError)
+  end
+
+  it "'2 * ( 1 + 3'" do
+    lambda { @parser.parse('2 * ( 1 + 3') }.should raise_error(ParserError)
+  end
+	
+end

data/spec/ariteval/evaluator_spec.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'evaluator'
+require 'buffer'
+
+
+describe 'An Evaluator' do
+	
+  before(:each) do
+    @eval = Evaluator.new
+  end
+
+  it "should be able to visit all the elements" do
+    @eval.should respond_to(:visit_num_exp)
+    @eval.should respond_to(:visit_plus_exp)
+    @eval.should respond_to(:visit_minus_exp)
+    @eval.should respond_to(:visit_mul_exp)
+    @eval.should respond_to(:visit_div_exp)
+  end
+
+  it "should return the computated result" do
+    @eval.should respond_to(:result)
+  end
+end
+
+describe "An Evaluator should be able to eval" do
+
+  before(:each) do
+    @eval = Evaluator.new
+    @parser = Ariteval.new
+  end
+	
+  it "a NumExp" do
+    num = mock "NumExp"
+    num.should_receive(:value).and_return(5)
+
+    @eval.visit_num_exp(num)
+    @eval.result.should be_equal(5)
+  end
+	
+  it "a PlusExp" do
+    @parser.parse("1 + 1").accept(@eval)
+    @eval.result.should == 2
+  end
+
+  it "a MinusExp" do
+    @parser.parse("5 - 1").accept(@eval)
+    @eval.result.should == 4
+  end
+	
+  it "a MulExp" do
+    @parser.parse("5 * 2").accept(@eval)
+    @eval.result.should == 10
+  end
+
+  it "a DivExp" do
+    @parser.parse("4 / 2").accept(@eval)
+    @eval.result.should == 2
+  end
+
+  it "a complex expression" 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)
+    )
+    )
+    )
+		
+    exp.accept(@eval)
+    @eval.result.should == eval(expression)
+  end
+
+  it "should have a ident_table" do
+    @eval.should respond_to(:ident_table)
+    @eval.ident_table.should == {}
+  end
+
+  it "an AssignIdentExp" do
+    @parser.parse("a = 4").accept(@eval)
+    @eval.result.should == 4
+    @eval.ident_table["a"].should == 4
+  end
+
+  it "an IdentExp" do
+    @eval.ident_table["a"] = 5
+    @parser.parse("a").accept(@eval)
+    @eval.result.should == @eval.ident_table["a"]
+  end
+end