sender 1.5.7 → 1.5.8

data/ext/sender/RPSender_internal.c

@@ -0,0 +1,37 @@
+
+#include "RPSender_internal.h"
+#include "RubySourceSupport.h"
+
+/******************
+ *  framePriorTo  *
+ *****************/
+
+rb_control_frame_t* RPRuby_internal_framePriorTo( rb_control_frame_t* c_control_frame )	{
+	
+	rb_thread_t*			c_thread					= GET_THREAD();
+	rb_control_frame_t*		c_prior_control_frame		= NULL;
+	//	get the current frame pointer
+	if ( c_control_frame == NULL )	{
+		c_control_frame	= c_thread->cfp;
+	}
+	
+    if ( ( c_prior_control_frame = rb_vm_get_ruby_level_next_cfp( c_thread, c_control_frame ) ) != 0) {
+		
+		//	not sure why we have to call this a second time after it was called at the end of rb_vm_get_ruby_level_next_cfp,
+		//	but for some reason it seems to be necessary
+		c_prior_control_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_prior_control_frame );
+
+    }
+	else {
+		c_prior_control_frame = NULL;
+	}
+	
+	//	if we have a nil object we've passed main, we're done
+	if ( c_prior_control_frame->self == Qnil )	{
+		return NULL;
+	}
+
+	return c_prior_control_frame;
+	
+}
+

data/ext/sender/RPSender_internal.h

@@ -0,0 +1,15 @@
+#ifndef RP_SENDER_INTERNAL
+	#define RP_SENDER_INTERNAL
+
+	#include "ruby.h"
+	#include "eval_intern.h"
+
+	typedef enum BOOL_e	{
+		FALSE,
+		TRUE
+	} BOOL;
+
+	rb_control_frame_t* RPRuby_internal_framePriorTo( rb_control_frame_t* control_frame );
+	VALUE RPSender_internal_backtraceHashForControlFrame( const rb_control_frame_t* c_top_of_control_frame );
+
+#endif

data/ext/sender/RubySourceSupport.c

@@ -0,0 +1,47 @@
+
+#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
+
+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;
+}
+
+struct enumerator* enumerator_ptr(VALUE obj)
+{
+    struct enumerator *ptr;
+	
+    Data_Get_Struct(obj, struct enumerator, ptr);
+	
+	//	modified because a call to a local version of enumerator_mark won't verify
+	
+    if (!ptr || ptr->obj == Qundef) {
+		rb_raise(rb_eArgError, "uninitialized enumerator");
+    }
+    return ptr;
+}

data/ext/sender/RubySourceSupport.h

@@ -0,0 +1,77 @@
+#ifndef RP_SENDER_RUBY_SOURCE_SUPPORT
+	#define RP_SENDER_RUBY_SOURCE_SUPPORT
+
+	#include "ruby.h"
+	#include "eval_intern.h"
+	#include "version.h"
+	#if RUBY_PATCHLEVEL == -1
+		#include "vm_core.h"
+	#endif
+	#include "method.h"
+
+	#define MAX_POSBUF 128
+
+	enum context_type {
+		CONTINUATION_CONTEXT = 0,
+		FIBER_CONTEXT = 1,
+		ROOT_FIBER_CONTEXT = 2
+	};
+
+	typedef struct rb_context_struct {
+		enum context_type type;
+		VALUE self;
+		int argc;
+		VALUE value;
+		VALUE *vm_stack;
+	#ifdef CAPTURE_JUST_VALID_VM_STACK
+		int vm_stack_slen;  /* length of stack (head of th->stack) */
+		int vm_stack_clen;  /* length of control frames (tail of th->stack) */
+	#endif
+		VALUE *machine_stack;
+		VALUE *machine_stack_src;
+	#ifdef __ia64
+		VALUE *machine_register_stack;
+		VALUE *machine_register_stack_src;
+		int machine_register_stack_size;
+	#endif
+		rb_thread_t saved_thread;
+		rb_jmpbuf_t jmpbuf;
+		int machine_stack_size;
+	} rb_context_t;
+
+	enum fiber_status {
+		CREATED,
+		RUNNING,
+		TERMINATED
+	};
+
+	typedef struct rb_fiber_struct {
+		rb_context_t cont;
+		VALUE prev;
+		enum fiber_status status;
+		struct rb_fiber_struct *prev_fiber;
+		struct rb_fiber_struct *next_fiber;
+	} rb_fiber_t;
+
+	struct enumerator {
+		VALUE obj;
+		ID    meth;
+		VALUE args;
+		VALUE fib;
+		VALUE dst;
+		VALUE no_next;
+	};
+
+	#define GetFiberPtr(obj, ptr)  do {\
+				ptr = (rb_fiber_t*)DATA_PTR(obj);\
+				if (!ptr) rb_raise(rb_eFiberError, "uninitialized fiber");\
+			} while(0)
+
+
+	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);
+	void control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp);
+	struct enumerator* enumerator_ptr(VALUE obj);
+	
+#endif

data/ext/sender/rb_Global.c

@@ -0,0 +1,151 @@
+
+#include "rb_Global.h"
+#include "rb_Kernel.h"
+
+//	Internals from ruby that aren't included in the ruby lib
+#include "RubySourceSupport.h"
+
+#include "eval_intern.h"
+
+/***********
+*  Global  *
+***********/
+
+void Init_senderGlobal()	{
+	
+	rb_define_global_function( "__sender__",		rb_RPRuby_Sender___sender__,			0 );
+	rb_define_global_function( "__caller__",		rb_RPRuby_Sender___caller__,			0 );
+
+}
+
+/***************************************************************************************************************************************************************
+****************************************************************************************************************************************************************
+													Ruby Global Methods
+****************************************************************************************************************************************************************
+***************************************************************************************************************************************************************/
+
+/***************
+*  __sender__  *
+***************/
+
+/*
+ * call-seq:
+ *   __sender__ -> object
+ *
+ * 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 );
+	
+	int		c_backtrace_index		=	1;
+	
+	VALUE	rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, c_backtrace_index );
+													
+	VALUE	rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+											ID2SYM( rb_intern( "method" ) ) );
+	
+	//	if we get :initialize as our caller and our __method__ is :initialize, we need to go up the chain
+	//	until our caller is no longer :initialize or :new
+	while ( rb_caller == ID2SYM( rb_intern( "initialize" ) ) )	{	
+		c_backtrace_index++;
+		rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, c_backtrace_index );
+		rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+										ID2SYM( rb_intern( "method" ) ) );
+										
+		//	we have one parent past our current method; if that is also :initialize, get the whole backtrace
+		if ( c_backtrace_index == 2 )	{
+			rb_backtrace_array		=	rb_RPRuby_Sender_Kernel_backtrace( 0, NULL, rb_mKernel );
+		}
+	}	
+
+	//	if we get "new" as our caller we need to get the next level, as we are in :initialize
+	//	and want to know what called :new
+	//
+	//	since we might have had to go up the chain from :initialize through parents before getting here we
+	//	want to use a separate if statement
+	if ( rb_caller == ID2SYM( rb_intern( "new" ) ) )	{	
+		c_backtrace_index++;
+		rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, c_backtrace_index );
+	}
+	
+	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 rb_sender;
+}
+
+/***************
+*  __caller__  *
+***************/
+
+/*
+ * call-seq:
+ *   __caller__ -> object
+ *
+ * Return method sending message to receiver.
+ */
+VALUE rb_RPRuby_Sender___caller__()	{
+
+
+	//	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 );
+	
+	int		c_backtrace_index		=	1;
+	
+	VALUE	rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, c_backtrace_index );
+	
+	VALUE	rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+											ID2SYM( rb_intern( "method" ) ) );
+	
+	//	we want to compare our caller as we go up the chain to our first caller to deal with super methods
+	//	we have a symbol so no cloning is necessary (or appropriate)
+	VALUE	rb_first_caller	=	rb_hash_aref(	rb_ary_entry( rb_backtrace_array, 0 ),
+												ID2SYM( rb_intern( "method" ) ) );
+	
+	//	if we get :initialize as our caller and our __method__ is :initialize, we need to go up the chain
+	//	until our caller is no longer :initialize or :new
+	while ( rb_caller == rb_first_caller )	{	
+		c_backtrace_index++;
+		rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, c_backtrace_index );
+		rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+										ID2SYM( rb_intern( "method" ) ) );
+		
+		//	we have one parent past our current method; if that is also :initialize, get the whole backtrace
+		if ( c_backtrace_index == 2 )	{
+			rb_backtrace_array		=	rb_RPRuby_Sender_Kernel_backtrace( 0, NULL, rb_mKernel );
+		}
+	}	
+	
+	//	if we get "new" as our caller we need to get the next level, as we are in :initialize
+	//	and want to know what called :new
+	//
+	//	since we might have had to go up the chain from :initialize through parents before getting here we
+	//	want to use a separate if statement	
+	if ( rb_caller == ID2SYM( rb_intern( "new" ) ) )	{	
+		c_backtrace_index++;
+		rb_backtrace_frame_hash	=	rb_ary_entry( rb_backtrace_array, c_backtrace_index );		
+		rb_caller	=	rb_hash_aref(	rb_backtrace_frame_hash,
+										ID2SYM( rb_intern( "method" ) ) );
+	}
+	
+	//	assuming we have a previous frame, return its rb_self (our current receiver's sender)
+	return rb_caller;
+}
+

data/ext/sender/rb_Global.h

@@ -0,0 +1,11 @@
+#ifndef RP_SENDER_GLOBAL
+	#define RP_SENDER_GLOBAL
+
+	#include "RPSender_internal.h"
+
+	void Init_senderGlobal();
+
+	VALUE rb_RPRuby_Sender___sender__();
+	VALUE rb_RPRuby_Sender___caller__();
+	
+#endif

data/ext/sender/rb_Global_internal.h

@@ -0,0 +1,8 @@
+
+#ifndef RP_SENDER_CALLER_GLOBAL_INTERNAL
+	#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

@@ -0,0 +1,683 @@
+
+#include "rb_Kernel.h"
+#include "rb_Kernel_internal.h"
+
+#include "RPSender_internal.h"
+
+#include "RubySourceSupport.h"
+
+/***********
+*  Kernel  *
+***********/
+
+void Init_senderKernel()	{
+	
+	rb_define_singleton_method( rb_mKernel, "backtrace",						rb_RPRuby_Sender_Kernel_backtrace,						-1 );
+	rb_define_singleton_method( rb_mKernel, "each_backtrace_frame",				rb_RPRuby_Sender_Kernel_each_backtrace_frame,			-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_includes?",				rb_RPRuby_Sender_Kernel_backtrace_includes,				-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_includes_one_of?",		rb_RPRuby_Sender_Kernel_backtrace_includes_one_of,		-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_frame_with",				rb_RPRuby_Sender_Kernel_backtrace_frame_with,			-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_frames_with",			rb_RPRuby_Sender_Kernel_backtrace_frames_with,			-1 );
+
+
+}
+
+static VALUE rb_eFiberError;
+
+#define RPRUBY_SENDER_ERROR_NO_ENUMERATORS							"Enumerators not currently enabled due to difficulty with Fiber support."
+
+/***************************************************************************************************************************************************************
+****************************************************************************************************************************************************************
+													Ruby Kernel Methods
+****************************************************************************************************************************************************************
+***************************************************************************************************************************************************************/
+
+/**********************
+ *  Kernel.backtrace  *
+ *********************/
+
+/*
+ * call-seq:
+ *   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 )	{
+
+	//	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 );
+		}
+		
+	}
+	
+	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 ) ) {
+		
+		VALUE	rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
+	   
+		if ( rb_frame_hash == Qnil )	{
+			break;
+		}
+		
+		//	push hash to array
+		rb_ary_push(	rb_return_array,
+						rb_frame_hash );
+	   
+	   c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );
+	   c_stack_level++;
+   }
+   
+   return rb_return_array;
+}
+
+/*********************************
+ *  Kernel.each_backtrace_frame  *
+ ********************************/
+
+/*
+ * call-seq:
+ *   Kernel.each_backtrace_frame( & block )
+ *
+ * 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_each_backtrace_frame(	int		argc,
+													VALUE*	args,
+													VALUE	rb_self )	{
+
+	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 ) );
+	
+	//	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_stored_backtrace_array	=	Qnil;
+	
+	//	if we were passed a stored backtrace array, use it
+	if (	argc == 1
+		&&	TYPE( args[ 0 ] ) == T_ARRAY )	{
+		rb_stored_backtrace_array	=	args[ 0 ];
+	}
+				
+	//	for each control frame:
+    while ( c_current_context_frame < c_top_of_control_frame ) {
+
+		VALUE	rb_frame_hash;
+		//	if we are using a stored backtrace we don't need to ask for a new hash
+		if ( rb_stored_backtrace_array == Qnil )	{
+			rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
+		}
+		else {
+			rb_frame_hash	=	rb_ary_shift( rb_stored_backtrace_array );
+		}
+
+		if ( rb_frame_hash == Qnil )	{
+			break;
+		}
+		
+		//	if we try to iterate using an Enumerator we will lose our context
+		if ( ! rb_block_given_p() )	{
+			
+			//	we solve this by assuming that the desired context is the moment when each_backtrace_frame is called
+			//	this allows us to store the backtrace and iterate it as we want
+			//	the only downside is that we have to get the entire backtrace first in order to store it
+			rb_stored_backtrace_array	=	rb_RPRuby_Sender_Kernel_backtrace(	0,
+																				NULL,
+																				rb_self );
+		
+			RETURN_ENUMERATOR( rb_self, 1, & rb_stored_backtrace_array );
+		}
+		
+		//	otherwise, yield the block
+		rb_yield( rb_frame_hash );
+		
+		//	only move the frame if we are not using a stored backtrace
+		if ( rb_stored_backtrace_array == Qnil )	{
+			c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );		
+		}
+	}
+	
+	return Qnil;
+}
+	
+/********************************
+ *  Kernel.backtrace_includes?  *
+ *******************************/
+
+/*
+ * call-seq:
+ *   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.
+ * 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,
+													VALUE*	args,
+													VALUE	rb_self )	{
+	
+	//	this function is also used for 
+	//	* backtrace_includes_one_of?
+	//	* backtrace_includes_frame?
+	//	* backtrace_includes_one_of_frames?
+	
+	//	create tracking array
+	VALUE	rb_tracking_array	=	rb_ary_new();
+	
+	//	populate tracking array with methods/objects
+	//	optional - if first arg is Qtrue, we are looking for one of the args instead of all of the args
+	int		c_which_arg				=	0;
+	BOOL	c_requires_all_items	= TRUE;
+	if (	args[ 0 ] == Qnil
+		||	(	argc > 1
+			 &&	args[ 1 ] == Qnil ) )	{
+		c_which_arg++;
+		c_requires_all_items = FALSE;
+	}
+	BOOL	c_return_frame	=	FALSE;
+	if (	args[ 0 ] == Qfalse
+		||	(	argc > 1
+			 &&	args[ 1 ] == Qfalse ) )	{
+		c_which_arg++;
+		c_return_frame = TRUE;
+	}
+	BOOL	c_return_all_frames	=	FALSE;
+	if (	args[ 0 ] == Qtrue
+		||	(	argc > 1
+			 &&	args[ 1 ] == Qtrue ) )	{
+		c_which_arg++;
+		c_return_all_frames = TRUE;
+	}
+	int	c_args_offset	=	c_which_arg;
+	for ( ; 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 ) );
+	
+	//	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_test_index_array	=	rb_ary_new();
+	//	:object
+	//	instance or class
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "object" ) ) );
+	//	:method				
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "method" ) ) );
+	//	:file
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "file" ) ) );
+	//	:line
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "line" ) ) );
+	
+	//	only used if c_return_all_frames == TRUE
+	VALUE	rb_frame_hashes_array	=	Qnil;
+	if ( c_return_all_frames == TRUE )	{
+		rb_frame_hashes_array		=	rb_ary_new();
+	}
+	
+	VALUE	rb_frame_hash	=	Qnil;
+	
+	//	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_this_arg	=	args[ c_which_member + c_args_offset ];
+		   
+			BOOL		matched	=	FALSE;
+		   
+			rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
+			
+			//	if we have a hash we are testing multiple items in a frame
+			if ( TYPE( rb_this_arg ) == T_HASH )	{
+
+				VALUE	rb_frame_test_array	=	rb_obj_clone( rb_test_index_array );
+			
+				//	for each element that we could test for
+				int	c_which_index;
+				int	c_skipped_index_count	=	0;
+				for ( c_which_index = 0 ; c_which_index < RARRAY_LEN( rb_frame_test_array ) ; c_which_index++ )	{
+					
+					VALUE	rb_this_index	=	RARRAY_PTR( rb_frame_test_array )[ c_which_index ];
+					
+					//	see if our requested test hash includes the potential test element
+					if ( rb_hash_lookup(	rb_this_arg,
+											rb_this_index ) != Qnil )	{
+						
+						VALUE	rb_required_element	=	rb_hash_aref(	rb_this_arg,
+																		rb_this_index );
+						VALUE	rb_frame_element	=	rb_hash_aref(	rb_frame_hash,
+																		rb_this_index	);
+									 						
+						//	if it does, we need to see if the current frame's element matches this element
+						VALUE	rb_required_element_klass;
+						if ( rb_required_element == rb_frame_element
+							//	if we have a string, which is a filename
+							||	(	TYPE( rb_required_element ) == T_STRING
+								 &&	rb_funcall( rb_frame_element, rb_intern( "==" ), 1, rb_required_element ) == Qtrue )
+							//	if we have a class, which is a special case for :object
+							||	(	rb_this_index == ID2SYM( rb_intern( "class" ) ) 
+								 &&	( rb_required_element_klass = ( ( TYPE( rb_required_element ) == T_CLASS ) ? rb_required_element : rb_funcall( rb_required_element, rb_intern( "class" ), 0 ) ) )
+								 &&	rb_required_element_klass == rb_required_element ) )	{
+
+							rb_ary_delete_at(	rb_frame_test_array,
+												c_which_index );
+							c_which_index--;
+						}
+					}
+					else {
+						c_skipped_index_count++;
+					}
+
+					if ( RARRAY_LEN( rb_frame_test_array ) == c_skipped_index_count )	{
+						if ( c_return_frame == TRUE )	{
+							return rb_frame_hash;
+						}
+						else if ( c_return_all_frames == TRUE )	{
+							rb_ary_push(	rb_frame_hashes_array,
+											rb_frame_hash );
+						}
+						else {
+							return Qtrue;							
+						}
+					}					
+				}
+			}
+			else {
+
+				//	:object => <class:instance>
+				if	(	TYPE( rb_this_arg ) == T_OBJECT )	{
+
+					if ( rb_hash_aref(	rb_frame_hash,
+										ID2SYM( rb_intern( "object" ) ) ) == rb_this_arg )	{
+						matched = TRUE;
+					}
+				}
+				//	:object => <class>
+				else if	( TYPE( rb_this_arg ) == T_CLASS )	{
+					
+					VALUE	rb_frame_object			=	rb_hash_aref(	rb_frame_hash,
+																		ID2SYM( rb_intern( "object" ) ) );
+					VALUE	rb_frame_object_klass	=	TYPE( rb_frame_object ) == T_CLASS ? rb_frame_object : rb_funcall( rb_frame_object, rb_intern( "class" ), 0 );
+					if ( rb_frame_object_klass == rb_this_arg )	{
+						matched = TRUE;
+					}
+				}
+				//	:method => :method
+				else if	( TYPE( rb_this_arg ) == T_SYMBOL )	{
+				   
+					if ( rb_hash_aref(	rb_frame_hash,
+										ID2SYM( rb_intern( "method" ) ) ) == rb_this_arg )	{
+						matched = TRUE;
+					}
+				}
+				//	:file => "filename"
+				else if ( TYPE( rb_this_arg ) == T_STRING )	{
+					VALUE	rb_filename	=	rb_hash_aref(	rb_frame_hash,
+															ID2SYM( rb_intern( "file" ) ) );
+					VALUE	rb_comparison	=	rb_funcall( rb_filename, rb_intern( "==" ), 1, rb_this_arg );
+					if ( rb_comparison == Qtrue )	{
+						matched = TRUE;
+					}
+				}
+				//	:line => number
+				else if ( TYPE( rb_this_arg ) == T_FIXNUM )	{
+					if ( rb_hash_aref(	rb_frame_hash,
+										ID2SYM( rb_intern( "line" ) ) ) == rb_this_arg )	{
+						matched = TRUE;
+					}
+				}
+			   
+				//	if array member exists in frame, remove from array
+				if ( matched )	{
+					if ( c_requires_all_items == FALSE )	{
+						if ( c_return_frame == TRUE )	{
+							return rb_frame_hash;
+						}
+						else {
+							return Qtrue;							
+						}
+
+					}
+					else {
+						
+						//	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 )	{
+			if ( c_return_frame == TRUE )	{
+				return rb_frame_hash;
+			}
+			else if ( c_return_all_frames == TRUE )	{
+				rb_ary_push(	rb_frame_hashes_array,
+								rb_frame_hash );
+				return rb_frame_hashes_array;
+			}
+			else {
+				return Qtrue;							
+			}
+		}
+		c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );		
+	}
+	
+	if (	c_return_all_frames == TRUE
+		&&	RARRAY_LEN( rb_frame_hashes_array ) > 0 ) {
+		return rb_frame_hashes_array;
+	}
+	//	if we finish iterating frames and still have items in the array, return false
+	else if ( RARRAY_LEN( rb_tracking_array ) > 0 )	{
+		if ( c_return_frame == TRUE )	{
+			return Qnil;
+		}
+		else {
+			return Qfalse;
+		}
+	}
+	//	otherwise, return true
+	else if ( c_return_frame == TRUE )	{
+		return rb_frame_hash;
+	}
+	else {
+		return Qtrue;							
+	}
+	//	we don't get here
+	return Qnil;
+}
+
+/***************************************
+ *  Kernel.backtrace_includes_one_of?  *
+ **************************************/
+
+/*
+ * call-seq:
+ *   Kernel.backtrace_includes_one_of?( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_includes_one_of?( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns whether one of the specified methods or objects or classes are in the current backtrace context.
+ * Kernel.backtrace_includes_one_of? 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_one_of(	int		argc,
+															VALUE*	args,
+															VALUE	rb_self )	{
+
+	//	method implemented as special case of backtrace_includes?
+	
+	//	create a new array starting with Qtrue and then followed by args
+	VALUE		c_methods_array[ argc + 1 ];
+	c_methods_array[ 0 ] = Qnil;
+	int	c_which_arg;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		c_methods_array[ c_which_arg + 1 ] = args[ c_which_arg ];
+	}
+	return rb_RPRuby_Sender_Kernel_backtrace_includes(	argc + 1,
+														c_methods_array,
+														rb_self );
+}
+
+/*********************************
+ *  Kernel.backtrace_frame_with  *
+ ********************************/
+
+/*
+ * call-seq:
+ *   Kernel.backtrace_frame_with( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_frame_with( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns first frame matching specifications, which work like Kernel.backtrace_includes?. 
+ * Kernel.backtrace_includes_one_of? 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_frame_with(	int		argc,
+													VALUE*	args,
+													VALUE	rb_self )	{
+	
+	//	create a new array starting with Qtrue and then followed by args
+	VALUE		c_methods_array[ argc + 1 ];
+	//	Qfalse tells backtrace_includes to return frame hash instead of true/false
+	c_methods_array[ 0 ] = Qfalse;
+	int	c_which_arg;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		c_methods_array[ c_which_arg + 1 ] = args[ c_which_arg ];
+	}
+	return rb_RPRuby_Sender_Kernel_backtrace_includes_one_of(	argc + 1,
+																c_methods_array,
+																rb_self );	
+}
+
+/**********************************
+ *  Kernel.backtrace_frames_with  *
+ *********************************/
+
+/*
+ * call-seq:
+ *   Kernel.backtrace_frames_with( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_frames_with( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns all frames matching specifications, which work like Kernel.backtrace_includes?. 
+ * Kernel.backtrace_includes_one_of? 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_frames_with(	int		argc,
+														VALUE*	args,
+														VALUE	rb_self )	{
+	
+	
+	//	create a new array starting with Qtrue and then followed by args
+	VALUE		c_methods_array[ argc + 1 ];
+	//	Qtrue tells backtrace_includes to return all frame hashes specified instead of the first
+	c_methods_array[ 0 ] = Qtrue;
+	int	c_which_arg;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		c_methods_array[ c_which_arg + 1 ] = args[ c_which_arg ];
+	}
+	return rb_RPRuby_Sender_Kernel_backtrace_includes(	argc + 1,
+														c_methods_array,
+														rb_self );	
+}
+
+/***************************************************************************************************************************************************************
+****************************************************************************************************************************************************************
+													Internal Methods
+****************************************************************************************************************************************************************
+***************************************************************************************************************************************************************/
+
+/**********************************
+ *  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 ) ) );				
+			rb_object_for_frame	=	( *c_current_frame )->self;
+		}
+	}
+	else if ( RUBYVM_CFUNC_FRAME_P( *c_current_frame ) ) {
+		
+		//	get name of method
+
+		#if RUBY_PATCHLEVEL >= -1
+		//	For 1.9.2:
+		const rb_method_entry_t*	c_method_for_frame	=	( *c_current_frame )->me;
+		c_method_name				=	rb_id2name( c_method_for_frame->called_id );
+		#else
+		//	For 1.9.1:
+		c_method_name				=	rb_id2name( ( *c_current_frame )->method_id );
+		#endif
+		
+		rb_method_name				=	( c_method_name == NULL ? Qnil : ID2SYM( rb_intern( c_method_name ) ) );
+		rb_object_for_frame	=	( *c_current_frame )->self;		
+	}
+	//	we have to test this case - it works for blocks but there may be other cases too
+	else if (	( *c_current_frame )->block_iseq != 0
+			 &&	( *c_current_frame )->pc == 0)	{
+	
+		//	If we got here we have a fiber
+		//	There doesn't seem to be much that we can tell about a fiber's context
+			
+		VALUE			rb_current_fiber	=	rb_fiber_current();
+		rb_fiber_t*		c_current_fiber		=	NULL;
+
+		GetFiberPtr(	rb_current_fiber, 
+						c_current_fiber);
+						
+		rb_context_t*	c_context			=	& c_current_fiber->cont;
+		
+//		rb_block_t*	c_blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP( *c_current_frame );
+		 
+		rb_object_for_frame	=	( *c_current_frame )->self;
+		
+		//	get sourcefile name and set in hash
+		rb_sourcefile_name		=	Qnil;
+
+		//	get sourcefile line and set in hash
+		rb_sourcefile_line		=	Qnil;
+		
+		//	get name of instruction sequence
+		rb_method_name			=	rb_str_new2( "<Fiber>" );		
+		
+		//	if we have a fiber we also include its ruby reference since we have so little other context
+		rb_hash_aset(	rb_frame_hash,
+						ID2SYM( rb_intern( "fiber" ) ),
+						c_context->self );
+		
+		//	The one time that we know a fiber is in use in the Ruby base is with Enumerators
+		//	For now we will handle that with a special case
+		
+		VALUE	rb_enumerator_class	=	rb_const_get(	rb_cObject,
+														rb_intern( "Enumerator" ) );
+		
+		VALUE	rb_object_for_frame_klass	=	( ( TYPE( rb_object_for_frame ) == T_CLASS ) ? rb_object_for_frame : rb_funcall( rb_object_for_frame, rb_intern( "class" ), 0 ) );
+
+		VALUE	rb_ancestors	=	rb_funcall(	rb_object_for_frame_klass,
+												rb_intern( "ancestors" ),
+												0 );
+		
+		if ( rb_ary_includes(	rb_ancestors,
+								rb_enumerator_class ) )	{
+			
+			struct enumerator* c_enumerator		=	enumerator_ptr( rb_object_for_frame );
+			
+			rb_object_for_frame	=	c_enumerator->obj;
+			rb_method_name		=	ID2SYM( c_enumerator->meth );			
+		}
+		
+	}
+	else if (	( *c_current_frame )->block_iseq == 0
+			 &&	( *c_current_frame )->pc == 0)	{
+		//	this happens after we had a fiber and we try to go up - which doesn't make sense with a fiber
+		//	not sure what we want to do here, if anything
+		return Qnil;
+	}
+	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_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

@@ -0,0 +1,31 @@
+
+#ifndef RP_SENDER_KERNEL
+	#define RP_SENDER_KERNEL
+
+	#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_each_backtrace_frame(	int		argc,
+													   VALUE*	args,
+													   VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int	argc,
+														VALUE*	args,
+														VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_includes_one_of(	int		argc,
+																VALUE*	args,
+																VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_frame_with(	int		argc,
+														VALUE*	args,
+														VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_frames_with(	int		argc,
+															VALUE*	args,
+															VALUE	rb_self );
+	
+	
+#endif

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/ext/sender/sender.c

@@ -0,0 +1,16 @@
+
+#include "rb_Global.h"
+#include "rb_Kernel.h"
+
+/*************
+*	 Init	 *
+*************/
+
+//	Called from ruby when RPBDB module is initialized
+void Init_sender()	{
+
+	Init_senderGlobal();
+	Init_senderKernel();
+	
+}
+

data/test/test_sender.rb

@@ -0,0 +1,22 @@
+require "test/unit"
+require "sender"
+
+class TestSender < Test::Unit::TestCase
+
+  def test___sender__
+    assert_equal self, __sender__
+  end
+
+  def test___caller__
+    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

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 5
-  - 7
-  version: 1.5.7
+  - 8
+  version: 1.5.8
 platform: ruby
 authors: 
 - Asher
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-28 00:00:00 -04:00
+date: 2011-02-12 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -65,10 +65,20 @@ extensions:
 extra_rdoc_files: []
 
 files: 
-- lib/sender.rb
-- lib/VERSION.rdoc
-- README.rdoc
 - ext/sender/extconf.rb
+- 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/RPSender_internal.c
+- ext/sender/RPSender_internal.h
+- ext/sender/RubySourceSupport.c
+- ext/sender/RubySourceSupport.h
+- ext/sender/sender.c
+- test/test_sender.rb
+- README.rdoc
 has_rdoc: true
 homepage: http://rubygems.org/gems/sender
 licenses: []

data/lib/VERSION.rdoc

@@ -1 +0,0 @@
-1.5.4

data/lib/sender.rb

@@ -1,5 +0,0 @@
-require 'sender/sender'
-
-module Sender
-
-end