ruby2cext 0.2.0

data/lib/ruby2cext/plugins/case_optimize.rb

@@ -0,0 +1,105 @@
+
+require "ruby2cext/plugin"
+require "ruby2cext/tools"
+
+module Ruby2CExtension::Plugins
+
+	class CaseOptimize < Ruby2CExtension::Plugin
+
+		include Ruby2CExtension::Tools::EnsureNodeTypeMixin
+
+		def initialize(compiler)
+			super
+			compiler.add_preprocessor(:case) { |cfun, node|
+				handle_case(cfun, node.last) || node
+			}
+		end
+
+		def fixnum?(node)
+			Array === node && node.first == :lit && Fixnum === node.last[:lit]
+		end
+
+		def fixed_immediate?(node)
+			# checks if the node is optimizable and if yes returns the equivalent C value
+			if fixnum?(node)
+				"LONG2FIX(#{node.last[:lit].inspect})"
+			elsif Array === node
+				case node.first
+				when :nil
+					"Qnil"
+				when :true
+					"Qtrue"
+				when :false
+					"Qfalse"
+				else
+					false
+				end
+			else
+				false
+			end
+		end
+
+		def handle_case(cfun, hash)
+			cur_when = hash[:body]
+			fallback_whens = []
+			opt_cases = []
+			while cur_when.first == :when
+				ensure_node_type(head = cur_when.last[:head], :array)
+				cases = head.last.map { |wn| fixed_immediate?(wn) }
+				break unless cases.all?
+				case_c_code = cases.map { |c| "case #{c}:" }.join("\n")
+				fixnum_whens = head.last.select { |wn| fixnum?(wn) }
+				unless fixnum_whens.empty?
+					goto_label = compiler.un("case_opt_label")
+					case_c_code << "\n#{goto_label}:"
+					fallback_whens << [:when, {
+						:body => "Qnil;\ngoto #{goto_label}", # TODO: evil, depends on impl. details of comp_case/handle_when
+						:head => [:array, fixnum_whens]
+					}]
+				end
+				opt_cases << [case_c_code, cur_when.last[:body]]
+				cur_when = cur_when.last[:next] || [:nil, {}]
+			end
+			return nil if opt_cases.empty? # nothing to optimize
+			rest = cur_when
+			if rest.first == :when # some whens are left construct a complete new case node
+				rest = [:case, {:head => "case_opt_val", :body => rest}]
+			end
+			cfun.instance_eval {
+				c_scope_res {
+					l "VALUE case_opt_val;"
+					l "case_opt_val = #{comp(hash[:head])};"
+					l "switch (case_opt_val) {"
+					opt_cases.each { |(case_code, body_node)|
+						l case_code
+						assign_res(comp(body_node))
+						l "break;"
+					}
+					l "default:"
+					if fallback_whens.empty?
+						assign_res(comp(rest))
+					else
+						# link the fallback_whens
+						fallback_whens.each_with_index { |wn, i|
+							fallback_whens[i - 1].last[:next] = wn if i > 0
+						}
+						fallback_whens.last.last[:next] = "Qundef"
+						c_if("!FIXNUM_P(case_opt_val)") {
+							assign_res(comp_case({:head => "case_opt_val", :body => fallback_whens.first}))
+						}
+						c_else {
+							assign_res("Qundef")
+						}
+						c_if("res == Qundef") {
+							assign_res(comp(rest))
+						}
+					end
+					l "}"
+					"res"
+				}
+			}
+		end
+
+	end
+
+end

data/lib/ruby2cext/plugins/const_cache.rb

@@ -0,0 +1,38 @@
+
+require "ruby2cext/plugin"
+
+module Ruby2CExtension::Plugins
+
+	class ConstCache < Ruby2CExtension::Plugin
+		def initialize(compiler)
+			super
+			compiler.add_preprocessor(:const) { |cfun, node|
+				cfun.instance_eval {
+					c_static_once {
+						comp_const(node.last)
+					}
+				}
+			}
+			compiler.add_preprocessor(:colon2) { |cfun, node|
+				mid = node.last[:mid]
+				if mid.to_s[0,1].downcase != mid.to_s[0,1] # then it is a constant
+					cfun.instance_eval {
+						c_static_once {
+							comp_colon2(node.last)
+						}
+					}
+				else
+					node
+				end
+			}
+			compiler.add_preprocessor(:colon3) { |cfun, node|
+				cfun.instance_eval {
+					c_static_once {
+						comp_colon3(node.last)
+					}
+				}
+			}
+		end
+	end
+
+end

data/lib/ruby2cext/plugins/inline_methods.rb

@@ -0,0 +1,69 @@
+
+require "ruby2cext/plugin"
+
+module Ruby2CExtension::Plugins
+
+	class InlineMethods < Ruby2CExtension::Plugin
+
+		METHODS = {
+			[:nil?, 0] => proc { |cfun, recv, args|
+				"(Qnil == (#{recv}) ? Qtrue : Qfalse)"
+			},
+			[:equal?, 1] => proc { |cfun, recv, args|
+				cfun.instance_eval {
+					c_scope_res {
+						l "VALUE recv = #{recv};"
+						"(recv == (#{comp(args[0])}) ? Qtrue : Qfalse)"
+					}
+				}
+			},
+			:__send__ => proc { |cfun, recv, args|
+				unless args
+					raise Ruby2CExtension::Ruby2CExtError, "inlining #__send__ without arguments is not allowed"
+				end
+				cfun.instance_eval {
+					add_helper <<-EOC
+						static void inline_method_send_no_method_name() {
+							rb_raise(rb_eArgError, "no method name given");
+						}
+					EOC
+					c_scope_res {
+						l "VALUE recv = #{recv};"
+						build_args(args)
+						l "if (argc == 0) inline_method_send_no_method_name();"
+						"rb_funcall2(recv, rb_to_id(argv[0]), argc - 1, (&(argv[0])) + 1)"
+					}
+				}
+			},
+		}
+
+		def initialize(compiler)
+			super
+			self_node = [:self, {}]
+			compiler.add_preprocessor(:vcall) { |cfun, node|
+				handle(cfun, node.last[:mid], self_node, false) || node
+			}
+			compiler.add_preprocessor(:fcall) { |cfun, node|
+				handle(cfun, node.last[:mid], self_node, node.last[:args]) || node
+			}
+			compiler.add_preprocessor(:call) { |cfun, node|
+				handle(cfun, node.last[:mid], node.last[:recv], node.last[:args]) || node
+			}
+		end
+
+		def handle(cfun, method, recv, args)
+			if (pr = METHODS[method])
+				pr.call(cfun, cfun.comp(recv), args)
+			else
+				args ||= [:array, []]
+				if args.first == :array && (pr = METHODS[[method, args.last.size]])
+					pr.call(cfun, cfun.comp(recv), args.last)
+				else
+					nil
+				end
+			end
+		end
+
+	end
+
+end

data/lib/ruby2cext/plugins/require_include.rb

@@ -0,0 +1,71 @@
+
+require "ruby2cext/plugin"
+
+module Ruby2CExtension::Plugins
+
+	class RequireInclude < Ruby2CExtension::Plugin
+
+		attr_reader :include_paths
+
+		def initialize(compiler, include_paths, ignore_files = nil)
+			super(compiler)
+			@include_paths = include_paths
+			done = {}
+			if ignore_files
+				ignore_files.each { |file|
+					done[File.expand_path(file)] = true
+				}
+			end
+			compiler.add_preprocessor(:fcall) { |cfun, node|
+				hash = node.last
+				if hash[:mid] == :require &&
+						(args = hash[:args]) &&
+						args.first == :array &&
+						(args = args.last).size == 1 &&
+						Array === args[0] &&
+						args[0].first == :str &&
+						(file = search_file(args[0].last[:lit]))
+					unless done[File.expand_path(file)]
+						done[File.expand_path(file)] = true
+						cfun.compiler.log "including require'd file: #{file}"
+						cfun.instance_eval {
+							add_helper <<-EOC
+								static NODE * find_top_cref(NODE *cref) {
+									while (cref && cref->nd_next) cref = cref->nd_next;
+									return cref;
+								}
+							EOC
+							c_scope {
+								l "NODE *top_cref = find_top_cref(#{get_cref});"
+								l "static int done = 0;"
+								c_if("!done") {
+									l "done = 1;"
+									compiler.rb_file_to_toplevel_functions(IO.read(file), file).each { |tlfn|
+										l "#{tlfn}(org_ruby_top_self, top_cref);"
+									}
+								}
+							}
+						}
+					end
+					"Qtrue"
+				else
+					node
+				end
+			}
+		end
+
+		def search_file(req_str)
+			req_str = req_str.dup
+			unless req_str =~ /\.rb\z/
+				req_str << ".rb"
+			end
+			res = false
+			include_paths.map { |path|
+				File.join(path, req_str)
+			}.find { |file|
+				File.exists? file
+			}
+		end
+	end
+
+end

data/lib/ruby2cext/plugins/warnings.rb

@@ -0,0 +1,123 @@
+
+require "ruby2cext/plugin"
+
+module Ruby2CExtension::Plugins
+
+	# TODO: Module.nesting, Module.constants, Kernel#autoload and Kernel#autoload?
+
+	class Warnings < Ruby2CExtension::Plugin
+
+		CALL_TYPES = [:vcall, :fcall, :call]
+
+		exp = "might not behave as expected"
+		exp2 = "will not behave as expected"
+		vis_exp = "visibility of the defined %s might not be as expected"
+
+		VCALL_WARNINGS = {
+			:binding => exp2,
+			:local_variables => exp2,
+			:callcc => exp,
+		}
+
+		FCALL_WARNINGS = {
+			:set_trace_func => exp,
+			:eval => exp,
+			:define_method => vis_exp % "method",
+			:attr => vis_exp % "attribute",
+			:attr_reader => vis_exp % "attribute(s)",
+			:attr_writer => vis_exp % "attribute(s)",
+			:attr_accessor => vis_exp % "attribute(s)",
+			:instance_eval => exp,
+			:module_eval => exp,
+			:class_eval => exp,
+		}
+
+		CALL_WARNINGS = {
+			:arity => "will return -1 for all methods defined in compiled Ruby code",
+			:instance_eval => exp,
+			:module_eval => exp,
+			:class_eval => exp,
+		}
+
+		BLOCK_PASS_WARNINGS = {
+			:define_method => true,
+			:instance_eval => true,
+			:module_eval => true,
+			:class_eval => true,
+		}
+
+		NO_WARNING_WITH_ITER = {
+			:instance_eval => true,
+			:module_eval => true,
+			:class_eval => true,
+		}
+
+		def initialize(compiler)
+			super
+			CALL_TYPES.each { |ct|
+				ct_sym = "check_#{ct}".to_sym
+				compiler.add_preprocessor(ct) { |cfun, node|
+					send(ct_sym, node.last)
+					node
+				}
+			}
+			[:iter, :block_pass].each { |it|
+				it_sym = "check_#{it}".to_sym
+				compiler.add_preprocessor(it) { |cfun, node|
+					if node.last[:iter] && CALL_TYPES.include?(node.last[:iter].first)
+						send(it_sym, node.last[:iter])
+					end
+					node
+				}
+			}
+		end
+
+		def warn(str, node_hash = {})
+			lstr = ""
+			if (n = node_hash[:node])
+				lstr << "#{n.file}:#{n.line}: "
+			end
+			lstr << "warning: " << str
+			compiler.log(lstr, true)
+		end
+
+		def check_vcall(hash)
+			if (m = VCALL_WARNINGS[hash[:mid]])
+				warn("#{hash[:mid]}: #{m}", hash)
+			end
+		end
+
+		def check_fcall(hash)
+			if (m = FCALL_WARNINGS[hash[:mid]])
+				warn("#{hash[:mid]}: #{m}", hash)
+			else
+				unless hash[:args]
+					check_vcall(hash)
+				end
+			end
+		end
+
+		def check_call(hash)
+			if (m = CALL_WARNINGS[hash[:mid]])
+				warn("#{hash[:mid]}: #{m}", hash)
+			end
+		end
+
+		def check_iter(iter_node)
+			mid = iter_node.last[:mid]
+			unless NO_WARNING_WITH_ITER[mid]
+				send("check_#{iter_node.first}", iter_node.last)
+			end
+		end
+
+		def check_block_pass(iter_node)
+			mid = iter_node.last[:mid]
+			if BLOCK_PASS_WARNINGS[mid]
+				warn("#{mid} with block_pass: might not behave as expected", iter_node.last)
+			else
+				send("check_#{iter_node.first}", iter_node.last)
+			end
+		end
+	end
+
+end

data/lib/ruby2cext/scopes.rb

@@ -0,0 +1,227 @@
+
+require "ruby2cext/error"
+
+module Ruby2CExtension
+
+	module Scopes
+		class Scope
+			VMODES = [:public, :private, :protected, :module_function].freeze
+
+			def initialize(tbl, vmode_methods = VMODES, private_vmode = false)
+				@vmode_methods = vmode_methods
+				@vmode = private_vmode ? :private : :public
+				@tbl = tbl || []
+				@closure_tbl = nil # must be set by user
+			end
+			attr_reader :tbl, :vmode, :vmode_methods
+			attr_accessor :need_heap, :closure_tbl
+
+			def get_lvar_idx(i)
+				raise Ruby2CExtError, "wrong lvar index: #{i}" unless i >= 0 && i < tbl.size
+				"lvar[#{i}]"
+			end
+			def get_lvar(sym)
+				raise Ruby2CExtError, "unknown lvar: #{sym}" unless (i = tbl.index(sym))
+				get_lvar_idx(i)
+			end
+			def get_lvar_ary
+				self.need_heap = true
+				"lvar_ary"
+			end
+			def get_dvar(arg)
+				raise Ruby2CExtError, "dvars not available here"
+			end
+			alias get_dvar_curr get_dvar
+			alias get_dvar_ary get_dvar
+
+			def vmode_method?(method_id)
+				if (res = vmode_methods.include?(method_id))
+					@vmode = method_id
+				end
+				res
+			end
+			def vmode_def_fun
+				case vmode
+				when :protected, :private
+					"rb_define_#{vmode}_method"
+				when :public
+					"rb_define_method"
+				when :module_function
+					"rb_define_module_function"
+				else
+					raise Ruby2CExtError::Bug, "unknown vmode: #{@vmode}"
+				end
+			end
+
+			def new_dyna_scope
+				DynaScope.new(self, nil, 1)
+			end
+
+			def var_ptr_for_wrap
+				tbl.empty? ? nil : "lvar"
+			end
+
+			def init_c_code
+				return nil if tbl.empty?
+				res = []
+				if need_heap
+					res << "VALUE *lvar;"
+					res << "VALUE lvar_ary = rb_ary_new2(#{tbl.size});"
+					res << "rb_mem_clear(RARRAY(lvar_ary)->ptr, #{tbl.size});"
+					res << "RARRAY(lvar_ary)->len = #{tbl.size};"
+					res << "lvar = RARRAY(lvar_ary)->ptr;"
+				else
+					res << "VALUE lvar[#{tbl.size}];\nrb_mem_clear(lvar, #{tbl.size});"
+				end
+				res.join("\n")
+			end
+		end
+
+		class DynaScope
+			def initialize(base_scope, outer_scope, depth)
+				@base_scope = base_scope
+				@outer_scope = outer_scope
+				@depth = depth
+				@closure_tbl = nil # must be set by user
+				@tbl = []
+			end
+			attr_reader :tbl, :base_scope, :outer_scope, :depth
+			attr_accessor :need_heap, :need_closure, :closure_tbl
+
+			def outer_closure_tbl
+				(outer_scope || base_scope).closure_tbl
+			end
+			def add_closure_need(need)
+				# need is in [1, self.depth) or :lvar
+				unless need == :lvar || (1...depth) === need
+					raise Ruby2CExtError::Bug, "unexpected needed closure vars: #{need}"
+				end
+				self.need_closure = true
+				outer_closure_tbl << need unless outer_closure_tbl.include? need
+			end
+			def get_closure_ary(clos_idx)
+				add_closure_need(clos_idx)
+				"closure[#{outer_closure_tbl.index(clos_idx)}]"
+			end
+			def get_closure_var(clos_idx, var_idx)
+				"RARRAY(#{get_closure_ary(clos_idx)})->ptr[#{var_idx}]"
+			end
+
+			def get_lvar_idx(i)
+				raise Ruby2CExtError, "wrong lvar index: #{i}" unless i >= 0 && i < base_scope.tbl.size
+				get_closure_var(:lvar, i)
+			end
+			def get_lvar(sym)
+				raise Ruby2CExtError, "unknown lvar: #{sym}" unless (i = base_scope.tbl.index(sym))
+				get_lvar_idx(i)
+			end
+			def get_lvar_ary
+				get_closure_ary(:lvar)
+			end
+
+			def get_dvar(sym)
+				if tbl.include?(sym)
+					return get_dvar_curr(sym)
+				end
+				cur = self
+				while (cur = cur.outer_scope)
+					if (i = cur.tbl.index(sym))
+						return get_closure_var(cur.depth, i)
+					end
+				end
+				# Ruby versions <= 1.8.5 should/will never reach here
+				# (otherwise it is a bug in the parser).
+				# But starting after 1.8.5 dvars are only initialized, if there
+				# is an assignment in a sub-block. Because of that we can reach
+				# here, in that case we want a new dvar_curr:
+				get_dvar_curr(sym)
+			end
+			def get_dvar_curr(sym)
+				unless (i = tbl.index(sym))
+					i = tbl.size
+					tbl << sym
+				end
+				"dvar[#{i}]"
+			end
+			def get_dvar_ary(idx)
+				if idx == depth
+					self.need_heap = true
+					"dvar_ary"
+				else
+					get_closure_ary(idx)
+				end
+			end
+
+			# blocks always has public vmode
+			def vmode
+				:public
+			end
+			def vmode_method?(method_id)
+				false
+			end
+			def vmode_def_fun
+				"rb_define_method"
+			end
+
+			def new_dyna_scope
+				DynaScope.new(base_scope, self, depth + 1)
+			end
+
+			def var_ptr_for_wrap
+				tbl.empty? ? nil : "dvar"
+			end
+
+			def init_c_code
+				return nil if tbl.empty?
+				res = []
+				if need_heap
+					res << "VALUE *dvar;"
+					res << "VALUE dvar_ary = rb_ary_new2(#{tbl.size});"
+					res << "rb_mem_clear(RARRAY(dvar_ary)->ptr, #{tbl.size});"
+					res << "RARRAY(dvar_ary)->len = #{tbl.size};"
+					res << "dvar = RARRAY(dvar_ary)->ptr;"
+				else
+					res << "VALUE dvar[#{tbl.size}];\nrb_mem_clear(dvar, #{tbl.size});"
+				end
+				res.join("\n")
+			end
+		end
+
+		class WrappedScope
+			def initialize(base_scope)
+				@base_scope = base_scope
+			end
+
+			# redirect to @base_scope
+			def method_missing(meth, *arg)
+				res = @base_scope.send(meth, *arg)
+				if String === res
+					case res
+					when "lvar_ary"
+						raise Ruby2CExtError::Bug, "unexpected need for lvar_ary in WrappedScope"
+					when "dvar_ary"
+						raise Ruby2CExtError::Bug, "unexpected need for dvar_ary in WrappedScope"
+					when /\bclosure\b/
+						res.gsub!(/\bclosure\b/, "(wrap_ptr->closure)")
+					when /\b[ld]var\b/
+						res.gsub!(/\b[ld]var\b/, "(wrap_ptr->var)")
+					when /^rb_define/
+						# nothing
+					else
+						raise Ruby2CExtError::Bug, "unexpected string returned from #{@base_scope.class}##{meth}: #{res}"
+					end
+				end
+				res
+			end
+
+			def var_ptr_for_wrap
+				raise Ruby2CExtError::Bug, "unexpected call of var_ptr_for_wrap"
+			end
+
+			def init_c_code
+				raise Ruby2CExtError::Bug, "unexpected call of init_c_code"
+			end
+		end
+	end
+
+end