sender 1.3 → 1.4

data/CHANGELOG.rdoc

@@ -26,3 +26,9 @@ in the long term, I am investing what needs to be done for the special case.
 
 Added init_sender_callbacks( sender, caller ) to take care of :initialize issue. Include Sender module in your class to activate and 
 :init_sender_callbacks( __sender__, __caller__ ) will be called on self from self.class.new before self.initialize.
+
+=== 1.4 2010-06-29
+
+Removed init_sender_callbacks that were added in 1.3.
+New implementation of backtrace- now works for :initialize.
+__sender__ and __caller__ now work for :initialize and return the object and method that called :new.

data/Makefile

@@ -53,7 +53,7 @@ COUTFLAG = -o
 RUBY_EXTCONF_H = 
 cflags   = $(optflags) $(debugflags) $(warnflags)
 optflags = 
-debugflags = -g
+debugflags = -gdwarf-2 -g3  
 warnflags = -Wall -Wno-parentheses
 CFLAGS   =  -fno-common  $(cflags)  -fno-common -pipe -fno-common 
 INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir) -I/usr/src/ruby

data/Manifest.txt

@@ -4,6 +4,7 @@ Makefile
 Manifest.txt
 README.rdoc
 Rakefile
+VERSION.rdoc
 ext/sender/RPSender_internal.c
 ext/sender/RPSender_internal.h
 ext/sender/RubySourceSupport.c
@@ -24,6 +25,7 @@ ext/sender/rb_Global.h
 ext/sender/rb_Global_internal.h
 ext/sender/rb_Kernel.c
 ext/sender/rb_Kernel.h
+ext/sender/rb_Kernel_internal.h
 ext/sender/regenc.h
 ext/sender/regint.h
 ext/sender/regparse.h

data/README.rdoc

@@ -28,28 +28,42 @@ which allows contents of the backtrace to be queried.
 
 == EXAMPLE:
 
-	require 'sender'
-
 	require '../sender/lib/sender/sender'
 
 	require 'pp'
 
 	class Test
-
+  
+	  def initialize
+	    puts 'In method <Test>:initialize'
+	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
+	    puts 'Caller was: ' + __caller__.to_s
+	  end
+  
 	  def test
+	    puts 'In <Test>:test'
 	    self.another_test
 	  end
-
+  
 	  def another_test
+	    puts 'In method <Test>:another_test'
 	    test2 = Test2.new
 	    test2.and_another_test_in_another_object
 	  end
-
+    
 	end
 
 	class Test2
-
+  
+	  def initialize
+	    puts 'In method <Test2>:initialize'
+	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
+	    puts 'Caller was: ' + __caller__.to_s
+	  end
+  
 	  def and_another_test_in_another_object
+	    puts 'In method <Test2>:and_another_test_in_another_object'
+	    pp self
 	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
 	    puts 'Caller was: ' + __caller__.to_s
 	    pp Kernel.backtrace    
@@ -60,26 +74,56 @@ which allows contents of the backtrace to be queried.
 	    pp Kernel.backtrace_includes?( $test )
 	    pp Kernel.backtrace_includes?( :another_test, Test, $test )
 	    puts 'These should be false:'
-	    pp Kernel.backtrace_includes?( :non_existing_function )
+	    pp Kernel.backtrace_includes?( :yet_another_test )
 	    pp Kernel.backtrace_includes?( Test2 )
 	    pp Kernel.backtrace_includes?( self )
-	    pp Kernel.backtrace_includes?( :non_existing_function, Test2, self )
+	    pp Kernel.backtrace_includes?( :yet_another_test, Test2, self )
 	  end
-
+  
 	end
 
 	$test = Test.new
 	$test.test
+
+	puts 'Finished Test.'
+	exit
 	
 == EXAMPLE's OUTPUT:
 	
-	Sender was: #<Test:0x0000010101ef18>
-	Caller was: and_another_test_in_another_object
-	[{:object=>#<Test:0x0000010101ef18>, :method=>:another_test},
-	 {:object=>#<Test:0x0000010101ef18>, :method=>:test},
-	 {:object=>main}]
-	[{:object=>#<Test:0x0000010101ef18>, :method=>:another_test},
-	 {:object=>#<Test:0x0000010101ef18>, :method=>:test}]
+	In method <Test>:initialize
+	Sender was: main
+	Caller was: <main>
+	In <Test>:test
+	In method <Test>:another_test
+	In method <Test2>:initialize
+	Sender was: #<Test:0x0000010180ddf8>
+	Caller was: another_test
+	In method <Test2>:and_another_test_in_another_object
+	#<Test2:0x0000010180b158>
+	Sender was: #<Test:0x0000010180ddf8>
+	Caller was: another_test
+	[{:object=>#<Test2:0x0000010180b158>,
+	  :file=>"sender_test.rb",
+	  :line=>39,
+	  :method=>"and_another_test_in_another_object"},
+	 {:object=>#<Test:0x0000010180ddf8>,
+	  :file=>"sender_test.rb",
+	  :line=>21,
+	  :method=>"another_test"},
+	 {:object=>#<Test:0x0000010180ddf8>,
+	  :file=>"sender_test.rb",
+	  :line=>15,
+	  :method=>"test"},
+	 {:object=>main, :file=>"sender_test.rb", :line=>56, :method=>"<main>"},
+	 {:object=>main, :file=>"<main>", :line=>0, :method=>"<main>"}]
+	[{:object=>#<Test2:0x0000010180b158>,
+	  :file=>"sender_test.rb",
+	  :line=>40,
+	  :method=>"and_another_test_in_another_object"},
+	 {:object=>#<Test:0x0000010180ddf8>,
+	  :file=>"sender_test.rb",
+	  :line=>21,
+	  :method=>"another_test"}]
 	These should be true:
 	true
 	true
@@ -90,6 +134,7 @@ which allows contents of the backtrace to be queried.
 	false
 	false
 	false
+	Finished Test.
 
 == LICENSE:
 

data/Rakefile

@@ -11,7 +11,7 @@ Hoe.spec 'sender' do
   self.spec_extras			= { :extensions => ["ext/sender/extconf.rb"] }
   self.extra_dev_deps << ['rake-compiler', '>= 0']  
 
-  self.version="1.3"
+  self.version=File.open( 'VERSION.rdoc' ).readline
 
   Rake::ExtensionTask.new( 'sender', spec ) do |ext|
     ext.lib_dir = File.join('lib', 'sender')

data/VERSION.rdoc

@@ -0,0 +1 @@
+1.4

data/ext/sender/RPSender_internal.c

@@ -2,9 +2,9 @@
 #include "RPSender_internal.h"
 #include "RubySourceSupport.h"
 
-/*************************
- *  framePriorToCurrent  *
- ************************/
+/******************
+ *  framePriorTo  *
+ *****************/
 
 rb_control_frame_t* RPRuby_internal_framePriorTo( rb_control_frame_t* c_control_frame )	{
 	
@@ -35,32 +35,3 @@ rb_control_frame_t* RPRuby_internal_framePriorTo( rb_control_frame_t* c_control_
 	
 }
 
-/**********************************
- *  backtraceHashForControlFrame  *
- *********************************/
-
-VALUE RPSender_internal_backtraceHashForControlFrame( rb_control_frame_t* c_control_frame )	{
-
-	//	create new hash for this frame
-	VALUE	rb_frame_hash		=	rb_hash_new();
-	
-	//	get object and set in hash
-	VALUE	rb_object_for_frame	=	c_control_frame->self;
-	//	if we get nil we're done with our backtrace
-	rb_hash_aset(	rb_frame_hash,
-					ID2SYM( rb_intern( "object" ) ),
-					rb_object_for_frame );
-	
-	//	get method and set in hash
-	ID		c_frame_function_id	=	frame_func_id( c_control_frame );
-	//	main has no method name
-	if ( c_frame_function_id != 0)	{
-		VALUE	rb_method_for_frame	=	ID2SYM( c_frame_function_id );
-		rb_hash_aset(	rb_frame_hash,
-						ID2SYM( rb_intern( "method" ) ),
-						rb_method_for_frame );
-		
-	}
-	
-	return rb_frame_hash;
-}

data/ext/sender/RPSender_internal.h

@@ -5,6 +5,6 @@
 	#include "eval_intern.h"
 
 	rb_control_frame_t* RPRuby_internal_framePriorTo( rb_control_frame_t* control_frame );
-	VALUE RPSender_internal_backtraceHashForControlFrame( rb_control_frame_t* c_control_frame );
+	VALUE RPSender_internal_backtraceHashForControlFrame( const rb_control_frame_t* c_top_of_control_frame );
 
 #endif

data/ext/sender/RubySourceSupport.c

@@ -1,6 +1,11 @@
 
 #include "RubySourceSupport.h"
 
+#include "rb_Kernel.h"
+#include "RPSender_internal.h"
+
+#include "iseq.h"
+
 //	Taken from eval.c in Ruby source
 //	No header, so easiest way to integrate was to copy the code and make my own header.
 //	Previously declared static; otherwise unchanged
@@ -38,3 +43,33 @@ ID rb_frame_caller(void)
     return frame_func_id(prev_cfp);
 }
 
+int rb_vm_get_sourceline(const rb_control_frame_t *cfp)
+{
+    int line_no = 0;
+    const rb_iseq_t *iseq = cfp->iseq;
+	
+    if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+		rb_num_t i;
+		size_t pos = cfp->pc - cfp->iseq->iseq_encoded;
+		
+		for (i = 0; i < iseq->insn_info_size; i++) {
+			if (iseq->insn_info_table[i].position == pos) {
+				if (i == 0) goto found;
+				line_no = iseq->insn_info_table[i - 1].line_no;
+				goto found;
+			}
+		}
+		line_no = iseq->insn_info_table[i - 1].line_no;
+    }
+found:
+    return line_no;
+}
+
+
+
+
+
+
+
+
+

data/ext/sender/RubySourceSupport.h

@@ -7,5 +7,6 @@
 
 	ID frame_func_id( rb_control_frame_t *cfp );
 	ID rb_frame_caller(void);
+	int rb_vm_get_sourceline(const rb_control_frame_t *cfp);
 
 #endif

data/ext/sender/rb_Global.c

@@ -1,5 +1,6 @@
 
 #include "rb_Global.h"
+#include "rb_Kernel.h"
 
 //	Internals from ruby that aren't included in the ruby lib
 #include "RubySourceSupport.h"
@@ -34,17 +35,31 @@ void Init_senderGlobal()	{
  * Return object sending message to receiver.
  */
 VALUE rb_RPRuby_Sender___sender__()	{
+	
+	//	we want 3 levels of backtrace:
+	//	1: current call to __method__ (__method__ in context)
+	//	2: the frame we want, unless it is :new (call to context: __sender__)
+	//	3: the frame we want in the case #2 is :new
+	VALUE	rb_backtrace_limit		=	INT2FIX( 3 );
+
+	VALUE	rb_backtrace_array		=	rb_RPRuby_Sender_Kernel_backtrace(	1,
+																		& rb_backtrace_limit,
+																		rb_mKernel );
 
-	//	get the frame prior to current frame
-	rb_control_frame_t*		c_sending_frame	=	RPRuby_internal_framePriorTo( NULL );
+	VALUE	rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, 1 );
+													
+	VALUE	rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+											ID2SYM( rb_intern( "method" ) ) );
 	
-	//	make sure the current frame wasn't the first frame or return nil
-	if ( c_sending_frame == NULL )	{
-		return Qnil;
+	if ( rb_caller == ID2SYM( rb_intern( "new" ) ) )	{	
+		rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, 2 );
 	}
 	
+	VALUE	rb_sender	=	rb_hash_aref(	rb_backtrace_frame_hash,
+											ID2SYM( rb_intern( "object" ) ) );
+
 	//	assuming we have a previous frame, return its rb_self (our current receiver's sender)
-	return c_sending_frame->self;
+	return rb_sender;
 }
 
 /***************
@@ -59,14 +74,30 @@ VALUE rb_RPRuby_Sender___sender__()	{
  */
 VALUE rb_RPRuby_Sender___caller__()	{
 
-	//	get the frame prior to current frame
-	rb_control_frame_t*		c_sending_frame	=	RPRuby_internal_framePriorTo( NULL );
+
+	//	we want 3 levels of backtrace:
+	//	1: current call to __method__ (__method__ in context)
+	//	2: the frame we want, unless it is :new (call to context: __sender__)
+	//	3: the frame we want in the case #2 is :new
+	VALUE	rb_backtrace_limit		=	INT2FIX( 3 );
 	
-	//	make sure the current frame wasn't the first frame or return nil
-	if ( c_sending_frame == NULL )	{
-		return Qnil;
+	VALUE	rb_backtrace_array		=	rb_RPRuby_Sender_Kernel_backtrace(	1,
+																		  & rb_backtrace_limit,
+																		  rb_mKernel );
+	
+	VALUE	rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, 1 );
+	
+	VALUE	rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+										 ID2SYM( rb_intern( "method" ) ) );
+	
+	if ( rb_caller == ID2SYM( rb_intern( "new" ) ) )	{	
+		rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, 2 );
+		
+		rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+										ID2SYM( rb_intern( "method" ) ) );
 	}
 	
-	return ID2SYM( frame_func_id( c_sending_frame ) );
+	//	assuming we have a previous frame, return its rb_self (our current receiver's sender)
+	return rb_caller;
 }
 

data/ext/sender/rb_Global_internal.h

@@ -3,5 +3,6 @@
 	#define RP_SENDER_CALLER_GLOBAL_INTERNAL
 	
 	rb_control_frame_t* RPRuby_internal_framePriorTo();
+	rb_control_instruction_t* RPRuby_internal_instructionPriorTo( rb_control_instruction_t* c_control_instruction );
 
 #endif

data/ext/sender/rb_Kernel.c

@@ -1,5 +1,6 @@
 
 #include "rb_Kernel.h"
+#include "rb_Kernel_internal.h"
 
 #include "RPSender_internal.h"
 
@@ -28,60 +29,73 @@ void Init_senderKernel()	{
 
 /*
  * call-seq:
- *   __backtrace__( number_of_frames = nil ) -> [ { :object => object, :method => method }, ... ]
+ *   Kernel.backtrace( number_of_frames = nil ) -> [ { :object => object, :method => method }, ... ]
  *
  * Return array of hashes with object and method frame information for backtrace.
  * Specifying number_of_frames will cause only the last number_of_frames to be returned.
+ * Kernel.backtrace returns all frames including the current context (__method__/__callee__).
  */
 VALUE rb_RPRuby_Sender_Kernel_backtrace(	int		argc,
 											VALUE*	args,
 											VALUE	rb_self )	{
-	
-	//	create return array
-	VALUE	rb_return_array	=	rb_ary_new();
-	
-	//	for each previous frame
-	rb_control_frame_t*		c_control_frame		=	NULL;
-	int						c_stack_level		=	0;
-	int						c_max_stack_level	=	0;
+
+	//	Get max stack level from args if it is there
+	int		c_max_stack_level	=	0;
 	if ( argc )	{
 		c_max_stack_level	=	FIX2INT( args[ 0 ] );
+		
+		//	if max_stack_level is 0 return empty array
+		if ( c_max_stack_level == 0 )	{
+			return rb_ary_new();
+		}
+		//	if max_stack_level < 0, throw error
+		else if ( c_max_stack_level < 0 ) {
+			rb_raise( rb_eArgError, RPRUBY_SENDER_ERROR_STACK_LEVEL_LESS_THAN_ZERO );
+		}
+		
 	}
-	//	loop while we have a prior control frame
-	while (		( c_control_frame = RPRuby_internal_framePriorTo( c_control_frame ) ) != NULL
-		   //	and as long as we either have no stack limit specified, or until we reach the stack limit
+	
+	rb_thread_t*			c_thread					= GET_THREAD();
+	//	Get the current frame - we're doing a backtrace, so our current working frame to start is the first previous thread
+	rb_control_frame_t*		c_current_context_frame		= RUBY_VM_PREVIOUS_CONTROL_FRAME( c_thread->cfp );
+	
+	//	c_top_of_control_frame describes the top edge of the stack trace
+	//	set c_top_of_control_frame to the first frame in <main>
+    rb_control_frame_t*		c_top_of_control_frame	=	RUBY_VM_NEXT_CONTROL_FRAME( RUBY_VM_NEXT_CONTROL_FRAME( (void *)( c_thread->stack + c_thread->stack_size ) ) );
+	
+	VALUE	rb_return_array	=	rb_ary_new();
+	
+	int	c_stack_level	=	0;
+	//	for each control frame:
+    while (		c_current_context_frame < c_top_of_control_frame
 		   &&	(	argc == 0
-				 ||	c_stack_level < c_max_stack_level ) )	{
-
-		//	get hash of info for this frame
-		VALUE	rb_frame_hash	=	RPSender_internal_backtraceHashForControlFrame( c_control_frame );
-
-		if ( rb_frame_hash == Qnil )	{
-			break;
-		}
-			   
+				 ||	c_stack_level < c_max_stack_level ) ) {
+		
+		VALUE	rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
+	   
 		//	push hash to array
 		rb_ary_push(	rb_return_array,
 						rb_frame_hash );
-		
-		c_stack_level++;
-	}
-	
-	//	return return array
-	return rb_return_array;
+	   
+	   c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );
+	   c_stack_level++;
+   }
+   
+   return rb_return_array;
 }
 
+
 /*****************************
  *  __backtrace_includes?__  *
  ****************************/
 
 /*
  * call-seq:
- *   __backtrace_includes?( method_or_object, ... ) -> true or false
- *   __backtrace_includes?( number_of_frames, method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_includes?( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_includes?( number_of_frames, method_or_object, ... ) -> true or false
  *
  * Returns whether specified methods or objects or classes are in the current backtrace context.
- * Backtrace begins with the prior frame, so asking if the backtrace includes the current method
+ * Kernel.backtrace_includes? begins with the prior frame, so asking if the backtrace includes the current method
  * will only report true if the current method is part of the earlier call chain.
  */
 VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
@@ -91,66 +105,74 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
 	//	create tracking array
 	VALUE	rb_tracking_array	=	rb_ary_new();
 	
-	//	populate array with methods/objects
+	//	populate tracking array with methods/objects
 	int	c_which_arg	=	0;
 	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
 		rb_ary_push(	rb_tracking_array,
 						args[ c_which_arg ] );
 	}
+		
+	rb_thread_t*			c_thread					= GET_THREAD();
+	//	Get the current frame - we're doing a backtrace, so our current working frame to start is the first previous thread
+	rb_control_frame_t*		c_current_context_frame		= RUBY_VM_PREVIOUS_CONTROL_FRAME( RUBY_VM_PREVIOUS_CONTROL_FRAME( c_thread->cfp ) );
 	
-	//	for each previous frame
-	rb_control_frame_t*	c_control_frame	=	NULL;
-	while (	 ( c_control_frame = RPRuby_internal_framePriorTo( c_control_frame ) ) != NULL )	{
+	//	c_top_of_control_frame describes the top edge of the stack trace
+	//	set c_top_of_control_frame to the first frame in <main>
+    rb_control_frame_t*		c_top_of_control_frame	=	RUBY_VM_NEXT_CONTROL_FRAME( RUBY_VM_NEXT_CONTROL_FRAME( (void *)( c_thread->stack + c_thread->stack_size ) ) );
 	
+	//	for each control frame:
+    while ( c_current_context_frame < c_top_of_control_frame ) {
+	   
 		//	iterate each array member 
 		int	c_which_member;
 		for ( c_which_member = 0 ; c_which_member < RARRAY_LEN( rb_tracking_array ) ; c_which_member++ )	{
-			
+		   
 			VALUE	rb_array_member	=	args[ c_which_member ];
-			
+		   
 			int		matched	=	0;
-			
+		   
 			//	if rb_array_member is a class
 			if	( TYPE( rb_array_member ) == T_CLASS ) {
 				//	if rb_array_member is the current frame's object's class
-				if ( rb_array_member == rb_class_of( c_control_frame->self ) )	{
+				if ( rb_array_member == rb_class_of( c_current_context_frame->self ) )	{
 					matched	=	1;
 				}
 			}
 			//	if rb_array_member is a method symbol and matches our current frame's method
 			else if	( TYPE( rb_array_member ) == T_SYMBOL )	{
-				
-				if ( rb_to_id( rb_array_member ) == frame_func_id( c_control_frame ) )	{
+			   
+				if ( rb_to_id( rb_array_member ) == frame_func_id( c_current_context_frame ) )	{
 					matched	=	1;
 				}
 			}
 			//	if rb_array_member is an object
 			else if ( TYPE( rb_array_member ) == T_OBJECT )	{
 				//	if rb_array_member is the current frame's object (self)
-				if ( rb_array_member == c_control_frame->self )	{
+				if ( rb_array_member == c_current_context_frame->self )	{
 					matched	=	1;
 				}
 			}
-			
+		   
 			//	if array member exists in frame, remove from array
 			if ( matched )	{
 				//	delete this index
 				rb_ary_delete_at(	rb_tracking_array,
 									c_which_member );
-				
+			   
 				//	decrement the loop iterator so that the increase is offset
 				//	this is necessary since we just removed an index and are iterating vs. the length of the array
 				c_which_member--;
 			}
 		}
-		
+	   
 		//	if array is empty, return true
 		//	we check here as well as at the end so we can stop iterating the backtrace if we find all our items
 		if ( RARRAY_LEN( rb_tracking_array ) == 0 )	{
 			return Qtrue;
-		}		
+		}
+		c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );		
 	}
-		
+
 	//	if we finish iterating frames and still have items in the array, return false
 	if ( RARRAY_LEN( rb_tracking_array ) > 0 )	{
 		return Qfalse;
@@ -160,3 +182,79 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
 	return Qtrue;
 }
 
+/**********************************
+ *  backtraceHashForControlFrame  *
+ *********************************/
+
+VALUE rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	rb_control_frame_t**		c_current_frame )	{
+
+	const char*		c_method_name		=	NULL;
+	int				c_sourcefile_line	=	0;
+	
+	//	create new hash for this frame
+	VALUE	rb_frame_hash			=	rb_hash_new();
+		
+	VALUE	rb_sourcefile_name		=	Qnil;
+	VALUE	rb_sourcefile_line		=	Qnil;
+	VALUE	rb_method_name			=	Qnil;
+	VALUE	rb_object_for_frame		=	Qnil;
+	
+	if ( ( *c_current_frame )->iseq != 0 ) {
+		
+		if ( ( *c_current_frame )->pc != 0 ) {
+			
+			rb_iseq_t *iseq			= ( *c_current_frame )->iseq;
+			
+			//	get sourcefile name and set in hash
+			rb_sourcefile_name		=	iseq->filename;
+			
+			//	get sourcefile line and set in hash
+			c_sourcefile_line		=	rb_vm_get_sourceline( *c_current_frame );
+			rb_sourcefile_line		=	INT2FIX( c_sourcefile_line );
+			
+			//	get name of instruction sequence
+			rb_method_name			=	ID2SYM( rb_intern( StringValuePtr( iseq->name ) ) );				
+		}
+	}
+	else if ( RUBYVM_CFUNC_FRAME_P( *c_current_frame ) ) {
+		
+		//	get name of method
+		c_method_name				=	rb_id2name( ( *c_current_frame )->method_id );
+		rb_method_name				=	( c_method_name == NULL ? Qnil : ID2SYM( rb_intern( c_method_name ) ) );
+	}
+	else {
+		//	The third possibility is that we have an iseq frame with nil params for what we want
+		//	In that case we can simply return the next frame
+		*c_current_frame	=	RUBY_VM_PREVIOUS_CONTROL_FRAME( *c_current_frame );
+		
+		//	in theory this could crash because we are going forward a frame when we don't know what's there
+		//	in practice I think we are ok, since we are only jumping forward from nil frames which should never be at the end
+		//	at least - I don't think they should... we shall see.
+		//	
+		//	a fix would be to check the next frame, but that requires access to the thread or the limit cfp, 
+		//	which requires passing more context; so for now, I'm leaving it there
+		
+		return rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame( c_current_frame );
+	}
+
+	//	Push values to return hash
+
+	rb_object_for_frame	=	( *c_current_frame )->self;
+	rb_hash_aset(	rb_frame_hash,
+					ID2SYM( rb_intern( "object" ) ),
+					rb_object_for_frame );
+					
+	rb_hash_aset(	rb_frame_hash,
+					ID2SYM( rb_intern( "file" ) ),
+					rb_sourcefile_name );
+
+	rb_hash_aset(	rb_frame_hash,
+					ID2SYM( rb_intern( "line" ) ),
+					rb_sourcefile_line );
+
+	rb_hash_aset(	rb_frame_hash,
+					ID2SYM( rb_intern( "method" ) ),
+					rb_method_name );
+	
+	return rb_frame_hash;
+}

data/ext/sender/rb_Kernel.h

@@ -4,11 +4,13 @@
 
 	#include "ruby.h"
 
+	#define RPRUBY_SENDER_ERROR_STACK_LEVEL_LESS_THAN_ZERO					"Maximum level for stack trace specified was less than zero."
+
 	void Init_senderKernel();
 
-	VALUE rb_RPRuby_Sender_Kernel_backtrace(	int	argc,
-												VALUE*	args,
-												VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace(	int		argc,
+											VALUE*	args,
+											VALUE	rb_self );
 	VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int	argc,
 														VALUE*	args,
 														VALUE	rb_self );

data/ext/sender/rb_Kernel_internal.h

@@ -0,0 +1,10 @@
+
+#ifndef RP_SENDER_KERNEL_INTERNAL
+	#define RP_SENDER_KERNEL_INTERNAL
+
+	#include "ruby.h"
+	#include "eval_intern.h"
+
+VALUE rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	rb_control_frame_t**		c_current_frame );
+	
+#endif

data/lib/sender.rb

@@ -2,33 +2,6 @@ require 'sender/sender'
 
 module Sender
 
-  # VERSION is set by hoe
-
-  ##############
-  #  included  #
-  ##############
-  
-  def self.included( module_or_class_const )
-
-    # define a class method "new" on self that calls :init_sender_callbacks if it is defined
-    module_or_class_const.class_eval do
-            
-      #########
-      #  new  #
-      #########
-
-      def new( *args )
-        new_self  = super( *args )
-        if self.respond_to?( :init_sender_callbacks )
-          # :init_sender_callbacks allows callback parameters to be defined during initialization
-          # it is called automatically when the object is created, prior to calling Object.initialize
-          self.__send__( :init_sender_callbacks, __sender__, __caller__ )
-        end
-        return new_self
-      end
-    
-    end
-    
-  end
+  Version = File.open( 'VERSION.rdoc' ).readline
 
 end

data/sender.gemspec

@@ -2,18 +2,18 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sender}
-  s.version = "1.3"
+  s.version = "1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Asher"]
-  s.date = %q{2010-06-27}
+  s.date = %q{2010-06-29}
   s.description = %q{Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1, as well
 as providing object-oriented :backtrace supporting n-levels backward, and :backtrace_includes?,
 which allows contents of the backtrace to be queried.}
   s.email = ["asher@ridiculouspower.com"]
   s.extensions = ["ext/sender/extconf.rb"]
-  s.extra_rdoc_files = ["Manifest.txt", "CHANGELOG.rdoc", "README.rdoc"]
-  s.files = [".autotest", "CHANGELOG.rdoc", "Makefile", "Manifest.txt", "README.rdoc", "Rakefile", "ext/sender/RPSender_internal.c", "ext/sender/RPSender_internal.h", "ext/sender/RubySourceSupport.c", "ext/sender/RubySourceSupport.h", "ext/sender/debug.h", "ext/sender/dln.h", "ext/sender/encdb.h", "ext/sender/eval_intern.h", "ext/sender/extconf.rb", "ext/sender/gc.h", "ext/sender/id.h", "ext/sender/iseq.h", "ext/sender/main.c", "ext/sender/node.h", "ext/sender/parse.h", "ext/sender/rb_Global.c", "ext/sender/rb_Global.h", "ext/sender/rb_Global_internal.h", "ext/sender/rb_Kernel.c", "ext/sender/rb_Kernel.h", "ext/sender/regenc.h", "ext/sender/regint.h", "ext/sender/regparse.h", "ext/sender/revision.h", "ext/sender/thread_pthread.h", "ext/sender/thread_win32.h", "ext/sender/transcode_data.h", "ext/sender/transdb.h", "ext/sender/version.h", "ext/sender/vm_core.h", "ext/sender/vm_exec.h", "ext/sender/vm_insnhelper.h", "ext/sender/vm_opts.h", "lib/sender.rb", "lib/sender/sender.bundle", "sender.gemspec", "test/test_sender.rb"]
+  s.extra_rdoc_files = ["Manifest.txt", "CHANGELOG.rdoc", "README.rdoc", "VERSION.rdoc"]
+  s.files = [".autotest", "CHANGELOG.rdoc", "Makefile", "Manifest.txt", "README.rdoc", "Rakefile", "VERSION.rdoc", "ext/sender/RPSender_internal.c", "ext/sender/RPSender_internal.h", "ext/sender/RubySourceSupport.c", "ext/sender/RubySourceSupport.h", "ext/sender/debug.h", "ext/sender/dln.h", "ext/sender/encdb.h", "ext/sender/eval_intern.h", "ext/sender/extconf.rb", "ext/sender/gc.h", "ext/sender/id.h", "ext/sender/iseq.h", "ext/sender/main.c", "ext/sender/node.h", "ext/sender/parse.h", "ext/sender/rb_Global.c", "ext/sender/rb_Global.h", "ext/sender/rb_Global_internal.h", "ext/sender/rb_Kernel.c", "ext/sender/rb_Kernel.h", "ext/sender/rb_Kernel_internal.h", "ext/sender/regenc.h", "ext/sender/regint.h", "ext/sender/regparse.h", "ext/sender/revision.h", "ext/sender/thread_pthread.h", "ext/sender/thread_win32.h", "ext/sender/transcode_data.h", "ext/sender/transdb.h", "ext/sender/version.h", "ext/sender/vm_core.h", "ext/sender/vm_exec.h", "ext/sender/vm_insnhelper.h", "ext/sender/vm_opts.h", "lib/sender.rb", "lib/sender/sender.bundle", "sender.gemspec", "test/test_sender.rb"]
   s.homepage = %q{http://rubygems.org/gems/sender}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]

data/test/test_sender.rb

@@ -11,4 +11,12 @@ class TestSender < Test::Unit::TestCase
     assert_equal :run, __caller__
   end
 
+  def test_Kernel_backtrace
+    # not sure how to test this
+  end
+  
+  def test_Kernel_backtrace_includes
+    # not sure how to test this    
+  end
+
 end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: sender
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 7
   prerelease: false
   segments: 
   - 1
-  - 3
-  version: "1.3"
+  - 4
+  version: "1.4"
 platform: ruby
 authors: 
 - Asher
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-27 00:00:00 -04:00
+date: 2010-06-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,6 +77,7 @@ extra_rdoc_files:
 - Manifest.txt
 - CHANGELOG.rdoc
 - README.rdoc
+- VERSION.rdoc
 files: 
 - .autotest
 - CHANGELOG.rdoc
@@ -84,6 +85,7 @@ files:
 - Manifest.txt
 - README.rdoc
 - Rakefile
+- VERSION.rdoc
 - ext/sender/RPSender_internal.c
 - ext/sender/RPSender_internal.h
 - ext/sender/RubySourceSupport.c
@@ -104,6 +106,7 @@ files:
 - ext/sender/rb_Global_internal.h
 - ext/sender/rb_Kernel.c
 - ext/sender/rb_Kernel.h
+- ext/sender/rb_Kernel_internal.h
 - ext/sender/regenc.h
 - ext/sender/regint.h
 - ext/sender/regparse.h