p-lang 0.0.1

data/lib/parser/p-lang.treetop

@@ -0,0 +1,197 @@
+grammar PLang
+
+  rule statements
+    (spaces? statement spaces?)* <NStatements>
+  end
+  
+  rule statement
+    unop / binop / let / object_op / expr
+  end
+
+  rule object_op
+    object_msg /
+    object_get
+  end
+
+  rule object_msg
+    expr spaces? '->' spaces? id sspaces? '(' spaces? statement_list:statement_list? spaces? ')' <NObjectMsg>
+  end
+
+  rule object_get
+    expr spaces? '->' spaces? id spaces? <NObjectGet>
+  end
+
+  rule let
+    var_let /
+    obj_let
+  end
+
+  rule var_let
+    var spaces? '=' spaces? statement <NVarLet>
+  end
+
+  rule obj_let
+    object_form spaces? '->' spaces? var spaces? '=' spaces? statement <NObjectLet>
+  end
+  
+  rule var
+    id / object
+  end
+
+  rule unop
+     'not' spaces? statement <NUnOp>
+  end
+  
+  rule binop
+    expr spaces? op spaces? statement <NBinOp>
+  end
+
+  rule op
+    '+' / '-' / '*' / '/' / '%' / '>=' / '<=' / '>' / '<' / '==' / 'and' / 'or'
+  end
+
+  rule call
+    cid:(id / lambda) sspaces? '(' spaces? cparams:statement_list? spaces? ')' <NCall>
+  end
+
+  rule sspaces
+    [\s\t]*
+  end
+  
+  rule expr
+	number / boolean / call / id / object / char / string / lambda / parem_expr
+  end
+
+  rule parem_expr
+    '(' spaces? statement spaces? ')' <NParemExpr>
+  end
+  
+  rule statement_list
+    cstatement_list / statement
+  end
+
+  rule cstatement_list
+    statement spaces?  ',' spaces? statement_list <NCStatementList>
+  end
+  
+  rule lambda
+    clamb / lamb
+  end
+
+  rule clamb
+    lamb spaces? ',' spaces? lambda <NCLambda>
+  end
+
+  rule lamb
+    '[' spaces? params:lambda_params? spaces? statement spaces? ']' spaces? where:where? <NLambda>
+  end
+  
+  rule where
+    ':' spaces? '(' spaces? where_params spaces? ')' <NWhere>
+  end
+
+  rule where_params
+    cwhere_params / let
+  end
+
+  rule cwhere_params
+    let spaces? ',' spaces? where_params <NCWhereParams>
+  end
+
+  rule lambda_params
+    lambda_params_list spaces? '|' <NLambdaParams>
+  end
+  
+  rule lambda_params_list
+    clambda_params_list / form
+  end
+
+  rule clambda_params_list
+    form spaces? ',' spaces? lambda_params_list <NCLambdaParamsList>
+  end
+  
+  rule form
+	  number / id / object_form / char / string
+  end
+  
+  rule object_form
+    '{' spaces? id spaces? obj_form_list:object_form_list? spaces? '}' <NObjectForm>
+  end
+  
+  rule object_form_list
+    ':' spaces? lambda_params_list <NLambdaParams>
+  end
+  
+  rule object
+	  '{' spaces? id spaces? obj_list:object_list? spaces? '}' <NObject>
+  end
+  
+  rule object_list
+    ':' spaces?  statement_list <NObjectList>
+  end
+
+  rule boolean
+    (true / false) <NBoolean>
+  end
+
+  rule true
+    "true"
+  end
+
+  rule false
+    "false"
+  end
+  
+  rule id
+    [a-zA-Z_0-9]+ <NId>
+  end
+  
+  rule string
+    "\"" str:(!"\"" .)* "\"" <NString>
+  end
+  
+  rule char
+    "'" c:(!"'" .) "'" <NChar>
+  end
+
+  rule number
+	  decimal / integer
+  end
+  
+  rule decimal
+	  sign? spaces? digits? dot digits <NDecimal>
+  end
+  
+  rule integer
+	  sign? spaces? digits <NInteger>
+  end
+  
+  rule digits
+	  digit+
+  end
+  
+  rule digit
+	  [0-9]
+  end
+  
+  rule sign
+    "-"
+  end
+  
+  rule dot
+	  "."
+  end
+  
+  rule spaces
+    space* ("#" (!break .)* break+ space*)*
+  end
+  
+  rule space
+    [\r\n\t\s]
+  end
+  
+  rule break
+    [\r\n]
+  end
+  
+end

data/lib/vm/environment.rb

@@ -0,0 +1,51 @@
+module PLang
+  class Environment
+    attr_accessor :parent
+
+    def initialize
+      @vars = Hash.new
+      @parent = nil
+      @object_call = Hash.new
+    end
+
+    def add_var(id, value)
+      unless @vars[id]
+        @vars[id] = value
+      else
+        raise "add_var"
+      end
+    end
+
+    def get_var(id)
+      v = @vars[id]
+      if v
+        return v
+      elsif @parent
+        return @parent.get_var(id)
+      else
+        raise "get_var"
+      end
+    end
+        
+    def add_object_call(form, msg, value)
+      unless @object_call[msg]
+        @object_call[msg] = Hash.new
+      end
+      @object_call[msg][form] = value
+    end
+    
+    def get_object_call(object, msg)
+      begin
+        lamb = []
+        @object_call[msg].each do |obj|
+          if obj[0][1] == object.type
+            lamb |= obj[1]
+          end
+        end
+        return lamb
+      rescue
+        raise "get_object_call"
+      end
+    end
+  end
+end

data/lib/vm/pobject.rb

@@ -0,0 +1,47 @@
+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)]
+      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(",")}}"
+      end
+    end
+    
+  end
+end

data/lib/vm/proc.rb

@@ -0,0 +1,41 @@
+class Proc
+  def form=(form)
+    @form = form
+  end
+  
+  def compare_form(form, obj)
+    if(form)
+      unless obj[1] == form[1]
+        return false
+      else
+        if form[0] == :literal
+          unless form == obj
+            return false
+          end
+        else
+          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
+        end
+      end
+    end
+    return true
+  end
+
+  def call?(params)
+    params.each_with_index do |param, i|
+      unless compare_form(@form[i], param.form)
+        return false
+      end
+    end
+    return true
+  end
+end

data/lib/vm/std/io.rb

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

data/lib/vm/vm.rb

@@ -0,0 +1,211 @@
+module PLang  
+  class VM
+    def initialize(ast)
+      @ast = ast
+    end
+
+    def execute!
+      env = PLang::Environment.new
+      initialize_global_environment(env)
+      @ast.each do |expr|
+        @ret = execute(expr, env)
+      end
+      @ret
+    end
+
+    def execute(expr, env)
+      case expr[0]
+        when :literal
+          execute_literal(expr[1], expr[2], env)
+        when :let
+          execute_let(expr[1], expr[2], env)
+        when :lambda
+          execute_lambda(expr[1], expr[2], expr[3], expr[4], env)
+        when :call
+          execute_call(expr[1], expr[2], env)
+        when :id
+          execute_id(expr[1], env)
+        when :+, :-, :*, :/, :%, :>, :<, :>=, :<=, :==
+          execute_binop(expr[0], expr[1], expr[2], env)
+        when :and
+          execute_and(expr[1], expr[2], env)
+        when :or
+          execute_or(expr[1], expr[2], env)
+        when :if
+          execute_if(expr[1], expr[2], expr[3], env)
+        when :begin
+          execute_begin(expr[1], env)
+        when :object
+          execute_object(expr[1], expr[2], env)
+        when :object_let
+          execute_object_let(expr[1], expr[2], expr[3], env)
+        when :object_call
+          execute_object_call(expr[1], expr[2], env)
+      end
+    end
+
+    def execute_literal(type, value, env)
+      case type
+        when :integer, :decimal, :char, :string
+          PObject.new(type, [value])
+        when :boolean
+          if value == :true
+            PObject.new(:boolean, [true])
+          elsif value == :false
+            PObject.new(:boolean, [false])
+          end
+      end
+    end
+
+    def execute_let(id, value, env)
+      case id[0]
+        when :id
+          unless id[1] == :_
+            env.add_var(id[1], execute(value, env))
+          end
+        when :object
+          add_object_var(id, execute(value, env), env)
+      end
+    end
+    
+    def add_object_var(obj, value, env)
+      if obj[1] == value.type
+        obj[2].each_with_index do |param, i|
+          case param[0]
+            when :id
+              unless param[1] == :_
+                case value.type
+                  when :integer, :decimal, :boolean
+                    env.add_var(param[1], PObject.new(value.type, [value.params[i]]))
+                  else
+                    env.add_var(param[1], value.params[i])
+                  end
+                end
+            when :object
+              add_object_var(param, value.params[i], env)
+            else
+              unless execute(param, env) == value.params[i]
+                raise "add_object_var #1"
+              end
+          end
+        end
+      else
+        raise "add_object_var #2"
+      end
+    end
+    
+    def execute_lambda(params, body, where, next_lambda, env)
+      lambda = []
+      lambda << Proc.new do |values|
+        new_env = PLang::Environment.new
+        new_env.parent = env
+        values.each_with_index do |value, i|
+          case params[i][0]
+            when :id
+              unless params[i][1] == :_
+                new_env.add_var(params[i][1], value)
+              end
+            when :object
+              add_object_var(params[i], value, new_env)
+          end
+        end
+        where.each do |w|
+          execute(w, new_env)
+        end
+        execute(body, new_env)
+      end
+      form = []
+      params.each do |param|
+        case param[0]
+          when :id
+            form << nil
+          when :object
+            form << param
+          else
+            form << execute(param, env).form
+        end
+      end
+      lambda[0].form = form
+      if next_lambda
+        lambda |= execute(next_lambda, env)
+      end
+      lambda
+    end
+
+    def execute_call(id, params, env)
+      values = []
+      params.each do |param|
+        values << execute(param, env)
+      end
+      execute(id, env).each do |lambda|
+        if lambda.call?(values)
+          return lambda.call(values)
+        end
+      end
+      raise "execute_call"
+    end
+
+    def execute_id(id, env)
+      env.get_var(id)
+    end
+
+    def execute_binop(op, lhs, rhs, env)
+      lhs = execute(lhs, env)
+      rhs = execute(rhs, env)
+      result = lhs.params[0].send(op,rhs.params[0])
+      if result.class == Fixnum or result.class == Bignum
+        return PObject.new(:integer, [result])
+      elsif result.class == Float
+        return PObject.new(:decimal, [result])
+      elsif result.class == TrueClass or result.class == FalseClass
+        return PObject.new(:boolean, [result])
+      end
+    end
+
+    def execute_and(lhs, rhs, env)
+      lhs = execute(lhs, env) 
+      rhs = execute(rhs, env)
+      PObject.new(:boolean, [(lhs.params[0] and rhs.params[0])])
+    end
+
+    def execute_or(lhs, rhs, env)
+      lhs = execute(lhs, env) 
+      rhs = execute(rhs, env)
+      PObject.new(:boolean, [(lhs.params[0] or rhs.params[0])])
+    end
+
+    def execute_if(cond, t, f, env)
+      cond = execute(cond, env)
+      if cond.params[0]
+        execute(t, env)
+      else
+        execute(f, env)
+      end
+    end
+
+    def execute_begin(exprs, env)
+      ret = nil
+      exprs.each do |expr|
+        ret = execute(expr, env)
+      end
+      ret
+    end
+    
+    def execute_object(type, params, env)
+      values = []
+      params.each do |param|
+        values << execute(param, env)
+      end
+      PObject.new(type, values)
+    end
+    
+    def execute_object_let(obj, msg, value, env)
+      value[1] << obj
+      env.add_object_call(obj, msg[1], execute(value, env))
+    end
+    
+    def execute_object_call(object, id, env)
+      env.get_object_call(execute(object, env), id[1])
+    end
+  end
+end