ruby2cext 0.2.0

data/lib/ruby2cext/str_to_c_strlit.rb

@@ -0,0 +1,12 @@
+
+class String
+	C_STRLIT_MAP = (0..255).map { |b| b.chr.inspect[1..-2] }.freeze
+	def to_c_strlit
+		# this might be a bit slow, but #inspect escapes ruby specific stuff,
+		# that generates warnings in C (e.g. '#$' => "\#$")
+		map = C_STRLIT_MAP
+		res = ""
+		each_byte { |b| res << map[b] }
+		"\"#{res}\""
+	end
+end

data/lib/ruby2cext/tools.rb

@@ -0,0 +1,84 @@
+
+require "ruby2cext/str_to_c_strlit"
+require "ruby2cext/error"
+
+module Ruby2CExtension
+
+	module Tools
+		# keeps track of used symbols and provides global variables that hold the corresponding ID
+		class SymbolManager
+			def initialize
+				@syms = {}
+			end
+
+			# returns the var name for sym
+			def get(sym)
+				idx = (@syms[sym] ||= @syms.size)
+				"sym[#{idx}] /* #{sym.to_s.gsub(/[^\w<=>+\-*\/!?@$|&~.]/, "_").gsub("*/", "__")} */"
+			end
+
+			def to_c_code(init_fun_name = "init_syms")
+				res = []
+				res << "static ID sym[#{@syms.size}];" unless @syms.empty?
+				res << "static void #{init_fun_name}() {"
+				@syms.sort_by { |sym, idx| idx }.each { |sym, idx|
+					res << "sym[#{idx}] = rb_intern(#{sym.to_s.to_c_strlit});"
+				}
+				res << "}"
+				res.join("\n")
+			end
+		end
+
+		class GlobalManager
+			def initialize
+				@cnt = 0
+				@src = []
+				@reusable = {}
+			end
+
+			# returns the var name for sym
+			def get(str, allow_reuse, register_gc)
+				if allow_reuse && (name = @reusable[str])
+					return name
+				end
+				name = "global[#{@cnt}]"
+				@cnt += 1
+				@src << "#{name} = #{str};"
+				@src << "rb_global_variable(&(#{name}));" if register_gc
+				if allow_reuse
+					@reusable[str] = name
+				end
+				name
+			end
+
+			def to_c_code(init_fun_name = "init_globals")
+				res = []
+				res << "static VALUE global[#{@cnt}];" if @cnt > 0
+				res << "static void #{init_fun_name}() {"
+				res.concat(@src)
+				res << "}"
+				res.join("\n")
+			end
+		end
+
+		class UniqueNames
+			def initialize
+				@prefix_cnt = Hash.new(0)
+			end
+			def get(prefix)
+				"#{prefix}_#{@prefix_cnt[prefix]+=1}"
+			end
+		end
+
+		module EnsureNodeTypeMixin
+			def ensure_node_type(node, expected_types)
+				expected_types = [expected_types] unless Array === expected_types
+				unless node && expected_types.index(node.first)
+					raise Ruby2CExtError, "unexpected node type: expected #{expected_types.join(" or ")}, found #{node.inspect}"
+				end
+			end
+		end
+
+	end
+
+end

data/lib/ruby2cext/version.rb

@@ -0,0 +1,22 @@
+
+module Ruby2CExtension
+
+	VERSION = "0.2.0"
+
+	FULL_VERSION_STRING = "Ruby2CExtension #{VERSION} (ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}])"
+
+	SUPPORTED_RUBY_VERSIONS = {
+		"1.8.4" => ["2005-12-24"],
+		"1.8.5" => ["2006-08-25", "2006-12-04", "2006-12-25", "2007-03-13", "2007-06-07"],
+		"1.8.6" => ["2007-03-13", "2007-06-07"],
+	}
+
+	if (dates = SUPPORTED_RUBY_VERSIONS[RUBY_VERSION])
+		unless dates.include? RUBY_RELEASE_DATE
+			warn "Ruby2CExtension warning: ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) is an unknown release of Ruby #{RUBY_VERSION}, there might be problems"
+		end
+	else
+		warn "Ruby2CExtension warning: ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) is not supported by Ruby2CExtension #{VERSION}"
+	end
+
+end

data/testfiles/bench.rb

@@ -0,0 +1,116 @@
+# some benchmarks
+
+require "benchmark"
+
+def fib(n)
+	if n < 2
+		n
+	else
+		fib(n - 1) + fib(n - 2)
+	end
+end
+
+def mkmatrix(rows, cols)
+	count = 1
+	mx = Array.new(rows)
+	(0 .. (rows - 1)).each do |bi|
+		row = Array.new(cols, 0)
+		(0 .. (cols - 1)).each do |j|
+			row[j] = count
+			count += 1
+		end
+		mx[bi] = row
+	end
+	mx
+end
+
+def mmult(rows, cols, m1, m2)
+	m3 = Array.new(rows)
+	(0 .. (rows - 1)).each do |bi|
+		row = Array.new(cols, 0)
+		(0 .. (cols - 1)).each do |j|
+			val = 0
+			(0 .. (cols - 1)).each do |k|
+				val += m1.at(bi).at(k) * m2.at(k).at(j)
+			end
+			row[j] = val
+		end
+		m3[bi] = row
+	end
+	m3
+end
+
+def sqrt(x)
+	x = x.to_f
+	average = lambda { |a, b| (a+b)/2 }
+	impr    = lambda { |g| average[g, x/g] }
+	good_en = lambda { |g| (g*g - x).abs < 0.001 }
+	try     = lambda { |g| good_en[g] ? g : try[impr[g]] }
+	try[1.0]
+end
+
+
+Benchmark.bm(10) { |bmx|
+	bmx.report("times") { 3000000.times{|e| e + e } }
+	bmx.report("fib") { fib 30 }
+	bmx.report("array") {
+		n = 2000
+		x = Array.new(n)
+		y = Array.new(n, 0)
+		n.times{|bi| x[bi] = bi + 1 }
+		(0 .. 999).each do |e|
+			(n-1).step(0,-1) do |bi|
+				y[bi] += x.at(bi)
+			end
+		end
+	}
+	bmx.report("matrix") {
+		n = 40
+		size = 30
+		m1 = mkmatrix(size, size)
+		m2 = mkmatrix(size, size)
+		mm = Array.new
+		n.times do
+			mm = mmult(size, size, m1, m2)
+		end
+	}
+	bmx.report("while") {
+		i = 3000000
+		while i > 0
+			break if i == 5
+			i -= 1
+			next if i % 100 == 0
+			redo if (i-=1) % 100 == 1
+		end
+	}
+	bmx.report("sqrt") {
+		i = 40000
+		while (i-=1) > 0
+			sqrt 2
+		end
+	}
+	bmx.report("3 [] alloc") {
+		i = 40000
+		while (i-=1) > 0
+			[[], []]
+		end
+	}
+	bmx.report("const cache") {
+		50000.times {
+			a = Array
+			a = Object::Array
+			a = ::Array
+		}
+	}
+	bmx.report("method calls") {
+		max = 2000
+		z = x = 0
+		while (x+=1) <= max
+			y = 0
+			while (y+=1) <= max
+				z = (x+y-z) % 32000
+			end
+		end
+	}
+	bmx.report("") {  }
+}

data/testfiles/eval2c/test_eval2c.rb

@@ -0,0 +1,37 @@
+
+require "ruby2cext/eval2c"
+
+$e2c = Ruby2CExtension::Eval2C.new
+
+$e2c.toplevel_eval("p __FILE__")
+
+3.times { $e2c.toplevel_eval("p 'hello'") }
+
+class A
+	$e2c.module_eval(self, %{
+		def initialize(x)
+			@x = x
+		end
+		def foo(y)
+			@x + y
+		end
+	})
+end
+
+p A.new(5).foo(6)
+
+p $e2c.instance_eval("4321", "reverse")
+
+p $e2c.compile_to_proc("|a,b| a+b").call(2, 3)
+
+class B
+	def m1; m2; end
+	protected
+	def m2; m3; end
+	private
+	def m3; :m3; end
+
+	$e2c.compile_methods(self, :m1, :m2, :m3)
+end
+
+p B.new.m1

data/testfiles/test.rb

@@ -0,0 +1,615 @@
+# this file contains code that uses many different node types and everything in
+# here works with Ruby2CExtension
+
+BEGIN {puts "begin1"}
+BEGIN {puts "begin2"}
+
+p self
+puts
+p 1,1.2,(p 23;-1),:sym,1...1,1..1
+p [1,2],"oij\0iuj","",[1,[2,[3,4]]]
+begin
+	p 1,*[2,3]
+end while false
+p({:a=>[1], :b=>[2]}.values_at(:a, :b))
+p [1,2,3].index(2)
+a=b="hello"
+puts a, b + " you"
+p(@a=7)
+p($a=6)
+xx=$a=$b=@c=@d=xxx=5
+p [$a,$b,@c,@d,xx,xxx]
+for a in 0..1
+	a = (a == 0 ? :a : :b)
+	unless a == :b
+		puts "a"
+	else
+		puts "not a"
+	end
+end
+p(if puts
+else
+end)
+def m(a)
+	p a
+end
+m 1 + 2
+m [1,2,3].first
+m 2.between?(1, 5)
+p method(:m)
+
+p [1111111111111222222333345342323, /ab/i, /cd/m, /xx/n]
+
+__send__(:p, true.__id__, false.__send__(:inspect), "abc".__send__(:[], 1), 2.equal?(3), nil.nil?, 1.nil?)
+
+def m1(a,b=[],*c)
+	p a,b,c
+end
+m1(1,2,3,4,5)
+m1 3
+def m2(*)
+	p "STAR"
+end
+m2 1,2,3
+
+a="hello"
+def a.a
+	p self
+end
+a.a
+
+public
+
+def fib(n)
+	if n < 2
+		n
+	else
+		fib(n - 1) + fib(n - 2)
+	end
+end
+
+p fib(10)
+
+case
+when 1 == 1
+	p "woo"
+when *[false, true]
+	p (1..3).inspect
+else
+	p "uhh"
+end
+
+for a in 0...7
+	case a
+	when true, false
+		p "bool"
+	when nil
+		p "nil"
+	when 0
+		p "null"
+	when 3, *[1,2]
+		p "1 2 3"
+	when 4, 5
+		p "4 5"
+	else
+		p 6
+	end
+end
+
+case true
+when false
+	p "false"
+when true
+	p "true"
+end
+
+case 2.0
+when 1, nil
+	p 1
+when 2
+	p 2
+when 3
+	p 3
+end
+
+case "a"
+when /a/
+	p "good"
+else
+	p "bad"
+end
+
+a = 1,3
+p a
+p [__FILE__, __LINE__]
+
+a = [1,nil,3]
+
+a[0]+=2
+a[1]||=4
+a[2]&&=5
+
+p a
+
+a = Object.new
+def a.method_missing(*args) p args; end
+
+a[1,*[2,3]]
+a[1,*[2,3]]=4
+a[1,*[2,3]]||=4
+
+class AliasTest
+	def foo
+		p "afoo"
+	end
+
+	alias afoo foo
+	undef foo
+end
+
+$at = AliasTest.new
+alias $aat $at
+$aat.afoo
+
+a = Struct.new(:aa).new
+
+a.aa=3
+a.aa+=2
+p a.aa
+a.aa||=raise
+p a.aa
+a.aa&&=8
+p a.aa
+
+Object::AAA=5
+BBB=6
+p [AAA,BBB,::AAA,::BBB,Object::AAA,Object::Object::BBB]
+
+p [:"a#{1+2}b#{"123".inspect}", "str#{:sym}xx", /a#{2}b#{3}c/, /a#{2}b#{3}c/o, `echo #{2+3}`, `echo 23`.chomp, /null\000null/]
+
+def ct
+	def argv
+		::ARGV
+	end
+end
+
+ct
+p argv
+ct
+
+class AA < String
+	def rev
+		reverse
+	end
+end
+p AA.new("abc").rev
+
+class A
+	@@var = :A
+	C = :CA
+end
+
+class B
+	@@var = :B
+	C = :CB
+
+	a = A.new
+	class ::A
+		p [@@var, C] # => [:A, :CA]
+		def foo
+			[@@var, C]
+		end
+	end
+	def a.bar
+		[@@var, C]
+	end
+	class << a
+		p [@@var, C] # => [:B, :CB]
+		def baz
+			[@@var, C]
+		end
+	end
+	p a.foo # => [:A, :CA]
+	p a.bar # => [:B, :CB]
+	p a.baz # => [:B, :CB]
+	p [@@var, ::A::C, C, class << a;C;end] # => [:B, :CA, :CB, :CB]
+	class << a
+		@@var = :ASing # this changes B's @@var
+		C = :CASing # this creates a new C for a's sing. class
+	end
+	p [@@var, ::A::C, C, class << a;C;end] # => [:ASing, :CA, :CB, :CASing]
+	p a.foo # => [:A, :CA]
+	p a.bar # => [:ASing, :CB]
+	p a.baz # => [:ASing, :CASing]
+end
+
+class F; FF = 3;end
+FF = 4
+class G < F; p FF; end # should be 3, not 4
+
+def pt
+	p Proc.new[]
+end
+pt { 'Proc.new ok!' }
+
+a,@b,$c,(D,*e),*f = [1,2,3,[4,5,6,7],8,9,10]
+p [a,@b,$c,D,e,f]
+a,((@b,$c),(DDD,*e)),*f = [1,[[2,3],[4,5,6,7]],8,9,10]
+p [a,@b,$c,DDD,e,f]
+a,b = 2
+p [a,b]
+*b=1,2
+p b
+
+a=[1,2,3]
+a[5],a[7]=4, 6
+p a
+class << a
+	attr_accessor :c, :d
+end
+a.c,a.d=7,8
+p [a.c,a.d]
+
+p [1,2,3].map { |a| a+1 }
+
+def yield_t(a)
+	yield a, a+1
+end
+
+p(yield_t(23) { |a, b| a+b })
+
+p "abc".instance_eval { reverse }
+p proc { |xx| xx }[24]
+
+END { p "END" }
+def end_t
+	at_exit { p "at_exit" }
+end
+end_t
+end_t
+
+class SupA
+	def test(*arg)
+		p "SupA#test", arg
+		yield 23
+	end
+end
+class SupB < SupA
+	def test(*a)
+		p a
+		super
+		super()
+		super(a)
+		super { |b| p b+1 }
+		super() { |b| p b+2 }
+		super(a) { |b| p b+3 }
+	end
+end
+SupB.new.test { |a| p a }
+SupB.new.test(23) { |a| p a }
+
+for i in 1..9
+	p i
+end
+
+def sqrt(x)
+	x = x.to_f
+	average = lambda { |a, b| (a+b)/2 }
+	impr    = lambda { |g| average[g, x/g] }
+	good_en = lambda { |g| (g*g - x).abs < 0.001 }
+	try     = lambda { |g| good_en[g] ? g : try[impr[g]] }
+	try[1.0]
+end
+
+p sqrt(2)
+
+
+def my_while(cond)
+	if cond
+		yield
+		retry
+	end
+end
+
+i=3
+my_while((i-=1)>0) { p i }
+
+p (11..20).map { |i| (i%4==0)..(i%3==0) ? i : nil }
+p (11..20).map { |i| (i%4==0)...(i%3==0) ? i : nil }
+
+"a" =~ /(a)/
+p [
+	defined? ""=~//,
+	defined? yield,
+	defined? self,
+	defined? nil,
+	defined? true,
+	defined? false,
+	defined? a=5,
+	defined? a,
+	defined? $a,
+	defined? $udef,
+	defined? @c,
+	defined? @udef,
+	defined? A,
+	defined? Udef,
+	defined? @@udef,
+	defined? ::A,
+	defined? ::Udef,
+	defined? $1,
+	defined? $9,
+	defined? $',
+]
+
+class AAAAAA
+	xx=5
+	proc { |yy|
+		begin
+			@@a||=xx
+			@@a||=yy
+			@a||=5
+			@a||=6
+			$f||=5
+			$f||=6
+			a||=5
+			a||=6
+			p [@@a, @a, $f, a]
+			@@a&&=5
+			@@a&&=6
+			@a&&=5
+			@a&&=6
+			$f&&=5
+			$f&&=6
+			a&&=5
+			a&&=6
+			p [@@a, @a, $f, a]
+		ensure
+			p "in ensure"
+		end
+	}[6]
+end
+
+class AEx < RuntimeError;end
+class BEx < RuntimeError;end
+class CEx < RuntimeError;end
+
+ex = AEx
+p(begin
+  p "in body"
+  ex && raise(ex.new)
+  p "not raised"
+rescue TypeError, AEx
+	p "in AEx"
+	ex = BEx
+	retry
+rescue *[TypeError, BEx] => b
+	p "in BEx #{b}"
+	ex = CEx
+	retry
+rescue
+	p "in rescue"
+	ex = nil
+	retry
+else
+	"res"
+ensure
+	p "in ensure"
+end)
+
+ex = AEx
+begin
+	begin
+		p "in body"
+		raise ex
+	rescue AEx
+		p "in AEx"
+		ex = BEx
+		retry
+	end
+rescue BEx
+	p "in BEx"
+else
+	p "in else: BUG!"
+end
+
+begin
+	begin
+		raise
+	rescue 1
+		2
+	end
+rescue => e
+	p e
+end
+
+def cf1
+	begin
+		return 5
+	ensure
+		puts "ensure"
+	end
+	6
+end
+p cf1
+
+def cf2
+	begin
+		while true
+			begin
+				return 5555
+			ensure
+				puts "ensure"
+			end
+		end
+	ensure
+		puts "ensure"
+	end
+	6
+end
+p cf2
+
+def cf22
+	begin
+		while true
+			begin
+				break 5555
+			ensure
+				puts "ensure"
+			end
+		end
+	ensure
+		puts "ensure"
+	end + 6
+end
+p cf22
+
+def cf3
+	1.instance_eval {
+		begin
+			break
+		ensure
+			puts "ensure"
+		end
+	}
+end
+p cf3
+
+def cf4
+	i = 0
+	5.times {
+		begin
+			break if i == 3
+			i+=1
+			puts "xxx"
+			begin
+				redo
+			ensure
+				puts "ensure"
+				while true
+					break
+				end
+			end
+		ensure
+			puts "ensure"
+		end
+	}
+	i
+end
+p cf4
+
+def cf5
+	i = 0
+	5.instance_eval {
+		begin
+			next
+		ensure
+			puts "ensure"
+		end
+	}
+end
+p cf5
+
+def cf6
+	i = 0
+	5.instance_eval {
+		begin
+			next 24
+		rescue
+			puts "bug"
+		end
+	}
+end
+p cf6
+
+def cf61
+	i = 0
+	5.instance_eval {
+		begin
+			raise
+		rescue
+			next 24
+		end
+	}
+end
+p cf61
+
+def cf7
+	loop {
+		begin
+			break
+		rescue
+			puts "bug"
+		ensure
+			puts "ensure"
+		end
+	}
+	23
+end
+p cf7
+
+def cf71
+	loop {
+		begin
+			raise
+		rescue
+			break
+		ensure
+			puts "ensure"
+		end
+	}
+	23
+end
+p cf71
+
+def cf8
+	while true
+		begin
+			return 1234
+		rescue
+			puts "bug"
+		ensure
+			puts "ensure"
+		end
+	end
+	23
+end
+p cf8
+
+def cf81
+	while true
+		begin
+			raise
+		rescue
+			return 1234
+		ensure
+			puts "ensure"
+		end
+	end
+	23
+end
+p cf81
+
+def cf9
+	i = 0
+	5.times {
+		begin
+			break if i == 3
+			i+=1
+			puts "xxx"
+			begin
+				raise
+			rescue
+				while true
+					puts "yyy"
+					break
+				end
+				redo
+			end
+		ensure
+			puts "ensure"
+		end
+	}
+	i
+end
+p cf9
+