personify 1.0.0

data/vendor/treetop/examples/lambda_calculus/arithmetic.rb

@@ -0,0 +1,551 @@
+module Arithmetic
+  include Treetop::Runtime
+  
+  def root
+    @root || :expression
+  end
+  
+  def _nt_expression
+    start_index = index
+    cached = node_cache[:expression][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    r1 = _nt_comparative
+    if r1.success?
+      r0 = r1
+    else
+      r2 = _nt_additive
+      if r2.success?
+        r0 = r2
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0)
+      end
+    end
+    
+    node_cache[:expression][start_index] = r0
+    
+    return r0
+  end
+  
+  module Comparative0
+    def operand_1
+      elements[0]
+    end
+    
+    def space
+      elements[1]
+    end
+    
+    def operator
+      elements[2]
+    end
+    
+    def space
+      elements[3]
+    end
+    
+    def operand_2
+      elements[4]
+    end
+  end
+  
+  def _nt_comparative
+    start_index = index
+    cached = node_cache[:comparative][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0, s0 = index, []
+    r1 = _nt_additive
+    s0 << r1
+    if r1.success?
+      r2 = _nt_space
+      s0 << r2
+      if r2.success?
+        r3 = _nt_equality_op
+        s0 << r3
+        if r3.success?
+          r4 = _nt_space
+          s0 << r4
+          if r4.success?
+            r5 = _nt_additive
+            s0 << r5
+          end
+        end
+      end
+    end
+    if s0.last.success?
+      r0 = (BinaryOperation).new(input, i0...index, s0)
+      r0.extend(Comparative0)
+    else
+      self.index = i0
+      r0 = ParseFailure.new(input, i0)
+    end
+    
+    node_cache[:comparative][start_index] = r0
+    
+    return r0
+  end
+  
+  module EqualityOp0
+    def apply(a, b)
+      a == b
+    end
+  end
+  
+  def _nt_equality_op
+    start_index = index
+    cached = node_cache[:equality_op][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    r0 = parse_terminal('==', SyntaxNode, EqualityOp0)
+    
+    node_cache[:equality_op][start_index] = r0
+    
+    return r0
+  end
+  
+  module Additive0
+    def operand_1
+      elements[0]
+    end
+    
+    def space
+      elements[1]
+    end
+    
+    def operator
+      elements[2]
+    end
+    
+    def space
+      elements[3]
+    end
+    
+    def operand_2
+      elements[4]
+    end
+  end
+  
+  def _nt_additive
+    start_index = index
+    cached = node_cache[:additive][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_multitive
+    s1 << r2
+    if r2.success?
+      r3 = _nt_space
+      s1 << r3
+      if r3.success?
+        r4 = _nt_additive_op
+        s1 << r4
+        if r4.success?
+          r5 = _nt_space
+          s1 << r5
+          if r5.success?
+            r6 = _nt_additive
+            s1 << r6
+          end
+        end
+      end
+    end
+    if s1.last.success?
+      r1 = (BinaryOperation).new(input, i1...index, s1)
+      r1.extend(Additive0)
+    else
+      self.index = i1
+      r1 = ParseFailure.new(input, i1)
+    end
+    if r1.success?
+      r0 = r1
+    else
+      r7 = _nt_multitive
+      if r7.success?
+        r0 = r7
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0)
+      end
+    end
+    
+    node_cache[:additive][start_index] = r0
+    
+    return r0
+  end
+  
+  module AdditiveOp0
+    def apply(a, b)
+      a + b
+    end
+  end
+  
+  module AdditiveOp1
+    def apply(a, b)
+      a - b
+    end
+  end
+  
+  def _nt_additive_op
+    start_index = index
+    cached = node_cache[:additive_op][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    r1 = parse_terminal('+', SyntaxNode, AdditiveOp0)
+    if r1.success?
+      r0 = r1
+    else
+      r2 = parse_terminal('-', SyntaxNode, AdditiveOp1)
+      if r2.success?
+        r0 = r2
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0)
+      end
+    end
+    
+    node_cache[:additive_op][start_index] = r0
+    
+    return r0
+  end
+  
+  module Multitive0
+    def operand_1
+      elements[0]
+    end
+    
+    def space
+      elements[1]
+    end
+    
+    def operator
+      elements[2]
+    end
+    
+    def space
+      elements[3]
+    end
+    
+    def operand_2
+      elements[4]
+    end
+  end
+  
+  def _nt_multitive
+    start_index = index
+    cached = node_cache[:multitive][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_primary
+    s1 << r2
+    if r2.success?
+      r3 = _nt_space
+      s1 << r3
+      if r3.success?
+        r4 = _nt_multitive_op
+        s1 << r4
+        if r4.success?
+          r5 = _nt_space
+          s1 << r5
+          if r5.success?
+            r6 = _nt_multitive
+            s1 << r6
+          end
+        end
+      end
+    end
+    if s1.last.success?
+      r1 = (BinaryOperation).new(input, i1...index, s1)
+      r1.extend(Multitive0)
+    else
+      self.index = i1
+      r1 = ParseFailure.new(input, i1)
+    end
+    if r1.success?
+      r0 = r1
+    else
+      r7 = _nt_primary
+      if r7.success?
+        r0 = r7
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0)
+      end
+    end
+    
+    node_cache[:multitive][start_index] = r0
+    
+    return r0
+  end
+  
+  module MultitiveOp0
+    def apply(a, b)
+      a * b
+    end
+  end
+  
+  module MultitiveOp1
+    def apply(a, b)
+      a / b
+    end
+  end
+  
+  def _nt_multitive_op
+    start_index = index
+    cached = node_cache[:multitive_op][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    r1 = parse_terminal('*', SyntaxNode, MultitiveOp0)
+    if r1.success?
+      r0 = r1
+    else
+      r2 = parse_terminal('/', SyntaxNode, MultitiveOp1)
+      if r2.success?
+        r0 = r2
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0)
+      end
+    end
+    
+    node_cache[:multitive_op][start_index] = r0
+    
+    return r0
+  end
+  
+  module Primary0
+    def space
+      elements[1]
+    end
+    
+    def expression
+      elements[2]
+    end
+    
+    def space
+      elements[3]
+    end
+    
+  end
+  
+  module Primary1
+    def eval(env={})
+      expression.eval(env)
+    end
+  end
+  
+  def _nt_primary
+    start_index = index
+    cached = node_cache[:primary][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    r1 = _nt_variable
+    if r1.success?
+      r0 = r1
+    else
+      r2 = _nt_number
+      if r2.success?
+        r0 = r2
+      else
+        i3, s3 = index, []
+        r4 = parse_terminal('(', SyntaxNode)
+        s3 << r4
+        if r4.success?
+          r5 = _nt_space
+          s3 << r5
+          if r5.success?
+            r6 = _nt_expression
+            s3 << r6
+            if r6.success?
+              r7 = _nt_space
+              s3 << r7
+              if r7.success?
+                r8 = parse_terminal(')', SyntaxNode)
+                s3 << r8
+              end
+            end
+          end
+        end
+        if s3.last.success?
+          r3 = (SyntaxNode).new(input, i3...index, s3)
+          r3.extend(Primary0)
+          r3.extend(Primary1)
+        else
+          self.index = i3
+          r3 = ParseFailure.new(input, i3)
+        end
+        if r3.success?
+          r0 = r3
+        else
+          self.index = i0
+          r0 = ParseFailure.new(input, i0)
+        end
+      end
+    end
+    
+    node_cache[:primary][start_index] = r0
+    
+    return r0
+  end
+  
+  module Variable0
+    def eval(env={})
+      env[name]
+    end
+    
+    def name
+      text_value
+    end
+  end
+  
+  def _nt_variable
+    start_index = index
+    cached = node_cache[:variable][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    s0, i0 = [], index
+    loop do
+      r1 = parse_char_class(/[a-z]/, 'a-z', SyntaxNode)
+      if r1.success?
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      self.index = i0
+      r0 = ParseFailure.new(input, i0)
+    else
+      r0 = SyntaxNode.new(input, i0...index, s0)
+      r0.extend(Variable0)
+    end
+    
+    node_cache[:variable][start_index] = r0
+    
+    return r0
+  end
+  
+  module Number0
+  end
+  
+  module Number1
+    def eval(env={})
+      text_value.to_i
+    end
+  end
+  
+  def _nt_number
+    start_index = index
+    cached = node_cache[:number][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    i0 = index
+    i1, s1 = index, []
+    r2 = parse_char_class(/[1-9]/, '1-9', SyntaxNode)
+    s1 << r2
+    if r2.success?
+      s3, i3 = [], index
+      loop do
+        r4 = parse_char_class(/[0-9]/, '0-9', SyntaxNode)
+        if r4.success?
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = SyntaxNode.new(input, i3...index, s3)
+      s1 << r3
+    end
+    if s1.last.success?
+      r1 = (SyntaxNode).new(input, i1...index, s1)
+      r1.extend(Number0)
+    else
+      self.index = i1
+      r1 = ParseFailure.new(input, i1)
+    end
+    if r1.success?
+      r0 = r1
+      r0.extend(Number1)
+    else
+      r5 = parse_terminal('0', SyntaxNode)
+      if r5.success?
+        r0 = r5
+        r0.extend(Number1)
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0)
+      end
+    end
+    
+    node_cache[:number][start_index] = r0
+    
+    return r0
+  end
+  
+  def _nt_space
+    start_index = index
+    cached = node_cache[:space][index]
+    if cached
+      @index = cached.interval.end
+      return cached
+    end
+    
+    s0, i0 = [], index
+    loop do
+      r1 = parse_terminal(' ', SyntaxNode)
+      if r1.success?
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = SyntaxNode.new(input, i0...index, s0)
+    
+    node_cache[:space][start_index] = r0
+    
+    return r0
+  end
+  
+end
+
+class ArithmeticParser < Treetop::Runtime::CompiledParser
+  include Arithmetic
+end

data/vendor/treetop/examples/lambda_calculus/arithmetic.treetop

@@ -0,0 +1,97 @@
+grammar Arithmetic  
+  rule expression
+    comparative / additive
+  end
+  
+  rule comparative
+    operand_1:additive space operator:equality_op space operand_2:additive <BinaryOperation>
+  end
+  
+  rule equality_op
+    '==' {
+      def apply(a, b)
+        a == b
+      end
+    }
+  end
+  
+  rule additive
+    operand_1:multitive
+    space operator:additive_op space
+    operand_2:additive <BinaryOperation>
+    /
+    multitive
+  end
+  
+  rule additive_op
+    '+' {
+      def apply(a, b)
+        a + b
+      end
+    }
+    /
+    '-' {
+      def apply(a, b)
+        a - b
+      end
+    }
+  end
+
+  rule multitive
+    operand_1:primary
+    space operator:multitive_op space
+    operand_2:multitive <BinaryOperation>
+    /
+    primary
+  end
+  
+  rule multitive_op
+    '*' {
+      def apply(a, b)
+        a * b
+      end
+    }
+    /
+    '/' {
+      def apply(a, b)
+        a / b
+      end
+    }
+  end  
+  
+  rule primary
+    variable
+    /
+    number
+    /
+    '(' space expression space ')' {
+      def eval(env={})
+        expression.eval(env)
+      end
+    }
+  end
+
+  rule variable
+    [a-z]+ {
+      def eval(env={})
+        env[name]
+      end
+      
+      def name
+        text_value
+      end
+    }
+  end
+
+  rule number
+    ([1-9] [0-9]* / '0') {
+      def eval(env={})
+        text_value.to_i
+      end
+    }
+  end
+  
+  rule space
+    ' '*
+  end
+end

data/vendor/treetop/examples/lambda_calculus/arithmetic_node_classes.rb

@@ -0,0 +1,7 @@
+module Arithmetic
+  class BinaryOperation < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      operator.apply(operand_1.eval(env), operand_2.eval(env))      
+    end
+  end
+end

data/vendor/treetop/examples/lambda_calculus/arithmetic_test.rb

@@ -0,0 +1,54 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/test_helper")
+
+require File.expand_path("#{dir}/arithmetic_node_classes")
+Treetop.load File.expand_path("#{dir}/arithmetic")
+
+class ArithmeticParserTest < Test::Unit::TestCase
+  include ParserTestHelper
+  
+  def setup
+    @parser = ArithmeticParser.new
+  end
+  
+  def test_number
+    assert_equal 0, parse('0').eval
+    assert_equal 1, parse('1').eval
+    assert_equal 123, parse('123').eval
+  end
+  
+  def test_variable
+    assert_equal 0, parse('x').eval('x' => 0)
+    assert_equal 3, parse('x').eval('x' => 3)
+    assert_equal 10, parse('y').eval('y' => 10)
+  end
+  
+  def test_addition
+    assert_equal 10, parse('x + 5').eval('x' => 5)
+  end
+  
+  def test_subtraction
+    assert_equal 0, parse('x - 5').eval('x' => 5)
+  end
+  
+  def test_multiplication
+    assert_equal 6, parse('x * 2').eval('x' => 3)
+  end
+  
+  def test_division
+    assert_equal 3, parse('x / 2').eval('x' => 6)
+  end
+  
+  def test_order_of_operations
+    assert_equal 11, parse('1 + 2 * 3 + 4').eval
+  end
+  
+  def test_parentheses
+    assert_equal 25, parse('(5 + x) * (10 - y)').eval('x' => 0, 'y' => 5)
+  end
+  
+  def test_equality
+    assert parse('4 == 4').eval
+    assert !parse('4 == 3').eval
+  end
+end