static VALUE rb_fastadd_add_one(int argc, VALUE *argv, VALUE self)
{
int n = NUM2INT(rb_funcall(self, rb_intern("n"), 0));
return INT2NUM(n + 1);
}
VALUE
ossl_call_verify_cb_proc(struct ossl_verify_cb_args *args)
{
return rb_funcall(args->proc, rb_intern("call"), 2,
args->preverify_ok, args->store_ctx);
}
/*
* 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 = (rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current());
// 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;
}
static VALUE get_value(const char* buffer, int* position, int type) {
VALUE value;
switch (type) {
case 1:
{
double d;
memcpy(&d, buffer + *position, 8);
value = rb_float_new(d);
*position += 8;
break;
}
case 2:
case 13:
{
int value_length;
*position += 4;
value_length = strlen(buffer + *position);
value = STR_NEW(buffer + *position, value_length);
*position += value_length + 1;
break;
}
case 3:
{
int size;
memcpy(&size, buffer + *position, 4);
if (strcmp(buffer + *position + 5, "$ref") == 0) { // DBRef
int offset = *position + 14;
VALUE argv[2];
int collection_length = strlen(buffer + offset);
char id_type;
argv[0] = STR_NEW(buffer + offset, collection_length);
offset += collection_length + 1;
id_type = buffer[offset];
offset += 5;
argv[1] = get_value(buffer, &offset, (int)id_type);
value = rb_class_new_instance(2, argv, DBRef);
} else {
value = elements_to_hash(buffer + *position + 4, size - 5);
}
*position += size;
break;
}
case 4:
{
int size, end;
memcpy(&size, buffer + *position, 4);
end = *position + size - 1;
*position += 4;
value = rb_ary_new();
while (*position < end) {
int type = (int)buffer[(*position)++];
int key_size = strlen(buffer + *position);
VALUE to_append;
*position += key_size + 1; // just skip the key, they're in order.
to_append = get_value(buffer, position, type);
rb_ary_push(value, to_append);
}
(*position)++;
break;
}
case 5:
{
int length, subtype;
VALUE data, st;
VALUE argv[2];
memcpy(&length, buffer + *position, 4);
subtype = (unsigned char)buffer[*position + 4];
if (subtype == 2) {
data = rb_str_new(buffer + *position + 9, length - 4);
} else {
data = rb_str_new(buffer + *position + 5, length);
}
st = INT2FIX(subtype);
argv[0] = data;
argv[1] = st;
value = rb_class_new_instance(2, argv, Binary);
*position += length + 5;
break;
}
case 6:
{
value = Qnil;
break;
}
case 7:
{
VALUE str = rb_str_new(buffer + *position, 12);
VALUE oid = rb_funcall(str, rb_intern("unpack"), 1, rb_str_new2("C*"));
value = rb_class_new_instance(1, &oid, ObjectID);
*position += 12;
break;
}
case 8:
{
value = buffer[(*position)++] ? Qtrue : Qfalse;
break;
}
case 9:
{
long long millis;
VALUE seconds, microseconds;
memcpy(&millis, buffer + *position, 8);
seconds = LL2NUM(millis / 1000);
microseconds = INT2NUM((millis % 1000) * 1000);
value = rb_funcall(Time, rb_intern("at"), 2, seconds, microseconds);
value = rb_funcall(value, rb_intern("utc"), 0);
*position += 8;
break;
}
case 10:
{
value = Qnil;
break;
}
case 11:
{
int pattern_length = strlen(buffer + *position);
VALUE pattern = STR_NEW(buffer + *position, pattern_length);
int flags_length, flags = 0, i = 0;
char extra[10];
VALUE argv[3];
*position += pattern_length + 1;
flags_length = strlen(buffer + *position);
extra[0] = 0;
for (i = 0; i < flags_length; i++) {
char flag = buffer[*position + i];
if (flag == 'i') {
flags |= IGNORECASE;
}
else if (flag == 'm') {
flags |= MULTILINE;
}
else if (flag == 'x') {
flags |= EXTENDED;
}
else if (strlen(extra) < 9) {
strncat(extra, &flag, 1);
}
}
argv[0] = pattern;
argv[1] = INT2FIX(flags);
argv[2] = rb_str_new2(extra);
value = rb_class_new_instance(3, argv, RegexpOfHolding);
*position += flags_length + 1;
break;
}
case 12:
{
int collection_length;
VALUE collection, str, oid, id, argv[2];
*position += 4;
collection_length = strlen(buffer + *position);
collection = STR_NEW(buffer + *position, collection_length);
*position += collection_length + 1;
str = rb_str_new(buffer + *position, 12);
oid = rb_funcall(str, rb_intern("unpack"), 1, rb_str_new2("C*"));
id = rb_class_new_instance(1, &oid, ObjectID);
*position += 12;
argv[0] = collection;
argv[1] = id;
value = rb_class_new_instance(2, argv, DBRef);
break;
}
case 14:
{
int value_length;
memcpy(&value_length, buffer + *position, 4);
value = ID2SYM(rb_intern(buffer + *position + 4));
*position += value_length + 4;
break;
}
case 15:
{
int code_length, scope_size;
VALUE code, scope, argv[2];
*position += 8;
code_length = strlen(buffer + *position);
code = STR_NEW(buffer + *position, code_length);
*position += code_length + 1;
memcpy(&scope_size, buffer + *position, 4);
scope = elements_to_hash(buffer + *position + 4, scope_size - 5);
*position += scope_size;
argv[0] = code;
argv[1] = scope;
value = rb_class_new_instance(2, argv, Code);
break;
}
case 16:
{
int i;
memcpy(&i, buffer + *position, 4);
value = LL2NUM(i);
*position += 4;
break;
}
case 17:
{
int i;
int j;
memcpy(&i, buffer + *position, 4);
memcpy(&j, buffer + *position + 4, 4);
value = rb_ary_new3(2, LL2NUM(i), LL2NUM(j));
*position += 8;
break;
}
case 18:
{
long long ll;
memcpy(&ll, buffer + *position, 8);
value = LL2NUM(ll);
*position += 8;
break;
}
default:
{
rb_raise(rb_eTypeError, "no c decoder for this type yet (%d)", type);
break;
}
}
return value;
}
VALUE
rbgutil_def_setters(VALUE klass)
{
return rb_funcall(mGLib, id_add_one_arg_setter, 1, klass);
}
static VALUE rb_gsl_call_name(VALUE obj)
{
return rb_funcall(obj, rb_gsl_id_name, 0);
}
void klassify(VALUE obj, char * name) {
VALUE klassname;
klassname = rb_funcall(rb_funcall(obj, rb_intern("class"), 0), rb_intern("name"), 0);
printf("obj %s was a: %s\n", name, StringValuePtr(klassname));
}
void init_mpcrnd()
{
ID new_id = rb_intern ("new");
cMPC = rb_define_class ("MPC", rb_cNumeric);
cMPC_Rnd = rb_define_class_under (cMPC, "Rnd", rb_cObject);
rb_define_singleton_method (cMPC_Rnd, "new", r_mpcrndsg_new, -1);
rb_define_method (cMPC_Rnd, "initialize", r_mpcrnd_initialize, -1);
rb_define_method (cMPC_Rnd, "inspect", r_mpcrnd_inspect, 0);
rb_define_attr (cMPC_Rnd, "mode", 1, 0);
rb_define_attr (cMPC_Rnd, "name", 1, 0);
rb_define_attr (cMPC_Rnd, "ieee754", 1, 0);
rb_define_const(cMPC, "MPC_RNDNN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(0)));
rb_define_const(cMPC, "MPC_RNDNZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(16)));
rb_define_const(cMPC, "MPC_RNDNU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(32)));
rb_define_const(cMPC, "MPC_RNDND", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(48)));
rb_define_const(cMPC, "MPC_RNDZN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(1)));
rb_define_const(cMPC, "MPC_RNDZZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(17)));
rb_define_const(cMPC, "MPC_RNDZU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(33)));
rb_define_const(cMPC, "MPC_RNDZD", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(49)));
rb_define_const(cMPC, "MPC_RNDUN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(2)));
rb_define_const(cMPC, "MPC_RNDUZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(18)));
rb_define_const(cMPC, "MPC_RNDUU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(34)));
rb_define_const(cMPC, "MPC_RNDUD", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(50)));
rb_define_const(cMPC, "MPC_RNDDN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(3)));
rb_define_const(cMPC, "MPC_RNDDZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(19)));
rb_define_const(cMPC, "MPC_RNDDU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(35)));
rb_define_const(cMPC, "MPC_RNDDD", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(51)));
}
jobject event_cast<jobject, VALUE>(VALUE rEvent)
{
if (NIL_P(rEvent))
return NULL;
RHO_TRACE("eventFromRuby (1)");
JNIEnv *env = jnienv();
if (!init_event_stuff(env))
return NULL;
RHO_TRACE("eventFromRuby (2)");
VALUE rId = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_ID));
if (NIL_P(rId))
rId = rb_str_new2("");
Check_Type(rId, T_STRING);
RHO_TRACE("eventFromRuby (3)");
jmethodID mid = getJNIClassMethod(env, clsEvent, "<init>", "(Ljava/lang/String;)V");
if (!mid) return NULL;
jhstring jhId = rho_cast<jstring>(env, rId);
jobject jEvent = env->NewObject(clsEvent, mid, jhId.get());
if (!jEvent) return NULL;
RHO_TRACE("eventFromRuby (4)");
VALUE rTitle = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_TITLE));
if (!NIL_P(rTitle))
{
Check_Type(rTitle, T_STRING);
jhstring jhTitle = rho_cast<jstring>(env, rTitle);
env->SetObjectField(jEvent, fidTitle, jhTitle.get());
}
RHO_TRACE("eventFromRuby (5)");
VALUE rStartDate = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_START_DATE));
if (!NIL_P(rStartDate))
env->SetObjectField(jEvent, fidStartDate, date_cast<jobject>(rStartDate));
RHO_TRACE("eventFromRuby (6)");
VALUE rEndDate = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_END_DATE));
if (!NIL_P(rEndDate))
env->SetObjectField(jEvent, fidEndDate, date_cast<jobject>(rEndDate));
RHO_TRACE("eventFromRuby (7)");
VALUE rLastModified = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_LAST_MODIFIED));
if (!NIL_P(rLastModified))
env->SetObjectField(jEvent, fidLastModified, date_cast<jobject>(rLastModified));
RHO_TRACE("eventFromRuby (8)");
VALUE rLocation = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_LOCATION));
if (!NIL_P(rLocation))
{
Check_Type(rLocation, T_STRING);
jhstring jhLocation = rho_cast<jstring>(env, rLocation);
env->SetObjectField(jEvent, fidLocation, jhLocation.get());
}
RHO_TRACE("eventFromRuby (9)");
VALUE rNotes = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_NOTES));
if (!NIL_P(rNotes))
{
Check_Type(rNotes, T_STRING);
jhstring jhNotes = rho_cast<jstring>(env, rNotes);
env->SetObjectField(jEvent, fidNotes, jhNotes.get());
}
RHO_TRACE("eventFromRuby privacy");
VALUE rPrivacy = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_PRIVACY));
if (!NIL_P(rPrivacy))
{
Check_Type(rPrivacy, T_STRING);
jhstring jhPrivacy = rho_cast<jstring>(env, rPrivacy);
env->SetObjectField(jEvent, fidPrivacy, jhPrivacy.get());
}
RHO_TRACE("eventFromRuby recurrence");
VALUE rRecurrence = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_RECURRENCE));
if (!NIL_P(rRecurrence)) {
Check_Type(rRecurrence, T_HASH);
VALUE rFrequency = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_FREQUENCY));
Check_Type(rFrequency, T_STRING);
const char *frequency = RSTRING_PTR(rFrequency);
if ( strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_DAILY) != 0
&& strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) != 0
&& strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) != 0
&& strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) != 0)
{
rb_raise(rb_eArgError, "Wrong recurrence frequency: %s", frequency);
}
jhstring jhFreq = rho_cast<jstring>(env, rFrequency);
env->SetObjectField(jEvent, fidFrequency, jhFreq.get());
VALUE rInterval = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_INTERVAL));
rInterval = rb_funcall(rInterval, rb_intern("to_i"), 0);
int interval = NUM2INT(rInterval);
env->SetIntField(jEvent, fidInterval, interval);
RAWTRACE1("eventFromRuby recurrence interval: %d", interval);
VALUE rUntilDate = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_END));
if (!NIL_P(rUntilDate))
{
env->SetObjectField(jEvent, fidRecurrenceEnd, date_cast<jobject>(rUntilDate));
RAWTRACE("eventFromRuby recurrence until date");
}
VALUE rTimes = rb_funcall(rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_COUNT)), rb_intern("to_i"), 0);;
int times = NUM2INT(rTimes);
env->SetIntField(jEvent, fidRecurrenceTimes, times);
RAWTRACE1("eventFromRuby recurrence count: %d", times);
}
RHO_TRACE("eventFromRuby: return");
return jEvent;
}
static VALUE
rg_s_type_register(int argc, VALUE* argv, VALUE self)
{
VALUE type_name, flags;
volatile VALUE class_init_proc = Qnil;
GType parent_type;
GTypeInfo* info;
rb_scan_args(argc, argv, "03", &type_name, &info, &flags);
{
const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
if (cinfo->klass == self)
rb_raise(rb_eTypeError, "already registered");
}
{
VALUE superclass = rb_funcall(self, rb_intern("superclass"), 0);
const RGObjClassInfo* cinfo = rbgobj_lookup_class(superclass);
if (cinfo->klass != superclass)
rb_raise(rb_eTypeError, "super class must be registered to GLib");
parent_type = cinfo->gtype;
}
if (NIL_P(type_name)) {
VALUE s = rb_funcall(self, rb_intern("name"), 0);
if (strlen(StringValuePtr(s)) == 0)
rb_raise(rb_eTypeError, "can't determine type name");
type_name = rb_funcall(
rb_eval_string("lambda{|x| x.gsub(/::/,'') }"),
rb_intern("call"), 1, s);
}
{
GTypeQuery query;
g_type_query(parent_type, &query);
/* TODO: Why new? g_type_register_static() doesn’t retain a copy, so
* this should be allocated on the stack. */
info = g_new0(GTypeInfo, 1);
info->class_size = query.class_size;
info->base_init = NULL;
info->base_finalize = NULL;
info->class_init = class_init_func;
info->class_finalize = NULL;
info->class_data = (gpointer)class_init_proc;
info->instance_size = query.instance_size;
info->n_preallocs = 0;
info->instance_init = NULL;
info->value_table = NULL;
}
{
GType type = g_type_register_static(parent_type,
StringValuePtr(type_name),
info,
NIL_P(flags) ? 0 : NUM2INT(flags));
G_RELATIVE(self, class_init_proc);
rbgobj_register_class(self, type, TRUE, TRUE);
{
RGObjClassInfo* cinfo = (RGObjClassInfo*)rbgobj_lookup_class(self);
cinfo->flags |= RBGOBJ_DEFINED_BY_RUBY;
}
{
GType parent = g_type_parent(type);
const RGObjClassInfo* cinfo = GTYPE2CINFO(parent);
VALUE m = rb_define_module_under(self, RubyGObjectHookModule);
if (! (cinfo->flags & RBGOBJ_DEFINED_BY_RUBY)) {
rbg_define_method(m, "initialize", rg_initialize, -1);
}
rb_include_module(self, m);
}
return Qnil;
}
}
/*
* Returns the record in this DtraceBufdata. Records are returned as
* either DtraceRecords or DtraceStackRecords as appropriate for the
* type of action.
*/
VALUE dtracebufdata_record(VALUE self)
{
dtrace_bufdata_t *bufdata;
const dtrace_recdesc_t *rec;
dtrace_actkind_t act = DTRACEACT_NONE;
const char *s;
VALUE v = Qnil;
VALUE dtracerecord;
VALUE dtraceaggdata;
VALUE dtracerecdesc;
Data_Get_Struct(self, dtrace_bufdata_t, bufdata);
if (bufdata->dtbda_aggdata) {
dtraceaggdata = Data_Wrap_Struct(cDtraceAggData, 0, NULL, (dtrace_bufdata_t *)bufdata);
return dtraceaggdata;
}
s = bufdata->dtbda_buffered;
if (s == NULL) {
return Qnil;
}
rec = bufdata->dtbda_recdesc;
if (rec) {
act = rec->dtrd_action;
}
switch (act) {
case DTRACEACT_DIFEXPR:
/* trace() action */
break;
case DTRACEACT_PRINTF:
/* printf action, not available in probedata */
v = rb_str_new2(s);
dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::PrintfRecord"));
rb_iv_set(dtracerecord, "@from", rb_str_new2("bufdata"));
rb_iv_set(dtracerecord, "@value", v);
return (dtracerecord);
break;
case DTRACEACT_STACK:
case DTRACEACT_USTACK:
case DTRACEACT_JSTACK:
/* stand-alone stack(), ustack(), or jstack() action */
v = rb_str_new2(s);
dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::StackRecord"));
rb_iv_set(dtracerecord, "@from", rb_str_new2("bufdata"));
rb_funcall(dtracerecord, rb_intern("parse"), 1, v);
return (dtracerecord);
break;
case DTRACEACT_USYM:
case DTRACEACT_UADDR:
case DTRACEACT_UMOD:
case DTRACEACT_SYM:
case DTRACEACT_MOD:
v = rb_str_new2(s);
break;
case DTRACEACT_PRINTA:
v = rb_str_new2(s);
break;
default:
/*
* The record handle defers nothing else to this
* bufhandler.
*/
break;
}
if (!NIL_P(v)) {
dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::Record"));
rb_iv_set(dtracerecord, "@value", v);
rb_iv_set(dtracerecord, "@action", INT2FIX(act));
rb_iv_set(dtracerecord, "@from", rb_str_new2("bufdata"));
return (dtracerecord);
}
else {
return Qnil;
}
}
static VALUE
ossl_asn1_decode0(unsigned char **pp, long length, long *offset, long depth,
int once, int yield)
{
unsigned char *start, *p;
const unsigned char *p0;
long len, off = *offset;
int hlen, tag, tc, j;
VALUE ary, asn1data, value, tag_class;
ary = rb_ary_new();
p = *pp;
while(length > 0){
start = p;
p0 = p;
j = ASN1_get_object(&p0, &len, &tag, &tc, length);
p = (unsigned char *)p0;
if(j & 0x80) ossl_raise(eASN1Error, NULL);
hlen = p - start;
if(yield){
VALUE arg = rb_ary_new();
rb_ary_push(arg, LONG2NUM(depth));
rb_ary_push(arg, LONG2NUM(off));
rb_ary_push(arg, LONG2NUM(hlen));
rb_ary_push(arg, LONG2NUM(len));
rb_ary_push(arg, (j & V_ASN1_CONSTRUCTED) ? Qtrue : Qfalse);
rb_ary_push(arg, ossl_asn1_class2sym(tc));
rb_ary_push(arg, INT2NUM(tag));
rb_yield(arg);
}
length -= hlen;
off += hlen;
if(len > length) ossl_raise(eASN1Error, "value is too short");
if((tc & V_ASN1_PRIVATE) == V_ASN1_PRIVATE)
tag_class = sPRIVATE;
else if((tc & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC)
tag_class = sCONTEXT_SPECIFIC;
else if((tc & V_ASN1_APPLICATION) == V_ASN1_APPLICATION)
tag_class = sAPPLICATION;
else
tag_class = sUNIVERSAL;
if(j & V_ASN1_CONSTRUCTED){
/* TODO: if j == 0x21 it is indefinite length object. */
if((j == 0x21) && (len == 0)){
long lastoff = off;
value = ossl_asn1_decode0(&p, length, &off, depth+1, 0, yield);
len = off - lastoff;
}
else value = ossl_asn1_decode0(&p, len, &off, depth+1, 0, yield);
}
else{
value = rb_str_new((const char *)p, len);
p += len;
off += len;
}
if(tag_class == sUNIVERSAL &&
tag < ossl_asn1_info_size && ossl_asn1_info[tag].klass){
VALUE klass = *ossl_asn1_info[tag].klass;
long flag = 0;
if(!rb_obj_is_kind_of(value, rb_cArray)){
switch(tag){
case V_ASN1_BOOLEAN:
value = decode_bool(start, hlen+len);
break;
case V_ASN1_INTEGER:
value = decode_int(start, hlen+len);
break;
case V_ASN1_BIT_STRING:
value = decode_bstr(start, hlen+len, &flag);
break;
case V_ASN1_NULL:
value = decode_null(start, hlen+len);
break;
case V_ASN1_ENUMERATED:
value = decode_enum(start, hlen+len);
break;
case V_ASN1_OBJECT:
value = decode_obj(start, hlen+len);
break;
case V_ASN1_UTCTIME: /* FALLTHROUGH */
case V_ASN1_GENERALIZEDTIME:
value = decode_time(start, hlen+len);
break;
default:
/* use original value */
break;
}
}
asn1data = rb_funcall(klass, rb_intern("new"), 1, value);
if(tag == V_ASN1_BIT_STRING){
rb_iv_set(asn1data, "@unused_bits", LONG2NUM(flag));
}
}
else{
asn1data = rb_funcall(cASN1Data, rb_intern("new"), 3,
value, INT2NUM(tag), ID2SYM(tag_class));
}
rb_ary_push(ary, asn1data);
length -= len;
if(once) break;
}
*pp = p;
*offset = off;
return ary;
}
/*
* call-seq:
* Raindrops::Linux.tcp_listener_stats([addrs[, sock]]) => hash
*
* If specified, +addr+ may be a string or array of strings representing
* listen addresses to filter for. Returns a hash with given addresses as
* keys and ListenStats objects as the values or a hash of all addresses.
*
* addrs = %w(0.0.0.0:80 127.0.0.1:8080)
*
* If +addr+ is nil or not specified, all (IPv4) addresses are returned.
* If +sock+ is specified, it should be a Raindrops::InetDiagSock object.
*/
static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
{
VALUE rv = rb_hash_new();
struct nogvl_args args;
VALUE addrs, sock;
rb_scan_args(argc, argv, "02", &addrs, &sock);
/*
* allocating page_size instead of OP_LEN since we'll reuse the
* buffer for recvmsg() later, we already checked for
* OPLEN <= page_size at initialization
*/
args.iov[2].iov_len = OPLEN;
args.iov[2].iov_base = alloca(page_size);
args.table = NULL;
if (NIL_P(sock))
sock = rb_funcall(cIDSock, id_new, 0);
args.fd = my_fileno(sock);
switch (TYPE(addrs)) {
case T_STRING:
rb_hash_aset(rv, addrs, tcp_stats(&args, addrs));
return rv;
case T_ARRAY: {
long i;
long len = RARRAY_LEN(addrs);
VALUE cur;
if (len == 1) {
cur = rb_ary_entry(addrs, 0);
rb_hash_aset(rv, cur, tcp_stats(&args, cur));
return rv;
}
for (i = 0; i < len; i++) {
union any_addr check;
VALUE cur = rb_ary_entry(addrs, i);
parse_addr(&check, cur);
rb_hash_aset(rv, cur, Qtrue);
}
/* fall through */
}
case T_NIL:
args.table = st_init_strtable();
gen_bytecode_all(&args.iov[2]);
break;
default:
rb_raise(rb_eArgError,
"addr must be an array of strings, a string, or nil");
}
nl_errcheck(rb_thread_io_blocking_region(diag, &args, args.fd));
st_foreach(args.table, NIL_P(addrs) ? st_to_hash : st_AND_hash, rv);
st_free_table(args.table);
/* let GC deal with corner cases */
if (argc < 2) rb_io_close(sock);
return rv;
}
/* True if there are monitors on the loop */
static VALUE NIO_Selector_is_empty(VALUE self)
{
VALUE selectables = rb_ivar_get(self, rb_intern("selectables"));
return rb_funcall(selectables, rb_intern("empty?"), 0) == Qtrue ? Qtrue : Qfalse;
}
VALUE
rb_exc_new_str(VALUE etype, VALUE str)
{
StringValue(str);
return rb_funcall(etype, rb_intern("new"), 1, str);
}
static VALUE
range_check(VALUE *args)
{
return rb_funcall(args[0], id_cmp, 1, args[1]);
}
static VALUE
exc_message(VALUE exc)
{
return rb_funcall(exc, rb_intern("to_s"), 0, 0);
}
static VALUE
range_step(int argc, VALUE *argv, VALUE range)
{
VALUE b, e, step, tmp;
RETURN_ENUMERATOR(range, argc, argv);
b = RANGE_BEG(range);
e = RANGE_END(range);
if (argc == 0) {
step = INT2FIX(1);
}
else {
rb_scan_args(argc, argv, "01", &step);
if (!rb_obj_is_kind_of(step, rb_cNumeric)) {
step = rb_to_int(step);
}
if (rb_funcall(step, '<', 1, INT2FIX(0))) {
rb_raise(rb_eArgError, "step can't be negative");
}
else if (!rb_funcall(step, '>', 1, INT2FIX(0))) {
rb_raise(rb_eArgError, "step can't be 0");
}
}
if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) { /* fixnums are special */
long end = FIX2LONG(e);
long i, unit = FIX2LONG(step);
if (!EXCL(range))
end += 1;
i = FIX2LONG(b);
while (i < end) {
rb_yield(LONG2NUM(i));
if (i + unit < i) break;
i += unit;
}
}
else if (SYMBOL_P(b) && SYMBOL_P(e)) { /* symbols are special */
VALUE args[2], iter[2];
args[0] = rb_sym_to_s(e);
args[1] = EXCL(range) ? Qtrue : Qfalse;
iter[0] = INT2FIX(1);
iter[1] = step;
rb_block_call(rb_sym_to_s(b), rb_intern("upto"), 2, args, sym_step_i, (VALUE)iter);
}
else if (ruby_float_step(b, e, step, EXCL(range))) {
/* done */
}
else if (rb_obj_is_kind_of(b, rb_cNumeric) ||
!NIL_P(rb_check_to_integer(b, "to_int")) ||
!NIL_P(rb_check_to_integer(e, "to_int"))) {
ID op = EXCL(range) ? '<' : rb_intern("<=");
VALUE v = b;
int i = 0;
while (RTEST(rb_funcall(v, op, 1, e))) {
rb_yield(v);
i++;
v = rb_funcall(b, '+', 1, rb_funcall(INT2NUM(i), '*', 1, step));
}
}
else {
tmp = rb_check_string_type(b);
if (!NIL_P(tmp)) {
VALUE args[2], iter[2];
b = tmp;
args[0] = e;
args[1] = EXCL(range) ? Qtrue : Qfalse;
iter[0] = INT2FIX(1);
iter[1] = step;
rb_block_call(b, rb_intern("upto"), 2, args, step_i, (VALUE)iter);
}
else {
VALUE args[2];
if (!rb_respond_to(b, id_succ)) {
rb_raise(rb_eTypeError, "can't iterate from %s",
rb_obj_classname(b));
}
args[0] = INT2FIX(1);
args[1] = step;
range_each_func(range, step_i, args);
}
}
return range;
}
static VALUE rb_gsl_call_size(VALUE obj)
{
return rb_funcall(obj, rb_gsl_id_size, 0);
}
static VALUE
range_eqq(VALUE range, VALUE val)
{
return rb_funcall(range, rb_intern("include?"), 1, val);
}
static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow_id) {
buffer_t buffer = (buffer_t)NUM2LL(rb_ary_entry(extra, 0));
VALUE check_keys = rb_ary_entry(extra, 1);
if (TYPE(key) == T_SYMBOL) {
// TODO better way to do this... ?
key = rb_str_new2(rb_id2name(SYM2ID(key)));
}
if (TYPE(key) != T_STRING) {
buffer_free(buffer);
rb_raise(rb_eTypeError, "keys must be strings or symbols");
}
if (!allow_id && strcmp("_id", RSTRING_PTR(key)) == 0) {
return ST_CONTINUE;
}
if (check_keys == Qtrue) {
int i;
if (RSTRING_LEN(key) > 0 && RSTRING_PTR(key)[0] == '$') {
buffer_free(buffer);
rb_raise(InvalidName, "key must not start with '$'");
}
for (i = 0; i < RSTRING_LEN(key); i++) {
if (RSTRING_PTR(key)[i] == '.') {
buffer_free(buffer);
rb_raise(InvalidName, "key must not contain '.'");
}
}
}
switch(TYPE(value)) {
case T_BIGNUM:
case T_FIXNUM:
{
if (rb_funcall(value, rb_intern(">"), 1, LL2NUM(9223372036854775807LL)) == Qtrue ||
rb_funcall(value, rb_intern("<"), 1, LL2NUM(-9223372036854775808LL)) == Qtrue) {
buffer_free(buffer);
rb_raise(rb_eRangeError, "MongoDB can only handle 8-byte ints");
}
if (rb_funcall(value, rb_intern(">"), 1, INT2NUM(2147483647L)) == Qtrue ||
rb_funcall(value, rb_intern("<"), 1, INT2NUM(-2147483648L)) == Qtrue) {
long long ll_value;
write_name_and_type(buffer, key, 0x12);
ll_value = NUM2LL(value);
SAFE_WRITE(buffer, (char*)&ll_value, 8);
} else {
int int_value;
write_name_and_type(buffer, key, 0x10);
int_value = NUM2LL(value);
SAFE_WRITE(buffer, (char*)&int_value, 4);
}
break;
}
case T_TRUE:
{
write_name_and_type(buffer, key, 0x08);
SAFE_WRITE(buffer, &one, 1);
break;
}
case T_FALSE:
{
write_name_and_type(buffer, key, 0x08);
SAFE_WRITE(buffer, &zero, 1);
break;
}
case T_FLOAT:
{
double d = NUM2DBL(value);
write_name_and_type(buffer, key, 0x01);
SAFE_WRITE(buffer, (char*)&d, 8);
break;
}
case T_NIL:
{
write_name_and_type(buffer, key, 0x0A);
break;
}
case T_HASH:
{
write_name_and_type(buffer, key, 0x03);
write_doc(buffer, value, check_keys);
break;
}
case T_ARRAY:
{
buffer_position length_location, start_position, obj_length;
int items, i;
VALUE* values;
write_name_and_type(buffer, key, 0x04);
start_position = buffer_get_position(buffer);
// save space for length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
items = RARRAY_LEN(value);
values = RARRAY_PTR(value);
for(i = 0; i < items; i++) {
char* name;
VALUE key;
INT2STRING(&name, i);
key = rb_str_new2(name);
write_element(key, values[i], pack_extra(buffer, check_keys));
free(name);
}
// write null byte and fill in length
SAFE_WRITE(buffer, &zero, 1);
obj_length = buffer_get_position(buffer) - start_position;
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4);
break;
}
case T_STRING:
{
if (strcmp(rb_class2name(RBASIC(value)->klass),
"Mongo::Code") == 0) {
buffer_position length_location, start_position, total_length;
int length;
write_name_and_type(buffer, key, 0x0F);
start_position = buffer_get_position(buffer);
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
length = RSTRING_LEN(value) + 1;
SAFE_WRITE(buffer, (char*)&length, 4);
SAFE_WRITE(buffer, RSTRING_PTR(value), length - 1);
SAFE_WRITE(buffer, &zero, 1);
write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0), Qfalse);
total_length = buffer_get_position(buffer) - start_position;
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&total_length, 4);
break;
} else {
int length;
write_name_and_type(buffer, key, 0x02);
value = TO_UTF8(value);
length = RSTRING_LEN(value) + 1;
SAFE_WRITE(buffer, (char*)&length, 4);
write_utf8(buffer, value);
SAFE_WRITE(buffer, &zero, 1);
break;
}
}
case T_SYMBOL:
{
const char* str_value = rb_id2name(SYM2ID(value));
int length = strlen(str_value) + 1;
write_name_and_type(buffer, key, 0x0E);
SAFE_WRITE(buffer, (char*)&length, 4);
SAFE_WRITE(buffer, str_value, length);
break;
}
case T_OBJECT:
{
// TODO there has to be a better way to do these checks...
const char* cls = rb_class2name(RBASIC(value)->klass);
if (strcmp(cls, "Mongo::Binary") == 0 ||
strcmp(cls, "ByteBuffer") == 0) {
const char subtype = strcmp(cls, "ByteBuffer") ?
(const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2;
VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0);
int length = RSTRING_LEN(string_data);
write_name_and_type(buffer, key, 0x05);
if (subtype == 2) {
const int other_length = length + 4;
SAFE_WRITE(buffer, (const char*)&other_length, 4);
SAFE_WRITE(buffer, &subtype, 1);
}
SAFE_WRITE(buffer, (const char*)&length, 4);
if (subtype != 2) {
SAFE_WRITE(buffer, &subtype, 1);
}
SAFE_WRITE(buffer, RSTRING_PTR(string_data), length);
break;
}
if (strcmp(cls, "Mongo::ObjectID") == 0) {
VALUE as_array = rb_funcall(value, rb_intern("to_a"), 0);
int i;
write_name_and_type(buffer, key, 0x07);
for (i = 0; i < 12; i++) {
char byte = (char)FIX2INT(RARRAY_PTR(as_array)[i]);
SAFE_WRITE(buffer, &byte, 1);
}
break;
}
if (strcmp(cls, "Mongo::DBRef") == 0) {
buffer_position length_location, start_position, obj_length;
VALUE ns, oid;
write_name_and_type(buffer, key, 0x03);
start_position = buffer_get_position(buffer);
// save space for length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
ns = rb_funcall(value, rb_intern("namespace"), 0);
write_element(rb_str_new2("$ref"), ns, pack_extra(buffer, Qfalse));
oid = rb_funcall(value, rb_intern("object_id"), 0);
write_element(rb_str_new2("$id"), oid, pack_extra(buffer, Qfalse));
// write null byte and fill in length
SAFE_WRITE(buffer, &zero, 1);
obj_length = buffer_get_position(buffer) - start_position;
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4);
break;
}
}
case T_DATA:
{
// TODO again, is this really the only way to do this?
const char* cls = rb_class2name(RBASIC(value)->klass);
if (strcmp(cls, "Time") == 0) {
double t = NUM2DBL(rb_funcall(value, rb_intern("to_f"), 0));
long long time_since_epoch = (long long)round(t * 1000);
write_name_and_type(buffer, key, 0x09);
SAFE_WRITE(buffer, (const char*)&time_since_epoch, 8);
break;
}
}
case T_REGEXP:
{
int length = RREGEXP_SRC_LEN(value);
char* pattern = (char*)RREGEXP_SRC_PTR(value);
long flags = RREGEXP(value)->ptr->options;
VALUE has_extra;
write_name_and_type(buffer, key, 0x0B);
SAFE_WRITE(buffer, pattern, length);
SAFE_WRITE(buffer, &zero, 1);
if (flags & IGNORECASE) {
char ignorecase = 'i';
SAFE_WRITE(buffer, &ignorecase, 1);
}
if (flags & MULTILINE) {
char multiline = 'm';
SAFE_WRITE(buffer, &multiline, 1);
}
if (flags & EXTENDED) {
char extended = 'x';
SAFE_WRITE(buffer, &extended, 1);
}
has_extra = rb_funcall(value, rb_intern("respond_to?"), 1, rb_str_new2("extra_options_str"));
if (TYPE(has_extra) == T_TRUE) {
VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0);
buffer_position old_position = buffer_get_position(buffer);
SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LEN(extra));
qsort(buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char);
}
SAFE_WRITE(buffer, &zero, 1);
break;
}
default:
{
buffer_free(buffer);
rb_raise(rb_eTypeError, "no c encoder for this type yet (%d)", TYPE(value));
break;
}
}
return ST_CONTINUE;
}
/* call-seq:
* OpenSSL::PKey::EC.new()
* OpenSSL::PKey::EC.new(ec_key)
* OpenSSL::PKey::EC.new(ec_group)
* OpenSSL::PKey::EC.new("secp112r1")
* OpenSSL::PKey::EC.new(pem_string)
* OpenSSL::PKey::EC.new(pem_string [, pwd])
* OpenSSL::PKey::EC.new(der_string)
*
* See the OpenSSL documentation for:
* EC_KEY_*
*/
static VALUE ossl_ec_key_initialize(int argc, VALUE *argv, VALUE self)
{
EVP_PKEY *pkey;
EC_KEY *ec = NULL;
VALUE arg, pass;
VALUE group = Qnil;
char *passwd = NULL;
GetPKey(self, pkey);
if (pkey->pkey.ec)
ossl_raise(eECError, "EC_KEY already initialized");
rb_scan_args(argc, argv, "02", &arg, &pass);
if (NIL_P(arg)) {
ec = EC_KEY_new();
} else {
if (rb_obj_is_kind_of(arg, cEC)) {
EC_KEY *other_ec = NULL;
SafeRequire_EC_KEY(arg, other_ec);
ec = EC_KEY_dup(other_ec);
} else if (rb_obj_is_kind_of(arg, cEC_GROUP)) {
ec = EC_KEY_new();
group = arg;
} else {
BIO *in = ossl_obj2bio(arg);
if (!NIL_P(pass)) {
passwd = StringValuePtr(pass);
}
ec = PEM_read_bio_ECPrivateKey(in, NULL, ossl_pem_passwd_cb, passwd);
if (!ec) {
OSSL_BIO_reset(in);
ec = PEM_read_bio_EC_PUBKEY(in, NULL, ossl_pem_passwd_cb, passwd);
}
if (!ec) {
OSSL_BIO_reset(in);
ec = d2i_ECPrivateKey_bio(in, NULL);
}
if (!ec) {
OSSL_BIO_reset(in);
ec = d2i_EC_PUBKEY_bio(in, NULL);
}
BIO_free(in);
if (ec == NULL) {
const char *name = StringValueCStr(arg);
int nid = OBJ_sn2nid(name);
(void)ERR_get_error();
if (nid == NID_undef)
ossl_raise(eECError, "unknown curve name (%s)\n", name);
if ((ec = EC_KEY_new_by_curve_name(nid)) == NULL)
ossl_raise(eECError, "unable to create curve (%s)\n", name);
EC_KEY_set_asn1_flag(ec, OPENSSL_EC_NAMED_CURVE);
EC_KEY_set_conv_form(ec, POINT_CONVERSION_UNCOMPRESSED);
}
}
}
if (ec == NULL)
ossl_raise(eECError, NULL);
if (!EVP_PKEY_assign_EC_KEY(pkey, ec)) {
EC_KEY_free(ec);
ossl_raise(eECError, "EVP_PKEY_assign_EC_KEY");
}
rb_iv_set(self, "@group", Qnil);
if (!NIL_P(group))
rb_funcall(self, rb_intern("group="), 1, arg);
return self;
}
/*
* A Ruby interface for gathering process table information.
*/
void Init_proctable(){
VALUE mSys, cProcTable;
/* The Sys module serves as a namespace only */
mSys = rb_define_module("Sys");
/* The ProcTable class encapsulates process table information */
cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
/* The Error class typically raised if any of the ProcTable methods fail */
cProcTableError = rb_define_class_under(cProcTable, "Error", rb_eStandardError);
/* Singleton methods */
rb_define_singleton_method(cProcTable, "ps", pt_ps, -1);
rb_define_singleton_method(cProcTable, "fields", pt_fields, 0);
/* There is no constructor */
rb_funcall(cProcTable, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
/* Constants */
/* 0.9.3: The version of the sys-proctable library */
rb_define_const(cProcTable, "VERSION", rb_str_new2(SYS_PROCTABLE_VERSION));
/* Structs */
sProcStruct = rb_struct_define("ProcTableStruct",
"pid", /* Process identifier */
"ppid", /* Parent process id */
"pgid", /* Process group id */
"ruid", /* Real user id */
"rgid", /* Real group id */
"euid", /* Effective user id */
"egid", /* Effective group id */
"groups", /* All effective group ids */
"svuid", /* Saved effective user id */
"svgid", /* Saved effective group id */
"comm", /* Command name (15 chars) */
"state", /* Process status */
"pctcpu", /* %cpu for this process during p_swtime */
"oncpu", /* nil */
"tnum", /* Controlling tty dev */
"tdev", /* Controlling tty name */
"wmesg", /* Wchan message */
"rtime", /* Real time */
"priority", /* Process priority */
"usrpri", /* User-priority */
"nice", /* Process "nice" value */
"cmdline", /* Complete command line */
"exe", /* Saved pathname of the executed command */
"environ", /* Hash with process environment variables */
"starttime", /* Process start time */
"maxrss", /* Max resident set size (PL) */
"ixrss", /* Integral shared memory size (NU) */
"idrss", /* Integral unshared data (NU) */
"isrss", /* Integral unshared stack (NU) */
"minflt", /* Page reclaims (NU) */
"majflt", /* Page faults (NU) */
"nswap", /* Swaps (NU) */
"inblock", /* Block input operations (atomic) */
"oublock", /* Block output operations (atomic) */
"msgsnd", /* Messages sent (atomic) */
"msgrcv", /* Messages received (atomic) */
"nsignals", /* Signals received (atomic) */
"nvcsw", /* Voluntary context switches (atomic) */
"nivcsw", /* Involuntary context switches (atomic) */
"utime", /* User time used (PL) */
"stime", /* System time used (PL) */
NULL
);
}
static VALUE
invoke_callback(VALUE arg_)
{
struct callback_arg *arg = (struct callback_arg *)arg_;
return rb_funcall(arg->callback, id_call, 1, arg->page_setup);
}
VALUE regexp_spec_match(VALUE self, VALUE regexp, VALUE str) {
return rb_funcall(regexp, rb_intern("match"), 1, str);
}
static VALUE rldap_msg_keys(VALUE obj)
{
return rb_funcall(rb_iv_get(obj, "@attrs"), rb_intern("keys"), 0);
}
/* call-seq: default_options=(opts)
*
* Sets the default options for load and dump.
* @param [Hash] opts options to change
* @param [Fixnum] :indent number of spaces to indent each element in an JSON document
* @param [String] :encoding character encoding for the JSON file
* @param [true|false|nil] :circular support circular references while dumping
* @param [true|false|nil] :auto_define automatically define classes if they do not exist
* @param [true|false|nil] :symbol_keys convert hash keys to symbols
* @param [true|false|nil] :ascii_only encode all high-bit characters as escaped sequences if true
* @param [:object|:strict|:compat|:null] load and dump mode to use for JSON
* :strict raises an exception when a non-supported Object is
* encountered. :compat attempts to extract variable values from an
* Object using to_json() or to_hash() then it walks the Object's
* variables if neither is found. The :object mode ignores to_hash()
* and to_json() methods and encodes variables using code internal to
* the Oj gem. The :null mode ignores non-supported Objects and
* replaces them with a null. @return [nil]
*/
static VALUE
set_def_opts(VALUE self, VALUE opts) {
struct _YesNoOpt ynos[] = {
{ circular_sym, &oj_default_options.circular },
{ auto_define_sym, &oj_default_options.auto_define },
{ symbol_keys_sym, &oj_default_options.sym_key },
{ ascii_only_sym, &oj_default_options.ascii_only },
{ Qnil, 0 }
};
YesNoOpt o;
VALUE v;
Check_Type(opts, T_HASH);
#ifdef HAVE_RUBY_ENCODING_H
if (Qtrue == rb_funcall(opts, rb_intern("has_key?"), 1, encoding_sym)) {
v = rb_hash_lookup(opts, encoding_sym);
if (Qnil == v) {
oj_default_options.encoding = 0;
} else if (T_STRING == rb_type(v)) {
oj_default_options.encoding = rb_enc_find(StringValuePtr(v));
} else if (rb_cEncoding == rb_obj_class(v)) {
oj_default_options.encoding = rb_to_encoding(v);
} else {
rb_raise(rb_eArgError, ":encoding must be nil, a String, or an Encoding.\n");
}
}
#endif
v = rb_hash_aref(opts, indent_sym);
if (Qnil != v) {
Check_Type(v, T_FIXNUM);
oj_default_options.indent = FIX2INT(v);
}
v = rb_hash_lookup(opts, mode_sym);
if (Qnil == v) {
// ignore
} else if (object_sym == v) {
oj_default_options.mode = ObjectMode;
} else if (strict_sym == v) {
oj_default_options.mode = StrictMode;
} else if (compat_sym == v) {
oj_default_options.mode = CompatMode;
} else if (null_sym == v) {
oj_default_options.mode = NullMode;
} else {
rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.\n");
}
for (o = ynos; 0 != o->attr; o++) {
if (Qtrue != rb_funcall(opts, rb_intern("has_key?"), 1, o->sym)) {
continue;
}
if (Qnil != (v = rb_hash_lookup(opts, o->sym))) {
if (Qtrue == v) {
*o->attr = Yes;
} else if (Qfalse == v) {
*o->attr = No;
} else {
rb_raise(rb_eArgError, "%s must be true, false, or nil.\n", rb_id2name(SYM2ID(o->sym)));
}
}
}
return Qnil;
}
VALUE
rb_exc_new(VALUE etype, const char *ptr, long len)
{
return rb_funcall(etype, rb_intern("new"), 1, rb_str_new(ptr, len));
}
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;
}
static VALUE
call_next(VALUE obj)
{
return rb_funcall(obj, id_next, 0);
}
