fastruby 0.0.12 → 0.0.13

data/lib/fastruby/translator/modules/literal.rb

@@ -0,0 +1,86 @@
+=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
+  module LiteralTranslator
+    register_translator_module self
+
+    def to_c_lit(tree)
+      literal_value tree[1]
+    end
+
+    def to_c_nil(tree)
+      "Qnil"
+    end
+
+    def to_c_str(tree)
+      literal_value tree[1]
+    end
+
+    def to_c_hash(tree)
+
+      hash_aset_code = ""
+      (0..(tree.size-3)/2).each do |i|
+        strkey = to_c tree[1 + i * 2]
+        strvalue = to_c tree[2 + i * 2]
+        hash_aset_code << "rb_hash_aset(hash, #{strkey}, #{strvalue});"
+      end
+
+      anonymous_function{ |name| "
+        static VALUE #{name}(VALUE value_params) {
+          #{@frame_struct} *pframe;
+          #{@locals_struct} *plocals;
+          pframe = (void*)value_params;
+          plocals = (void*)pframe->plocals;
+
+          VALUE hash = rb_hash_new();
+          #{hash_aset_code}
+          return hash;
+        }
+      " } + "((VALUE)pframe)"
+    end
+
+    def to_c_array(tree)
+      if tree.size > 1
+        strargs = tree[1..-1].map{|subtree| to_c subtree}.join(",")
+        "rb_ary_new3(#{tree.size-1}, #{strargs})"
+      else
+        "rb_ary_new3(0)"
+      end
+    end
+
+    def to_c_self(tree)
+      locals_accessor + "self"
+    end
+
+    def to_c_false(tree)
+      "Qfalse"
+    end
+
+    def to_c_true(tree)
+      "Qtrue"
+    end
+
+    def to_c_dot2(tree)
+      "rb_range_new(#{to_c tree[1]}, #{to_c tree[2]},0)"
+    end
+    
+  end
+end

data/lib/fastruby/translator/modules/logical.rb

@@ -0,0 +1,38 @@
+=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
+  module LogicalOperatorTranslator
+    register_translator_module self
+
+    def to_c_and(tree)
+      "(RTEST(#{to_c tree[1]}) && RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
+    end
+
+    def to_c_or(tree)
+      "(RTEST(#{to_c tree[1]}) || RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
+    end
+
+    def to_c_not(tree)
+      "RTEST(#{to_c tree[1]}) ? Qfalse : Qtrue"
+    end
+    
+  end
+end

data/lib/fastruby/translator/modules/method_group.rb

@@ -0,0 +1,174 @@
+=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
+  module BlockTranslator
+    register_translator_module self
+    
+    def to_c_class(tree)
+      str_class_name = get_class_name(tree[1])
+      container_tree = get_container_tree(tree[1])
+
+      if container_tree == s(:self)
+        method_group("
+                    VALUE tmpklass = rb_define_class(
+                      #{str_class_name.inspect},
+                      #{tree[2] ? to_c(tree[2]) : "rb_cObject"}
+                  );
+        ", tree[3])
+      else
+        method_group("
+                    VALUE container_klass = #{to_c(container_tree)};
+                    VALUE tmpklass = rb_define_class_under(
+                      container_klass,
+                      #{str_class_name.inspect},
+                      #{tree[2] ? to_c(tree[2]) : "rb_cObject"}
+                  );
+        ", tree[3])
+      end
+    end
+
+    def to_c_module(tree)
+      str_class_name = get_class_name(tree[1])
+      container_tree = get_container_tree(tree[1])
+
+      if container_tree == s(:self)
+        method_group("
+                      VALUE tmpklass = rb_define_module(#{str_class_name.inspect});
+        ", tree[2])
+      else
+        method_group("
+                      VALUE container_klass = #{to_c(container_tree)};
+                      VALUE tmpklass = rb_define_module_under(container_klass,#{str_class_name.inspect});
+        ", tree[2])
+      end
+    end
+    
+private
+    def method_group(init_code, tree)
+
+      alt_locals = Set.new
+      alt_locals << :self
+
+      FastRuby::GetLocalsProcessor.get_locals(tree).each do |local|
+        alt_locals << local
+      end
+
+      fun = nil
+
+      locals_scope(alt_locals) do
+        fun = anonymous_function { |method_name| "static VALUE #{method_name}(VALUE self) {
+
+            #{@frame_struct} frame;
+            typeof(&frame) pframe = &frame;
+            #{@locals_struct} *plocals;
+
+            frame.parent_frame = 0;
+            frame.return_value = Qnil;
+            frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = rb_current_thread_data();
+
+            int stack_chunk_instantiated = 0;
+            VALUE rb_previous_stack_chunk = Qnil;
+            VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
+            struct STACKCHUNK* stack_chunk = 0;
+
+            if (rb_stack_chunk != Qnil) {
+              Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
+            }
+
+            if (stack_chunk == 0 || (stack_chunk == 0 ? 0 : stack_chunk_frozen(stack_chunk)) ) {
+              rb_previous_stack_chunk = rb_stack_chunk;
+              rb_gc_register_address(&rb_stack_chunk);
+              stack_chunk_instantiated = 1;
+
+              rb_stack_chunk = rb_stack_chunk_create(Qnil);
+              frame.thread_data->rb_stack_chunk = rb_stack_chunk;
+
+              rb_ivar_set(rb_stack_chunk, #{intern_num :_parent_stack_chunk}, rb_previous_stack_chunk);
+
+              Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
+            }
+
+            int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
+
+            plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
+
+            frame.plocals = plocals;
+            plocals->active = Qtrue;
+            plocals->self = self;
+            plocals->targetted = Qfalse;
+            plocals->call_frame = LONG2FIX(0);
+
+            #{to_c tree};
+
+            stack_chunk_set_current_position(stack_chunk, previous_stack_position);
+
+            if (stack_chunk_instantiated) {
+              rb_gc_unregister_address(&rb_stack_chunk);
+              frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
+            }
+
+            plocals->active = Qfalse;
+            return Qnil;
+          }
+        "
+        }
+      end
+
+      inline_block("
+        #{init_code}
+
+        rb_funcall(tmpklass, #{intern_num :__id__},0);
+
+        #{fun}(tmpklass);
+        return Qnil;
+
+
+      ")
+
+    end
+
+    def get_class_name(argument)
+      if argument.instance_of? Symbol
+        argument.to_s
+      elsif argument.instance_of? FastRuby::FastRubySexp
+        if argument[0] == :colon3
+          get_class_name(argument[1])
+        elsif argument[0] == :colon2
+          get_class_name(argument[2])
+        end
+      end
+    end
+
+    def get_container_tree(argument)
+      if argument.instance_of? Symbol
+        s(:self)
+      elsif argument.instance_of? FastRuby::FastRubySexp
+        if argument[0] == :colon3
+          s(:const, :Object)
+        elsif argument[0] == :colon2
+          argument[1]
+        end
+      end
+    end
+  end
+end

data/lib/fastruby/translator/modules/nonlocal.rb

@@ -0,0 +1,96 @@
+=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
+  module NonLocalTranslator
+    register_translator_module self
+
+    def to_c_return(tree)
+      inline_block "
+        plocals->return_value = #{to_c(tree[1])};
+        plocals->targetted = 1;
+        longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
+        return Qnil;
+        "
+    end
+
+    def to_c_break(tree)
+        inline_block(
+         "
+
+         VALUE value = #{tree[1] ? to_c(tree[1]) : "Qnil"};
+
+         typeof(pframe) target_frame_;
+         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+
+         if (target_frame_ == 0) {
+            #{_raise("rb_eLocalJumpError","illegal break")};
+         }
+
+         plocals->call_frame = LONG2FIX(0);
+
+         target_frame_->return_value = value;
+         target_frame_->targetted = 1;
+         pframe->thread_data->exception = Qnil;
+         longjmp(pframe->jmp,FASTRUBY_TAG_BREAK);"
+        )
+    end
+
+    def to_c_retry(tree)
+        inline_block(
+         "
+         typeof(pframe) target_frame_;
+         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+
+         if (target_frame_ == 0) {
+            #{_raise("rb_eLocalJumpError","illegal retry")};
+         }
+
+         target_frame_->targetted = 1;
+         longjmp(pframe->jmp,FASTRUBY_TAG_RETRY);"
+        )
+    end
+
+    def to_c_redo(tree)
+      if @on_block
+         inline_block "
+          longjmp(pframe->jmp,FASTRUBY_TAG_REDO);
+          return Qnil;
+          "
+      else
+          _raise("rb_eLocalJumpError","illegal redo");
+      end
+    end
+
+    def to_c_next(tree)
+      if @on_block
+       inline_block "
+        pframe->thread_data->accumulator = #{tree[1] ? to_c(tree[1]) : "Qnil"};
+        longjmp(pframe->jmp,FASTRUBY_TAG_NEXT);
+        return Qnil;
+        "
+      else
+        _raise("rb_eLocalJumpError","illegal next");
+      end
+    end
+
+    
+  end
+end

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

@@ -0,0 +1,190 @@
+=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
+  module VariabeTranslator
+    register_translator_module self
+
+
+    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
+
+    def to_c_cvasgn(tree)
+      "__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
+
+    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
+
+    def to_c_gasgn(tree)
+      "_rb_gvar_set((void*)#{global_entry(tree[1])}, #{to_c tree[2]})"
+    end
+
+    def to_c_ivar(tree)
+      "rb_ivar_get(#{locals_accessor}self,#{intern_num tree[1]})"
+    end
+
+    def to_c_iasgn(tree)
+      "_rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{to_c tree[2]})"
+    end
+
+    def to_c_const(tree)
+      "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
+    end
+    
+    def to_c_cdecl(tree)
+      if tree[1].instance_of? Symbol
+        inline_block "
+          // set constant #{tree[1].to_s}
+          VALUE val = #{to_c tree[2]};
+          rb_const_set(rb_cObject, #{intern_num tree[1]}, val);
+          return val;
+          "
+      elsif tree[1].instance_of? FastRuby::FastRubySexp
+
+        if tree[1].node_type == :colon2
+          inline_block "
+            // set constant #{tree[1].to_s}
+            VALUE val = #{to_c tree[2]};
+            VALUE klass = #{to_c tree[1][1]};
+            rb_const_set(klass, #{intern_num tree[1][2]}, val);
+            return val;
+            "
+        elsif tree[1].node_type == :colon3
+          inline_block "
+            // set constant #{tree[1].to_s}
+            VALUE val = #{to_c tree[2]};
+            rb_const_set(rb_cObject, #{intern_num tree[1][1]}, val);
+            return val;
+            "
+        end
+      end
+    end
+
+    def to_c_colon3(tree)
+      "rb_const_get_from(rb_cObject, #{intern_num tree[1]})"
+    end
+    
+    def to_c_colon2(tree)
+      inline_block "
+        VALUE klass = #{to_c tree[1]};
+
+      if (rb_is_const_id(#{intern_num tree[2]})) {
+        switch (TYPE(klass)) {
+          case T_CLASS:
+          case T_MODULE:
+            return rb_const_get_from(klass, #{intern_num tree[2]});
+            break;
+          default:
+            #{_raise("rb_eTypeError","not a class/module")};
+            break;
+        }
+      }
+      else {
+        return rb_funcall(klass, #{intern_num tree[2]}, 0, 0);
+      }
+
+        return Qnil;
+      "
+    end
+
+    def to_c_lasgn(tree)
+      if options[:validate_lvar_types]
+        klass = @infer_lvar_map[tree[1]]
+        if klass
+
+          verify_type_function = proc { |name| "
+            static VALUE #{name}(VALUE arg, void* pframe ) {
+              if (CLASS_OF(arg)!=#{literal_value klass}) {
+                #{_raise(literal_value(FastRuby::TypeMismatchAssignmentException), "Illegal assignment at runtime (type mismatch)")};
+              }
+              return arg;
+            }
+          "
+          }
+
+
+          "_lvar_assing(&#{locals_accessor}#{tree[1]}, #{anonymous_function(&verify_type_function)}(#{to_c tree[2]},pframe))"
+        else
+          "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+        end
+      else
+        "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+      end
+    end
+
+    def to_c_lvar(tree)
+      locals_accessor + tree[1].to_s
+    end
+
+
+    def to_c_defined(tree)
+      nt = tree[1].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(tree[1][1])}) ? #{literal_value "global-variable"} : Qnil"
+      elsif nt == :const
+      "rb_const_defined(rb_cObject, #{intern_num tree[1][1]}) ? #{literal_value "constant"} : Qnil"
+      elsif nt == :call
+      "rb_method_node(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
+      elsif nt == :yield
+        "rb_block_given_p() ? #{literal_value "yield"} : Qnil"
+      elsif nt == :ivar
+      "rb_ivar_defined(plocals->self,#{intern_num tree[1][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