p-lang 0.1.1 → 0.2.0

data/test/test_lexer_tokens

@@ -0,0 +1,34 @@
+:id
+:integer
+:break
+:string
+:char
+:lsquare
+:rsquare
+:lround
+:rround
+:lcurly
+:rcurly
+:comma
+:pipe
+:colon
+:sub
+:arrow
+:add
+:mul
+:div
+:mod
+:let
+:equal
+:diff
+:major
+:major_equal
+:minor
+:minor_equal
+:and
+:or
+:not
+:true
+:false
+:nil
+:begin

data/test/{test_parser_ok.txt → test_parser}

@@ -1,24 +1,32 @@
 1+2
+1-2
+1*2
+1/2
+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/3
+1-2%3
+1-(1*2)+((2-3)*4)
 1>2
-x>=1
-2<=b
-4==1
-2<x
-{obj}
-{obj: 1, 2, 3}
-{obj: 1+2, x}
-{obj: 1, 2}
+1<2
+1>=2
+1<=2
+1==2
+1!=2
+(1>2) and (1<2)
+(1>2) or (1<2)
+not ((1>2) and (1<2))
+'(1,2,3+4)
+begin(x=1, y=x+1)
+fib = [1|1]; [2|1]; [n| fib(n-1) + fib(n-2)]
+fib(10)
+x->aaa()
+f()->aaa()
+f = [12+n] : (n=123)
+{aaaa: 1,2,3}
+{aaaa: 1,2,3}->aaaa()
+{aaaa: 1,2,3}->aaaa() + f(1,2,3) - 1->next()
 {obj: x, 2, {other}}
-{obj: 1} 
 "teste"
 'a'
 if(x>1, "verdadeiro", "falso")
@@ -36,10 +44,8 @@ p1 = point(1,2)
 [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| y] : (y = [x| x+6], z = [x| x-6])
 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]
@@ -63,10 +69,3 @@ x->algo()
 {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_parser.rb

@@ -2,25 +2,18 @@ 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"))
+  EXPRESSIONS = File.readlines(File.join(File.dirname(__FILE__), "test_parser"))
+  BUILD = File.readlines(File.join(File.dirname(__FILE__), "test_parser_build"))
   
-  context "The PLangParser" do
-    setup do
-      @parser = PLangParser.new
-    end
+  context "The Parser" do
     
     EXPRESSIONS.each_with_index do |expr, i|
+      parser = PLang::Parser::SyntaxAnalyser.new(EXPRESSIONS[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)
+        assert_equal eval(parser.parse.inspect), eval(BUILD[i])
       end
     end
+  
   end
   
 end

data/test/test_parser_build

@@ -0,0 +1,73 @@
+[[:add, [:integer, 1], [:integer, 2]]]
+[[:sub, [:integer, 1], [:integer, 2]]]
+[[:mul, [:integer, 1], [:integer, 2]]]
+[[:div, [:integer, 1], [:integer, 2]]]
+[[:mod, [:integer, 1], [:integer, 2]]]
+[[:add,[:add, [:integer, 1], [:integer, 2]],[:integer, 3]]]
+[[:div,[:mul, [:integer, 1], [:integer, 2]],[:integer, 3]]]
+[[:mod,[:sub, [:integer, 1], [:integer, 2]],[:integer, 3]]]
+[[:add,[:sub,[:integer, 1],[:mul, [:integer, 1], [:integer, 2]]],[:mul,[:sub, [:integer, 2], [:integer, 3]],[:integer, 4]]]]
+[[:major, [:integer, 1], [:integer, 2]]]
+[[:minor, [:integer, 1], [:integer, 2]]]
+[[:major_equal, [:integer, 1], [:integer, 2]]]
+[[:minor_equal, [:integer, 1], [:integer, 2]]]
+[[:equal, [:integer, 1], [:integer, 2]]]
+[[:diff, [:integer, 1], [:integer, 2]]]
+[[:and,[:major, [:integer, 1], [:integer, 2]],[:minor, [:integer, 1], [:integer, 2]]]]
+[[:or,[:major, [:integer, 1], [:integer, 2]],[:minor, [:integer, 1], [:integer, 2]]]]
+[[:not,[:and,[:major, [:integer, 1], [:integer, 2]],[:minor, [:integer, 1], [:integer, 2]]]]]
+[[:list,[[:integer, 1],[:integer, 2],[:add, [:integer, 3], [:integer, 4]]]]]
+[[:begin,[[:let, [:id, :x], [:integer, 1]],[:let, [:id, :y], [:add, [:id, :x], [:integer, 1]]]]]]
+[[:let,[:id, :fib],[:lambda,[[:integer, 1]],[:integer, 1],[],[:lambda,[[:integer, 2]],[:integer, 1],[],[:lambda,[[:id, :n]],[:add,[:call, [:id, :fib], [[:sub, [:id, :n], [:integer, 1]]]],[:call, [:id, :fib], [[:sub, [:id, :n], [:integer, 2]]]]],[],nil]]]]]
+[[:call, [:id, :fib], [[:integer, 10]]]]
+[[:call, [:object_message, [:id, :x], [:id, :aaa]], []]]
+[[:call, [:object_message, [:call, [:id, :f], []], [:id, :aaa]], []]]
+[[:let,[:id, :f],[:lambda,[],[:add, [:integer, 12], [:id, :n]],[[:let, [:id, :n], [:integer, 123]]],nil]]]
+[[:object,[:id,:aaaa],[[:integer, 1], [:integer, 2], [:integer, 3]]]]
+[[:call,[:object_message,[:object,[:id,:aaaa],[[:integer, 1],[:integer, 2],[:integer, 3]]],[:id, :aaaa]],[]]]
+[[:sub,[:add,[:call,[:object_message,[:object,[:id,:aaaa],[[:integer, 1],[:integer, 2],[:integer, 3]]],[:id, :aaaa]],[]],[:call,[:id, :f],[[:integer, 1],[:integer, 2],[:integer, 3]]]],[:call, [:object_message, [:integer, 1], [:id, :next]], []]]]
+[[:object,[:id, :obj],[[:id, :x], [:integer, 2], [:object, [:id, :other], []]]]]
+[[:string, "teste"]]
+[[:char, "a"]]
+[[:if,[:major, [:id, :x], [:integer, 1]],[:string, "verdadeiro"],[:string, "falso"]]]
+[[:begin,[[:add, [:add, [:integer, 1], [:integer, 2]], [:integer, 3]],[:string, "oi"],[:minor, [:integer, 2], [:integer, 3]],[:char, "a"]]]]
+[[:sub,[:call, [:id, :sin], [[:mul, [:integer, 2], [:id, :pi]]]],[:call, [:id, :cos], [[:mul, [:integer, 2], [:id, :pi]]]]]]
+[[:call, [:id, :f], []]]
+[[:let, [:id, :x], [:integer, 1]]]
+[[:let,[:id, :x],[:add,[:add, [:add, [:integer, 1], [:integer, 2]], [:integer, 3]],[:integer, 4]]]]
+[[:let,[:id, :y],[:div,[:mul, [:add, [:integer, 1], [:integer, 2]], [:id, :x]],[:integer, 2]]]]
+[[:let, [:id, :str], [:string, "string"]]]
+[[:let, [:id, :p1], [:call, [:id, :point], [[:integer, 1], [:integer, 2]]]]]
+[[:let, [:object, [:id,:obj], [[:id, :x]]], [:object, [:id,:obj], [[:integer, 1]]]]]
+[[:let, [:object, [:id,:obj], [[:id, :x], [:id, :t]]], [:id, :obj]]]
+[[:lambda, [[:id, :x]], [:id, :x], [], nil]]
+[[:lambda, [[:id, :x], [:id, :y]], [:add, [:id, :x], [:id, :y]], [], nil]]
+[[:lambda,[[:integer, 1],[:integer, 2],[:id, :x],[:object, [:id,:obj], [[:id, :x], [:id, :y]]]],[:integer, 1],[],nil]]
+[[:lambda,[[:id, :x]],[:id, :y],[[:let,[:id, :y],[:lambda, [[:id, :x]], [:add, [:id, :x], [:integer, 6]], [], nil]]],nil]]
+[[:lambda,[[:id, :x]],[:id, :y],[[:let,[:id, :y],[:lambda, [[:id, :x]], [:add, [:id, :x], [:integer, 6]], [], nil]],[:let,[:id, :z],[:lambda, [[:id, :x]], [:sub, [:id, :x], [:integer, 6]], [], nil]]],nil]]
+[[:let, [:id, :x], [:lambda, [], [:integer, 1], [], nil]]]
+[[:let,[:id, :point],[:lambda,[[:id, :x], [:id, :y]],[:object, [:id,:point], [[:id, :x], [:id, :y]]],[],nil]]]
+[[:let,[:id, :point_x],[:lambda, [[:object, [:id,:point], [[:id, :x], [:id, :y]]]], [:id, :x], [], nil]]]
+[[:let,[:id, :point_y],[:lambda, [[:object, [:id,:point], [[:id, :x], [:id, :y]]]], [:id, :y], [], nil]]]
+[[:let,[:id, :point_sum],[:lambda,[[:object, [:id,:point], [[:id, :x1], [:id, :y1]]],[:object, [:id,:point], [[:id, :x2], [:id, :y2]]]],[:object,[:id,:point],[[:add, [:id, :x1], [:id, :x2]], [:add, [:id, :y1], [:id, :y2]]]],[],nil]]]
+[[:let,[:id, :sum],[:lambda, [[:id, :a], [:id, :b]], [:add, [:id, :a], [:id, :b]], [], nil]]]
+[[:let,[:id, :f],[:lambda,[[:id, :x]],[:begin,[[:let, [:id, :algo], [:id, :x]],[:mul, [:id, :algo], [:id, :algo]],[:id, :algo]]],[],nil]]]
+[[:let,[:id, :f],[:lambda,[[:id, :x]],[:add, [:call, [:id, :f], [[:id, :x]]], [:call, [:id, :g], [[:id, :x]]]],[[:let,[:id, :f],[:lambda, [[:id, :x]], [:mul, [:id, :x], [:id, :x]], [], nil]],[:let,[:id, :g],[:lambda, [[:id, :x]], [:div, [:id, :x], [:integer, 2]], [], nil]]],nil]]]
+[[:let,[:id, :f],[:lambda,[[:id, :x]],[:id, :y],[[:let, [:id, :y], [:mul, [:integer, 2], [:id, :x]]]],nil]]]
+[[:object_message, [:id, :p], [:id, :x]]]
+[[:call, [:object_message, [:id, :p], [:id, :x]], [[:integer, 1]]]]
+[[:call, [:object_message, [:id, :p], [:id, :x]], []]]
+[[:call,[:object_message, [:call, [:id, :f], [[:integer, 1]]], [:id, :algo]],[[:integer, 1]]]]
+[[:call, [:object_message, [:id, :x], [:id, :algo]], []]]
+[[:call,[:object_message, [:integer, 10], [:id, :algo]],[[:integer, 1], [:integer, 2], [:integer, 3]]]]
+[[:call,[:object_message,[:object, [:id,:algo], [[:integer, 1], [:integer, 2]]],[:id, :algo]],[]]]
+[[:call,[:object_message, [:object, [:id,:algo], [[:id, :x], [:id, :y]]], [:id, :x]],[]]]
+[[:let,[:object_message, [:object, [:id,:point], [[:id, :x], [:id, :y]]], [:id, :x]],[:lambda, [[:id, :x]], [:id, :x], [], nil]]]
+[[:let,[:object_message, [:object, [:id,:aaaa], [[:id, :x], [:id, :y]]], [:id, :a]],[:lambda, [], [:id, :x], [[:let, [:id, :x], [:integer, 1]]], nil]]]
+[[:let,[:object_message, [:object, [:id,:aaaa], [[:id, :x], [:id, :y]]], [:id, :algo]],[:lambda,[[:id, :x]],[:id, :y],[[:let,[:id, :y],[:lambda, [[:id, :x]], [:add, [:id, :x], [:integer, 6]], [], nil]]],nil]]]
+[[:let,[:object_message, [:object, [:id,:algo], [[:id, :x], [:id, :y]]], [:id, :algo]],[:lambda, [[:id, :x]], [:id, :x], [], nil]]]
+[[:let,[:object_message, [:object, [:id, :algo], []], [:id, :algo]],[:integer, 1]]]
+[[:boolean, :true]]
+[[:boolean, :false]]
+
+

data/test/test_vm

@@ -0,0 +1,29 @@
+1
+1.1
+'a'
+"word"
+1+1
+1.1+1
+1+1.1
+1/2
+1.0/2
+1/2.0
+f = [x| x] f(10)
+f = [x|x+1] f(10)
+f = [x, y, z| x+y-z] f(10,9,8)
+f = [1|1]; [2|1]; [n|f(n-1)+f(n-2)] f(10)
+f = [1|1] f = [2|1] f = [n|f(n-1)+f(n-2)] f(10)
+f = [1, x| x+1] f(1,10)
+f = [x, {obj: y}| x+y] f(10, {obj: 15})
+f = [1, {obj: {obj2: x}}| x] f(1, {obj: {obj2: "dog"}})
+f = [1, {obj: {obj2: x}}| x->concat("s")] f(1, {obj: {obj2: "dog"}})
+'a'->ord()
+{obj: x} -> next = [x+1] x = {obj: 15} x->next()
+begin(x=1, y=2, x+y)
+x = '(1,2,3,4) x->head()
+x = '(1,2,3,4) x->tail()->head()
+x = '(1,2,3,4) x->concat(10)->head()
+x = '(1,2,3,4) x->concat(10)->tail()->head()
+sum = [{empty}| 0]; [x| x->head() + sum(x->tail())] x = '(1,2,3,4) sum(x)
+if(2>=2, 1, 2)
+if(2<2, 1, 2)

data/test/test_vm.rb

@@ -2,21 +2,18 @@ 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"))
+  PROGRAMS = File.readlines(File.join(File.dirname(__FILE__), "test_vm"))
+  RESULT = File.readlines(File.join(File.dirname(__FILE__), "test_vm_result"))
   
   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]
+      vm = PLang::VM::Interpreter.new(PLang::Parser::SyntaxAnalyser.new(program).parse)
+      should "interp the expression ##{i}" do
+        assert_equal vm.execute!.params[0], eval(RESULT[i])
       end
     end
+  
   end
   
 end

data/test/test_vm_result

@@ -0,0 +1,29 @@
+1
+1.1
+'a'
+"word"
+2
+2.1
+2.1
+0
+0.5
+0.5
+10
+11
+11
+55
+55
+11
+25
+"dog"
+"dogs"
+97
+16
+3
+1
+2
+10
+1
+10
+1
+2

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: p-lang
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Igor Bonadio
@@ -15,27 +15,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-12 00:00:00 -03:00
-default_executable: 
+date: 2010-07-29 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: :runtime
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: shoulda
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -45,12 +31,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id002
+  version_requirements: *id001
 description: P is a small ('pequena' in portuguese) functional programming language.
 email: igorbonadio@gmail.com
 executables: 
 - p-lang
-- teste.p
 extensions: []
 
 extra_rdoc_files: 
@@ -65,26 +50,33 @@ files:
 - VERSION.yml
 - bin/p-lang
 - lib/p-lang.rb
-- lib/parser/ast.rb
-- lib/parser/nodes.rb
-- lib/parser/p-lang.treetop
+- lib/parser/error.rb
+- lib/parser/lexer.rb
+- lib/parser/node.rb
+- lib/parser/syntax_analyser.rb
+- lib/parser/token.rb
+- lib/vm/core/pboolean.rb
+- lib/vm/core/pchar.rb
+- lib/vm/core/pdecimal.rb
+- lib/vm/core/pinteger.rb
+- lib/vm/core/pio.rb
+- lib/vm/core/plist.rb
+- lib/vm/core/pstring.rb
 - lib/vm/environment.rb
-- lib/vm/perror.rb
+- lib/vm/interpreter.rb
+- lib/vm/pfunctions.rb
+- lib/vm/plambda.rb
 - lib/vm/pobject.rb
-- lib/vm/proc.rb
-- lib/vm/std/pdecimal.rb
-- lib/vm/std/pinteger.rb
-- lib/vm/std/pio.rb
-- lib/vm/std/pstring.rb
-- lib/vm/vm.rb
 - test/helper.rb
+- test/test_lexer
+- test/test_lexer.rb
+- test/test_lexer_tokens
+- test/test_parser
 - test/test_parser.rb
-- test/test_parser_build.txt
-- test/test_parser_ok.txt
+- test/test_parser_build
+- test/test_vm
 - test/test_vm.rb
-- test/test_vm_programs.txt
-- test/test_vm_results.txt
-- bin/teste.p
+- test/test_vm_result
 has_rdoc: true
 homepage: http://github.com/igorbonadio/p-lang
 licenses: []
@@ -121,5 +113,6 @@ specification_version: 3
 summary: P programming language
 test_files: 
 - test/helper.rb
+- test/test_lexer.rb
 - test/test_parser.rb
 - test/test_vm.rb

data/bin/teste.p

@@ -1,3 +0,0 @@
-f = ["aaaa"->equal("aaaa")]
-
-print(f())

data/lib/parser/ast.rb

@@ -1,168 +0,0 @@
-module PLang
-  module Ast
-    class PStatement
-      def initialize(expression)
-        @expression = expression
-      end
-
-      def to_sexp
-        @expression.to_sexp
-      end
-    end
-
-    class PUnOp
-      attr_reader :op
-      attr_reader :right
-      def initialize(op, right)
-        @op = op
-        @right = right
-      end
-
-      def to_sexp
-        [@op, @right.to_sexp]
-      end
-    end
-
-    class PBinOp
-      attr_reader :op
-      attr_reader :left
-      attr_reader :right
-
-      def initialize(op, left, right)
-        @op = op.to_sym
-        @left = left
-        @right = right
-      end
-
-      def to_sexp
-        [@op, @left.to_sexp, @right.to_sexp]
-      end
-    end
-
-    class PLiteral
-      attr_reader :type
-      attr_reader :value
-
-      def initialize(type, value)
-        @type = type.to_sym
-        @value = value
-      end
-
-      def to_sexp
-        [:literal, @type, @value]
-      end
-    end
-
-    class PId
-      attr_reader :name
-
-      def initialize(name)
-        @name = name.to_sym
-      end
-
-      def to_sexp
-        [:id, @name]
-      end
-    end
-
-    class PObject
-      attr_reader :name
-
-      def initialize(name, params)
-        @name = name.to_sym
-        @params = params
-      end
-
-      def to_sexp
-        [:object, @name, @params.collect(&:to_sexp)]
-      end
-    end
-
-    class PCall
-      attr_reader :cid
-
-      def initialize(cid, params)
-        @cid = cid
-        @params = params
-      end
-
-      def to_sexp
-        @cid = @cid.to_sexp
-        if @cid == [:id, :if]
-          @params = @params.collect(&:to_sexp)
-          if @params.size == 3
-            [:if, @params[0], @params[1], @params[2]]
-          else
-            raise "'if' error"
-          end
-        elsif @cid == [:id, :begin]
-          [:begin, @params.collect(&:to_sexp)]
-        else
-          [:call, @cid, @params.collect(&:to_sexp)]
-        end
-      end
-    end
-
-    class PLet
-      attr_reader :var
-      attr_reader :val
-
-      def initialize(var, val)
-        @var = var
-        @val = val
-      end
-
-      def to_sexp
-        [:let, @var.to_sexp, @val.to_sexp]
-      end
-    end
-
-    class PLambda
-      attr_reader :params
-      attr_reader :expr
-      attr_reader :where
-      attr_accessor :next_lambda
-
-      def initialize(params, expr, where)
-        @params = params
-        @expr = expr
-        @where = where
-        @next_lambda = nil
-      end
-
-      def to_sexp
-        [:lambda, @params.collect(&:to_sexp), @expr.to_sexp, @where.collect(&:to_sexp), @next_lambda]
-      end
-    end
-
-    class PObjectCall
-      attr_reader :obj
-      attr_reader :msg
-
-      def initialize(obj, msg)
-        @obj = obj
-        @msg = msg
-      end
-
-      def to_sexp
-        [:object_call, @obj.to_sexp, @msg.to_sexp]
-      end
-    end
-
-    class PObjectLet
-      attr_reader :obj
-      attr_reader :id
-      attr_reader :value
-
-      def initialize(obj, id, value)
-        @obj = obj
-        @id = id
-        @value = value
-      end
-
-      def to_sexp
-        [:object_let, @obj.to_sexp, @id.to_sexp, @value.to_sexp]
-      end
-    end
-  end
-end