p-lang 0.0.1

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'p-lang'
+
+class Test::Unit::TestCase  
+end

data/test/test_parser.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class TestParser < Test::Unit::TestCase
+  
+  EXPRESSIONS = File.readlines(File.join(File.dirname(__FILE__), "test_parser_ok.txt"))
+  BUILT_EXPRESSIONS = File.readlines(File.join(File.dirname(__FILE__), "test_parser_build.txt"))
+  
+  context "The PLangParser" do
+    setup do
+      @parser = PLangParser.new
+    end
+    
+    EXPRESSIONS.each_with_index do |expr, i|
+      should "parse the expression ##{i}" do
+        assert @parser.parse expr
+      end
+    end
+
+    EXPRESSIONS.each_with_index do |expr, i|
+      should "build the expression ##{i}" do
+        assert_equal eval(BUILT_EXPRESSIONS[i]), @parser.parse(expr).build.collect(&:to_sexp)
+      end
+    end
+  end
+  
+end

data/test/test_parser_build.txt

@@ -0,0 +1,72 @@
+[[:+, [:literal, :integer, 1], [:literal, :integer, 2]]]
+[[:+,[:literal, :integer, 1],[:+, [:literal, :integer, 2], [:literal, :integer, 3]]]]
+[[:*, [:literal, :integer, 4], [:literal, :integer, 5]]]
+[[:/, [:literal, :integer, 4], [:literal, :integer, 2]]]
+[[:%, [:literal, :integer, 5], [:literal, :integer, 3]]]
+[[:+,[:literal, :integer, 1],[:*,[:literal, :integer, 2],[:/, [:literal, :integer, 3], [:literal, :integer, 5]]]]]
+[[:*,[:+,[:literal, :integer, 1],[:literal, :integer, 6]],[:literal, :integer, 5]]]
+[[:+,[:literal, :integer, 1],[:/,[:*, [:literal, :integer, 2], [:literal, :integer, 3]],[:-, [:literal, :integer, 5], [:literal, :integer, 1]]]]]
+[[:+,  [:literal, :decimal, 1.3],[:*,[:literal, :integer, 5],[:+, [:literal, :integer, 1], [:literal, :decimal, 1.568]]]]]
+[[:id, :xyz]]
+[[:>, [:literal, :integer, 1], [:literal, :integer, 2]]]
+[[:>=, [:id, :x], [:literal, :integer, 1]]]
+[[:<=, [:literal, :integer, 2], [:id, :b]]]
+[[:==, [:literal, :integer, 4], [:literal, :integer, 1]]]
+[[:<, [:literal, :integer, 2], [:id, :x]]]
+[[:object, :obj, []]]
+[[:object, :obj, [[:literal, :integer, 1], [:literal, :integer, 2], [:literal, :integer, 3]]]]
+[[:object,:obj,[[:+, [:literal, :integer, 1], [:literal, :integer, 2]], [:id, :x]]]]
+[[:object, :obj, [[:literal, :integer, 1], [:literal, :integer, 2]]]]
+[[:object, :obj, [[:id, :x], [:literal, :integer, 2], [:object, :other, []]]]]
+[[:object, :obj, [[:literal, :integer, 1]]]]
+[[:literal, :string, "teste"]]
+[[:literal, :char, "a"]]
+[[:if,[:>, [:id, :x], [:literal, :integer, 1]],[:literal, :string, "verdadeiro"],[:literal, :string, "falso"]]]
+[[:begin,[[:+,[:literal, :integer, 1],[:+, [:literal, :integer, 2], [:literal, :integer, 3]]],[:literal, :string, "oi"],[:<, [:literal, :integer, 2], [:literal, :integer, 3]],[:literal, :char, "a"]]]]
+[[:-,[:call, [:id, :sin], [[:*, [:literal, :integer, 2], [:id, :pi]]]],[:call, [:id, :cos], [[:*, [:literal, :integer, 2], [:id, :pi]]]]]]
+[[:call, [:id, :f], []]]
+[[:let, [:id, :x], [:literal, :integer, 1]]]
+[[:let,[:id, :x],[:+,[:literal, :integer, 1],[:+,[:literal, :integer, 2],[:+, [:literal, :integer, 3], [:literal, :integer, 4]]]]]]
+[[:let,[:id, :y],[:+,[:literal, :integer, 1],[:*, [:literal, :integer, 2], [:/, [:id, :x], [:literal, :integer, 2]]]]]]
+[[:let, [:id, :str], [:literal, :string, "string"]]]
+[[:let,[:id, :p1],[:call, [:id, :point], [[:literal, :integer, 1], [:literal, :integer, 2]]]]]
+[[:let,[:object, :obj, [[:id, :x]]],[:object, :obj, [[:literal, :integer, 1]]]]]
+[[:let, [:object, :obj, [[:id, :x], [:id, :t]]], [:id, :obj]]]
+[[:lambda, [[:id, :x]], [:id, :x], [],nil]]
+[[:lambda, [[:id, :x],[:id, :y]], [:+, [:id, :x], [:id, :y]], [],nil]]
+[[:lambda,[[:literal, :integer, 1],[:literal, :integer, 2],[:id, :x],[:object, :obj, [[:id, :x], [:id, :y]]]],[:literal, :integer, 1],[],nil]]
+[[:lambda,[[:id, :x]],[:id, :y],[[:let,[:id, :y],[:lambda, [[:id, :x]], [:+, [:id, :x], [:literal, :integer, 6]], [],nil]]],nil]]
+[[:lambda,[[:id, :x]],[:id, :y],[[:let,[:id, :y],[:lambda, [[:id, :x]], [:+, [:id, :x], [:literal, :integer, 6]], [], nil]],[:let,[:id, :z],[:lambda,[[:id, :x]],[:-, [:id, :x], [:literal, :integer, 6]],[],nil]],[:let, [:id, :k], [:literal, :integer, 1]]],nil]]
+[[:let, [:id, :x], [:lambda, [], [:literal, :integer, 1], [],nil]]]
+[[:let,[:id, :fibonacci],[:lambda,[[:literal, :integer, 1]],[:literal, :integer, 1],[],[:lambda,[[:literal, :integer, 2]],[:literal, :integer, 1],[],[:lambda,[[:id, :n]],[:+,[:call, [:id, :fibonacci], [[:-, [:id, :n], [:literal, :integer, 1]]]],[:call, [:id, :fibonacci], [[:-, [:id, :n], [:literal, :integer, 2]]]]],[],nil]]]]]
+[[:let,[:id, :str_list],[:object,:list,[[:literal, :char, "s"],[:object,:list,[[:literal, :char, "t"],[:object,:list,[[:literal, :char, "r"],[:object,:list,[[:literal, :char, "i"],[:object,:list,[[:literal, :char, "n"],[:object,:list,[[:literal, :char, "g"], [:object, :list, []]]]]]]]]]]]]]]]
+[[:let,[:id, :point],[:lambda,[[:id, :x], [:id, :y]],[:object, :point, [[:id, :x], [:id, :y]]],[],nil]]]
+[[:let,[:id, :point_x],[:lambda, [[:object, :point, [[:id, :x], [:id, :y]]]], [:id, :x], [],nil]]]
+[[:let,[:id, :point_y],[:lambda, [[:object, :point, [[:id, :x], [:id, :y]]]], [:id, :y], [],nil]]]
+[[:let,[:id, :point_sum],[:lambda,[[:object, :point, [[:id, :x1], [:id, :y1]]],[:object, :point, [[:id, :x2], [:id, :y2]]]],[:object,:point,[[:+, [:id, :x1], [:id, :x2]], [:+, [:id, :y1], [:id, :y2]]]],[],nil]]]
+[[:let,[:id, :sum],[:lambda, [[:id, :a], [:id, :b]], [:+, [:id, :a], [:id, :b]], [], nil]]]
+[[:let,[:id, :f],[:lambda,[[:id, :x]],[:begin,[[:let, [:id, :algo], [:id, :x]],[:*, [:id, :algo], [:id, :algo]],[:id, :algo]]],[], nil]]]
+[[:let,[:id, :f],[:lambda,[[:id, :x]],[:+, [:call, [:id, :f], [[:id, :x]]], [:call, [:id, :g], [[:id, :x]]]],[[:let,[:id, :f],[:lambda, [[:id, :x]], [:*, [:id, :x], [:id, :x]], [], nil]],[:let,[:id, :g],[:lambda,[[:id, :x]],[:/, [:id, :x], [:literal, :integer, 2]],[],nil]]],nil]]]
+[[:let,[:id, :f],[:lambda,[[:id, :x]],[:id, :y],[[:let, [:id, :y], [:*, [:literal, :integer, 2], [:id, :x]]]], nil]]]
+[[:object_call, [:id, :p], [:id, :x]]]
+[[:call,[:object_call, [:id, :p], [:id, :x]],[[:id, :p], [:literal, :integer, 1]]]]
+[[:call, [:object_call, [:id, :p], [:id, :x]], [[:id, :p]]]]
+[[:call,[:object_call, [:call, [:id, :f], [[:literal, :integer, 1]]], [:id, :algo]],[[:call, [:id, :f], [[:literal, :integer, 1]]], [:literal, :integer, 1]]]]
+[[:call, [:object_call, [:id, :x], [:id, :algo]], [[:id, :x]]]]
+[[:call,[:object_call, [:literal, :integer, 10], [:id, :algo]],[[:literal, :integer, 10],[:literal, :integer, 1],[:literal, :integer, 2],[:literal, :integer, 3]]]]
+[[:call,[:object_call,[:object, :algo, [[:literal, :integer, 1], [:literal, :integer, 2]]],[:id, :algo]],[[:object, :algo, [[:literal, :integer, 1], [:literal, :integer, 2]]]]]]
+[[:call,[:object_call, [:object, :algo, [[:id, :x], [:id, :y]]], [:id, :x]],[[:object, :algo, [[:id, :x], [:id, :y]]]]]]
+[[:object_let,[:object, :point, [[:id, :x], [:id, :y]]],[:id, :x],[:lambda, [[:id, :x]], [:id, :x], [], nil]]]
+[[:object_let,[:object, :aaaa, [[:id, :x], [:id, :y]]],[:id, :a],[:lambda, [], [:id, :x], [[:let, [:id, :x], [:literal, :integer, 1]]], nil]]]
+[[:object_let,[:object, :aaaa, [[:id, :x], [:id, :y]]],[:id, :algo],[:lambda,[[:id, :x]],[:id, :y],[[:let,[:id, :y],[:lambda, [[:id, :x]], [:+, [:id, :x], [:literal, :integer, 6]], [], nil]]], nil]]]
+[[:object_let,[:object, :algo, [[:id, :x], [:id, :y]]],[:id, :algo],[:lambda, [[:id, :x]], [:id, :x], [], nil]]]
+[[:object_let, [:object, :algo, []], [:id, :algo], [:literal, :integer, 1]]]
+[[:literal, :boolean, :true]]
+[[:literal, :boolean, :false]]
+[[:let, [:id, :x], [:literal, :boolean, :true]]]
+[[:if,[:literal, :boolean, :true],[:literal, :string, "sim"],[:literal, :string, "nao"]]]
+[[:and, [:id, :x], [:id, :y]]]
+[[:if,[:and, [:literal, :boolean, :true], [:literal, :boolean, :false]],[:literal, :integer, 1],[:literal, :integer, 2]]]
+[[:if,[:or, [:and, [:id, :x], [:id, :y]], [:id, :z]],[:literal, :integer, 1],[:literal, :integer, 2]]]
+[[:not, [:literal, :boolean, :true]]]
+[[:let, [:id, :x], [:or, [:and, [:id, :x], [:id, :y]], [:not, [:id, :k]]]]]

data/test/test_parser_ok.txt

@@ -0,0 +1,72 @@
+1+2
+1+2+3
+4*5
+4/2
+5%3
+1+2*3/5
+(1+6)*5
+1+(2*3)/(5-1)
+1.3+5*(1+1.568)
+xyz
+1>2
+x>=1
+2<=b
+4==1
+2<x
+{obj}
+{obj: 1, 2, 3}
+{obj: 1+2, x}
+{obj: 1, 2}
+{obj: x, 2, {other}}
+{obj: 1} 
+"teste"
+'a'
+if(x>1, "verdadeiro", "falso")
+begin(1+2+3, "oi", 2<3, 'a')
+sin(2*pi)-cos(2*pi)
+f()
+x = 1
+x = 1+2+3+4
+y = 1+2*x/2
+str = "string"
+p1 = point(1,2)
+{obj: x} = {obj: 1}
+{obj: x, t} = obj
+[x|x]
+[x,y| x+y]
+[1, 2, x, {obj: x, y}| 1]
+[x| y] : (y = [x| x+6])
+[x| y] : (y = [x| x+6], z = [x| x-6], k=1)
+x = [1]
+fibonacci = [1| 1], [2| 1] , [n| fibonacci(n-1)+fibonacci(n-2)]
+str_list = {list: 's', {list: 't', {list: 'r', {list: 'i', {list: 'n', {list: 'g', {list}}}}}}}
+point = [x, y| {point: x, y}]
+point_x = [{point: x, y}| x]
+point_y = [{point: x, y}| y]
+point_sum = [{point: x1, y1}, {point: x2, y2}| {point: x1+x2, y1+y2}]
+sum = [ a, b| a + b]
+f = [x| begin(algo=x, algo*algo, algo)]
+f = [x| f(x) + g(x)] : (f = [x| x*x], g = [x| x/2])
+f = [x| y] : (y = 2*x)
+p->x
+p->x(1)
+p->x()
+f(1)->algo(1)
+x->algo()
+10->algo(1,2,3)
+{algo: 1, 2} -> algo()
+{algo: x, y} -> x()
+{point: x, y} -> x = [x|x]
+{aaaa: x, y}->a = [x] : (x = 1)
+{aaaa: x, y} -> algo = [x| y] : (y = [x| x+6])
+{algo: x, y}->algo = [x| x]
+{algo} -> algo = 1
+true
+false
+x = true
+if(true, "sim", "nao")
+x and y
+if(true and false, 1, 2)
+if((x and y) or z, 1, 2)
+not true
+x = (x and y) or (not k)

data/test/test_vm.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class TestVM < Test::Unit::TestCase
+  
+  PROGRAMS = File.readlines(File.join(File.dirname(__FILE__), "test_vm_programs.txt"))
+  RESULTS = File.readlines(File.join(File.dirname(__FILE__), "test_vm_results.txt"))
+  
+  context "The VM" do
+    setup do
+      @parser = PLangParser.new
+    end
+
+    PROGRAMS.each_with_index do |program, i|
+      should "interp the program ##{i}" do
+        ast = @parser.parse(program)
+        vm = PLang::VM.new(ast.build.collect(&:to_sexp))
+        assert_equal eval(RESULTS[i]), vm.execute!.params[0]
+      end
+    end
+  end
+  
+end

data/test/test_vm_programs.txt

@@ -0,0 +1,37 @@
+1
+1+2
+4-7
+3*2
+6/2
+6.0-0.5
+5%2
+1>2
+1>=1
+3<1
+7<=0
+(2>0) and (3<1)
+true or false
+x=1 x+2
+x=1 y=2 x+y
+soma = [a,b| a+b] soma(3,4)
+soma = [a,b| a+b] soma(3,4)+10
+soma = [a,b| sum] : (sum = a+b) soma(10,5)
+fib = [1|1], [2|1], [n| fib(n-1)+fib(n-2)] fib(8)
+x=1 y=2 f=[x| x+y] f(10)
+if (true, 1, 2)
+if (false, 1, 2)
+begin(1,2,3,4)
+{obj: x, y} = {obj: 1, 2} x+y
+{obj: 5, 10, z} = {obj: 5, 10, 15} z
+[{obj: 10, x}| x]({obj: 10, -5})
+[{obj: {algo}, x}| x]({obj: {algo}, 13})
+[{obj: {algo: 10}, x}| x]({obj: {algo: 10}, 1})
+[{obj: {algo: x}, y}| x+y]({obj: {algo: 1}, 2})
+[{obj: {algo: x}, y}, 1, z, {ok}| x+y+z]({obj: {algo: 1}, 2}, 1, 10, {ok})
+[{ok}| 10]({ok})
+{obj: 1, x} -> f = [x] {obj: 2, x} -> f = [x+1] a = {obj: 2, 20} a -> f()
+{obj: 1, x} -> f = [x] {obj: 2, x} -> f = [x+1] a = {obj: 1, 20} a -> f()
+{obj: x} -> f = [x-1] {obj: 1} -> f()
+{obj: 1, 2, 3, x} -> f = [1+2+3+x] {obj: 1, 2, 3, 10}->f()
+f = [_,x,_| x*2] f(1,2,3)
+f = [{obj: {xxx: _}, x}, y| x+y] f({obj: {xxx: 1}, 2}, 3)

data/test/test_vm_results.txt

@@ -0,0 +1,37 @@
+1
+3
+-3
+6
+3
+5.5
+1
+false
+true
+false
+false
+false
+true
+3
+3
+7
+17
+15
+21
+12
+1
+2
+4
+3
+15
+-5
+13
+1
+3
+13
+10
+21
+20
+0
+16
+4
+5

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: p-lang
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Igor Bonadio
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 -03:00
+default_executable: p-lang
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: P programming language
+email: igorbonadio@gmail.com
+executables: 
+- p-lang
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- bin/p-lang
+- lib/p-lang.rb
+- lib/parser/ast.rb
+- lib/parser/nodes.rb
+- lib/parser/p-lang.treetop
+- lib/vm/environment.rb
+- lib/vm/pobject.rb
+- lib/vm/proc.rb
+- lib/vm/std/io.rb
+- lib/vm/vm.rb
+- test/helper.rb
+- test/test_parser.rb
+- test/test_parser_build.txt
+- test/test_parser_ok.txt
+- test/test_vm.rb
+- test/test_vm_programs.txt
+- test/test_vm_results.txt
+has_rdoc: true
+homepage: http://github.com/igorbonadio/p-lang
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: P programming language
+test_files: 
+- test/helper.rb
+- test/test_parser.rb
+- test/test_vm.rb