Class: Ruby2CExtension::Compiler

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

Constant Summary collapse

NODE_TRANSFORM_OPTIONS = 
{:include_node => true, :keep_newline_nodes => true}
COMPILE_COMMAND = 
"#{conf["LDSHARED"]} #{cflags} -I . -I #{conf["archdir"]}"
DLEXT = 

      
    

  




  
Instance Attribute Summary collapse

  




  
    

      Class Method Summary
      collapse
    


    
  
    

      Instance Method Summary
      collapse
    


    
  



  
Constructor Details

  
    

  

  
    #initialize(name, logger = nil)  ⇒ Compiler 
  

  

  




  

    

Returns a new instance of Compiler.



  





  



  

    
      


16
17
18
19
20
21
22
23
24
25
26
27
28

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 16

def initialize(name, logger = nil)
	@name = name
	@logger = logger
	@funs = []
	@funs_reuseable = {}
	@toplevel_funs = []
	@sym_man = Tools::SymbolManager.new
	@global_man = Tools::GlobalManager.new
	@uniq_names = Tools::UniqueNames.new
	@helpers = {}
	@plugins = []
	@preprocessors = {}
end

    		
  





  



  

    
Instance Attribute Details

    
      
      
      

  

  
    #logger  ⇒ Object  (readonly)
  

  

  




  

    

Returns the value of attribute logger.



  





  



  

    
      


14
15
16

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 14

def logger
  @logger
end

    		
  





    
      
      
      

  

  
    #name  ⇒ Object  (readonly)
  

  

  




  

    

Returns the value of attribute name.



  





  



  

    
      


14
15
16

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 14

def name
  @name
end

    		
  





    
      
      
      

  

  
    #plugins  ⇒ Object  (readonly)
  

  

  




  

    

Returns the value of attribute plugins.



  





  



  

    
      


14
15
16

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 14

def plugins
  @plugins
end

    		
  





    
  



  

    
Class Method Details


    
      

  

  
    .compile_c_file_to_dllib(c_file_name, logger = nil)  ⇒ Object 
  

  

  




  

    

compiles a C file using the compiler from rbconfig



  





  



  

    
      


224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 224

def self.compile_c_file_to_dllib(c_file_name, logger = nil)
	unless c_file_name =~ /\.c\z/
		raise Ruby2CExtError, "#{c_file_name} is no C file"
	end
	dl_name = c_file_name.sub(/c\z/, DLEXT)
	cmd = "#{COMPILE_COMMAND} -o #{dl_name} #{c_file_name}"
	if RUBY_PLATFORM =~ /mswin32/
		cmd << " -link /INCREMENTAL:no /EXPORT:Init_#{File.basename(c_file_name, ".c")}"
	end
	logger.info(cmd) if logger
	unless system(cmd) # run it
		raise Ruby2CExtError, "error while executing '#{cmd}'"
	end
	dl_name
end

    		
  





    
  


  

    
Instance Method Details


    
      

  

  
    #add_fun(code, base_name)  ⇒ Object 
  

  

  




  

    
      


124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 124

def add_fun(code, base_name)
	unless (name = @funs_reuseable[code])
		name = un(base_name)
		lines = code.split("\n")
		unless lines.shift =~ /^\s*static / # first line needs static
			raise Ruby2CExtError::Bug, "trying to add a non static function"
		end
		if lines.grep(/^\s*static /).empty? # only reuseably without static variables
			@funs_reuseable[code] = name
		end
		unless code.sub!("FUNNAME", name)
			raise Ruby2CExtError::Bug, "trying to add a function without FUNNAME"
		end
		@funs << code
	end
	name
end

    		
  





    
      

  

  
    #add_helper(str)  ⇒ Object 
  

  

  




  

    
      


120
121
122

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 120

def add_helper(str)
	@helpers[str] ||= true
end

    		
  





    
      

  

  
    #add_plugin(plugin_class, *args)  ⇒ Object 
  

  

  




  

    
      


142
143
144

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 142

def add_plugin(plugin_class, *args)
	@plugins << plugin_class.new(self, *args)
end

    		
  





    
      

  

  
    #add_plugins(options)  ⇒ Object 
  

  

  




  

    
      


146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 146

def add_plugins(options)
	if options[:warnings]
		require "ruby2cext/plugins/warnings"
		add_plugin(Plugins::Warnings)
	end
	if (opt = options[:optimizations])
		if opt == :all
			opt = {
				:const_cache=>true, :case_optimize=>true,
				:builtin_methods=>true, :inline_methods=>true
			}
		end
		if opt[:const_cache]
			require "ruby2cext/plugins/const_cache"
			add_plugin(Plugins::ConstCache)
		end
		if opt[:case_optimize]
			require "ruby2cext/plugins/case_optimize"
			add_plugin(Plugins::CaseOptimize)
		end
		if opt[:inline_methods]
			require "ruby2cext/plugins/inline_methods"
			add_plugin(Plugins::InlineMethods)
		end
		if (builtins = opt[:builtin_methods])
			require "ruby2cext/plugins/builtin_methods"
			if Array === builtins
				builtins = builtins.map { |b| b.to_s.to_sym } # allow symbols, strings and the actual classes to work
			else
				builtins = Plugins::BuiltinMethods::SUPPORTED_BUILTINS
			end
			add_plugin(Plugins::BuiltinMethods, builtins)
		end
	end
	if (ri_args = options[:require_include])
		require "ruby2cext/plugins/require_include"
		unless Array === ri_args.first
			ri_args = [ri_args] # to allow just an array of include paths to also work
		end
		add_plugin(Plugins::RequireInclude, *ri_args)
	end
end

    		
  





    
      

  

  
    #add_preprocessor(node_type, &pp_proc)  ⇒ Object 
  

  

  




  

    

preprocessors can be added by plugins. preprocessors are procs that take two arguments: the current cfun and the node (tree) to preprocess (which will have type node_type)



The proc can either return a (modified) node (tree) or string. If a node (tree) is returned then that will be translated as usual, if a string is returned, that string will be the result



Example, a preprocessor that replaces 23 with 42: add_preprocessor(:lit) { |cfun, node|



node.last[:lit] == 23 ? [:lit, {:lit=>42}] : node




}



Another way to do the same: add_preprocessor(:lit) { |cfun, node|



node.last[:lit] == 23 ? cfun.comp_lit(:lit=>42) : node




}



If multiple preprocessors are added for the same node type then they will be called after each other with the result of the previous one unless it is a string, then the following preprocessors are ignored



  





  



  

    
      


210
211
212

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 210

def add_preprocessor(node_type, &pp_proc)
	(@preprocessors[node_type] ||= []) << pp_proc
end

    		
  





    
      

  

  
    #add_rb_file(source_str, file_name)  ⇒ Object 
  

  

  




  

    
      


90
91
92
93
94

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 90

def add_rb_file(source_str, file_name)
	rb_file_to_toplevel_functions(source_str, file_name).each { |fn|
		add_toplevel(fn)
	}
end

    		
  





    
      

  

  
    #add_toplevel(function_name)  ⇒ Object 
  

  

  




  

    
      


60
61
62

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 60

def add_toplevel(function_name)
	@toplevel_funs << function_name
end

    		
  





    
      

  

  
    #compile_toplevel_function(node_tree, private_vmode = true)  ⇒ Object 
  

  

  




  

    

non destructive: node_tree will not be changed



  





  



  

    
      


65
66
67

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 65

def compile_toplevel_function(node_tree, private_vmode = true)
	CFunction::ToplevelScope.compile(self, node_tree, private_vmode)
end

    		
  





    
      

  

  
    #global_const(str, register_gc = true)  ⇒ Object 
  

  

  




  

    
      


103
104
105

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 103

def global_const(str, register_gc = true)
	@global_man.get(str, true, register_gc)
end

    		
  





    
      

  

  
    #global_var(str)  ⇒ Object 
  

  

  




  

    
      


106
107
108

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 106

def global_var(str)
	@global_man.get(str, false, true)
end

    		
  





    
      

  

  
    #log(str, warning = false)  ⇒ Object 
  

  

  




  

    
      


110
111
112
113
114
115
116
117
118

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 110

def log(str, warning = false)
	if logger
		if warning
			logger.warn(str)
		else
			logger.info(str)
		end
	end
end

    		
  





    
      

  

  
    #preprocessors_for(node_type)  ⇒ Object 
  

  

  




  

    
      


214
215
216

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 214

def preprocessors_for(node_type)
	@preprocessors[node_type]
end

    		
  





    
      

  

  
    #rb_file_to_toplevel_functions(source_str, file_name)  ⇒ Object 
  

  

  




  

    
      


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 71

def rb_file_to_toplevel_functions(source_str, file_name)
	res = []
	hash = Parser.parse_string(source_str, file_name)
	# add all BEGIN blocks, if available
	if (beg_tree = hash[:begin])
		beg_tree = beg_tree.transform(NODE_TRANSFORM_OPTIONS)
		if beg_tree.first == :block
			beg_tree.last.each { |s| res << compile_toplevel_function(s, false) }
		else
			res << compile_toplevel_function(beg_tree, false)
		end
	end
	# add toplevel scope
	if (tree = hash[:tree])
		res << compile_toplevel_function(tree.transform(NODE_TRANSFORM_OPTIONS))
	end
	res
end

    		
  





    
      

  

  
    #sym(sym)  ⇒ Object 
  

  

  




  

    
      


100
101
102

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 100

def sym(sym)
	@sym_man.get(sym)
end

    		
  





    
      

  

  
    #to_c_code(time_stamp = Time.now)  ⇒ Object 
  

  

  




  

    
      


30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 30

def to_c_code(time_stamp = Time.now)
	plugins_global = @plugins.map { |plugin| plugin.global_c_code }
	plugins_init = @plugins.map { |plugin| plugin.init_c_code }
	res = [
		"/* generated by #{FULL_VERSION_STRING} on #{time_stamp} */",
		"#include <ruby.h>",
		"#include <node.h>",
		"#include <env.h>",
		"#include <st.h>",
		"extern VALUE ruby_top_self;",
		"static VALUE org_ruby_top_self;",
		@sym_man.to_c_code,
		@global_man.to_c_code,
	]
	res.concat(@helpers.keys.sort)
	res.concat(plugins_global)
	res.concat(@funs)
	res << "void Init_#{@name}() {"
	res << "org_ruby_top_self = ruby_top_self;"
	# just to be sure
	res << "rb_global_variable(&org_ruby_top_self);"
	res << "init_syms();"
	res << "init_globals();"
	res << "NODE *cref = rb_node_newnode(NODE_CREF, rb_cObject, 0, 0);"
	res.concat(plugins_init)
	@toplevel_funs.each { |f| res << "#{f}(ruby_top_self, cref);" }
	res << "}"
	res.join("\n").split("\n").map { |l| l.strip }.reject { |l| l.empty? }.join("\n")
end

    		
  





    
      

  

  
    #un(str)  ⇒ Object 
  

  

  




  

    

uniq name



  





  



  

    
      


97
98
99

    		
    
      
# File 'lib/ruby2cext/compiler.rb', line 97

def un(str)
	@uniq_names.get(str)
end