/*
* call-seq:
* digest_obj.new -> another_digest_obj
*
* Returns a new, initialized copy of the digest object. Equivalent
* to digest_obj.clone().reset().
*/
static VALUE
rb_digest_instance_new(VALUE self)
{
VALUE clone = rb_obj_clone(self);
rb_funcall(clone, id_reset, 0);
return clone;
}
VALUE
rb_eval_string_wrap(const char *str, int *state)
{
int status;
rb_thread_t *th = GET_THREAD();
VALUE self = th->top_self;
VALUE wrapper = th->top_wrapper;
VALUE val;
th->top_wrapper = rb_module_new();
th->top_self = rb_obj_clone(rb_vm_top_self());
rb_extend_object(th->top_self, th->top_wrapper);
val = rb_eval_string_protect(str, &status);
th->top_self = self;
th->top_wrapper = wrapper;
if (state) {
*state = status;
}
else if (status) {
JUMP_TAG(status);
}
return val;
}
/* call-seq:
* to_class(klass=Object) -> Class
*
* Makes a copy of the module, converts the copy to a class, and returns it. The
* returned class can then have instances created from it. The +klass+ argument
* sets the superclass of the returned class. If +klass+ is not a Class,
* raises +TypeError+. */
static VALUE evilr_to_class(int argc, VALUE *argv, VALUE self) {
VALUE klass = evilr__optional_class(argc, argv);
self = rb_obj_clone(self);
RBASIC_SET_KLASS(self, rb_singleton_class(klass));
RCLASS_SET_SUPER(self, klass);
FL_UNSET(self, T_MASK);
FL_SET(self, T_CLASS);
return self;
}
VALUE KeyboardEvent::get_observer_array(int type)
{
RAGE_CHECK_DISPOSED_RET(disposed, Qnil);
switch(type)
{
case RAGE_EVENTS_KEY_CHAR:
return rb_obj_clone(key_char_observer);
case RAGE_EVENTS_KEY_UP:
return rb_obj_clone(key_up_observer);
case RAGE_EVENTS_KEY_DOWN:
return rb_obj_clone(key_down_observer);
default:
return Qnil;
}
}
static VALUE
exc_exception(int argc, VALUE *argv, VALUE self)
{
VALUE exc;
if (argc == 0) return self;
if (argc == 1 && self == argv[0]) return self;
exc = rb_obj_clone(self);
exc_initialize(argc, argv, exc);
return exc;
}
static VALUE
exc_exception(VALUE self, SEL sel, int argc, VALUE *argv)
{
VALUE exc;
if (argc == 0) return self;
if (argc == 1 && self == argv[0]) return self;
exc = rb_obj_clone(self);
exc_initialize(exc, 0, argc, argv);
return exc;
}
VALUE JoyEvent::get_observer_array(int type)
{
RAGE_CHECK_DISPOSED_RET(disposed, Qnil);
switch(type)
{
case RAGE_EVENTS_JOY_UP:
return rb_obj_clone(joy_up_observer);
case RAGE_EVENTS_JOY_DOWN:
return rb_obj_clone(joy_down_observer);
case RAGE_EVENTS_JOY_AXIS:
return rb_obj_clone(joy_axis_observer);
case RAGE_EVENTS_JOY_CONFIG:
return rb_obj_clone(joy_reconf_observer);
default:
return Qnil;
}
}
/*
* call-seq:
* digest_obj.hexdigest -> string
* digest_obj.hexdigest(string) -> string
*
* If none is given, returns the resulting hash value of the digest in
* a hex-encoded form, keeping the digest's state.
*
* If a _string_ is given, returns the hash value for the given
* _string_ in a hex-encoded form, resetting the digest to the initial
* state before and after the process.
*/
static VALUE
rb_digest_instance_hexdigest(int argc, VALUE *argv, VALUE self)
{
VALUE str, value;
if (rb_scan_args(argc, argv, "01", &str) > 0) {
rb_funcall(self, id_reset, 0);
rb_funcall(self, id_update, 1, str);
value = rb_funcall(self, id_finish, 0);
rb_funcall(self, id_reset, 0);
} else {
value = rb_funcall(rb_obj_clone(self), id_finish, 0);
}
return hexencode_str_new(value);
}
/*
* call-seq:
* digest_obj.digest -> string
* digest_obj.digest(string) -> string
*
* If none is given, returns the resulting hash value of the digest,
* keeping the digest's state.
*
* If a _string_ is given, returns the hash value for the given
* _string_, resetting the digest to the initial state before and
* after the process.
*/
static VALUE
rb_digest_instance_digest(int argc, VALUE *argv, VALUE self)
{
VALUE str, value;
if (rb_scan_args(argc, argv, "01", &str) > 0) {
rb_funcall(self, id_reset, 0);
rb_funcall(self, id_update, 1, str);
value = rb_funcall(self, id_finish, 0);
rb_funcall(self, id_reset, 0);
} else {
VALUE clone = rb_obj_clone(self);
value = rb_funcall(clone, id_finish, 0);
rb_funcall(clone, id_reset, 0);
}
return value;
}
/* call-seq:
* to_module -> Module
*
* Makes a copy of the class, converts the copy to a module, and returns it. The
* returned module can be included in other classes. */
static VALUE evilr_to_module(VALUE klass) {
VALUE mod, iclass;
if (IS_SINGLETON_CLASS(klass)) {
if((mod = evilr_singleton_class_instance(klass))) {
mod = rb_singleton_class_clone(mod);
(void)evilr_detach_singleton(mod);
} else {
rb_raise(rb_eTypeError, "singleton class without attached instance");
}
} else {
mod = rb_obj_clone(klass);
}
RBASIC_SET_KLASS(mod, rb_cModule);
iclass = RCLASS_SUPER(mod);
RCLASS_SET_SUPER(mod, NULL);
FL_UNSET(mod, T_MASK);
FL_SET(mod, T_MODULE);
evilr__include_iclasses(mod, iclass);
return mod;
}
static int
rb_load_internal0(rb_thread_t *th, VALUE fname, int wrap)
{
int state;
volatile VALUE wrapper = th->top_wrapper;
volatile VALUE self = th->top_self;
volatile int loaded = FALSE;
volatile int mild_compile_error;
#if !defined __GNUC__
rb_thread_t *volatile th0 = th;
#endif
th->errinfo = Qnil; /* ensure */
if (!wrap) {
th->top_wrapper = 0;
}
else {
/* load in anonymous module as toplevel */
th->top_self = rb_obj_clone(rb_vm_top_self());
th->top_wrapper = rb_module_new();
rb_extend_object(th->top_self, th->top_wrapper);
}
mild_compile_error = th->mild_compile_error;
TH_PUSH_TAG(th);
state = EXEC_TAG();
if (state == 0) {
NODE *node;
rb_iseq_t *iseq;
th->mild_compile_error++;
node = (NODE *)rb_load_file_str(fname);
loaded = TRUE;
iseq = rb_iseq_new_top(node, rb_str_new2("<top (required)>"), fname, rb_realpath_internal(Qnil, fname, 1), NULL);
th->mild_compile_error--;
rb_iseq_eval(iseq);
}
TH_POP_TAG();
#if !defined __GNUC__
th = th0;
fname = RB_GC_GUARD(fname);
#endif
th->mild_compile_error = mild_compile_error;
th->top_self = self;
th->top_wrapper = wrapper;
if (!loaded && !FIXNUM_P(th->errinfo)) {
/* an error on loading don't include INT2FIX(TAG_FATAL) see r35625 */
return TAG_RAISE;
}
if (state) {
VALUE exc = rb_vm_make_jump_tag_but_local_jump(state, Qundef);
if (NIL_P(exc)) return state;
th->errinfo = exc;
return TAG_RAISE;
}
if (!NIL_P(th->errinfo)) {
/* exception during load */
return TAG_RAISE;
}
return state;
}
static int
rb_load_internal0(rb_execution_context_t *ec, VALUE fname, int wrap)
{
enum ruby_tag_type state;
rb_thread_t *th = rb_ec_thread_ptr(ec);
volatile VALUE wrapper = th->top_wrapper;
volatile VALUE self = th->top_self;
#if !defined __GNUC__
rb_thread_t *volatile th0 = th;
#endif
th->ec->errinfo = Qnil; /* ensure */
if (!wrap) {
th->top_wrapper = 0;
}
else {
/* load in anonymous module as toplevel */
th->top_self = rb_obj_clone(rb_vm_top_self());
th->top_wrapper = rb_module_new();
rb_extend_object(th->top_self, th->top_wrapper);
}
EC_PUSH_TAG(th->ec);
state = EC_EXEC_TAG();
if (state == TAG_NONE) {
rb_ast_t *ast;
const rb_iseq_t *iseq;
if ((iseq = rb_iseq_load_iseq(fname)) != NULL) {
/* OK */
}
else {
VALUE parser = rb_parser_new();
rb_parser_set_context(parser, NULL, FALSE);
ast = (rb_ast_t *)rb_parser_load_file(parser, fname);
iseq = rb_iseq_new_top(&ast->body, rb_fstring_lit("<top (required)>"),
fname, rb_realpath_internal(Qnil, fname, 1), NULL);
rb_ast_dispose(ast);
}
rb_exec_event_hook_script_compiled(ec, iseq, Qnil);
rb_iseq_eval(iseq);
}
EC_POP_TAG();
#if !defined __GNUC__
th = th0;
fname = RB_GC_GUARD(fname);
#endif
th->top_self = self;
th->top_wrapper = wrapper;
if (state) {
/* usually state == TAG_RAISE only, except for
* rb_iseq_load_iseq case */
VALUE exc = rb_vm_make_jump_tag_but_local_jump(state, Qundef);
if (NIL_P(exc)) return state;
th->ec->errinfo = exc;
return TAG_RAISE;
}
if (!NIL_P(th->ec->errinfo)) {
/* exception during load */
return TAG_RAISE;
}
return state;
}
static void
rb_load_internal(VALUE fname, int wrap)
{
int state;
rb_thread_t *th = GET_THREAD();
volatile VALUE wrapper = th->top_wrapper;
volatile VALUE self = th->top_self;
volatile int loaded = FALSE;
volatile int mild_compile_error;
#ifndef __GNUC__
rb_thread_t *volatile th0 = th;
#endif
th->errinfo = Qnil; /* ensure */
if (!wrap) {
rb_secure(4); /* should alter global state */
th->top_wrapper = 0;
}
else {
/* load in anonymous module as toplevel */
th->top_self = rb_obj_clone(rb_vm_top_self());
th->top_wrapper = rb_module_new();
rb_extend_object(th->top_self, th->top_wrapper);
}
mild_compile_error = th->mild_compile_error;
PUSH_TAG();
state = EXEC_TAG();
if (state == 0) {
NODE *node;
VALUE iseq;
th->mild_compile_error++;
node = (NODE *)rb_load_file(RSTRING_PTR(fname));
loaded = TRUE;
iseq = rb_iseq_new_top(node, rb_str_new2("<top (required)>"), fname, rb_realpath_internal(Qnil, fname, 1), Qfalse);
th->mild_compile_error--;
rb_iseq_eval(iseq);
}
POP_TAG();
#ifndef __GNUC__
th = th0;
fname = RB_GC_GUARD(fname);
#endif
th->mild_compile_error = mild_compile_error;
th->top_self = self;
th->top_wrapper = wrapper;
if (!loaded) {
rb_exc_raise(GET_THREAD()->errinfo);
}
if (state) {
rb_vm_jump_tag_but_local_jump(state, Qundef);
}
if (!NIL_P(GET_THREAD()->errinfo)) {
/* exception during load */
rb_exc_raise(th->errinfo);
}
}
VALUE TimerEvent::get_observer_array(void)
{
RAGE_CHECK_DISPOSED_RET(disposed, Qnil);
return rb_obj_clone(timer_observer);
}
/*
* 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;
}