fastruby 0.0.20 → 0.0.21

data/lib/fastruby/modules/translator/static.rb~

@@ -1,291 +0,0 @@
-=begin
-
-This file is part of the fastruby project, http://github.com/tario/fastruby
-
-Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
-
-fastruby is free software: you can redistribute it and/or modify
-it under the terms of the gnu general public license as published by
-the free software foundation, either version 3 of the license, or
-(at your option) any later version.
-
-fastruby is distributed in the hope that it will be useful,
-but without any warranty; without even the implied warranty of
-merchantability or fitness for a particular purpose.  see the
-gnu general public license for more details.
-
-you should have received a copy of the gnu general public license
-along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
-
-=end
-module FastRuby
-  class Context
-    define_translator_for(:iter, :arity => 1, :priority => 1) { |*x|
-      ret = nil
-      tree = x.first
-      enable_handler_group(:static_call) do
-              require "pry"; binding.pry
-        ret = x.size == 1 ? to_c(tree[3]) : to_c(tree[3], x.last)
-      end
-      ret
-    }.condition{ |*x|
-      tree = x.first
-      tree.node_type == :iter && tree[1][2] == :_static
-    }
-    
-    define_translator_for(:iter, :arity => 1, :priority => 1) { |*x|
-      ret = nil
-      tree = x.first
-      
-      disable_handler_group(:static_call) do
-        ret = x.size == 1 ? to_c(tree[3]) : to_c(tree[3], x.last)
-      end
-      ret
-    }.condition{ |*x|
-      tree = x.first
-      tree.node_type == :iter && tree[1][2] == :_dynamic
-    }
-    
-    handler_scope(:group => :static_call, :priority => 1000) do
-      define_translator_for(:call) do |*x|
-      tree, result = x
-
-        method_name = tree[2].to_s
-        recv_tree = tree[1]
-        
-        if method_name == "c_address_of"
-          arg = tree[3][1]
-          return "&"+to_c(arg)
-        end
-        
-        if method_name == "inline_c"
-          arg = tree[3][1]
-          
-          if arg.node_type != :str
-            raise RuntimeError, "invalid node for inline_c directive #{arg}"
-          end
-
-          next arg[1]
-        end
-
-        if recv_tree and recv_tree.node_type != :self
-          if (not tree[2].to_s =~ /^[a-zA-Z]/) and tree[2].to_s.size <= 3
-            c_op = tree[2].to_s
-            c_op = '==' if tree[2] == :===
-            code = "( ( #{to_c(tree[1])} )#{c_op}(#{to_c(tree[3][1])}) )"
-          elsif tree[2] == :_invariant
-            name = self.add_global_name("VALUE", "Qnil");
-            
-            init_extra << "
-                #{name} = #{to_c tree[1]};
-                rb_funcall(#{name},#{intern_num :gc_register_object},0);
-              "
-              
-            code = name;
-          else
-            args = tree[3][1..-1].map{|st| to_c(st)}.join(",")
-            code = "#{method_name}( #{args} )"
-          end
-        else
-          args = tree[3][1..-1].map{|st| to_c(st)}.join(",")
-          code = "#{method_name}( #{args} )"
-        end
-
-        if result
-          "#{result} = #{code};"
-        else
-          code
-        end
-      end
-      
-      define_translator_for(:lit) do |*x|
-      tree, result = x
-
-        if result
-          "#{result} = #{tree[1]};"
-        else
-          tree[1].to_s
-        end
-      end
-      
-      define_translator_for(:if) do |*x|
-      tree, result_variable_  = x
-
-        condition_tree = tree[1]
-        impl_tree = tree[2]
-        else_tree = tree[3]
-        
-        result_variable = result_variable_ || "last_expression"
-        
-        code = proc {"
-          {
-            VALUE condition_result;
-            #{to_c condition_tree, "condition_result"};
-            if (condition_result) {
-              #{to_c impl_tree, result_variable};
-            }#{else_tree ?
-              " else {
-              #{to_c else_tree, result_variable};
-              }
-              " : ""
-            }
-          }
-        "}
-  
-        if result_variable_
-          code.call
-        else
-          inline_block(&code) + "; return last_expression;"
-        end      
-      end
-      
-      define_translator_for(:const) do |*x|
-      tree, result_var  = x
-
-        if result_var
-          "#{result_var} = #{tree[1].to_s};"
-        else
-          "#{tree[1].to_s}"
-        end
-      end
-      
-      define_translator_for(:while) do |*x|
-      tree, result_var  = x
-
-        begin_while = "begin_while_"+rand(10000000).to_s
-        end_while = "end_while_"+rand(10000000).to_s
-        aux_varname = "_aux_" + rand(10000000).to_s
-        code = proc {"
-          {
-            VALUE while_condition;
-            VALUE #{aux_varname};
-            
-  #{begin_while}:
-            #{to_c tree[1], "while_condition"};
-            if (!(while_condition)) goto #{end_while}; 
-            #{to_c tree[2], aux_varname};
-            goto #{begin_while};
-  #{end_while}:
-            
-            #{
-            if result_var
-              "#{result_var} = Qnil;"
-            else
-              "return Qnil;"
-            end
-            }
-          }
-        "}
-        
-        if result_var
-          code.call
-        else
-          inline_block &code
-        end
-        
-      end
-           
-      define_translator_for(:and) do |*x|
-      tree, return_var  = x
-
-        if return_var
-          "
-            {
-              VALUE op1 = Qnil;
-              VALUE op2 = Qnil;
-              #{to_c tree[1], "op1"};
-              #{to_c tree[2], "op2"};
-              #{return_var} = ((op1) &&(op2));
-            }
-          "
-        else
-          "((#{to_c tree[1]}) && (#{to_c tree[2]}))"
-        end
-        
-      end
-      
-      define_translator_for(:or) do |*x|
-      tree, return_var  = x
-
-        if return_var
-          "
-            {
-              VALUE op1 = Qnil;
-              VALUE op2 = Qnil;
-              #{to_c tree[1], "op1"};
-              #{to_c tree[2], "op2"};
-              #{return_var} = ((op1) ||(op2));
-            }
-          "
-        else
-          "((#{to_c tree[1]}) || (#{to_c tree[2]}))"
-        end
-        
-      end
-      
-      define_translator_for(:not) do |*x|
-      tree, return_var  = x
-
-        if return_var
-          "
-            {
-              VALUE op1 = Qnil;
-              #{to_c tree[1], "op1"};
-              #{return_var} = ((op1) ? 0: 1);
-            }
-          "
-        else
-          "((#{to_c tree[1]}) ? 0 : 1)"
-        end
-      end
-          
-    end
-
-    define_method_handler(:initialize_to_c){|*x|}.condition do |*x|
-      disable_handler_group(:static_call, :to_c); false
-    end
-    
-
-    define_method_handler(:infer_value) { |*x| tree = x.first; 
-      Value.new(eval(tree[1].to_s))
-    }.condition{|*x| tree = x.first;  tree.node_type == :const}
-    
-    define_method_handler(:infer_value) { |*x| tree = x.first; 
-      args_tree = tree[3]
-      receiver_tree = tree[1]
-      
-      value_1 = infer_value(receiver_tree)
-      value_2 = infer_value(args_tree[1])
-
-      next false unless (value_1 and value_2)
-      
-      Value.new(value_1.value == value_2.value)
-    }.condition{|*x| tree = x.first; 
-      next false unless tree.node_type == :call
-      
-      args_tree = tree[3]
-      method_name = tree[2]
-       
-      next false unless method_name == :==
-      next false if args_tree.size < 2
-
-      true
-    }
-    define_method_handler(:infer_value) { |*x| tree = x.first; 
-      args_tree = tree[3]
-      receiver_tree = tree[1]
-      infered_type = infer_type(receiver_tree)
-
-      if infered_type
-        Value.new(infered_type)
-      else
-        nil
-      end
-    }.condition{|*x| tree = x.first; 
-      next false unless tree.node_type == :call
-      method_name = tree[2]
-      next false unless method_name == :_class
-      true
-    }
-  end
-end

data/lib/fastruby/modules/translator/variable.rb~

@@ -1,280 +0,0 @@
-=begin
-
-This file is part of the fastruby project, http://github.com/tario/fastruby
-
-Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
-
-fastruby is free software: you can redistribute it and/or modify
-it under the terms of the gnu general public license as published by
-the free software foundation, either version 3 of the license, or
-(at your option) any later version.
-
-fastruby is distributed in the hope that it will be useful,
-but without any warranty; without even the implied warranty of
-merchantability or fitness for a particular purpose.  see the
-gnu general public license for more details.
-
-you should have received a copy of the gnu general public license
-along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
-
-=end
-module FastRuby
-  class Context
-    define_translator_for(:cvar, :method => :to_c_cvar, :arity => 1)
-    def to_c_cvar(tree)
-      "rb_cvar_get(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]})"
-    end
-
-    define_translator_for(:cvasgn, :method => :to_c_cvasgn)
-    def to_c_cvasgn(tree, result_var = nil)
-      if result_var
-        "
-          {
-            VALUE recv = CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self;
-
-            #{to_c tree[2], result_var};
-            
-            #{if RUBY_VERSION =~ /^1\.9/
-              "rb_cvar_set(recv,#{intern_num tree[1]},#{result_var});"
-              elsif RUBY_VERSION =~ /^1\.8/
-              "rb_cvar_set(recv,#{intern_num tree[1]},#{result_var},Qfalse);"
-              else
-                raise RuntimeError, "unsupported ruby version #{RUBY_VERSION}"
-              end 
-            }
-          }
-       "
-      else
-      "__rb_cvar_set(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]},#{to_c tree[2]},Qfalse)"
-      end
-    end
-
-    define_translator_for(:gvar, :method => :to_c_gvar, :arity => 1)
-    def to_c_gvar(tree)
-      if (tree[1] == :$!)
-        "pframe->thread_data->exception"
-      else
-        "rb_gvar_get((struct global_entry*)#{global_entry(tree[1])})"
-      end
-    end
-
-    define_translator_for(:gasgn, :method => :to_c_gasgn)
-    def to_c_gasgn(tree, result_var = nil)
-      if result_var
-          "
-          {
-          #{to_c tree[2], result_var}; 
-          rb_gvar_set((void*)#{global_entry(tree[1])},#{result_var});
-          }
-          "
-      else
-      "_rb_gvar_set((void*)#{global_entry(tree[1])}, #{to_c tree[2]})"
-      end
-    end
-
-    define_translator_for(:ivar, :method => :to_c_ivar, :arity => 1)
-    def to_c_ivar(tree)
-      "rb_ivar_get(#{locals_accessor}self,#{intern_num tree[1]})"
-    end
-
-    define_translator_for(:iasgn, :method => :to_c_iasgn)
-    def to_c_iasgn(tree, result_var = nil)
-      if result_var
-          "
-          {
-          #{to_c tree[2], result_var}; 
-          rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{result_var});
-          }
-          "
-      else
-        "_rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{to_c tree[2]})"
-      end
-    end
-
-    define_translator_for(:const, :arity => 1) do |tree|
-      "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
-    end
-    
-    define_translator_for(:cdecl, :method => :to_c_cdecl)
-    def to_c_cdecl(tree, result_var_ = nil)
-      
-      result_var = result_var_ || "value"
-      
-      if tree[1].instance_of? Symbol
-        code = proc{"
-          {
-            // set constant #{tree[1].to_s}
-            #{to_c tree[2], result_var};
-            rb_const_set(rb_cObject, #{intern_num tree[1]}, #{result_var});
-          }
-          "}
-      elsif tree[1].instance_of? FastRuby::FastRubySexp
-
-        if tree[1].node_type == :colon2
-          code = proc{"
-            {
-              // set constant #{tree[1].to_s}
-              #{to_c tree[2], result_var};
-              VALUE klass = Qnil;
-              #{to_c tree[1][1], "klass"};
-              rb_const_set(klass, #{intern_num tree[1][2]}, #{result_var});
-            }
-            "}
-        elsif tree[1].node_type == :colon3
-          code = proc{"
-            {
-            // set constant #{tree[1].to_s}
-            #{to_c tree[2], result_var};
-            rb_const_set(rb_cObject, #{intern_num tree[1][1]}, #{result_var});
-            }
-            "}
-        end
-      end
-
-        if result_var_
-          code.call
-        else
-           inline_block{"VALUE #{result_var} = Qnil;\n" + code.call + "
-            return #{result_var};
-           "}
-        end
-    end
-
-    define_translator_for(:colon3, :method => :to_c_colon3, :arity => 1)
-    def to_c_colon3(tree)
-      "rb_const_get_from(rb_cObject, #{intern_num tree[1]})"
-    end
-   
-    define_translator_for(:colon2, :method => :to_c_colon2) 
-    def to_c_colon2(tree, result_var = nil)
-      code = proc{ "
-        {
-        VALUE klass = Qnil;
-        
-        #{to_c tree[1],"klass"};
-            #{
-            if result_var
-              "#{result_var} = Qnil;"
-            end
-          }
-
-      if (rb_is_const_id(#{intern_num tree[2]})) {
-        switch (TYPE(klass)) {
-          case T_CLASS:
-          case T_MODULE:
-            #{
-            if result_var
-              "#{result_var} = rb_const_get_from(klass, #{intern_num tree[2]});"
-            else
-              "return rb_const_get_from(klass, #{intern_num tree[2]});"
-            end
-            }
-            break;
-          default:
-            #{_raise("rb_eTypeError","not a class/module")};
-            break;
-        }
-      }
-      else {
-            #{
-            if result_var
-              "#{result_var} = rb_funcall(klass, #{intern_num tree[2]}, 0, 0);"
-            else
-              "return rb_funcall(klass, #{intern_num tree[2]}, 0, 0);"
-            end
-            }
-      }
-        
-            #{
-            unless result_var
-              "return Qnil;"
-            end
-            }
-        }
-      "}
-      
-      if result_var
-        code.call
-      else
-        inline_block &code
-      end
-    end
-
-    define_translator_for(:lasgn, :method => :to_c_lasgn)
-    def to_c_lasgn(tree, result_var = nil)
-      code = "
-          {
-            #{to_c tree[2], result_var};
-            #{locals_accessor}#{tree[1]} = #{result_var};
-           }
-           "
-
-      if result_var
-        code
-      else
-        "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
-      end
-    end
-    
-    define_translator_for(:lvar, :arity => 1) do |tree|
-      locals_accessor + tree[1].to_s
-    end
-
-    define_translator_for(:defined, :method => :to_c_defined, :arity => 1)
-    def to_c_defined(tree)
-      obj_tree = tree[1] 
-      
-      if obj_tree[0] == :call && obj_tree[2] == :infer
-        obj_tree = obj_tree[1]
-      end
-      
-      nt = obj_tree.node_type
-
-      if nt == :self
-      'rb_str_new2("self")'
-      elsif nt == :true
-      'rb_str_new2("true")'
-      elsif nt == :false
-      'rb_str_new2("false")'
-      elsif nt == :nil
-      'rb_str_new2("nil")'
-      elsif nt == :lvar
-      'rb_str_new2("local-variable")'
-      elsif nt == :gvar
-      "rb_gvar_defined((struct global_entry*)#{global_entry(obj_tree[1])}) ? #{literal_value "global-variable"} : Qnil"
-      elsif nt == :const
-      "rb_const_defined(rb_cObject, #{intern_num obj_tree[1]}) ? #{literal_value "constant"} : Qnil"
-      elsif nt == :call
-        if RUBY_VERSION =~ /^1\.8/
-        "rb_method_node(CLASS_OF(#{to_c obj_tree[1]}), #{intern_num obj_tree[2]}) ? #{literal_value "method"} : Qnil"
-        else
-        "rb_method_entry(CLASS_OF(#{to_c obj_tree[1]}), #{intern_num obj_tree[2]}) ? #{literal_value "method"} : Qnil"
-        end
-      elsif nt == :yield
-        "rb_block_given_p() ? #{literal_value "yield"} : Qnil"
-      elsif nt == :ivar
-      "rb_ivar_defined(plocals->self,#{intern_num obj_tree[1]}) ? #{literal_value "instance-variable"} : Qnil"
-      elsif nt == :attrset or
-            nt == :op_asgn1 or
-            nt == :op_asgn2 or
-            nt == :op_asgn_or or
-            nt == :op_asgn_and or
-            nt == :op_asgn_masgn or
-            nt == :masgn or
-            nt == :lasgn or
-            nt == :dasgn or
-            nt == :dasgn_curr or
-            nt == :gasgn or
-            nt == :iasgn or
-            nt == :cdecl or
-            nt == :cvdecl or
-            nt == :cvasgn
-        literal_value "assignment"
-      else
-        literal_value "expression"
-      end
-    end
-
-    
-  end
-end

data/lib/fastruby/set_tree.rb~

@@ -1,71 +0,0 @@
-=begin
-
-This file is part of the fastruby project, http://github.com/tario/fastruby
-
-Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
-
-fastruby is free software: you can redistribute it and/or modify
-it under the terms of the gnu general public license as published by
-the free software foundation, either version 3 of the license, or
-(at your option) any later version.
-
-fastruby is distributed in the hope that it will be useful,
-but without any warranty; without even the implied warranty of
-merchantability or fitness for a particular purpose.  see the
-gnu general public license for more details.
-
-you should have received a copy of the gnu general public license
-along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
-
-=end
-require "fastruby/builder"
-require "fastruby/getlocals"
-require "fastruby/method_extension"
-
-module FastRuby
-
-  def self.make_str_signature(method_name, signature)
-    "_" + method_name.to_s + signature.map(&:__id__).map(&:to_s).join
-  end
-
-  def self.set_builder_module(klass)
-    klass.class_eval do
-      class << self
-        include FastRuby::BuilderModule
-      end
-    end
-  end
-  
-  def self.unset_tree(klass, method_name)
-    fastrubym = klass.fastruby_method(method_name)
-    fastrubym.tree = nil
-    fastrubym.tree_changed
-    nil
-  end
-
-  def self.set_tree(klass, method_name, tree, options = {})
-    unless options[:skip_reduce]
-      unless defined? Reductor
-        require "fastruby/builder/reductor"
-      end
-      
-      tree = Reductor.new.reduce(tree)
-    end
-
-    klass.class_eval do
-      class << self
-        include FastRuby::BuilderModule
-      end
-    end
-
-    fastrubym = klass.fastruby_method(method_name)
-    
-    fastrubym.tree = tree
-    fastrubym.options = options
-    fastrubym.tree_changed
- require "pry"; binding.pry
-
-
-    nil
-  end
-end