fastruby 0.0.3 → 0.0.4

data/CHANGELOG

@@ -0,0 +1,21 @@
+0.0.4	Basic support fot non-local goto: return, break, next
+
+		Basic support for exceptions
+
+		Support for defined?
+
+		Support for modules
+
+		Support for singleton methods
+
+0.0.3	Implemented global array to make references to literal objects used in code
+
+		Added support to write and read constants
+
+		Added support to execution of complete ruby code (entire clases o any ruby code)
+
+		Refactored code to avoid use sexp_processor
+
+0.0.2	Added missing sexp_processor dependency
+
+0.0.1	First test release

data/README

@@ -55,11 +55,10 @@ I will stabilize the API and document it for next releases. I promise
 
 == Known Limitations & Issues
 
+* Bootstrap is very slow since this is a Poc :P
 * monkey patching does not work with fastruby methods
 * calls with blocks to ruby or cruby methods are almost as slow as normal ruby (if the called method is defined by fastruby, the call it's pretty fast)
-* does not support singleton methods (both define & call)
 * does not support methods with variable number of arguments
-* does not support exception handling (rescue, ensure, etc...)
 
 == Usage
 

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.3'
+  s.version = '0.0.4'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY
@@ -19,7 +19,7 @@ spec = Gem::Specification.new do |s|
   s.extra_rdoc_files = [ 'README' ]
 #  s.rdoc_options << '--main' << 'README'
   s.files = Dir.glob("{benchmarks,examples,lib,spec}/**/*") +
-    [ 'LICENSE', 'AUTHORS', 'README', 'Rakefile', 'TODO' ]
+    [ 'LICENSE', 'AUTHORS', 'README', 'Rakefile', 'TODO', 'CHANGELOG' ]
 end
 
 desc 'Run tests'

data/TODO

@@ -1,10 +1,8 @@
 Basic functionality:
 
 * Flow control setences: case
-* Exceptions
 * Defining and call of methods with variable number of arguments
 * Blocks with variable number of arguments
-* call to monkey patched methods from fastruby code
 * callcc
 
 To improve:

data/lib/fastruby/builder.rb

@@ -22,9 +22,27 @@ require "fastruby/translator"
 require "fastruby/inline_extension"
 require "fastruby/method_extension"
 require "fastruby/logging"
+require "fastruby/getlocals"
 
 module FastRuby
 
+  def self.build_defs(tree, *options)
+    method_name = tree[2].to_s
+
+    FastRuby.logger.info "Building singleton method #{self}::#{@method_name}"
+
+    locals = GetLocalsProcessor.get_locals(tree)
+    locals << :self
+
+    context = FastRuby::Context.new(false)
+    context.locals = locals
+    context.options = options
+
+    context.alt_method_name = "singleton_" + method_name + rand(100000000).to_s
+
+    [context.extra_code + context.to_c_method_defs(tree), context.alt_method_name]
+  end
+
   class Method
     attr_accessor :tree
     attr_accessor :locals
@@ -43,7 +61,7 @@ module FastRuby
       begin
         if (@owner.instance_method(mname))
           FastRuby.logger.info "NOT Building #{self}::#{@method_name} for signature #{signature.inspect}, it's already done"
-          return
+          return @owner.instance_method(mname)
         end
       rescue NameError
         FastRuby.logger.info "Building #{self}::#{@method_name} for signature #{signature.inspect}"

data/lib/fastruby/custom_require.rb

@@ -0,0 +1,48 @@
+=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 Kernel
+  def fastruby_require(path)
+    if path =~ /\.so$/
+      require(path)
+    else
+      FastRuby.logger.info "trying to load '#{path}'"
+
+      complete_path = path + (path =~ /\.rb$/ ? "" : ".rb")
+
+      $LOAD_PATH.each do |load_path|
+        begin
+          source = nil
+          File.open(load_path + "/" + complete_path) do |file|
+            source = file.read
+          end
+
+          FastRuby.logger.info "loading '#{load_path + "/" + complete_path}'"
+
+          fastruby source
+          return true
+        rescue Errno::ENOENT
+        end
+      end
+
+      raise LoadError
+    end
+  end
+end

data/lib/fastruby/object.rb

@@ -62,13 +62,25 @@ class Object
       raise ArgumentError
     end
 
+    return unless tree
+
     if tree[0] == :class
       classname = Object.to_class_name tree[1]
 
-      eval("
-      class #{classname}
+      if tree[2]
+        superclassname = Object.to_class_name tree[2]
+
+        eval("
+        class #{classname} < #{superclassname}
+        end
+        ", $top_level_binding)
+
+      else
+        eval("
+        class #{classname}
+        end
+        ", $top_level_binding)
       end
-      ", $top_level_binding)
 
       klass = eval(classname)
 
@@ -83,6 +95,29 @@ class Object
       end
 
       klass.send(method_name)
+    elsif tree[0] == :module
+      modulename = Object.to_class_name tree[1]
+
+      eval("
+      module #{modulename}
+      end
+      ", $top_level_binding)
+
+      klass = eval(modulename)
+
+      method_name = "_anonymous_" + rand(100000000000).to_s
+      $generated_tree = FastRuby.encapsulate_tree(tree[2],method_name)
+      $options_hashes = options_hashes
+
+      klass.class_eval do
+        class << self
+           fastruby $generated_tree, *$options_hashes
+        end
+      end
+
+      klass.send(method_name)
+    elsif tree[0] == :defn
+      Object.fastruby_defn(tree, *options_hashes)
     else
       method_name = "_anonymous_" + rand(100000000000).to_s
       Object.fastruby(FastRuby.encapsulate_tree(tree,method_name), *options_hashes)
@@ -90,6 +125,10 @@ class Object
     end
   end
 
+  def self.fastruby_defs(*args)
+    raise NoMethodError, "not implemented yet"
+  end
+
   def self.fastruby(argument,*options_hashes)
 
     tree = nil
@@ -102,6 +141,8 @@ class Object
       raise ArgumentError
     end
 
+    return unless tree
+
     if tree.node_type == :defn
       fastruby_defn(tree,*options_hashes)
     else
@@ -173,7 +214,7 @@ class Object
 
     eval("#{hashname} = hash")
 
-    value_cast = ( ["VALUE"]*(args_tree.size+1) ).join(",")
+    value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
 
     main_signature_argument = args_tree[1..-1].first || "self"
 
@@ -181,9 +222,9 @@ class Object
     strmethodargs_class = (["self"] + args_tree[1..-1]).map{|arg| "CLASS_OF(#{arg.to_s})"}.join(",")
 
     if args_tree.size > 1
-      strmethodargs = "self,block,#{args_tree[1..-1].map(&:to_s).join(",") }"
+      strmethodargs = "self,block,(VALUE)&frame,#{args_tree[1..-1].map(&:to_s).join(",") }"
     else
-      strmethodargs = "self,block"
+      strmethodargs = "self,block,(VALUE)&frame"
     end
 
     strmethod_signature = (["self"] + args_tree[1..-1]).map { |arg|
@@ -217,6 +258,22 @@ class Object
       }
 
         if (nd_type(body) == NODE_CFUNC) {
+          struct {
+            void* parent_frame;
+            void* target_frame;
+            void* plocals;
+            jmp_buf jmp;
+            VALUE return_value;
+            VALUE exception;
+            int rescue;
+          } frame;
+
+          frame.target_frame = 0;
+          frame.parent_frame = 0;
+          frame.rescue = 0;
+          frame.exception = Qnil;
+          frame.return_value = Qnil;
+
           int argc = body->nd_argc;
 
           VALUE block = Qfalse;
@@ -233,13 +290,19 @@ class Object
             block = (VALUE)&block_struct;
           }
 
-          if (argc == #{args_tree.size}) {
+          int aux = setjmp(frame.jmp);
+          if (aux != 0) {
+            rb_funcall(self, #{:raise.to_i}, 1, frame.exception);
+            return Qnil;
+          }
+
+          if (argc == #{args_tree.size+1}) {
             return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
           } else if (argc == -1) {
-            VALUE argv[] = {#{(["block"]+args_tree[1..-1]).map(&:to_s).join(",")} };
+            VALUE argv[] = {#{(["block,(VALUE)&frame"]+args_tree[1..-1]).map(&:to_s).join(",")} };
             return ((VALUE(*)(int,VALUE*,VALUE))body->nd_cfnc)(#{args_tree.size},argv,self);
           } else if (argc == -2) {
-            VALUE argv[] = {#{(["block"]+args_tree[1..-1]).map(&:to_s).join(",")} };
+            VALUE argv[] = {#{(["block,(VALUE)&frame"]+args_tree[1..-1]).map(&:to_s).join(",")} };
             return ((VALUE(*)(VALUE,VALUE))body->nd_cfnc)(self, rb_ary_new4(#{args_tree.size},argv));
           } else {
             rb_raise(rb_eArgError, \"wrong number of arguments (#{args_tree.size-1} for %d)\", argc);
@@ -251,7 +314,7 @@ class Object
 
     inline :C  do |builder|
       builder.include "<node.h>"
-      builder.inc << "static VALUE re_yield(int argc, VALUE* argv, VALUE param) {
+      builder.inc << "static VALUE re_yield(int argc, VALUE* argv, VALUE param, VALUE _parent_frame) {
         return rb_yield_splat(rb_ary_new4(argc,argv));
       }"
       builder.c c_code