static void
ole_delete_event(VALUE ary, VALUE ev)
{
long at = -1;
at = ole_search_event_at(ary, ev);
if (at >= 0) {
rb_ary_delete_at(ary, at);
}
}
void releaseValue(VALUE val){
VALUE ary = GET_THREAD()->vm->mark_object_ary;
int i = RARRAY_LEN(ary)-1;
for ( ; i >= 0; i-- ) {
if ( RARRAY_PTR(ary)[i]== val )
break;
}
if ( i >= 0 )
rb_ary_delete_at(ary,i);
}
// remove given menuitem from menu. arg is int or string
VALUE shoes_menu_remove(VALUE self, VALUE arg) {
shoes_menu *mn;
Data_Get_Struct(self, shoes_menu, mn);
VALUE posv = shoes_menu_index(self, arg);
if (NIL_P(posv))
rb_raise(rb_eArgError, "menuitem not found");
int pos = NUM2INT(posv);
// remove the native
shoes_native_menu_remove(mn ,pos);
// TODO: not documented online
rb_ary_delete_at(mn->items, pos);
return Qnil;
}
void
rb_exec_end_proc(void)
{
while (true) {
const int count = RARRAY_LEN(at_exit_procs);
if (count > 0) {
VALUE proc = RARRAY_AT(at_exit_procs, count - 1);
rb_ary_delete_at(at_exit_procs, count - 1);
rb_rescue(rb_end_proc_call_try, proc, rb_end_proc_call_catch, 0);
continue;
}
break;
}
}
void shoes_extras_remove_all(shoes_canvas *canvas) {
int i;
shoes_basic *basic;
shoes_canvas *parent;
if (canvas->app == NULL) return;
for (i = (int)RARRAY_LEN(canvas->app->extras) - 1; i >= 0; i--) {
VALUE ele = rb_ary_entry(canvas->app->extras, i);
if (!NIL_P(ele)) {
Data_Get_Struct(ele, shoes_basic, basic);
Data_Get_Struct(basic->parent, shoes_canvas, parent);
if (parent == canvas) {
rb_funcall(ele, s_remove, 0);
rb_ary_delete_at(canvas->app->extras, i);
}
}
}
}
/*
* call-seq:
* Debugger.remove_breakpoint(id) -> breakpoint
*
* Removes breakpoint by its id.
* <i>id</i> is an identificator of a breakpoint.
*/
VALUE
rdebug_remove_breakpoint(VALUE self, VALUE id_value)
{
int i;
int id;
VALUE breakpoint;
debug_breakpoint_t *debug_breakpoint;
id = FIX2INT(id_value);
for( i = 0; i < RARRAY_LEN(rdebug_breakpoints); i += 1 )
{
breakpoint = rb_ary_entry(rdebug_breakpoints, i);
Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
if(debug_breakpoint->id == id)
{
rb_ary_delete_at(rdebug_breakpoints, i);
return breakpoint;
}
}
return Qnil;
}
static VALUE
Breakpoint_remove(VALUE self, VALUE breakpoints, VALUE id_value)
{
int i;
int id;
VALUE breakpoint_object;
breakpoint_t *breakpoint;
if (breakpoints == Qnil) return Qnil;
id = FIX2INT(id_value);
for(i = 0; i < RARRAY_LEN(breakpoints); i++)
{
breakpoint_object = rb_ary_entry(breakpoints, i);
Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
if(breakpoint->id == id)
{
rb_ary_delete_at(breakpoints, i);
return breakpoint_object;
}
}
return Qnil;
}
static VALUE array_spec_rb_ary_delete_at(VALUE self, VALUE array, VALUE index) {
return rb_ary_delete_at(array, NUM2LONG(index));
}
bool KRubyList::Remove(unsigned int index)
{
return (rb_ary_delete_at(list, index) != Qnil);
}
/*
* 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;
}