static VALUE rg_operator_p_compare(VALUE self, VALUE other) { if (rb_obj_is_kind_of(other, GTYPE2CLASS(GTK_TYPE_PRINTER))){ return INT2NUM(gtk_printer_compare(_SELF(self), _SELF(other))); } else { rb_raise(rb_eTypeError, "%s isn't a kind of Gtk::Printer", rb_class2name(other)); } }
static VALUE zipruby_archive_replace_function(int argc, VALUE *argv, VALUE self) { VALUE index, flags, mtime; struct zipruby_archive *p_archive; struct zip_source *zsource; struct read_proc *z; int i_index, i_flags = 0; rb_scan_args(argc, argv, "12", &index, &mtime, &flags); rb_need_block(); if (TYPE(index) != T_STRING && !FIXNUM_P(index)) { rb_raise(rb_eTypeError, "wrong argument type %s (expected Fixnum or String)", rb_class2name(CLASS_OF(index))); } if (NIL_P(mtime)) { mtime = rb_funcall(rb_cTime, rb_intern("now"), 0); } else if (!rb_obj_is_instance_of(mtime, rb_cTime)) { rb_raise(rb_eTypeError, "wrong argument type %s (expected Time)", rb_class2name(CLASS_OF(mtime))); } if (!NIL_P(flags)) { i_flags = NUM2INT(flags); } Data_Get_Struct(self, struct zipruby_archive, p_archive); Check_Archive(p_archive); if (FIXNUM_P(index)) { i_index = NUM2INT(index); } else if ((i_index = zip_name_locate(p_archive->archive, RSTRING_PTR(index), i_flags)) == -1) { rb_raise(Error, "Replace file failed - %s: Archive does not contain a file", RSTRING_PTR(index)); } if ((z = malloc(sizeof(struct read_proc))) == NULL) { zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(rb_eRuntimeError, "Replace failed at %d: Cannot allocate memory", i_index); } z->proc = rb_block_proc(); rb_ary_push(p_archive->sources, z->proc); z->mtime = TIME2LONG(mtime); if ((zsource = zip_source_proc(p_archive->archive, z)) == NULL) { free(z); rb_raise(Error, "Replace failed at %d: %s", i_index, zip_strerror(p_archive->archive)); } if (zip_replace(p_archive->archive, i_index, zsource) == -1) { zip_source_free(zsource); zip_unchange_all(p_archive->archive); zip_unchange_archive(p_archive->archive); rb_raise(Error, "Replace failed at %d: %s", i_index, zip_strerror(p_archive->archive)); } return Qnil; }
static VALUE rb_ool_conmin_constraint_set_n(VALUE obj, VALUE n) { ool_conmin_constraint *C; if (!FIXNUM_P(n)) rb_raise(rb_eArgError, "Wrong argument type %s (Fixnum expected)", rb_class2name(CLASS_OF(n))); Data_Get_Struct(obj, ool_conmin_constraint, C); C->n = (size_t) FIX2INT(n); return n; }
/* * call-seq: * to_s -> "<Delineate::Point:(self.x,self.y)>" * * Return x and y by String. */ VALUE rb_point_to_s(VALUE self) { const int i = 4; VALUE str[i]; str[0] = rb_str_new2("<%s:(%g,%g)>"); str[1] = rb_str_new2(rb_class2name(CLASS_OF(self))); str[2] = rb_point_x(self); str[3] = rb_point_y(self); return rb_f_sprintf(i, str); }
static usb_dev_handle *check_usb_devhandle(VALUE v) { Check_Type(v, T_DATA); if (RDATA(v)->dfree != rusb_devhandle_free) { rb_raise(rb_eTypeError, "wrong argument type %s (expected USB::DevHandle)", rb_class2name(CLASS_OF(v))); } return DATA_PTR(v); }
void rb_undef(VALUE klass, ID id) { // TODO #if 0 VALUE origin; NODE *body; #if 0 // TODO if (rb_vm_cbase() == rb_cObject && klass == rb_cObject) { rb_secure(4); } #endif if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) { rb_raise(rb_eSecurityError, "Insecure: can't undef `%s'", rb_id2name(id)); } rb_frozen_class_p(klass); if (id == object_id || id == __send__ || id == idInitialize) { rb_warn("undefining `%s' may cause serious problem", rb_id2name(id)); } /* TODO: warn if a very important method of NSObject is undefined * by default, pure objc methods are not exposed by introspections API */ body = search_method(klass, id, &origin); if (!body || !body->nd_body) { const char *s0 = " class"; VALUE c = klass; if (RCLASS_SINGLETON(c)) { VALUE obj = rb_iv_get(klass, "__attached__"); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: c = obj; s0 = ""; } } else if (TYPE(c) == T_MODULE) { s0 = " module"; } rb_name_error(id, "undefined method `%s' for%s `%s'", rb_id2name(id), s0, rb_class2name(c)); } rb_add_method(klass, id, 0, NOEX_PUBLIC); if (RCLASS_SINGLETON(klass)) { rb_funcall(rb_iv_get(klass, "__attached__"), singleton_undefined, 1, ID2SYM(id)); } else { rb_funcall(klass, undefined, 1, ID2SYM(id)); } #endif }
static VALUE ossl_cipher_update_deprecated(VALUE self, VALUE data) { char *cname; cname = rb_class2name(rb_obj_class(self)); rb_warning("%s#<< is deprecated; use %s#update instead", cname, cname); return ossl_cipher_update(self, data); }
/* * call-seq: * cipher << data -> string * * === Parameters * +data+ is a nonempty string. * * This method is deprecated and not available in 1.9.x or later. */ static VALUE ossl_cipher_update_deprecated(VALUE self, VALUE data) { const char *cname; cname = rb_class2name(rb_obj_class(self)); rb_warning("%s#<< is deprecated; use %s#update instead", cname, cname); return rb_funcall(self, rb_intern("update"), 1, data); }
static void oci8_assign_lob(VALUE klass, oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest) { oci8_base_t *base = oci8_check_typeddata(lob, &oci8_lob_data_type, 1); if (!rb_obj_is_kind_of(lob, klass)) { rb_raise(rb_eTypeError, "wrong argument %s (expect %s)", rb_obj_classname(lob), rb_class2name(klass)); } chker2(OCILobLocatorAssign_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, base->hp.lob, dest), base); }
static VALUE actiongroup_add_actions(VALUE self, VALUE entries) { guint i; VALUE action_procs; guint n_entries = (guint)RARRAY_LEN(entries); GtkActionEntry* gentries = g_new0(GtkActionEntry, n_entries); if (rb_ivar_defined(self, id_action_procs) == Qtrue){ action_procs = rb_ivar_get(self, id_action_procs); } else { action_procs = rb_hash_new(); } for (i = 0; i < n_entries; i++){ VALUE entry; int size; entry = RARRAY_PTR(entries)[i]; size = RARRAY_LEN(entry); if (size < 1) rb_raise(rb_eArgError, "wrong array parameter"); gentries[i].name = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[0]); gentries[i].callback = G_CALLBACK(activate_action); if (size < 2) continue; if (NIL_P(RARRAY_PTR(entry)[1])){ gentries[i].stock_id = NULL; } else if (SYMBOL_P(RARRAY_PTR(entry)[1])){ gentries[i].stock_id = rb_id2name(SYM2ID(RARRAY_PTR(entry)[1])); } else if (TYPE(RARRAY_PTR(entry)[1]) == T_STRING){ gentries[i].stock_id = RVAL2CSTR(RARRAY_PTR(entry)[1]); } else{ rb_raise(rb_eArgError, "invalid argument %s (expect Symbol or String)", rb_class2name(CLASS_OF(RARRAY_PTR(entry)[1]))); } if (size < 3) continue; gentries[i].label = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[2]); if (size < 4) continue; gentries[i].accelerator = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[3]); if (size < 4) continue; gentries[i].tooltip = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[4]); if (size < 5) continue; rb_hash_aset(action_procs, RARRAY_PTR(entry)[0], RARRAY_PTR(entry)[5]); } rb_ivar_set(self, id_action_procs, action_procs); gtk_action_group_add_actions(_SELF(self), gentries, n_entries, (gpointer)self); g_free(gentries); return self; }
/* * Extern: rm_get_geometry * Purpose: Get the values from a Geometry object and return * them in C variables. */ void rm_get_geometry( VALUE geom, long *x, long *y, unsigned long *width, unsigned long *height, int *flag) { VALUE v; v = rb_funcall(geom, rm_ID_x, 0); *x = NUM2LONG(v); v = rb_funcall(geom, rm_ID_y, 0); *y = NUM2LONG(v); v = rb_funcall(geom, rm_ID_width, 0); *width = NUM2ULONG(v); v = rb_funcall(geom, rm_ID_height, 0); *height = NUM2ULONG(v); // Getting the flag field is a bit more difficult since it's // supposed to be an instance of the GeometryValue Enum class. We // may not know the VALUE for the GeometryValue class, and we // need to check that the flag field is an instance of that class. if (flag) { MagickEnum *magick_enum; v = rb_funcall(geom, rm_ID_flag, 0); if (!Class_GeometryValue) { Class_GeometryValue = rb_const_get(Module_Magick, rm_ID_GeometryValue); } if (CLASS_OF(v) != Class_GeometryValue) { rb_raise(rb_eTypeError, "wrong enumeration type - expected %s, got %s" , rb_class2name(Class_GeometryValue),rb_class2name(CLASS_OF(v))); } Data_Get_Struct(v, MagickEnum, magick_enum); *flag = magick_enum->val; } }
static VALUE mSyslog_inspect(VALUE self) { char buf[1024]; if (syslog_opened) { snprintf(buf, sizeof(buf), "<#%s: opened=true, ident=\"%s\", options=%d, facility=%d, mask=%d>", rb_class2name(self), syslog_ident, syslog_options, syslog_facility, syslog_mask); } else { snprintf(buf, sizeof(buf), "<#%s: opened=false>", rb_class2name(self)); } return rb_str_new2(buf); }
static TERMINAL * check_rt(VALUE self) { Check_Type(self, T_DATA); if (RDATA(self)->dfree != rt_free) { rb_raise(rb_eTypeError, "wrong argument type %s (expected TermInfo)", rb_class2name(CLASS_OF(self))); } return DATA_PTR(self); }
/* * call-seq: * CvSeq.new(<i>type[,storage]</i>) * * Return a new CvSeq. <i>type</i> should be following classes. * * * CvIndex * * CvPoint */ VALUE rb_initialize(int argc, VALUE *argv, VALUE self) { VALUE klass, storage_value; CvMemStorage *storage; if (rb_scan_args(argc, argv, "11", &klass, &storage_value) > 1) { storage_value = CHECK_CVMEMSTORAGE(storage_value); storage = CVMEMSTORAGE(storage_value); } else storage = cvCreateMemStorage(0); if(!rb_obj_is_kind_of(klass, rb_cClass)) rb_raise(rb_eTypeError, "argument 1 (sequence-block class) should be %s.", rb_class2name(rb_cClass)); int type = 0, size = 0; if (klass == cCvIndex::rb_class()) { type = CV_SEQ_ELTYPE_INDEX; size = sizeof(CvIndex); } else if (klass == cCvPoint::rb_class()) { type = CV_SEQ_ELTYPE_POINT; size = sizeof(CvPoint); } else if (klass == cCvPoint2D32f::rb_class()) { type = CV_SEQ_ELTYPE_POINT; size = sizeof(CvPoint2D32f); } else if (klass == cCvPoint3D32f::rb_class()) { type = CV_SEQ_ELTYPE_POINT3D; size = sizeof(CvPoint3D32f); } // todo: more various class will be support. if (!size) rb_raise(rb_eTypeError, "unsupport %s class for sequence-block.", rb_class2name(klass)); CvSeq* seq = cvCreateSeq(type, sizeof(CvSeq), size, storage); DATA_PTR(self) = seq; resist_class_information_of_sequence(seq, klass); return self; }
gpointer rbgobj_boxed_get(VALUE obj, GType gtype) { boxed_holder* holder; if (NIL_P(obj)) return NULL; if (!RVAL2CBOOL(rb_obj_is_kind_of(obj, GTYPE2CLASS(gtype)))) rb_raise(rb_eArgError, "invalid argument %s (expect %s)", rb_class2name(CLASS_OF(obj)), rb_class2name(GTYPE2CLASS(gtype))); Data_Get_Struct(obj, boxed_holder, holder); if (!holder->boxed) rb_raise(rb_eArgError, "uninitialize %s", rb_class2name(CLASS_OF(obj))); return holder->boxed; }
VALUE rb_mod_init_copy(VALUE clone, SEL sel, VALUE orig) { rb_obj_init_copy(clone, 0, orig); VALUE super; if (!RCLASS_RUBY(orig)) { super = orig; rb_warn("cloning class `%s' is not supported, creating a " \ "subclass instead", rb_class2name(orig)); } else { super = RCLASS_SUPER(orig); } RCLASS_SET_SUPER(clone, super); // Copy flags. unsigned long version_flag = RCLASS_IS_RUBY_CLASS; if ((RCLASS_VERSION(super) & RCLASS_IS_OBJECT_SUBCLASS) == RCLASS_IS_OBJECT_SUBCLASS) { version_flag |= RCLASS_IS_OBJECT_SUBCLASS; } if (RCLASS_MODULE(orig)) { version_flag |= RCLASS_IS_MODULE; } RCLASS_SET_VERSION(clone, version_flag); if (!class_isMetaClass((Class)clone)) { // Clear type info. RCLASS_SET_VERSION(*(Class *)clone, RCLASS_VERSION(*(Class *)clone)); } // Copy methods. rb_vm_copy_methods((Class)orig, (Class)clone); if (!class_isMetaClass((Class)orig)) { rb_vm_copy_methods(*(Class *)orig, *(Class *)clone); } // Copy ivars. CFMutableDictionaryRef orig_dict = rb_class_ivar_dict(orig); CFMutableDictionaryRef clone_dict; if (orig_dict != NULL) { clone_dict = CFDictionaryCreateMutableCopy(NULL, 0, orig_dict); rb_class_ivar_set_dict(clone, clone_dict); CFMakeCollectable(clone_dict); } else { clone_dict = rb_class_ivar_dict_or_create(clone); } // Remove the classpath & classid (name) so that they are not // copied over the new module / class. CFDictionaryRemoveValue(clone_dict, (const void *)id_classpath); CFDictionaryRemoveValue(clone_dict, (const void *)id_classid); return clone; }
/* * call-seq: * insert(<i>index,obj</i>) -> self * * Inserts the given values before element with the given index (which may be negative). */ VALUE rb_insert(VALUE self, VALUE index, VALUE object) { Check_Type(index, T_FIXNUM); CvSeq *seq = CVSEQ(self); VALUE klass = seqblock_class(seq); if(CLASS_OF(object) != klass) rb_raise(rb_eTypeError, "arguments should be %s.", rb_class2name(klass)); cvSeqInsert(seq, FIX2INT(index), DATA_PTR(object)); return self; }
void require_class(VALUE x, VALUE cls) { if(rb_obj_is_instance_of(x,cls) == Qfalse) { rb_raise( rb_eRuntimeError, "wrong argument type %s (expected %s)", rb_obj_classname(x), rb_class2name(cls) ); } }
/* * Object validity checker. Returns the data pointer. */ static struct rlink_sentence * check_sentence( VALUE self ) { Check_Type( self, T_DATA ); if ( !IsSentence(self) ) { rb_raise( rb_eTypeError, "wrong argument type %s (expected LinkParser::Sentence)", rb_class2name(CLASS_OF( self )) ); } return DATA_PTR( self ); }
static VALUE onum_inspect(VALUE self) { const char *name = rb_class2name(CLASS_OF(self)); volatile VALUE s = onum_to_s(self); size_t len = strlen(name) + RSTRING_LEN(s) + 5; char *str = ALLOCA_N(char, len); snprintf(str, len, "#<%s:%s>", name, RSTRING_PTR(s)); str[len - 1] = '\0'; return rb_usascii_str_new_cstr(str); }
static VALUE binding_entry_add_signal(int argc, VALUE *argv, VALUE self) { VALUE keyval, modifiers, signame, rest; long i; VALUE param; GSList *slist, *free_slist; slist = NULL; rb_scan_args(argc, argv, "3*", &keyval, &modifiers, &signame, &rest); for (i = 0; i < RARRAY_LEN(rest); i++) { GtkBindingArg *arg; arg = g_new0 (GtkBindingArg, 1); slist = g_slist_prepend (slist, arg); param = RARRAY_PTR(rest)[i]; if (TYPE(param) == T_FLOAT) { arg->arg_type = G_TYPE_DOUBLE; arg->d.double_data = NUM2DBL(param); } else if (rb_respond_to (param, rb_intern("to_int"))) { arg->arg_type = G_TYPE_LONG; arg->d.long_data = NUM2LONG(param); } else if (param == Qfalse) { arg->arg_type = G_TYPE_LONG; arg->d.long_data = 0; } else if (param == Qtrue) { arg->arg_type = G_TYPE_LONG; arg->d.long_data = 1; } else if (rb_respond_to (param, rb_intern("to_str"))) { arg->arg_type = G_TYPE_STRING; arg->d.string_data = RVAL2CSTR(param); } else { rb_raise(rb_eTypeError, "can not convert %s into String, Numeric, " "GLib::Enum/GLib::Flags or true/false", rb_class2name(CLASS_OF(param))); } } slist = g_slist_reverse (slist); gtk_binding_entry_add_signall (_SELF(self), NUM2UINT(keyval), RVAL2MOD(modifiers), RVAL2CSTR(signame), slist); free_slist = slist; while (slist) { g_free (slist->data); slist = slist->next; } g_slist_free (free_slist); return self; }
static const gsl_cqpminimizer_type* get_type(VALUE t) { switch (TYPE(t)) { case T_STRING: return type_by_string(t); break; default: rb_raise(rb_eTypeError, "Wrong argument type %s.", rb_class2name(CLASS_OF(t))); } }
/* * Object validity checker. Returns the data pointer. */ static MMIOT * bluecloth_check_ptr( VALUE self ) { Check_Type( self, T_DATA ); if ( !rb_obj_is_kind_of(self, bluecloth_cBlueCloth) ) { rb_raise( rb_eTypeError, "wrong argument type %s (expected BlueCloth object)", rb_class2name(CLASS_OF( self )) ); } return DATA_PTR( self ); }
static VALUE typecast(sqlite3_stmt *stmt, int i, VALUE ruby_class) { const char *ruby_type; VALUE ruby_value = Qnil; int original_type = sqlite3_column_type(stmt, i); int length = sqlite3_column_bytes(stmt, i); if ( original_type == SQLITE_NULL ) { return ruby_value; } if ( original_type == SQLITE_BLOB ) { return TAINTED_STRING((char*)sqlite3_column_blob(stmt, i), length); } if(ruby_class == Qnil) { switch(original_type) { case SQLITE_INTEGER: { ruby_type = "Integer"; break; } case SQLITE_FLOAT: { ruby_type = "Float"; break; } default: { ruby_type = "String"; break; } } } else { ruby_type = rb_class2name(ruby_class); } if ( strcmp(ruby_type, "Class") == 0) { return rb_funcall(rb_cObject, rb_intern("full_const_get"), 1, TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length)); } else if ( strcmp(ruby_type, "Object") == 0 ) { return rb_marshal_load(rb_str_new2((char*)sqlite3_column_text(stmt, i))); } else if ( strcmp(ruby_type, "TrueClass") == 0 ) { return strcmp((char*)sqlite3_column_text(stmt, i), "t") == 0 ? Qtrue : Qfalse; } else if ( strcmp(ruby_type, "Integer") == 0 || strcmp(ruby_type, "Fixnum") == 0 || strcmp(ruby_type, "Bignum") == 0 ) { return LL2NUM(sqlite3_column_int64(stmt, i)); } else if ( strcmp(ruby_type, "BigDecimal") == 0 ) { return rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length)); } else if ( strcmp(ruby_type, "Float") == 0 ) { return rb_float_new(sqlite3_column_double(stmt, i)); } else if ( strcmp(ruby_type, "Date") == 0 ) { return parse_date((char*)sqlite3_column_text(stmt, i)); } else if ( strcmp(ruby_type, "DateTime") == 0 ) { return parse_date_time((char*)sqlite3_column_text(stmt, i)); } else if ( strcmp(ruby_type, "Time") == 0 ) { return parse_time((char*)sqlite3_column_text(stmt, i)); } else { return TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length); } }
static void bind_lob_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val) { oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data; const oci8_bind_lob_class_t *klass = (const oci8_bind_lob_class_t *)obind->base.klass; oci8_base_t *h; if (!rb_obj_is_kind_of(val, *klass->klass)) rb_raise(rb_eArgError, "Invalid argument: %s (expect %s)", rb_class2name(CLASS_OF(val)), rb_class2name(*klass->klass)); h = DATA_PTR(val); oho->hp = h->hp.ptr; oho->obj = val; }
inline CEGUI::Vertex* wrap< CEGUI::Vertex* >(const VALUE &vvertex) { if (rb_obj_is_kind_of(vvertex, rb_cCeguiVertex)){ CEGUI::Vertex *vertex; Data_Get_Struct( vvertex, CEGUI::Vertex, vertex); return vertex; }else{ //TODO add struct support later rb_raise(rb_eTypeError,"Expected %s got %s!",rb_class2name(rb_cCeguiVertex),rb_obj_classname(vvertex)); return NULL; } }
/* Accepts an array of Ruby types (Fixnum, Float, String, etc...) and turns them into Ruby-strings so we can easily typecast later */ static VALUE cCommand_set_types(VALUE self, VALUE array) { VALUE type_strings = rb_ary_new(); int i; for (i = 0; i < RARRAY_LEN(array); i++) { rb_ary_push(type_strings, RUBY_STRING(rb_class2name(rb_ary_entry(array, i)))); } rb_iv_set(self, "@field_types", type_strings); return array; }
static const gsl_odeiv_step_type* rb_gsl_odeiv_step_type_get(VALUE tt) { const gsl_odeiv_step_type *T; int type; char name[64]; switch (TYPE(tt)) { case T_FIXNUM: type = FIX2INT(tt); switch (type) { case GSL_ODEIV_STEP_RK2: T = gsl_odeiv_step_rk2; break; case GSL_ODEIV_STEP_RK4: T = gsl_odeiv_step_rk4; break; case GSL_ODEIV_STEP_RKF45: T = gsl_odeiv_step_rkf45; break; case GSL_ODEIV_STEP_RKCK: T = gsl_odeiv_step_rkck; break; case GSL_ODEIV_STEP_RK8PD: T = gsl_odeiv_step_rk8pd; break; case GSL_ODEIV_STEP_RK2IMP: T = gsl_odeiv_step_rk2imp; break; case GSL_ODEIV_STEP_RK4IMP: T = gsl_odeiv_step_rk4imp; break; case GSL_ODEIV_STEP_BSIMP: T = gsl_odeiv_step_bsimp; break; case GSL_ODEIV_STEP_GEAR1: T = gsl_odeiv_step_gear1; break; case GSL_ODEIV_STEP_GEAR2: T = gsl_odeiv_step_gear2; break; #ifdef GSL_1_6_LATER case GSL_ODEIV_STEP_RK2SIMP: T = gsl_odeiv_step_rk2simp; break; #endif default: rb_raise(rb_eArgError, "wrong argument type (Fixnum expected)"); break; } break; case T_STRING: strcpy(name, STR2CSTR(tt)); if (str_tail_grep(name, "rk2") == 0) T = gsl_odeiv_step_rk2; else if (str_tail_grep(name, "rk4") == 0) T = gsl_odeiv_step_rk4; else if (str_tail_grep(name, "rkf45") == 0) T = gsl_odeiv_step_rkf45; else if (str_tail_grep(name, "rkck") == 0) T = gsl_odeiv_step_rkck; else if (str_tail_grep(name, "rk8pd") == 0) T = gsl_odeiv_step_rk8pd; else if (str_tail_grep(name, "rk2imp") == 0) T = gsl_odeiv_step_rk2imp; else if (str_tail_grep(name, "rk4imp") == 0) T = gsl_odeiv_step_rk4imp; else if (str_tail_grep(name, "bsimp") == 0) T = gsl_odeiv_step_bsimp; else if (str_tail_grep(name, "gear1") == 0) T = gsl_odeiv_step_gear1; else if (str_tail_grep(name, "gear2") == 0) T = gsl_odeiv_step_gear2; #ifdef GSL_1_6_LATER else if (str_tail_grep(name, "rk2simp") == 0) T = gsl_odeiv_step_rk2simp; #endif else { rb_raise(rb_eArgError, "wrong argument type %s", name); } break; default: rb_raise(rb_eArgError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(tt))); break; } return T; }
/* * call-seq: * Message.inspect => string * * Returns a human-readable string representing this message. It will be * formatted as "<MessageType: field1: value1, field2: value2, ...>". Each * field's value is represented according to its own #inspect method. */ VALUE Message_inspect(VALUE _self) { MessageHeader* self; TypedData_Get_Struct(_self, MessageHeader, &Message_type, self); VALUE str = rb_str_new2("<"); str = rb_str_append(str, rb_str_new2(rb_class2name(CLASS_OF(_self)))); str = rb_str_cat2(str, ": "); str = rb_str_append(str, layout_inspect( self->descriptor->layout, Message_data(self))); str = rb_str_cat2(str, ">"); return str; }
static VALUE rb_ool_conmin_function_set_n(VALUE obj, VALUE nn) { ool_conmin_function *F = NULL; if (FIXNUM_P(nn)) { Data_Get_Struct(obj, ool_conmin_function, F); F->n = (size_t) FIX2INT(nn); } else { rb_raise(rb_eArgError, "Wrong argument type %s (Fixnum expected)", rb_class2name(CLASS_OF(nn))); } return nn; }