fastruby 0.0.1

data/examples/example4.rb

@@ -0,0 +1,17 @@
+  require "fastruby"
+  
+  class X
+    fastruby '
+    def foo
+      lvar_type(i, Fixnum)
+      i = 100
+      
+      while (i > 0)
+	    i = i - 1
+      end
+      nil
+    end
+    '
+  end
+
+  X.new.foo

data/lib/fastruby/builder.rb

@@ -0,0 +1,97 @@
+=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/translator"
+require "fastruby/inline_extension"
+require "fastruby/logging"
+
+module FastRuby
+  module BuilderModule
+    def build(signature, method_name)
+      tree = self.method_tree[method_name]
+      locals = self.method_locals[method_name]
+      options = self.method_options[method_name]
+      mname = "_" + method_name.to_s + signature.map(&:internal_value).map(&:to_s).join
+
+      FastRuby.logger.info mname.to_s
+
+      begin
+        if (self.instance_method(mname))
+          FastRuby.logger.info "NOT Building #{self}::#{method_name} for signature #{signature.inspect}, it's already done"
+          return
+        end
+      rescue NameError
+        FastRuby.logger.info "Building #{self}::#{method_name} for signature #{signature.inspect}"
+      end
+
+      context = FastRuby::Context.new
+      context.locals = locals
+      context.options = options
+
+      args_tree = tree[2]
+
+      # create random method name
+      context.alt_method_name = mname
+
+      (1..signature.size).each do |i|
+        arg = args_tree[i]
+        context.infer_lvar_map[arg] = signature[i]
+      end
+
+      context.infer_self = signature[0]
+
+      c_code = context.to_c(tree)
+
+      inline :C  do |builder|
+        builder.inc << context.extra_code
+        builder.include "<node.h>"
+        builder.c c_code
+      end
+
+
+      ret = instance_method(mname)
+
+      ret.extend MethodExtent
+      ret.yield_signature = context.yield_signature
+
+      ret
+    end
+
+    module MethodExtent
+      attr_accessor :yield_signature
+    end
+
+    def method_tree
+      @method_tree = Hash.new unless @method_tree
+      @method_tree
+    end
+
+    def method_locals
+      @method_locals = Hash.new unless @method_locals
+      @method_locals
+    end
+
+    def method_options
+      @method_options = Hash.new unless @method_options
+      @method_options
+    end
+
+  end
+end

data/lib/fastruby/exceptions.rb

@@ -0,0 +1,24 @@
+=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 TypeMismatchAssignmentException < Exception
+  end
+end

data/lib/fastruby/getlocals.rb

@@ -0,0 +1,47 @@
+=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 "rubygems"
+require "sexp_processor"
+require "set"
+
+module FastRuby
+  class GetLocalsProcessor < SexpProcessor
+
+    attr_reader :locals
+
+    def initialize
+      super()
+      self.require_empty = false
+      @locals = Set.new
+    end
+
+    def process_lasgn(tree)
+       @locals << tree[1]
+       tree.dup
+    end
+
+    def self.get_locals(tree)
+      processor = GetLocalsProcessor.new
+      processor.process(tree)
+      processor.locals
+    end
+  end
+end

data/lib/fastruby/inline_extension.rb

@@ -0,0 +1,87 @@
+=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 Inline
+class C
+	attr_reader :inc
+
+    def generate(src, options={})
+      options = {:expand_types=>options} unless Hash === options
+
+      expand_types = options[:expand_types]
+      singleton = options[:singleton]
+      result = self.strip_comments(src)
+
+      signature = parse_signature(src, !expand_types)
+      function_name = signature['name']
+      method_name = options[:method_name]
+      method_name ||= test_to_normal function_name
+      return_type = signature['return']
+      arity = options[:arity] || signature['arity']
+
+      raise ArgumentError, "too many arguments" if arity > MAGIC_ARITY_THRESHOLD
+
+      if expand_types then
+        prefix = "static VALUE #{function_name}("
+        if arity <= MAGIC_ARITY then
+          prefix += "int argc, VALUE *argv, VALUE self"
+        else
+          prefix += "VALUE self"
+          prefix += signature['args'].map { |arg, type| ", VALUE _#{arg}"}.join
+        end
+        prefix += ") {\n"
+        prefix += signature['args'].map { |arg, type|
+          "  #{type} #{arg} = #{ruby2c(type)}(_#{arg});\n"
+        }.join
+
+        # replace the function signature (hopefully) with new sig (prefix)
+        result.sub!(/[^;\/\"\>]+#{function_name}\s*\([^\{]+\{/, "\n" + prefix)
+        result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
+        unless return_type == "void" then
+          raise SyntaxError, "Couldn't find return statement for #{function_name}" unless
+            result =~ /return/
+        else
+          result.sub!(/\s*\}\s*\Z/, "\nreturn Qnil;\n}")
+        end
+      else
+        prefix = "static #{return_type} #{function_name}("
+        result.sub!(/[^;\/\"\>]+#{function_name}\s*\(/, prefix)
+        result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
+      end
+
+      delta = if result =~ /\A(static.*?\{)/m then
+                $1.split(/\n/).size
+              else
+                warn "WAR\NING: Can't find signature in #{result.inspect}\n" unless $TESTING
+                0
+              end
+
+      file, line = caller[1].split(/:/)
+      result = "# line #{line.to_i + delta} \"#{file}\"\n" + result unless $DEBUG and not $TESTING
+
+      @src << result
+      @sig[function_name] = [arity,singleton,method_name]
+
+      return result if $TESTING
+    end # def generate
+
+end
+end
+

data/lib/fastruby/logging.rb

@@ -0,0 +1,37 @@
+=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 "logger"
+
+module FastRuby
+  module SingletonLogger
+    def logger
+      unless @logger
+        @logger = Logger.new(ENV['FASTRUBY_LOG'] || "/dev/stdout")
+        @logger.level = (ENV['FASTRUBY_LOG_LEVEL']||"2").to_i
+      end
+      @logger
+    end
+  end
+
+  class << self
+    include SingletonLogger
+  end
+end

data/lib/fastruby/object.rb

@@ -0,0 +1,168 @@
+=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/translator"
+require "fastruby/builder"
+require "fastruby/getlocals"
+require "ruby_parser"
+require "inline"
+
+# clean rubyinline cache
+system("rm -fr #{ENV["HOME"]}/.ruby_inline/*")
+
+class Object
+  def self.fastruby(rubycode, *options_hashes)
+    tree = RubyParser.new.parse rubycode
+
+    options_hash = {:validate_lvar_types => true}
+    options_hashes.each do |opt|
+      options_hash.merge!(opt)
+    end
+
+    if tree[0] != :defn
+      raise ArgumentError, "Only definition of methods are accepted"
+    end
+
+    method_name = tree[1]
+    args_tree = tree[2]
+
+    hashname = "$hash" + rand(1000000).to_s
+
+    hash = Hash.new
+
+    locals = Set.new
+    locals << :self
+
+    FastRuby::GetLocalsProcessor.get_locals(RubyParser.new.parse(rubycode)).each do |local|
+      locals << local
+    end
+
+    self_ = self
+    hash.instance_eval{@klass = self_}
+    hash.instance_eval{@method_name = method_name}
+
+    class_eval do
+      class << self
+        include FastRuby::BuilderModule
+      end
+    end
+
+    self_.method_tree[method_name] = tree
+    self_.method_locals[method_name] = locals
+    self_.method_options[method_name] = options_hash
+
+    def hash.build(key)
+      @klass.build(key, @method_name)
+    end
+
+    eval("#{hashname} = hash")
+
+    value_cast = ( ["VALUE"]*(args_tree.size+1) ).join(",")
+
+    main_signature_argument = args_tree[1..-1].first || "self"
+
+    strmethodargs = ""
+    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(",") }"
+    else
+      strmethodargs = "self,block"
+    end
+
+    strmethod_signature = (["self"] + args_tree[1..-1]).map { |arg|
+      "sprintf(method_name+strlen(method_name), \"%lu\", CLASS_OF(#{arg}));\n"
+    }.join
+
+    c_code = "VALUE #{method_name}(#{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",")}) {
+      VALUE method_hash = (VALUE)#{hash.internal_value};
+      VALUE klass = (VALUE)#{self.internal_value};
+
+      char method_name[0x100];
+
+      method_name[0] = '_';
+      method_name[1] = 0;
+
+      sprintf(method_name+1, \"#{method_name}\");
+      #{strmethod_signature}
+
+      NODE* body;
+      ID id;
+
+      id = rb_intern(method_name);
+      body = rb_method_node(klass,id);
+
+      if (body == 0) {
+        VALUE argv_class[] = {#{strmethodargs_class} };
+        VALUE signature = rb_ary_new4(#{args_tree.size},argv_class);
+
+        rb_funcall(method_hash, #{:build.to_i}, 1, signature);
+        body = rb_method_node(klass,id);
+      }
+
+        if (nd_type(body) == NODE_CFUNC) {
+          int argc = body->nd_argc;
+
+          VALUE block = Qfalse;
+
+          if (rb_block_given_p()) {
+            struct {
+              void *block_function_address;
+              void *block_function_param;
+            } block_struct;
+
+            block_struct.block_function_address = re_yield;
+            block_struct.block_function_param = 0;
+
+            block = (VALUE)&block_struct;
+          }
+
+          if (argc == #{args_tree.size}) {
+            return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
+          } else if (argc == -1) {
+            VALUE argv[] = {#{(["block"]+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(",")} };
+            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);
+          }
+        }
+
+      return Qnil;
+    }"
+
+    inline :C  do |builder|
+      builder.include "<node.h>"
+      builder.inc << "static VALUE re_yield(int argc, VALUE* argv, VALUE param) {
+        return rb_yield_splat(rb_ary_new4(argc,argv));
+      }"
+      builder.c c_code
+    end
+  end
+
+  inline :C do |builder|
+    builder.c "VALUE internal_value() {
+      return INT2FIX(self);
+    }"
+  end
+end
+