crystalizer 0.2.2

data/lib/ruby2cext/plugins/inline_methods.rb

@@ -0,0 +1,68 @@
+# this one inlines [trivial] ruby methods, like #nil?
+
+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/ivar_cache.rb

@@ -0,0 +1,147 @@
+# this one makes for faster
+# @a = 3
+# @b = 4
+# by doing the lookups locally, in C, instead of having ruby do it for us by a rb_ivar_set call.
+
+module Ruby2CExtension::Plugins
+
+class IVarCache < Ruby2CExtension::Plugin
+
+    include Util
+
+    def initialize(compiler)
+        super(compiler)
+        @cache_index = Hash.new { |h,k| h[k] = h.size }
+        compiler.add_preprocessor(:ivar) { |cfun, node|
+            hash = node.last
+            vid = hash[:vid]
+            key = [vid, cfun.__id__]
+            index = @cache_index[key]
+            entry = "ivar_cache[#{index}]"
+            "cache_ivar_get(&#{entry}, #{cfun.get_self}, #{cfun.sym(vid)})"
+        }
+        compiler.add_preprocessor(:iasgn) { |cfun, node|
+            hash = node.last
+            vid = hash[:vid]
+            key = [vid, cfun.__id__]
+            index = @cache_index[key]
+            entry = "ivar_cache[#{index}]"
+            "cache_ivar_set(&#{entry}, #{cfun.get_self}, #{cfun.sym(vid)}, #{cfun.comp(hash[:value])})"
+        }
+    end
+
+    def global_c_code
+        code = %{
+            typedef struct {
+                unsigned num_bins;
+                unsigned bin_pos;
+            } ivar_cache_entry;
+            static ivar_cache_entry ivar_cache[#{@cache_index.size}];
+            static void init_ivar_cache() {
+                ivar_cache_entry* entry;
+                for (entry = &ivar_cache[#{@cache_index.size-1}]; entry >= ivar_cache; --entry) {
+                    entry->num_bins = 0;
+                    entry->bin_pos = 0;
+                }
+            }
+            typedef struct st_table_entry st_table_entry;
+            struct st_table_entry {
+                unsigned int hash;
+                st_data_t key;
+                st_data_t record;
+                st_table_entry *next;
+            };
+            static st_table_entry *st_find_collided(st_table_entry **prev, ID id) {
+                st_table_entry *cur = *prev;
+                while (cur = cur->next) {
+                    if (cur->hash == id) {
+                        (*prev)->next = cur->next;
+                        cur->next = *prev;
+                        *prev = cur;
+                        return cur;
+                    }
+                    prev = &(*prev)->next;
+                }
+                return 0;
+            }
+            static VALUE cache_ivar_get(ivar_cache_entry* entry,
+                                               VALUE obj, ID id)
+            {
+                st_table* table = ROBJECT(obj)->iv_tbl;
+                unsigned bin_pos;
+                st_table_entry *cur;
+                switch (TYPE(obj)) {
+                    case T_OBJECT:
+                    case T_CLASS:
+                    case T_MODULE:
+                        break;
+                    default:
+                        return rb_ivar_get(obj, id);
+                }
+                if (!table) return Qnil;
+                if (entry->num_bins==table->num_bins) {
+                    bin_pos = entry->bin_pos;
+                } else {
+                    entry->num_bins = table->num_bins;
+                    bin_pos = entry->bin_pos = id % table->num_bins;
+                }
+                cur = table->bins[bin_pos];
+                if (!cur) return Qnil;
+                if (cur->hash == id) return cur->record;
+                cur = st_find_collided(&table->bins[bin_pos], id);
+                return cur ? cur->record : Qnil;
+            }
+            static VALUE cache_ivar_set(ivar_cache_entry* entry,
+                                               VALUE obj, ID id, VALUE val)
+            {
+                st_table* table;
+                unsigned bin_pos;
+                st_table_entry *cur;
+                if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4 || OBJ_FROZEN(obj))
+                    return rb_ivar_set(obj, id, val);
+                switch (TYPE(obj)) {
+                    case T_OBJECT:
+                    case T_CLASS:
+                    case T_MODULE:
+                        break;
+                    default:
+                        return rb_ivar_set(obj, id, val);
+                }
+                table = ROBJECT(obj)->iv_tbl;
+                if (!table) {
+                    table = ROBJECT(obj)->iv_tbl = st_init_numtable();
+                }
+                if (entry->num_bins==table->num_bins) {
+                    bin_pos = entry->bin_pos;
+                } else {
+                    entry->num_bins = table->num_bins;
+                    bin_pos = entry->bin_pos = id % table->num_bins;
+                }
+                cur = table->bins[bin_pos];
+                if (!cur) {
+                    st_add_direct(table, id, val);
+                    return val;
+                }
+                if (cur->hash == id) return (cur->record = val);
+                cur = st_find_collided(&table->bins[bin_pos], id);
+                if (cur) {
+                    return (cur->record = val);
+                } else {
+                    st_add_direct(table, id, val);
+                    return val;
+                }
+            }
+        }
+        code
+    end
+
+    def init_c_code
+        %{
+            init_ivar_cache();
+        }
+    end
+
+end
+
+end
+

data/lib/ruby2cext/plugins/require_include.rb

@@ -0,0 +1,69 @@
+
+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/util.rb

@@ -0,0 +1,154 @@
+
+module Ruby2CExtension::Plugins
+
+module Util
+
+    def deduce_type(node)
+        while true
+            Array === node or return
+            case node.first
+            when :lit
+                return Kernel.const_get(node.last[:lit].class.name)
+            when :nil
+                return NilClass
+            when :false
+                return FalseClass
+            when :true
+                return TrueClass
+            when :str, :dstr
+                return String
+            when :dsym
+                return Symbol
+            when :array, :zarray, :masgn
+                return Array
+            when :hash
+                return Hash
+            when :dregx, :dregx_once
+                return Regexp
+            when :dasn_curr, :iasgn, :cvdecl, :gasgn, :cdecl
+                node = node.last[:value]
+            when :attrasgn
+                args = node.last[:args]
+                Array === args or return
+                case args.first
+                when :array
+                    node = args.last.last
+                when :argspush
+                    node = args.last[:body]
+                else
+                    return
+                end
+            else
+                return
+            end
+        end
+    end
+
+    def values(cfun, nreused, *rvalues) # :yield: *vals
+        header = "{"
+        cfun.l(header)
+        res = 0
+        reuse = 0
+        vals = []
+        res_assign = ""
+        res_val = ""
+        direct = /\A\s*(\w+(\s*\[\s*\d+\s*\])?|\d+)\s*\Z/
+        rvalues.each { |rvalue|
+            nreused -= 1
+            val = rvalue && cfun.comp(rvalue)
+            if val == "res"
+                if res_assign
+                    header.concat("VALUE res#{res};")
+                    res += 1
+                end
+                var = "res#{res}"
+                cfun.l(res_assign = "#{var} = #{val};")
+                res_val = val = var
+            elsif nreused >= 0 and val and val !~ direct
+                var = "reuse#{reuse}"
+                header.concat("VALUE #{var};")
+                cfun.l("#{var} = #{val};")
+                val = var
+            end
+            vals << val
+        }
+        res_assign.replace("")
+        res_val.replace("res")
+        if header.size == 1
+            header.replace("")
+            yield(*vals)
+        else
+            res_rvalue = yield(*vals)
+            cfun.assign_res(res_rvalue)
+            cfun.l "}"
+            "res"
+        end
+    end
+
+    def split_args(arity, args, extra_allowed=nil)
+        if arity<0
+            extra_allowed = true
+            arity = -arity -1
+        end
+        data = args.last
+        required = []
+        remaining = nil
+        case args.first
+        when :array
+            if data.size>arity
+                required = data[0, arity]
+                remaining = [:array, data[arity, data.size-arity]]
+            else
+                required = data
+            end
+        when :splat
+            remaining = args
+        when :argscat
+            required = split_args(arity, data[:head], true) or return nil
+            remaining = [:argscat, {:head => required.pop, :body => data[:body]}]
+        when :argspush
+            if extra_allowed
+                required = split_args(arity, data[:head], true) or return nil
+                remaining = [:argspush, {:head => required.pop, :body => data[:body]}]
+            else
+                required = split_args(arity-1, data[:head], false) or return nil
+                required << data[:body]
+            end
+        else
+            return nil
+        end
+        if required.size<arity
+            nil
+        elsif extra_allowed
+            remaining ||= [:array, []]
+            required << remaining
+        elsif remaining
+            nil
+        else
+            required
+        end
+    end
+
+    def args_arity(args)
+        data = args.last
+        case args.first
+        when :array
+            data.size
+        when :splat
+            -1
+        when :argscat
+            arity = args_arity(data[:head])
+            (arity<0) ? arity : -arity - 1
+        when :argspush
+            arity = args_arity(data[:head])
+            (arity<0) ? arity : arity + 1
+        else
+            -1
+        end
+    end
+
+end
+
+end
+
+

data/lib/ruby2cext/plugins/warnings.rb

@@ -0,0 +1,121 @@
+
+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