p-lang 0.1.1 → 0.2.0

data/lib/vm/interpreter.rb

@@ -0,0 +1,209 @@
+module PLang
+  module VM
+    class Interpreter
+      include PFunctions
+      
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def execute!
+        result = nil
+        env = load_basic_environment
+        @ast.each do |ast|
+          result = execute(ast, env)
+        end
+        result
+      end
+
+      private
+      
+      def load_basic_environment
+        @env = Environment.new
+        libraries = methods.grep /^add_to_interpreter/
+        libraries.each do |library|
+          send(library)
+        end
+        @env
+      end
+
+      def execute(ast, env)
+        if ast.class == PLang::Parser::Node
+          case ast.type
+            when :integer, :decimal, :string, :char, :boolean
+              execute_literal(ast.type, ast.value, env)
+            when :object
+              execute_object(ast.id, ast.params, env)
+            when :list
+              execute_list(ast.elements, env)
+            when :if
+              execute_if(ast.condition, ast.true_expr, ast.false_expr, env)
+            when :lambda
+              execute_lambda(ast.params, ast.body, ast.where, ast.next_lambda, env)
+            when :call
+              execute_call(ast.lambda, ast.params, env)
+            when :object_message
+              execute_object_message(ast.object, ast.message, env)
+            when :let
+              execute_let(ast.lhs, ast.rhs, env)
+            when :id
+              execute_id(ast.value, env)
+            when :begin
+              execute_begin(ast.expressions, env)
+            when :add, :sub, :mul, :div, :equal, :diff, :major, :major_equal, :minor, :minor_equal
+              execute_binop(ast.type, ast.lhs, ast.rhs, env)
+            when :and, :or
+              execute_binop("_#{ast.type}".to_sym, ast.lhs, ast.rhs, env)
+            when :not
+              execute_unop("_#{ast.type}".to_sym, ast.lhs, env)
+          end
+        else
+          ast
+        end
+      end
+
+      def execute_if(cond, true_expr, false_expr, env)
+        cond = execute(cond, env)
+        if cond.id == :boolean
+          if cond.params[0] == :true
+            execute(true_expr, env)
+          else
+            execute(false_expr, env)
+          end
+        else
+          raise "IfError"
+        end
+      end
+      
+      def execute_binop(type, lhs, rhs, env)
+        execute_call(execute_object_message(lhs,PLang::Parser::Node.new(:id, {:value => type}), env), [rhs], env)
+      end
+      
+      def execute_unop(type, lhs, env)
+        execute_call(execute_object_message(lhs,PLang::Parser::Node.new(:id, {:value => type}), env), [], env)
+      end
+
+      def execute_literal(type, value, env)
+        PObject.new(type, [value])
+      end
+
+      def execute_object(id, params, env)
+        object_params = []
+        params.each do |param|
+          object_params << execute(param, env)
+        end
+        case id.value
+          when :integer, :decimal, :string, :char, :boolean
+            if object_params.length == 1 and object_params[0].id == id.value
+              PObject.new(id.value, object_params[0].params)
+            end
+          else
+            PObject.new(id.value, object_params)
+        end
+      end
+
+      def execute_lambda(params, body, where, next_lambda, env)
+        lambda = []
+        lambda << PLambda.new do |values|
+          new_env = Environment.new
+          new_env.parent = env
+          values.each_with_index do |value, i|
+            case params[i].type
+              when :id
+                unless params[i].value == :_
+                  new_env.set_var(params[i].value, value)
+                end
+              when :object
+                new_env.set_object_var(params[i], value)
+            end
+          end
+          where.each do |w|
+            execute(w, new_env)
+          end
+          execute(body, new_env)
+        end
+        params.each do |param|
+          case param.type
+            when :id
+              lambda[0].form <<  nil
+            else
+              lambda[0].form << param
+          end
+        end
+        if next_lambda
+          lambda |= execute(next_lambda, env).params
+        end
+        PObject.new(:lambda, lambda)
+      end
+      
+      def execute_call(lambda, params, env)
+        values = []
+        params.each do |param|
+          values << execute(param, env)
+        end
+        lambda = execute(lambda, env)
+        lambda.params.each do |lamb|
+          return lamb.call(values) if lamb.call?(values)
+        end
+        raise "CallError"
+      end
+
+      def execute_let(lhs, rhs, env)
+        case lhs.type
+          when :id
+            if lhs.value == :_
+              raise "WildCardError"
+            else
+              begin
+                env.set_var(lhs.value, execute(rhs, env))
+              rescue Exception => e
+                var = env.get_var(lhs.value)
+                if var.id == :lambda
+                  env.add_lambda(lhs.value, execute(rhs, env))
+                else
+                  raise e
+                end
+              end
+            end
+          when :object
+            env.set_object_var(lhs, execute(rhs, env))
+          when :object_message
+            params = [lhs.object, PLang::Parser::Node.new(:object, {:id => PLang::Parser::Node.new(:id, {:value => lhs.message.value}), :params => []})]
+            lamb = execute_lambda(params, rhs, [], nil, env)
+            begin
+              env.set_var(:get_object_message, lamb)
+            rescue
+              env.add_lambda(:get_object_message, lamb)
+            end
+        end
+      end
+      
+      def execute_id(id, env)
+        env.get_var(id)
+      end
+
+      def execute_begin(expressions, env)
+        ret = nil
+        expressions.each do |expr|
+          ret = execute(expr, env)
+        end
+        ret
+      end
+
+      def execute_list(elements, env)
+        element = elements.delete_at(0)
+        if element
+          PObject.new(:list, [execute(element, env), execute_list(elements, env)])
+        else
+          PObject.new(:empty, [])
+        end
+      end
+      
+      def execute_object_message(object, message, env)
+        get_object_message = PLang::Parser::Node.new(:id, {:value => :get_object_message})
+        message = PLang::Parser::Node.new(:object, {:id => PLang::Parser::Node.new(:id, {:value => message.value}), :params => []})
+        execute_call(get_object_message, [object, message], env)
+      end
+    end
+  end
+end

data/lib/vm/pfunctions.rb

@@ -0,0 +1,46 @@
+module PLang
+  module VM
+    module PFunctions
+      
+      def plambda(*params)
+        lamb = PLambda.new do |values|
+          yield(values)
+        end
+        
+        obj_params = []
+        params.each do |param|
+          param = object(param)
+          case param.type
+            when :id
+              lamb.form <<  nil
+            else
+              lamb.form << param
+          end
+          obj_params << param
+        end
+                
+        PObject.new(:lambda, [lamb])
+      end
+      
+      def object_message(object, message)
+        lamb = plambda(object, "{#{message.to_s}}") do |values|
+          yield(values[0], values[1])
+        end
+        begin
+          @env.set_var(:get_object_message, lamb)
+        rescue
+          @env.add_lambda(:get_object_message, lamb)
+        end
+      end
+      
+      def var(id, value)
+        @env.set_var(id.to_sym, value)
+      end
+      
+      def object(expr)
+        PLang::Parser::SyntaxAnalyser.new(expr).parse[0]
+      end
+      
+    end
+  end
+end

data/lib/vm/plambda.rb

@@ -0,0 +1,42 @@
+module PLang
+  module VM
+    class PLambda < Proc
+            
+      def call?(params)
+        _call?(params, @form||[])
+      end
+      
+      def _call?(params, form)
+        if form.length == params.length
+          form.each_with_index do |f, i|
+            if f
+              case f.type
+                when :integer, :decimal, :char, :string
+                  if f.type == params[i].id
+                    unless f.value == params[i].params[0]
+                      return false
+                    end
+                  end
+                when :object
+                  unless f.id.value == params[i].id
+                    return false
+                  else
+                    unless _call?(params[i].params, f.params)
+                      return false
+                    end
+                  end
+              end
+            end
+          end
+          return true
+        else
+          return false
+        end
+      end
+      
+      def form
+        @form ||= []
+      end
+    end
+  end
+end

data/lib/vm/pobject.rb

@@ -1,47 +1,49 @@
 module PLang
-  class PObject
-    attr_accessor :type
-    attr_accessor :params
-    
-    def initialize(type, params)
-      @type = type
-      @params = params
-    end
-    
-    def ==(obj)
-      if @type == obj.type
-        @params.each_with_index do |param, i|
-          unless param == obj.params[i]
-            return false
-          end
-        end
-        return true
-      else
-        return false
-      end
-    end
-    
-    def form
-      case @type
-        when :integer, :decimal, :boolean, :char, :string
-          [:literal, @type, @params[0]]
-        else
-          [:object, @type, @params.collect(&:form)]
+  module VM
+    class PObject
+      attr_reader :id
+      attr_accessor :params
+
+      def initialize(id, params)
+        @id = id
+        @params = params
       end
-    end
-    
-    def to_s
-      case @type
-        when :integer, :decimal, :boolean
-          @params[0]
-        when :string
-          "\"#{@params[0]}\""
-        when :char
-          "\'#{@params[0]}\'"
-        else
-          "{#{@type}: #{@params.collect(&:to_s).join(",")}}"
+
+      def to_s
+        case @id
+          when :integer, :decimal, :char, :string, :boolean
+            return params[0]
+          when :empty
+            return "'()"
+          when :list
+            str = "'("
+            params = @params
+            ok = false
+            while params and params != []
+              str += "#{params[0].to_s}, "
+              params = params[1].params
+              ok = true
+            end
+            if ok
+              str[-2] = ')'
+            else
+              str += ')'
+            end
+            return str.strip
+          else
+            str = "{#{@id}"
+            if @params.length > 0
+              str += ": "
+              @params.each do |param|
+                str += "#{param.to_s}, "
+              end
+              str[-2] = "}"
+            else
+              str += "}"
+            end
+            return str.strip
+        end
       end
     end
-    
   end
-end
+end

data/test/test_lexer

@@ -0,0 +1,34 @@
+abc
+123
+
+"aaaaaa"
+'s'
+[
+]
+(
+)
+{
+}
+,
+|
+:
+-
+->
++
+*
+/
+%
+=
+==
+!=
+>
+>=
+<
+<=
+and
+or
+not
+true
+false
+nil
+begin

data/test/test_lexer.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestLexer < Test::Unit::TestCase
+  
+  EXPRESSIONS = File.readlines(File.join(File.dirname(__FILE__), "test_lexer"))
+  TOKENS = File.readlines(File.join(File.dirname(__FILE__), "test_lexer_tokens"))
+  
+  context "The Lexer" do
+    
+    EXPRESSIONS.each_with_index do |expr, i|
+      lexer = PLang::Parser::Lexer.new(EXPRESSIONS[i])
+      should "tokenize the expression ##{i}" do
+        assert_equal lexer.next_token.type, eval(TOKENS[i])
+      end
+    end
+  
+  end
+  
+end