p-lang 0.0.4 → 0.1.0

data/README.rdoc

@@ -8,6 +8,32 @@ P is a small ('pequena' in portuguese) functional programming language.
   
   fib(10)
 
+= Features
+
+Functions:
+
+  fib = [1| 1],
+        [2| 1],
+        [n| fib(n-1) + fib(n-2)]
+  
+  fib(10)
+
+Objects:
+
+  {rectangle: 10, 30}
+
+Pattern:
+
+  {rectangle: x, y} = {rectangle: 10, 30}
+  # => x = 10
+  # => y = 30
+
+Messages:
+
+  {integer: x} -> plus2 = [x+2]
+  
+  3->plus2() # => 5
+
 == Requirements
 
 * Ruby

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
-:patch: 4
+:patch: 0
 :build: 
 :major: 0
-:minor: 0
+:minor: 1

data/bin/p-lang

@@ -9,6 +9,7 @@ if ARGV[0]
 
   if ast
     vm = PLang::VM.new(ast.build.collect(&:to_sexp))
+    
     vm.execute!
   else
     puts @parser.failure_reason

data/bin/teste.p

@@ -1,5 +0,0 @@
-f = [x| x(1)]
-
-g = [x| x+1]
-
-print(f(g))

data/lib/p-lang.rb

@@ -14,12 +14,18 @@ require File.join(ROOT_PATH, '/vm/proc')
 require File.join(ROOT_PATH, '/vm/pobject')
 require File.join(ROOT_PATH, '/vm/perror')
 
-require File.join(ROOT_PATH, '/vm/std/io')
+require File.join(ROOT_PATH, '/vm/std/pio')
+require File.join(ROOT_PATH, '/vm/std/pstring')
+require File.join(ROOT_PATH, '/vm/std/pinteger')
+require File.join(ROOT_PATH, '/vm/std/pdecimal')
 
 module PLang  
   class VM
     def initialize_global_environment(env)
-      IO.def_pfunctions(env)
+      PIO.def_pfunctions(env)
+      PString.def_pfunctions(env)
+      PInteger.def_pfunctions(env)
+      PDecimal.def_pfunctions(env)
     end
   end
 end

data/lib/vm/perror.rb

@@ -2,7 +2,7 @@ module PLang
   class PError    
     def PError.raise_error(error_name, error_message)
       puts error_name.to_s + ": " + error_message
-      exit
+      raise "PError.raise_error"
     end
   end
 end

data/lib/vm/proc.rb

@@ -11,20 +11,30 @@ class Proc
             return false
           end
         else
-          if form[2].length == obj[2].length
-            form[2].each_with_index do |p, i|
-              unless p[0] == :id
-                unless p == obj[2][i]
-                  if p[0] == :object
-                    return compare_form(p, obj[2][i])
-                  else
-                    return false
+          if obj[0] == :literal
+            unless form[2].length == 1
+              return false
+            else
+              unless form[2][0][0] == :id
+                return false
+              end
+            end
+          else
+            if form[2].length == obj[2].length
+              form[2].each_with_index do |p, i|
+                unless p[0] == :id
+                  unless p == obj[2][i]
+                    if p[0] == :object
+                      return compare_form(p, obj[2][i])
+                    else
+                      return false
+                    end
                   end
                 end
               end
+            else
+              return false
             end
-          else
-            return false
           end
         end
       end
@@ -50,4 +60,8 @@ class Proc
       return false
     end
   end
+  
+  def to_s
+    "#lambda:#{self.object_id}"
+  end
 end

data/lib/vm/std/pdecimal.rb

@@ -0,0 +1,42 @@
+module PLang
+  module PDecimal
+    def PDecimal.def_pfunctions(env)
+      env.add_object_call([:object, :decimal, [[:id, :x]]], :abs, PDecimal.abs)
+      env.add_object_call([:object, :decimal, [[:id, :x]]], :ceil, PDecimal.ceil)
+      env.add_object_call([:object, :decimal, [[:id, :x]]], :floor, PDecimal.floor)
+      env.add_object_call([:object, :decimal, [[:id, :x]]], :to_string, PDecimal.to_string)
+    end
+    
+    def PDecimal.abs
+      lamb = Proc.new do |values|
+        PObject.new(:decimal, [values[0].params[0].abs])
+      end
+      lamb.form = [[:object, :decimal, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PDecimal.ceil
+      lamb = Proc.new do |values|
+        PObject.new(:decimal, [values[0].params[0].ceil])
+      end
+      lamb.form = [[:object, :decimal, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PDecimal.floor
+      lamb = Proc.new do |values|
+        PObject.new(:decimal, [values[0].params[0].floor])
+      end
+      lamb.form = [[:object, :decimal, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PDecimal.to_string
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].to_s])
+      end
+      lamb.form = [[:object, :decimal, [[:id, :x]]]]
+      [lamb]
+    end
+  end
+end

data/lib/vm/std/pinteger.rb

@@ -0,0 +1,42 @@
+module PLang
+  module PInteger
+    def PInteger.def_pfunctions(env)
+      env.add_object_call([:object, :integer, [[:id, :x]]], :abs, PInteger.abs)
+      env.add_object_call([:object, :integer, [[:id, :x]]], :to_decimal, PInteger.to_decimal)
+      env.add_object_call([:object, :integer, [[:id, :x]]], :to_string, PInteger.to_string)
+      env.add_object_call([:object, :integer, [[:id, :x]]], :next, PInteger.next)
+    end
+    
+    def PInteger.abs
+      lamb = Proc.new do |values|
+        PObject.new(:integer, [values[0].params[0].abs])
+      end
+      lamb.form = [[:object, :integer, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PInteger.next
+      lamb = Proc.new do |values|
+        PObject.new(:integer, [values[0].params[0].next])
+      end
+      lamb.form = [[:object, :integer, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PInteger.to_decimal
+      lamb = Proc.new do |values|
+        PObject.new(:decimal, [values[0].params[0].to_f])
+      end
+      lamb.form = [[:object, :integer, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PInteger.to_string
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].to_s])
+      end
+      lamb.form = [[:object, :integer, [[:id, :x]]]]
+      [lamb]
+    end
+  end
+end

data/lib/vm/std/{io.rb → pio.rb}

@@ -1,10 +1,10 @@
 module PLang
-  module IO
-    def IO.def_pfunctions(env)
-      env.add_var(:print, IO.pprint)
+  module PIO
+    def PIO.def_pfunctions(env)
+      env.add_var(:print, PIO.pprint)
     end
     
-    def IO.pprint
+    def PIO.pprint
       lamb = Proc.new do |values|
         values.each do |value|
           puts value.to_s

data/lib/vm/std/pstring.rb

@@ -0,0 +1,160 @@
+module PLang
+  module PString
+    def PString.def_pfunctions(env)
+      env.add_object_call([:object, :string, [[:id, :x]]], :append, PString.append)
+      env.add_object_call([:object, :string, [[:id, :x]]], :equal, PString.equal)
+      env.add_object_call([:object, :string, [[:id, :x]]], :at, PString.at)
+      env.add_object_call([:object, :string, [[:id, :x]]], :capitalize, PString.capitalize)
+      env.add_object_call([:object, :string, [[:id, :x]]], :center, PString.center)
+      env.add_object_call([:object, :string, [[:id, :x]]], :downcase, PString.downcase)
+      env.add_object_call([:object, :string, [[:id, :x]]], :is_empty, PString.is_empty)
+      env.add_object_call([:object, :string, [[:id, :x]]], :hex, PString.hex)
+      env.add_object_call([:object, :string, [[:id, :x]]], :index, PString.index)
+      env.add_object_call([:object, :string, [[:id, :x]]], :insert, PString.insert)
+      env.add_object_call([:object, :string, [[:id, :x]]], :length, PString.length)
+      env.add_object_call([:object, :string, [[:id, :x]]], :oct, PString.oct)
+      env.add_object_call([:object, :string, [[:id, :x]]], :reverse, PString.reverse)
+      env.add_object_call([:object, :string, [[:id, :x]]], :to_integer, PString.to_integer)
+      env.add_object_call([:object, :string, [[:id, :x]]], :to_decimal, PString.to_decimal)
+      env.add_object_call([:object, :string, [[:id, :x]]], :upcase, PString.upcase)
+    end
+    
+    def PString.append
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0] + values[1].params[0]])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]], [:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.equal
+      lamb = Proc.new do |values|
+        if values[0].params[0] == values[1].params[0]
+          PObject.new(:boolean, [true])
+        else
+          PObject.new(:boolean, [false])
+        end
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]], [:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.at
+      lamb = Proc.new do |values|
+        PObject.new(:char, [values[0].params[0][values[1].params[0],1]])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]], [:object, :integer, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.capitalize
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].capitalize])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.center
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].center(values[1].params[0])])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]], [:object, :integer, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.downcase
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].downcase])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.is_empty
+      lamb = Proc.new do |values|
+        PObject.new(:boolean, [values[0].params[0].empty?])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.hex
+      lamb = Proc.new do |values|
+        PObject.new(:integer, [values[0].params[0].hex])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.index
+      lamb = Proc.new do |values|
+        i = values[0].params[0].index(values[1].params[0])
+        if i
+          PObject.new(:integer, [i])
+        else
+          PObject.new(:nil, [])
+        end
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]], [:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.insert
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].insert(values[1].params[0], values[2].params[0])])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]], [:object, :integer, [[:id, :x]]], [:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.length
+      lamb = Proc.new do |values|
+        PObject.new(:integer, [values[0].params[0].length])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.oct
+      lamb = Proc.new do |values|
+        PObject.new(:integer, [values[0].params[0].oct])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.reverse
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].reverse])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.to_integer
+      lamb = Proc.new do |values|
+        PObject.new(:integer, [values[0].params[0].to_i])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.to_decimal
+      lamb = Proc.new do |values|
+        PObject.new(:decimal, [values[0].params[0].to_f])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+    def PString.upcase
+      lamb = Proc.new do |values|
+        PObject.new(:string, [values[0].params[0].upcase])
+      end
+      lamb.form = [[:object, :string, [[:id, :x]]]]
+      [lamb]
+    end
+    
+  end
+end

data/lib/vm/vm.rb

@@ -144,11 +144,13 @@ module PLang
         end
       end
       # CallFunctionError
+      ok = false
       str_value = "("
       values.each do |v|
         str_value += "#{v.to_s}" + ","
+        ok = true
       end
-      if str_value[-1] == ","
+      if ok
         str_value[-1] = ")"
       else
         str_value += ")"
@@ -166,6 +168,8 @@ module PLang
     def execute_binop(op, lhs, rhs, env)
       lhs = execute(lhs, env)
       rhs = execute(rhs, env)
+      #p lhs
+      #p rhs
       result = lhs.params[0].send(op,rhs.params[0])
       if result.class == Fixnum or result.class == Bignum
         return PObject.new(:integer, [result])
@@ -207,10 +211,14 @@ module PLang
     
     def execute_object(type, params, env)
       values = []
-      params.each do |param|
-        values << execute(param, env)
+      if type == :integer and params.length == 1
+        return PObject.new(type, [params[0][2]])
+      else
+        params.each do |param|
+          values << execute(param, env)
+        end
+        return PObject.new(type, values)
       end
-      PObject.new(type, values)
     end
     
     def execute_object_let(obj, msg, value, env)

data/test/test_vm_programs.txt

@@ -37,3 +37,28 @@ f = [_,x,_| x*2] f(1,2,3)
 f = [{obj: {xxx: _}, x}, y| x+y] f({obj: {xxx: 1}, 2}, 3)
 list_sum = [{list: head, tail}| head + list_sum(tail)], [{list}| 0] list_sum({list: 1, {list: 2, {list}}})
 f = [x| x(10)] g = [x| x+1] f(g)
+"aaaaa"->append("bbbbb")
+"aaaaa"->equal("bbbbb")
+"aaaaa"->equal("aaaaa")
+"abcde"->at(2)
+"abcde"->capitalize()
+"abcde"->center(10)
+"aBcDe"->downcase()
+"aBcDe"->is_empty()
+"0xB"->hex()
+"abcde"->index("c")
+"abcde"->insert(3, "X")
+"abcde"->length()
+"10"->oct()
+"abcde"->reverse()
+"10"->to_integer()
+"10.11"->to_decimal()
+"aBcDe"->upcase()
+(-1)->abs()
+(-1)->next()
+(-1)->to_decimal()
+(-1)->to_string()
+(-1.1)->abs()
+(-1.1)->ceil()
+(-1.1)->floor()
+(-1.1)->to_string()

data/test/test_vm_results.txt

@@ -37,3 +37,28 @@ true
 5
 3
 11
+"aaaaabbbbb"
+false
+true
+"c"
+"Abcde"
+"  abcde   "
+"abcde"
+false
+11
+2
+"abcXde"
+5
+8
+"edcba"
+10
+10.11
+"ABCDE"
+1
+0
+-1.0
+"-1"
+1.1
+-1
+-2
+"-1.1"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: p-lang
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 4
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - Igor Bonadio
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-08 00:00:00 -03:00
+date: 2010-07-12 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -72,7 +72,10 @@ files:
 - lib/vm/perror.rb
 - lib/vm/pobject.rb
 - lib/vm/proc.rb
-- lib/vm/std/io.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_parser.rb