Class: Ruby2CExtension::Eval2C

Inherits:
Object
  • Object
show all
Defined in:
lib/ruby2cext/eval2c.rb

Constant Summary collapse

DEFAULT_PATH = 
File.join(File.expand_path(ENV["HOME"] || ENV["USERPROFILE"] || ENV["HOMEPATH"] || "."), ".ruby2cext")

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Eval2C

Returns a new instance of Eval2C.



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/ruby2cext/eval2c.rb', line 16

def initialize(options = {})
	unless (@path = options[:path])
		@path = DEFAULT_PATH
		Dir.mkdir(@path, 0700) unless File.exists?(@path)
	end
	@path = File.expand_path(@path)
	unless File.directory?(@path)
		raise Ruby2CExtError, "#{@path} is no directory"
	end
	unless File.stat(@path).mode & 022 == 0 # no writing for group and others
		warn "Ruby2CExtension::Eval2C warning: #{@path} is insecure"
	end
	@prefix = options[:prefix] || "eval2c"
	@plugins = options[:plugins] || {:optimizations => :all}
	@logger = options[:logger]
	@force_recompile = options[:force_recompile]
	@done = {}
	@digest_extra = Ruby2CExtension::FULL_VERSION_STRING + @plugins.inspect.split(//).sort.join("")
end

Instance Attribute Details

#force_recompile ⇒ Object (readonly)

Returns the value of attribute force_recompile.



12
13
14
 
# File 'lib/ruby2cext/eval2c.rb', line 12

def force_recompile
  @force_recompile
end

#logger ⇒ Object (readonly)

Returns the value of attribute logger.



12
13
14
 
# File 'lib/ruby2cext/eval2c.rb', line 12

def logger
  @logger
end

#path ⇒ Object (readonly)

Returns the value of attribute path.



12
13
14
 
# File 'lib/ruby2cext/eval2c.rb', line 12

def path
  @path
end

#plugins ⇒ Object (readonly)

Returns the value of attribute plugins.



12
13
14
 
# File 'lib/ruby2cext/eval2c.rb', line 12

def plugins
  @plugins
end

#prefix ⇒ Object (readonly)

Returns the value of attribute prefix.



12
13
14
 
# File 'lib/ruby2cext/eval2c.rb', line 12

def prefix
  @prefix
end

Instance Method Details

#compile_methods(mod, *methods) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/ruby2cext/eval2c.rb', line 78

def compile_methods(mod, *methods)
	methods = methods.map { |m| m.to_sym }.uniq
	defs = methods.map { |m|
		bnode = mod.instance_method(m).body_node
		unless bnode.type == :scope
			raise Ruby2CExtError, "the method #{m} cannot be compiled, only methods defined using def can be compiled"
		end
		[:defn, {:mid => m, :defn => bnode.transform(Compiler::NODE_TRANSFORM_OPTIONS)}]
	}
	node_tree = [:scope, {:next => [:gasgn, {:vid => :$test, :value =>
		[:iter, {
			:var => false,
			:iter => [:fcall, {:args => false, :mid => :proc}],
			:body => [:block, defs]
		}]
	}]}]
	# save current visibility of the methods
	publ_methods = mod.public_instance_methods.map { |m| m.to_sym } & methods
	prot_methods = mod.protected_instance_methods.map { |m| m.to_sym } & methods
	priv_methods = mod.private_instance_methods.map { |m| m.to_sym } & methods
	# compile to test if the methods don't need a cref and to get a string for the hash
	c = Compiler.new("test")
	c.add_toplevel(c.compile_toplevel_function(node_tree))
	test_code = c.to_c_code(nil) # no time_stamp
	# don't allow methods that need a cref, because the compiled version would get a different cref
	if test_code =~ /^static void def_only_once/ # a bit hackish ...
		raise Ruby2CExtError, "the method(s) cannot be compiled, because at least one needs a cref"
	end
	# compile the proc
	def_proc = compile_helper(test_code) { |compiler, name, gvar_name|
		node_tree.last[:next].last[:vid] = gvar_name.to_sym
		compiler.add_toplevel(compiler.compile_toplevel_function(node_tree))
	}
	# try to remove all the methods
	mod.module_eval {
		methods.each { |m|
			remove_method(m) rescue nil
		}
	}
	# add the compiled methods
	mod.module_eval &def_proc
	# restore original visibility
	mod.module_eval {
		public *publ_methods unless publ_methods.empty?
		protected *prot_methods unless prot_methods.empty?
		private *priv_methods unless priv_methods.empty?
	}
end

#compile_to_proc(code_str) ⇒ Object 



59
60
61
62
63
 
# File 'lib/ruby2cext/eval2c.rb', line 59

def compile_to_proc(code_str)
	compile_helper(code_str) { |compiler, name, gvar_name|
		compiler.add_rb_file("#{gvar_name} = proc { #{code_str} }", name)
	}
end

#instance_eval(object, code_str) ⇒ Object 



70
71
72
 
# File 'lib/ruby2cext/eval2c.rb', line 70

def instance_eval(object, code_str)
	object.instance_eval(&compile_to_proc(code_str))
end

#module_eval(mod, code_str) ⇒ Object Also known as: class_eval 



65
66
67
 
# File 'lib/ruby2cext/eval2c.rb', line 65

def module_eval(mod, code_str)
	mod.module_eval(&compile_to_proc(code_str))
end

#toplevel_eval(code_str) ⇒ Object 



74
75
76
 
# File 'lib/ruby2cext/eval2c.rb', line 74

def toplevel_eval(code_str)
	compile_to_proc(code_str).call
end