fastruby 0.0.19 → 0.0.20

data/lib/fastruby/{translator/modules/call.rb → modules/translator/call.rb~}

@@ -20,7 +20,6 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 =end
 module FastRuby
   class Context
-
     define_translator_for(:call, :method => :to_c_call)
     def to_c_call(tree, result_var = nil)
       repass_var = @repass_var
@@ -30,6 +29,29 @@ module FastRuby
       args = tree[3]
       args_tree = tree[3]
       
+      if mname == :_class
+        if result_var
+          return "#{result_var} = CLASS_OF(#{to_c(recv)});"
+        else
+          return "CLASS_OF(#{to_c(recv)})"
+        end
+      end
+      
+      if mname == :_raise
+        if result_var
+          return "
+            #{_raise(to_c(args_tree[1]), "")};
+            #{result_var} = Qnil;
+          "
+        else
+          return inline_block lambda{"
+            #{_raise(to_c(args_tree[1]), "")};
+            return Qnil;
+          "}
+        end
+      end
+        
+ 
       # search block_pass on arguments
       block_pass_arg = args.find{|arg| if arg == :arglist
             false
@@ -57,7 +79,7 @@ module FastRuby
       recvtype = infer_type(recv)
       
       if args.size > 1
-        if (not recvtype) or args.last[0] == :splat
+        if (not recvtype) or args.last[0] == :splat or true
           if block_pass_arg
             call_tree = tree.dup
             call_tree[3] = args.select{|arg| if arg == :arglist 
@@ -74,7 +96,6 @@ module FastRuby
                 s(:lasgn, :__x_proc, s(:call, block_pass_arg[1], :to_proc, s(:arglist))),
                 s(:iter, call_tree, block_arguments_tree, block_tree)
                 ).to_fastruby_sexp
-          
             if result_var  
               return to_c(replace_iter_tree,result_var)
             else

data/lib/fastruby/{translator/modules → modules/translator}/defn.rb

@@ -44,15 +44,18 @@ module FastRuby
       
       
         if (rb_obj_is_kind_of(plocals->self, rb_cClass) || rb_obj_is_kind_of(plocals->self, rb_cModule)) {
-          rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);
+
+          #{unless options[:fastruby_only]
+           "rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);"
+          end
+          }
           
           #{global_klass_variable} = plocals->self;
           // set tree
-          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
+          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
                   #{global_klass_variable},
                   rb_str_new2(#{method_name.to_s.inspect}),
                   #{literal_value tree},
-                  #{literal_value snippet_hash},
                   #{literal_value alt_options}
   
                   );
@@ -63,11 +66,10 @@ module FastRuby
           
           #{global_klass_variable} = CLASS_OF(obj);
           // set tree
-          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
+          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
                   #{global_klass_variable},
                   rb_str_new2(#{method_name.to_s.inspect}),
                   #{literal_value tree},
-                  #{literal_value snippet_hash},
                   #{literal_value alt_options}
   
                   );
@@ -109,11 +111,10 @@ module FastRuby
         
         #{global_klass_variable} = CLASS_OF(obj);
         // set tree
-        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
+        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
                 #{global_klass_variable},
                 rb_str_new2(#{method_name.to_s.inspect}),
                 #{literal_value tree},
-                #{literal_value snippet_hash},
                 #{literal_value alt_options}
 
                 );
@@ -155,11 +156,11 @@ private
           method_name[1] = 0;
 
           sprintf(method_name+1, \"#{method_name}\");
-          sprintf(method_name+strlen(method_name), \"%lu\", (unsigned long)NUM2PTR(rb_obj_id(CLASS_OF(self))));
+          sprintf(method_name+strlen(method_name), \"%li\", (long)NUM2PTR(rb_obj_id(CLASS_OF(self))));
           
                       int i;
                       for (i=0; i<argc_; i++) {
-                        sprintf(method_name+strlen(method_name), \"%lu\", (unsigned long)NUM2PTR(rb_obj_id(CLASS_OF(argv[i]))));
+                        sprintf(method_name+strlen(method_name), \"%li\", (long)NUM2PTR(rb_obj_id(CLASS_OF(argv[i]))));
                       }
 
           void** address = 0;

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

@@ -0,0 +1,267 @@
+=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(:defn, :method => :to_c_defn)
+    def to_c_defn(tree, result_var = nil)
+
+      method_name = tree[1]
+      args_tree = tree[2].select{|x| x.to_s[0] != ?&}
+      
+      global_klass_variable = add_global_name("VALUE", "Qnil");
+
+      hash = Hash.new
+      value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
+      
+      strmethodargs = "self,block,(VALUE)&frame"
+      
+      anonymous_method_name = anonymous_dispatcher(global_klass_variable, method_name)
+      alt_options = options.dup
+
+      alt_options.delete(:self)
+      alt_options.delete(:main)
+
+      code = "
+      
+      
+        if (rb_obj_is_kind_of(plocals->self, rb_cClass) || rb_obj_is_kind_of(plocals->self, rb_cModule)) {
+
+          #{unless options[:fastruby_only]
+           "rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);"
+          end
+          }
+          
+          #{global_klass_variable} = plocals->self;
+          // set tree
+          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
+                  #{global_klass_variable},
+                  rb_str_new2(#{method_name.to_s.inspect}),
+                  #{literal_value tree},
+                  #{literal_value alt_options}
+  
+                  );
+          
+        } else {
+          VALUE obj = plocals->self;
+          rb_define_singleton_method(obj, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+          
+          #{global_klass_variable} = CLASS_OF(obj);
+          // set tree
+          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
+                  #{global_klass_variable},
+                  rb_str_new2(#{method_name.to_s.inspect}),
+                  #{literal_value tree},
+                  #{literal_value alt_options}
+  
+                  );
+        }
+        
+        "
+
+      if result_var
+        code + "\n#{result_var} = Qnil;"
+      else
+        inline_block code + "\nreturn Qnil;\n"
+      end
+    end
+
+    define_translator_for(:defs, :method => :to_c_defs)
+    def to_c_defs(tree, result_var = nil)
+      method_name = tree[2]
+      args_tree = tree[3].select{|x| x.to_s[0] != ?&}
+      
+      global_klass_variable = add_global_name("VALUE", "Qnil");
+
+      hash = Hash.new
+      value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
+      
+      strmethodargs = "self,block,(VALUE)&frame"
+      
+      anonymous_method_name = anonymous_dispatcher(global_klass_variable, method_name)
+
+      alt_options = options.dup
+
+      alt_options.delete(:self)
+      alt_options.delete(:main)
+
+      code = "
+      
+        VALUE obj = Qnil;
+        #{to_c tree[1], "obj"};
+        rb_define_singleton_method(obj, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+        
+        #{global_klass_variable} = CLASS_OF(obj);
+        // set tree
+        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
+                #{global_klass_variable},
+                rb_str_new2(#{method_name.to_s.inspect}),
+                #{literal_value tree},
+                #{literal_value alt_options}
+
+                );
+
+        "
+
+      if result_var
+        code + "\n#{result_var} = Qnil;"
+      else
+        inline_block code + "\nreturn Qnil;\n"
+      end
+        
+    end
+
+    define_translator_for(:scope, :method => :to_c_scope)
+    def to_c_scope(tree, result_var = nil)
+      if tree[1]
+        if result_var
+          to_c(tree[1], result_var)
+        else
+          to_c(tree[1])
+        end
+      else
+        "Qnil"
+      end
+    end
+    
+private
+ 
+    def anonymous_dispatcher(global_klass_variable, method_name)
+      
+      strmethodargs = "self,block,(VALUE)&frame"
+      
+      anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
+          VALUE klass = #{global_klass_variable};
+          char method_name[argc_*40+64];
+
+          method_name[0] = '_';
+          method_name[1] = 0;
+
+          sprintf(method_name+1, \"#{method_name}\");
+          sprintf(method_name+strlen(method_name), \"%l\", (long)NUM2PTR(rb_obj_id(CLASS_OF(self))));
+          
+                      int i;
+                      for (i=0; i<argc_; i++) {
+                        sprintf(method_name+strlen(method_name), \"%l\", (long)NUM2PTR(rb_obj_id(CLASS_OF(argv[i]))));
+                      }
+
+          void** address = 0;
+          void* fptr = 0;
+          ID id;
+          VALUE rb_method_hash;
+
+          id = rb_intern(method_name);
+          rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value method_name});
+          
+          if (rb_method_hash != Qnil) {
+            VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
+            if (tmp != Qnil) {
+                address = (void**)NUM2PTR(tmp);
+                fptr = *address;
+            }
+          }
+
+          if (fptr == 0) {
+                          VALUE argv_class[argc_+1];
+                          
+                          argv_class[0] = CLASS_OF(self); 
+                          for (i=0; i<argc_; i++) {
+                            argv_class[i+1] = CLASS_OF(argv[i]);
+                          }
+                          
+                          VALUE signature = rb_ary_new4(argc_+1,argv_class);
+            
+            rb_funcall(#{global_klass_variable}, #{intern_num :build}, 2, signature,rb_str_new2(#{method_name.to_s.inspect}));
+  
+            id = rb_intern(method_name);
+            rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value method_name});
+            
+            if (rb_method_hash != Qnil) {
+              VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
+              if (tmp != Qnil) {
+                  address = (void**)NUM2PTR(tmp);
+                  fptr = *address;
+              }
+            }
+            
+            if (fptr == 0) {
+              rb_raise(rb_eRuntimeError, \"Error: method not found after build\");
+            }
+
+          }
+
+              struct {
+                void* parent_frame;
+                void* plocals;
+                jmp_buf jmp;
+                VALUE return_value;
+                int rescue;
+                VALUE last_error;
+                VALUE next_recv;
+                int targetted;
+                struct FASTRUBYTHREADDATA* thread_data;
+              } frame;
+
+              frame.parent_frame = 0;
+              frame.rescue = 0;
+              frame.return_value = Qnil;
+              frame.thread_data = rb_current_thread_data();
+              frame.targetted = 0;
+
+              volatile VALUE block = Qfalse;
+
+              if (rb_block_given_p()) {
+                struct {
+                  void* block_function_address;
+                  void* block_function_param;
+                  VALUE proc;
+                } block_struct;
+
+                block_struct.block_function_address = re_yield;
+                block_struct.block_function_param = 0;
+                block_struct.proc = rb_block_proc();
+
+                block = (VALUE)&block_struct;
+              }
+
+              int aux = setjmp(frame.jmp);
+              if (aux != 0) {
+                if (aux == FASTRUBY_TAG_RAISE) {
+                  rb_funcall(self, #{intern_num :raise}, 1, frame.thread_data->exception);
+                }
+
+                if (frame.targetted == 0) {
+                    frb_jump_tag(aux);
+                }
+
+                return Qnil;
+              }
+              
+              VALUE tmp = Qnil;
+              if (argv == 0) argv = &tmp;
+
+              return ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))fptr)(#{strmethodargs}, argc_, argv);
+        }"
+      }
+      
+    end
+  end
+end

data/lib/fastruby/{translator/modules → modules/translator}/directive.rb

@@ -21,7 +21,9 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 module FastRuby
   class Context
 
-    define_translator_for(:call, :priority => 100){ |tree, result_var=nil|
+    define_translator_for(:call, :priority => 100){ |*x|
+      tree, result_var = x
+
       directive_code = directive(tree)
 
       if result_var

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

@@ -0,0 +1,44 @@
+=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(:call, :priority => 100){ |*x|
+      tree, result_var = x
+
+      directive_code = directive(tree)
+
+      if result_var
+        return "#{result_var} = #{directive_code};\n"
+      else
+        return directive_code
+      end
+      
+    }.condition{|*x|
+      tree = x.first; tree.node_type == :call && directive(tree)
+    }
+
+    define_translator_for(:call, :method => :to_c_attrasgn, :arity => 1)
+    def to_c_attrasgn(tree)
+      to_c_call(tree)
+    end
+  end
+end

data/lib/fastruby/{translator/modules → modules/translator}/exceptions.rb

@@ -107,7 +107,9 @@ module FastRuby
       end
     end
 
-    define_translator_for(:call, :priority => 100){ |tree, result_var=nil|
+    define_translator_for(:call, :priority => 100){ |*x|
+      tree, result_var = x
+
       # raise code
       args = tree[3]
       _raise(args[1],args[2])

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

@@ -0,0 +1,120 @@
+=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(:rescue, :method => :to_c_rescue, :arity => 1)
+    def to_c_rescue(tree)
+      catch_on_throw do
+        if tree[1][0] == :resbody
+          else_tree = tree[2]
+  
+          if else_tree
+            to_c else_tree
+          else
+            "Qnil"
+          end
+        else
+          resbody_tree = tree[2]
+          else_tree = nil
+          if tree[-1]
+            if tree[-1][0] != :resbody
+              else_tree = tree[-1]
+            end
+          end
+  
+          catch_condition_array = []
+          lasgn_code = ""
+          resbody_code = to_c(resbody_tree[2])
+  
+          rescue_code = ""
+  
+          tree[1..-1].each do |resbody_tree|
+            next if resbody_tree[0] != :resbody
+  
+            if resbody_tree[1].size == 1
+              resbody_tree[1][1] = s(:const, :Exception)
+            end
+  
+            if resbody_tree[1].last[0] == :lasgn
+              lasgn_code = to_c(resbody_tree[1].last)
+            end
+  
+            resbody_tree[1][1..-1].each do |xtree|
+              if xtree[0] != :lasgn
+                trapcode = "rb_eException";
+  
+                if xtree
+                  trapcode = to_c(xtree)
+                end
+  
+                catch_condition_array << "(rb_obj_is_kind_of(frame.thread_data->exception,#{trapcode}) == Qtrue)"
+              end
+            end
+  
+            rescue_code << "
+              if (aux == FASTRUBY_TAG_RAISE) {
+                if (#{catch_condition_array.join(" || ")})
+                {
+                  // trap exception
+                  frame.targetted = 1;
+  
+                  #{lasgn_code};
+  
+                   #{resbody_code};
+                }
+              }
+            "
+          end
+  
+          frame_call(
+            "ret = " + frame(to_c(tree[1])+";","
+              #{rescue_code}
+            ", else_tree ? to_c(else_tree) : nil, 1)
+  
+            )
+        end
+      end
+    end
+
+    define_translator_for(:ensure, :method => :to_c_ensure, :arity => 1)
+    def to_c_ensure(tree)
+      if tree.size == 2
+        to_c tree[1]
+      else
+        ensured_code = to_c tree[2]
+        inline_block {
+          "#{frame(to_c(tree[1]),ensured_code,ensured_code,1)};"
+        }
+      end
+    end
+
+    define_translator_for(:call, :priority => 100){ |*x|
+      tree, result_var = x
+
+      # raise code
+      args = tree[3]
+      _raise(args[1],args[2])
+    }.condition{|*x|
+      tree = x.first; tree.node_type == :call && tree[2] == :raise
+    }
+  end
+end