rb-threadframe 0.32

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (C) 2010  Rocky Bernstein <rockyb@rubyforge.org>
+All rights reserved.
+ *
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ *
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/NEWS

@@ -0,0 +1,2 @@
+September 12 2010 (0.32)
+  First release on gemcutter

data/README.md

@@ -0,0 +1,9 @@
+# rb-threadframe
+
+rb-threadframe gives introspection access for frames of a thread.
+
+## Requirements
+
+A patched version of Ruby 1.9.2 is needed.
+
+See the [wiki](http://github.com/rocky/rb-threadframe/wiki) for more information.

data/Rakefile

@@ -0,0 +1,162 @@
+#!/usr/bin/env rake
+# -*- Ruby -*-
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+rake_dir = File.dirname(__FILE__)
+
+require 'rbconfig'
+RUBY_PATH = File.join(RbConfig::CONFIG['bindir'],  
+                      RbConfig::CONFIG['RUBY_INSTALL_NAME'])
+
+SO_NAME = 'thread_frame.so'
+
+PACKAGE_VERSION = open("ext/thread_frame.c") do |f| 
+  f.grep(/^#define THREADFRAME_VERSION/).first[/"(.+)"/,1]
+end
+
+EXT_FILES     = FileList[%w(ext/*.c ext/*.h)]
+INCLUDE_FILES = FileList['include/*.h']
+LIB_FILES     = FileList['lib/*.rb']
+TEST_FILES    = FileList['test/**/*.rb']
+COMMON_FILES  = FileList[%w(README.md Rakefile LICENSE NEWS)]
+ALL_FILES     = COMMON_FILES + INCLUDE_FILES + LIB_FILES + EXT_FILES + 
+  TEST_FILES
+
+desc 'Create the core thread-frame shared library extension'
+task :ext do
+  Dir.chdir('ext') do
+    system("#{Gem.ruby} extconf.rb && make")
+  end
+end
+
+desc 'Remove built files'
+task :clean do
+  cd 'ext' do
+    if File.exist?('Makefile')
+      sh 'make clean'
+      rm 'Makefile'
+    end
+    derived_files = Dir.glob('.o') + Dir.glob('*.so')
+    rm derived_files unless derived_files.empty?
+  end
+end
+
+def run_standalone_ruby_file(directory)
+  puts ('*' * 10) + ' ' + directory + ' ' + ('*' * 10)
+  Dir.chdir(directory) do
+    Dir.glob('*.rb').each do |ruby_file|
+      puts ('-' * 20) + ' ' + ruby_file + ' ' + ('-' * 20)
+      system(RUBY_PATH, ruby_file)
+    end
+  end
+end
+
+desc "Create a GNU-style ChangeLog via git2cl"
+task :ChangeLog do
+  system("git log --pretty --numstat --summary | git2cl > ChangeLog")
+end
+
+task :default => [:test]
+
+desc 'Test units - the smaller tests'
+task :'test:unit' => [:ext] do |t|
+  Rake::TestTask.new(:'test:unit') do |t|
+    t.libs << './ext'
+    t.test_files = FileList['test/unit/**/*.rb']
+    # t.pattern = 'test/**/*test-*.rb' # instead of above
+    t.verbose = true
+  end
+end
+
+desc 'Test everything - unit tests for now.'
+task :test do
+  exceptions = ['test:unit'].collect do |task|
+    begin
+      Rake::Task[task].invoke
+      nil
+    rescue => e
+      e
+    end
+  end.compact
+  
+  exceptions.each {|e| puts e;puts e.backtrace }
+  raise "Test failures" unless exceptions.empty?
+end
+
+desc "Test everything - same as test."
+
+task :'check' do
+  run_standalone_ruby_file(File.join(%W(#{rake_dir} test unit)))
+end
+
+# ---------  RDoc Documentation ------
+desc 'Generate rdoc documentation'
+Rake::RDocTask.new('rdoc') do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.title    = 'rb-threadframe'
+  # Show source inline with line numbers
+  rdoc.options << '--inline-source' << '--line-numbers'
+  # Make the readme file the start page for the generated html
+  rdoc.options << '--main' << 'README.md'
+  rdoc.rdoc_files.include('ext/**/*.c',
+                          'README.md')
+end
+
+# Base GEM Specification
+spec = Gem::Specification.new do |spec|
+  spec.name = "rb-threadframe"
+  
+  spec.homepage = "http://github.com/rocky/rb-threadframe/tree/master"
+  spec.summary = "Frame introspection"
+  spec.description = <<-EOF
+
+rb-threadframe gives introspection access for frames of a thread.
+EOF
+
+  spec.version = PACKAGE_VERSION
+  spec.require_path = 'lib'
+  spec.extensions = ["ext/extconf.rb"]
+
+  spec.author = "R. Bernstein"
+  spec.email = "rocky@gnu.org"
+  spec.platform = Gem::Platform::RUBY
+  spec.files = ALL_FILES.to_a  
+
+  spec.required_ruby_version = '>= 1.9.2'
+  spec.date = Time.now
+  # spec.rubyforge_project = 'rocky-hacks'
+  
+  # rdoc
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = ['README.md', 'threadframe.rd'] + 
+                           FileList['ext/*.c']
+end
+
+# Rake task to build the default package
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end
+
+def install(spec, *opts)
+  args = ['gem', 'install', "pkg/#{spec.name}-#{spec.version}.gem"] + opts
+  system(*args)
+end
+
+desc 'Install locally'
+task :install => :package do
+  Dir.chdir(File::dirname(__FILE__)) do
+    # ri and rdoc take lots of time
+    install(spec, '--no-ri', '--no-rdoc')
+  end
+end    
+
+task :install_full => :package do
+  Dir.chdir(File::dirname(__FILE__)) do
+    install(spec)
+  end
+end    
+

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+
+fail "You need to install a threadframe-patched Ruby.
+See http://github.com/rocky/rb-threadframe/wiki/How-to-Install" unless 
+  RbConfig::CONFIG.member?('rb-threadframe')
+
+config_file = File.join(File.dirname(__FILE__), 'config_options')
+load config_file if File.exist?(config_file)
+
+# Temporary: to turn off optimization
+# $CFLAGS='-fno-strict-aliasing -g -fPIC'
+create_makefile("thread_frame")

data/ext/iseq_extra.c

@@ -0,0 +1,404 @@
+/* 
+ * Copyright (C) 2010 Rocky Bernstein
+ */
+#if 0  /* The following is to fake out rdoc, until I find a better fix. */
+/* 
+ *  Additions to the RubyVM::InstructionSequence class
+ */
+VALUE rb_cIseq = rb_define_class_under(rb_cRubyVM, "InstructionSequence", ...)
+#endif
+
+#include "../include/vm_core_mini.h"   /* Pulls in ruby.h and node.h */
+#ifdef HAVE_COMPILE_OPTIONS
+#endif
+#include "iseq_mini.h"  /* Pulls in ruby.h */
+#include "../include/ruby19_externs.h"
+#include <string.h>       /* For strlen() */
+
+struct iseq_insn_info_entry {
+    unsigned short position;
+    unsigned short line_no;
+    unsigned short sp;
+};
+
+#ifdef HAVE_COMPILE_OPTIONS
+/* 
+ *  Document-method: RubyVM::InstructionSequence::compile_options
+ *
+ *  call-seq:
+ *     RubyVM::InstructionSequence#compile_options -> Hash
+ *
+ *  Returns a hash of the compiler options used to create the 
+ *  instruction sequence.
+ */
+VALUE
+iseq_compile_options(VALUE iseqval)
+{
+    rb_iseq_t *iseq;
+    if (Qnil == iseqval) return Qnil;
+    else {
+	VALUE hash_opts = rb_hash_new();
+	rb_compile_option_t *compile_opts;
+	GetISeqPtr(iseqval, iseq);
+	if (!iseq->compile_data) return Qnil;
+	compile_opts = iseq->compile_data->option;
+	rb_hash_aset(hash_opts, rb_str_new2("inline_const_cache"), 
+		     (compile_opts->inline_const_cache) ? Qtrue : Qfalse);
+	return hash_opts;
+    }
+    
+}
+#endif
+
+/* 
+ *  Document-method: RubyVM::InstructionSequence::encoded
+ * 
+ *  call-seq:
+ *     RubyVM::InstructionSequence#iseq_encoded -> String
+ *
+ *  Returns a string of the encoded bytes of the instruction
+ *  sequence. Note that this is probably not usable as is, may be useful in
+ *  decoding instructions (using other info) or for getting a sha1
+ *  checksum.
+ */
+VALUE 
+iseq_iseq_encoded(VALUE iseqval)
+{
+    rb_iseq_t *iseq;
+    GetISeqPtr(iseqval, iseq);
+    return rb_str_new((char *) iseq->iseq_encoded, iseq->iseq_size);
+}
+
+
+/* 
+ *  Document-method: RubyVM::InstructionSequence::equal?
+ * 
+ *  call-seq:
+ *     RubyVM::InstructionSequence#equal?(iseq2) -> bool
+ *
+ *  Returns true if the instruction sequences are equal.
+ */
+VALUE 
+iseq_equal(VALUE iseqval1, VALUE iseqval2)
+{
+    rb_iseq_t *iseq1, *iseq2;
+
+    if (Qnil == iseqval2) return Qfalse;
+    if (!rb_obj_is_kind_of(iseqval2, rb_cISeq)) {
+	rb_raise(rb_eTypeError, 
+		 "comparison argument must be an instance of %s or nil (is %s)",
+		 rb_obj_classname(iseqval1), rb_obj_classname(iseqval2));
+    }
+    
+    if (iseqval1 == iseqval2) return Qtrue;
+    GetISeqPtr(iseqval1, iseq1);
+    GetISeqPtr(iseqval2, iseq2);
+
+    /* FIXME: the count 28 below  is bogus. I think this should be the fields
+       from "type" to  "mark_ary". Should also include iseq->encoded.
+     */
+    if (0 == memcmp(iseq1, iseq2, 28))
+	return Qtrue;
+    else
+	return Qfalse;
+}
+
+
+/* 
+ * call-seq:
+ *     RubyVM::InstructionSequence#local_name(i) - String
+ * 
+ *  Returns the string name of local variable in i'th position
+ *  of the instruction sequence local table, or nil if i is
+ * out of range.
+ */
+VALUE
+iseq_local_name(VALUE iseqval, VALUE val)
+{
+    rb_iseq_t *iseq;
+    if (FIXNUM_P(val)) {
+      long int i = FIX2INT(val);
+      long int size;
+      
+      GetISeqPtr(iseqval, iseq);
+      
+      size = iseq->local_table_size;
+      
+      if (i < 0) i = size + i;
+      
+      if (i >= size)
+	rb_raise(rb_eIndexError, 
+		 "local table index %ld should be in the range -%ld .. %ld",
+		 i, size, size-1);
+      
+      return rb_str_new2(rb_id2name(iseq->local_table[i]));
+    } else {
+      rb_raise(rb_eTypeError, "type mismatch: %s given, Fixnum expected", 
+	       rb_class2name(CLASS_OF(val)));
+    }
+    /* not reached. */
+    return Qnil;
+}
+
+/* 
+ * call-seq:
+ *     RubyVM::InstructionSequence#name -> String
+ * 
+ *  Returns the name if the instruction sequence.
+ */
+VALUE
+iseq_name(VALUE iseqval)
+{
+    rb_iseq_t *iseq;
+    GetISeqPtr(iseqval, iseq);
+    return(iseq->name);
+}
+
+/* 
+ * call-seq:
+ *     RubyVM::InstructionSequence#offsetlines -> Hash[Fixnum] -> [Fixnum]
+ * 
+ * Returns an hash. The keys in the hash form the VM offsets of the
+ * instructions.  The value of the hash for a given offset is a list
+ * of line numbers associated with that offset.
+ */
+VALUE iseq_offsetlines(VALUE iseqval)
+{
+    rb_iseq_t *iseq;
+    VALUE offsetlines = rb_hash_new();
+    unsigned long i, size;
+    struct iseq_insn_info_entry *table;
+   
+    GetISeqPtr(iseqval, iseq);
+    
+    size = iseq->insn_info_size;
+    table = iseq->insn_info_table;
+
+    for (i = 0; i < size; i++) {
+	VALUE ary = rb_ary_new2(1);
+	rb_ary_push(ary, INT2FIX(table[i].line_no));
+	rb_hash_aset(offsetlines, INT2FIX(table[i].position), ary);
+    }
+    return offsetlines;
+}
+
+/* 
+ * call-seq:
+ *     RubyVM::InstructionSequence#offset2lines(offset) -> [Fixnum]
+ * 
+ * Returns an Array or nil. If offset is found then return the list of
+ * lines associated with that offset. If the offset isn't found return nil.
+ */
+VALUE iseq_offset2lines(VALUE iseqval, VALUE offsetval)
+{
+    rb_iseq_t *iseq;
+   
+    GetISeqPtr(iseqval, iseq);
+    
+    if (FIXNUM_P(offsetval)) {
+	unsigned long i, size;
+	int offset = FIX2INT(offsetval);
+	struct iseq_insn_info_entry *table;
+
+	size = iseq->insn_info_size;
+	table = iseq->insn_info_table;
+
+	for (i = 0; i < size; i++) {
+	    if (table[i].position == offset) {
+		VALUE ary = rb_ary_new2(1);
+		rb_ary_push(ary, INT2FIX(table[i].line_no));
+		return ary;
+	    }
+	}
+    }
+    return Qnil;
+}
+
+/* FIXME: should return array of destroyed entries */
+VALUE iseq_killcache(VALUE iseqval)
+{
+    rb_iseq_t *iseqdat;
+    VALUE *iseq ;
+    unsigned long i, size, count = 0;
+    struct iseq_insn_info_entry *table;
+
+    GetISeqPtr(iseqval, iseqdat);
+    iseq = iseqdat->iseq;
+    size = iseqdat->insn_info_size;
+    table = iseqdat->insn_info_table;
+    for (i = 0; i < size; i++) {
+      const unsigned long pos = table[i].position;
+      const VALUE insn = iseq[pos];
+      if (0 == strncmp(insn_name(insn), "getinlinecache", 
+		       sizeof("getinlinecache")))
+      {
+	/* printf("pos: %lu\n", pos); */
+	count ++;
+	iseq[pos] = 0;
+	iseq[pos+1] = 0;
+	iseq[pos+2] = 0;
+      }
+    }
+    return INT2FIX(count);
+}
+
+const char *
+source_container_type(VALUE fileval) 
+{
+    const char *filename = RSTRING_PTR(fileval);
+    size_t len = strlen(filename);
+
+    /* FIXME: Looking for (...) is a hack that I would love to know how
+       to remove. Probably Ruby has to be changed to record this kind
+       of information.
+     */
+    if (len > 0 && 
+	((filename[0] == '(' && filename[len-1] == ')')
+	 || 0 == strncmp(filename, "<compiled>", 
+			 sizeof("<compiled>"))))
+	return "string";
+    else
+	return "file";
+}
+
+
+VALUE
+iseq_source_container_internal(rb_iseq_t *iseq)
+{
+    VALUE fileval = iseq->filename;
+    const char *contain_type = source_container_type(fileval);
+    
+    return rb_ary_new3(2, rb_str_new2(contain_type), fileval);
+}
+
+/*
+ * call-seq:
+ *    RubyVM::InstructionSequence#source_container() -> [Type, String]
+ *
+ * Returns a tuple representing kind of container, e.g. file
+ * eval'd string object, and the name of the container. If file,
+ * it would be a file name. If an eval'd string it might be the string.
+ */
+static VALUE
+iseq_source_container(VALUE iseqval)
+{
+    rb_iseq_t *iseq;
+   
+    if (Qnil == iseqval) return Qnil;
+    GetISeqPtr(iseqval, iseq);
+    return iseq_source_container_internal(iseq);
+}
+
+
+#if 0
+/*
+ * call-seq:
+ *    RubyVM::InstructionSequence#type() -> Fixnum
+ *
+ * Returns instruction-sequence type.
+ */
+static VALUE
+iseq_type(VALUE iseqval)
+#endif
+
+#define ISEQ_FIELD_METHOD(FIELD)		\
+static VALUE					\
+iseq_##FIELD(VALUE iseqval)			\
+{						\
+  rb_iseq_t *iseq;				\
+  if (Qnil == iseqval) return Qnil;		\
+  GetISeqPtr(iseqval, iseq);			\
+  return iseq->FIELD;				\
+}
+
+ISEQ_FIELD_METHOD(orig) ;
+ISEQ_FIELD_METHOD(self) ;
+ISEQ_FIELD_METHOD(type) ;
+
+#define ISEQ_INT_FIELD_METHOD(FIELD)		\
+extern VALUE					\
+iseq_##FIELD(VALUE iseqval)			\
+{						\
+  rb_iseq_t *iseq;				\
+  GetISeqPtr(iseqval, iseq);			\
+  return INT2FIX(iseq->FIELD);			\
+}
+
+ISEQ_INT_FIELD_METHOD(arg_block) ;
+ISEQ_INT_FIELD_METHOD(arg_opts) ;
+ISEQ_INT_FIELD_METHOD(arg_post_len) ;
+ISEQ_INT_FIELD_METHOD(arg_rest) ;
+ISEQ_INT_FIELD_METHOD(arg_simple) ;
+ISEQ_INT_FIELD_METHOD(argc) ;
+ISEQ_INT_FIELD_METHOD(iseq_size) ;
+ISEQ_INT_FIELD_METHOD(klass) ;
+ISEQ_INT_FIELD_METHOD(line_no) ;
+ISEQ_INT_FIELD_METHOD(local_size) ;
+ISEQ_INT_FIELD_METHOD(local_table_size) ;
+
+/*
+ * call-seq:
+ *    RubyVM::InstructionSequence#line_range() -> Range
+ *
+ * Returns a range containing the starting line number and the
+ * ending line of the source code for the instruction-sequence.
+ */
+static VALUE
+iseq_line_range(VALUE iseqval) 
+{
+    rb_iseq_t *iseq;
+
+    GetISeqPtr(iseqval, iseq);
+    if (Qnil == iseqval) return Qnil;
+    else {
+	unsigned long i, size = iseq->insn_info_size;
+	struct iseq_insn_info_entry *table = iseq->insn_info_table;
+	unsigned short min_line = table[0].line_no;
+	unsigned short max_line = table[0].line_no;
+	
+	for (i = 0; i < size; i++) {
+	    if (table[i].line_no < min_line) 
+		min_line = table[i].line_no;
+	    else if (table[i].line_no > max_line)
+		max_line = table[i].line_no;
+	}
+	return rb_range_new(INT2FIX(min_line), INT2FIX(max_line), 0);
+    }
+}
+
+
+/* RDoc can't find methods when we use a definition like this: */
+#define RB_DEFINE_ISEQ_METHOD(FIELD, ARGC) \
+    rb_define_method(rb_cISeq, #FIELD, iseq_##FIELD, ARGC);
+
+void
+Init_iseq_extra(void)
+{
+    rb_define_method(rb_cISeq, "arg_block",        iseq_arg_block, 0) ;
+    rb_define_method(rb_cISeq, "arg_opts",         iseq_arg_opts, 0) ;
+    rb_define_method(rb_cISeq, "arg_post_len",     iseq_arg_post_len, 0) ;
+    rb_define_method(rb_cISeq, "arg_rest",         iseq_arg_rest, 0) ;
+    rb_define_method(rb_cISeq, "arg_simple",       iseq_arg_simple, 0) ;
+    rb_define_method(rb_cISeq, "argc",             iseq_argc, 0) ;
+#ifdef HAVE_COMPILE_OPTIONS
+    rb_define_method(rb_cISeq, "compile_options",  iseq_compile_options, 0) ;
+#endif
+    rb_define_method(rb_cISeq, "equal?",           iseq_equal, 1) ;
+    rb_define_method(rb_cISeq, "encoded",          iseq_iseq_encoded, 0) ;
+    rb_define_method(rb_cISeq, "iseq_size",        iseq_iseq_size, 0) ;
+    rb_define_method(rb_cISeq, "killcache",        iseq_killcache, 0) ;
+    rb_define_method(rb_cISeq, "klass",            iseq_klass, 0) ;
+    rb_define_method(rb_cISeq, "lineno",           iseq_line_no, 0) ;
+    rb_define_method(rb_cISeq, "line_range",       iseq_line_range, 0) ;
+    rb_define_method(rb_cISeq, "local_name",       iseq_local_name, 1) ;
+    rb_define_method(rb_cISeq, "local_size",       iseq_local_size, 0) ;
+    rb_define_method(rb_cISeq, "local_table_size", iseq_local_table_size, 0) ;
+    rb_define_method(rb_cISeq, "offset2lines",     iseq_offset2lines, 1) ;
+    rb_define_method(rb_cISeq, "offsetlines",      iseq_offsetlines, 0) ;
+    rb_define_method(rb_cISeq, "orig",             iseq_orig, 0) ;
+    rb_define_method(rb_cISeq, "name",             iseq_name, 0) ;
+    rb_define_method(rb_cISeq, "self",             iseq_self, 0) ;
+    rb_define_method(rb_cISeq, "source_container", iseq_source_container, 0) ;
+    rb_define_method(rb_cISeq, "type",             iseq_type, 0) ;
+
+}