VALUE t_do(VALUE self, VALUE in, VALUE out, VALUE size) { rb_check_type(in, T_FILE); rb_check_type(out, T_FILE); FILE *source; if (rb_funcall(rb_eval_string("Socket"), rb_intern("=="), 1, rb_class_of(in)) == Qtrue) source= RFILE(in)->fptr->f2; else source= RFILE(in)->fptr->f; FILE *destination; if (rb_funcall(rb_eval_string("Socket"), rb_intern("=="), 1, rb_class_of(out)) == Qtrue) destination= RFILE(out)->fptr->f2; else destination= RFILE(out)->fptr->f; VALUE result= INT2NUM(0); char buffer[1024]; while ((size == Qnil) || (rb_funcall(result, rb_intern("<"), 1, size) == Qtrue)) { size_t done= fread(buffer, 1, sizeof(buffer), source); if (ferror(source)) { rb_sys_fail("io2io_do(read)"); } fwrite(buffer, 1, done, destination); if (ferror(destination)) { rb_sys_fail("io2io_do(write)"); } result= rb_funcall(result, rb_intern("+"), 1, INT2NUM(done)); if (done < sizeof(buffer)) { return result; } } return result; }
/* * call-seq: * inspect -> String * * Human-readable description. * ===Return value * String */ VALUE _inspect(VALUE self) { if(wrap< RubyWindowHolder* >(self)->window==NULL){ VALUE array[2]; array[0]=rb_str_new2("#<%s:(destroyed)>"); array[1]=rb_class_of(self); return rb_f_sprintf(2,array); }else{ if(rb_const_defined(rb_class_of(self),rb_intern("WidgetTypeName"))) if(_self->getType() == wrap<CEGUI::String>(rb_const_get(rb_class_of(self),rb_intern("WidgetTypeName")))) { VALUE array[3]; array[0]=rb_str_new2("#<%s:%s>"); array[1]=rb_class_of(self); array[2]=rb_funcall(self,rb_intern("name"),0); return rb_f_sprintf(3,array); } VALUE array[4]; array[0]=rb_str_new2("#<%s(%s):%s>"); array[1]=rb_class_of(self); array[2]=_getType(self); array[3]=rb_funcall(self,rb_intern("name"),0); return rb_f_sprintf(4,array); } }
static VALUE rb_cpBBcontains(VALUE self, VALUE other) { if (rb_class_of(other) == c_cpBB) { return rb_cpBBContainsBB(self, other); } else if (rb_class_of(other) == c_cpVect) { return rb_cpBBContainsVect(self, other); } rb_raise(rb_eArgError, "contains requires a BB or a Vect2 argument"); return Qnil; }
static VALUE rb_cpBBintersects(int argc, VALUE *argv, VALUE self) { VALUE other, b; rb_scan_args(argc, argv, "11", &other, &b); if (rb_class_of(other) == c_cpBB) { return rb_cpBBIntersectsBB(self, other); } else if ((rb_class_of(other) == c_cpVect) && (rb_class_of(b) == c_cpVect)) { return rb_cpBBIntersectsSegment(self, other, b); } rb_raise(rb_eArgError, "contains requires a BB or 2 Vect2 arguments"); return Qnil; }
static VALUE lich_script_gets(VALUE self) { VALUE rb_curidx, rb_scrlist; int scridx, offset; static int count = 0; if (RBASIC(self)->klass != rb_cScript) { rb_raise(rb_eArgumentError, "object is of type `%s' (expected Script)", rb_class_of(self)); } rb_scridx = rb_iv_get(self, id_lineno); scridx = FIX2INT(rb_scridx); if (scridx < minidx) { off void Init_scriptio() { rb_define_singleton_method(rb_cScript, "puts", lich_script_s_puts, -1); rb_define_method(rb_cScript, "gets", lich_script_gets, 0); id_lineno = rb_intern("@scriptio_lineno"); dbuffer = rb_ary_new(); rb_cvar_set(rb_cScript, rb_intern("@@data_buffer"), dbuffer); }
/* * call-seq: * udim.inspect -> String * * Human-readable description. * ===Return value * String */ VALUE _inspect(VALUE self) { VALUE array[3]; array[0]=rb_str_new2("#<%s:%s>"); array[1]=rb_class_of(self); array[2]=self; return rb_f_sprintf(3,array); }
/* * call-seq: * inspect -> String * * Human-readable description. * ===Return value * String */ VALUE _inspect(VALUE self) { VALUE array[4]; array[0]=rb_str_new2("#<%s:%s:%s>"); array[1]=rb_class_of(self); array[2]=rb_funcall(self,"name"); array[3]=rb_funcall(self,"value"); return rb_f_sprintf(4,array); }
/* * call-seq: * vector2.inspect -> String * * Human-readable description. * ===Return value * String */ VALUE _inspect(VALUE self) { VALUE array[4]; array[0]=rb_str_new2("#<%s:(%f, %f)>"); array[1]=rb_class_of(self); array[2]=_get_x(self); array[3]=_get_y(self); return rb_f_sprintf(4,array); }
/* * call-seq: * inspect -> String * * Human-readable description. * ===Return value * String */ VALUE _inspect(VALUE self) { VALUE array[5]; array[0]=rb_str_new2("#<%s:(%s, %s, %s)>"); array[1]=rb_class_of(self); array[2]=rb_funcall(_get_width(self),rb_intern("inspect"),0); array[3]=rb_funcall(_get_height(self),rb_intern("inspect"),0); array[4]=rb_funcall(_get_bitsPerPixel(self),rb_intern("inspect"),0); return rb_f_sprintf(5,array); }
/* * call-seq: * scale(x, y) -> WX::Size * scale(i) -> WX::Size * * i -> WX::Size * * scale this size and return new size. * ===Arguments * * x, y and i are Float * ===Return value * WX::Size */ DLL_LOCAL VALUE _scale(int argc,VALUE *argv,VALUE self) { VALUE x, y; rb_scan_args(argc, argv, "11", &x, &y); wxSize* result = new wxSize(*_self); result->Scale(NUM2DBL(x), NUM2DBL(NIL_P(y) ? x : y)); return wrapTypedPtr(result, rb_class_of(self)); }
static struct uwsgi_buffer *uwsgi_ruby_exception_class(struct wsgi_request *wsgi_req) { VALUE err = rb_errinfo(); VALUE e = rb_class_name(rb_class_of(err)); struct uwsgi_buffer *ub = uwsgi_buffer_new(RSTRING_LEN(e)); if (uwsgi_buffer_append(ub, RSTRING_PTR(e), RSTRING_LEN(e))) { uwsgi_buffer_destroy(ub); return NULL; } return ub; }
static VALUE t_init_cnpj(int argc, VALUE *argv, VALUE self) { int radix = 0; int filial = 0; int verif = 0; VALUE valid = Qnil; if (argc == 2) { radix = FIX2INT(argv[0]); if( radix >= 100000000 || radix < 0 ) rb_raise(rb_eArgError, "radix should be greater than -1 or lesser than 10_000_000"); filial = NUM2INT(argv[1]); if( filial >= 10000 || filial < 1) rb_raise(rb_eArgError, "filial should be greater than 0 or lesser than 10_000"); verif = calculate_digit(radix,filial); valid = Qtrue; } else if (argc == 1) { lldiv_t v; long long cnpj = 0; if (rb_class_of(argv[0]) == rb_cString) cnpj = NUM2LL(rb_str_to_inum(argv[0], 10, 0)); else if (rb_class_of(argv[0]) == rb_cFixnum || rb_class_of(argv[0]) == rb_cBignum) cnpj = NUM2LL(argv[0]); v = lldiv(cnpj, (long long)100); verif = (int)v.rem; v = lldiv(v.quot, (long long)10000); filial = (int)v.rem; radix = (int)v.quot; valid = (verif == calculate_digit(radix,filial)) ? Qtrue : Qfalse; } rb_iv_set(self, "@radix", INT2FIX(radix)); rb_iv_set(self, "@filial", INT2FIX(filial)); rb_iv_set(self, "@digit", INT2FIX(verif)); rb_iv_set(self, "@valid", valid); return self; }
/* * call-seq: * inspect -> String * * Human-readable description. * ===Return value * String */ VALUE _inspect(VALUE self) { VALUE array[6]; array[0]=rb_str_new2("#<%s:(%d, %d, %d, %d)>"); array[1]=rb_class_of(self); array[2]=_getX(self); array[3]=_getY(self); array[4]=_getWidth(self); array[5]=_getHeight(self); return rb_f_sprintf(6,array); }
void TimerEvent::unregister_callback(VALUE proc) { RAGE_CHECK_DISPOSED(disposed); if (TYPE(rb_ary_includes(timer_observer, proc)) == T_TRUE) { if (rb_class_of(proc) != rb_cProc) rb_raise(rb_eTypeError, RAGE_RB_PROC_ERROR); else rb_ary_delete(timer_observer, proc); } }
/* * call-seq: * / n -> WX::Size * * devide this size and return new size. * ===Arguments * * n are Float * ===Return value * WX::Size * === Exceptions * [ZeroDivisionError] * * if n is zero */ DLL_LOCAL VALUE _devide(VALUE self, VALUE n) { float d = NUM2DBL(n); if(d == 0) rb_raise(rb_eZeroDivError, "divided by 0"); d = 1.0 / d; wxSize* result = new wxSize(*_self); result->Scale(d, d); return wrapTypedPtr(result, rb_class_of(self)); }
VALUE rho_ruby_get_time(VALUE rDate) { VALUE res, cDate; if (TYPE(rDate) == T_STRING) { rDate = rb_funcall(rb_cTime, rb_intern("parse"), 1, rDate); } cDate = rb_class_of(rDate); if (!rb_equal(cDate, rb_cTime)) rb_raise(rb_eArgError, "Wrong type of parameter: %s (Time expected)", rb_class2name(cDate)); return rDate; }
static VALUE spgd_compute_name(VALUE self, VALUE split_rule, VALUE values) { VALUE res = 0; int encoding = -1; char *result = (char*) xmalloc(INITIAL_CAPA); int pos = 0, capa = INITIAL_CAPA; long i, rule_len = RARRAY_LEN(split_rule); if (!result) { rb_memerror(); } for (i = 0; i < rule_len; i++) { VALUE rule = rb_ary_entry(split_rule, i); if (rb_class_of(rule) == rb_cArray) { long fieldnum = NUM2LONG(rb_ary_entry(rule, 0)); VALUE actions = rb_ary_entry(rule, 1); rule = rb_ary_entry(values, fieldnum); encoding = ENCODING_GET(rule); if (RTEST(actions) && RARRAY_LEN(actions)) { rule = apply_actions(rule, actions); } } if (rb_class_of(rule) == rb_cString) { long size = RSTRING_LEN(rule); if (capa < pos + size + 1) { char *tmp; capa = pos + size + 1; if (i + 1 != rule_len) capa = (capa * 3) >> 1; tmp = (char*) xrealloc(result, capa); if (!tmp) { xfree(result); rb_memerror(); } result = tmp; } if (encoding == -1) encoding = ENCODING_GET(rule); strncpy(result + pos, RSTRING_PTR(rule), size + 1); pos += size; }
static VALUE rbosa_element_eql (VALUE self, VALUE other) { AEDesc * self_desc; AEDesc * other_desc; Size data_size; void * self_data; void * other_data; OSErr error; Boolean ok; if (!rb_obj_is_kind_of (other, rb_class_real (rb_class_of (self)))) return Qfalse; self_desc = rbosa_element_aedesc (self); other_desc = rbosa_element_aedesc (other); if (self_desc == other_desc) return Qtrue; if (self_desc->descriptorType != other_desc->descriptorType) return Qfalse; data_size = AEGetDescDataSize (self_desc); if (data_size != AEGetDescDataSize (other_desc)) return Qfalse; self_data = (void *)malloc (data_size); other_data = (void *)malloc (data_size); ok = 0; if (self_data == NULL || other_data == NULL) rb_fatal ("cannot allocate memory"); error = AEGetDescData (self_desc, self_data, data_size); if (error != noErr) goto bails; error = AEGetDescData (other_desc, other_data, data_size); if (error != noErr) goto bails; ok = memcmp (self_data, other_data, data_size) == 0; bails: free (self_data); free (other_data); return CBOOL2RVAL (ok); }
static rb_iseq_t *iseq_find(VALUE obj, VALUE mid, VALUE singleton_p) { rb_method_entry_t *me; rb_method_definition_t *def; VALUE km; int class; const char *msg = NULL; VALUE name; const char *sep = RTEST(singleton_p) ? "." : "#"; if (RTEST(singleton_p)) { class = 1; km = rb_class_of(obj); } else {
jobject date_cast<jobject, VALUE>(VALUE rDate) { RHO_TRACE("dateFromRuby"); if (NIL_P(rDate)) { RHO_TRACE("dateFromRuby - NIL object"); return NULL; } RHO_TRACE("dateFromRuby - check for string type"); if (TYPE(rDate) == T_STRING) { RHO_TRACE("dateFromRuby - converting from string"); if (strlen(RSTRING_PTR(rDate)) == 0) { RHO_TRACE("dateFromRuby - empty string"); return NULL; } rDate = rb_funcall(rb_cTime, rb_intern("parse"), 1, rDate); RHO_TRACE("dateFromRuby - converted to ruby date"); } VALUE cDate = rb_class_of(rDate); if (!rb_equal(cDate, rb_cTime)) rb_raise(rb_eArgError, "Wrong type of parameter: %s (Time expected)", rb_class2name(cDate)); RHO_TRACE("dateFromRuby (2)"); int year = NUM2INT(rb_funcall(rDate, rb_intern("year"), 0)) - 1900; RHO_TRACE("dateFromRuby (3)"); int month = NUM2INT(rb_funcall(rDate, rb_intern("month"), 0)) - 1; RHO_TRACE("dateFromRuby (4)"); int day = NUM2INT(rb_funcall(rDate, rb_intern("day"), 0)); RHO_TRACE("dateFromRuby (5)"); int hour = NUM2INT(rb_funcall(rDate, rb_intern("hour"), 0)); RHO_TRACE("dateFromRuby (6)"); int minute = NUM2INT(rb_funcall(rDate, rb_intern("min"), 0)); RHO_TRACE("dateFromRuby (7)"); int second = NUM2INT(rb_funcall(rDate, rb_intern("sec"), 0)); RHO_TRACE("dateFromRuby (8)"); JNIEnv *env = jnienv(); jclass cls = getJNIClass(RHODES_JAVA_CLASS_DATE); if (!cls) return NULL; jmethodID mid = getJNIClassMethod(env, cls, "<init>", "(IIIIII)V"); if (!mid) return NULL; RHO_TRACE("dateFromRuby (9)"); jobject jDate = env->NewObject(cls, mid, year, month, day, hour, minute, second); return jDate; }
mustache_node_t* get_partial(char* key, void* partials) { VALUE rb_partials = (VALUE) partials; Check_Type(rb_partials, T_HASH); VALUE rb_value; if (NIL_P(rb_value = rb_hash_aref(rb_partials, ID2SYM(rb_intern(key))))) { return NULL; } if (rb_class_of(rb_value) != cTemplate) { rb_raise(rb_eTypeError, "Expected Template"); } mustache_node_t* template = NULL;
// simulate ruby_error_print (this is sad... but it works well) static void uwsgi_ruby_exception_log(struct wsgi_request *wsgi_req) { VALUE err = rb_errinfo(); VALUE eclass = rb_class_name(rb_class_of(err)); VALUE msg = rb_funcall(err, rb_intern("message"), 0, 0); VALUE ary = rb_funcall(err, rb_intern("backtrace"), 0); int i; for (i=0; i<RARRAY_LEN(ary); i++) { if (i == 0) { uwsgi_log("%s: %s (%s)\n", RSTRING_PTR(RARRAY_PTR(ary)[i]), RSTRING_PTR(msg), RSTRING_PTR(eclass)); } else { uwsgi_log("\tfrom %s\n", RSTRING_PTR(RARRAY_PTR(ary)[i])); } } }
/* * call-seq: * dec_by(x, y) -> WX::Size * dec_by(i) -> WX::Size * dec_by(size) -> WX::Size * - i -> WX::Size * - size -> WX::Size * * decrease this size and return new size. * ===Arguments * * x, y and i are Integer * * size is a WX::Size * ===Return value * WX::Size */ DLL_LOCAL VALUE _decBy(int argc,VALUE *argv,VALUE self) { VALUE x, y; rb_scan_args(argc, argv, "11", &x, &y); wxSize* result = new wxSize(*_self); if(NIL_P(y)) { if(is_wrapable<wxSize>(x)) { result->DecBy(unwrap<wxSize>(x)); } else { result->DecBy(RB_NUM2INT(x)); } } else { result->DecBy(RB_NUM2INT(x), RB_NUM2INT(y)); } return wrapTypedPtr(result, rb_class_of(self)); }
void pg_coder_init_decoder( VALUE self ) { t_pg_coder *this = DATA_PTR( self ); VALUE klass = rb_class_of(self); this->enc_func = NULL; if( rb_const_defined( klass, s_id_CFUNC ) ){ VALUE cfunc = rb_const_get( klass, s_id_CFUNC ); this->dec_func = DATA_PTR(cfunc); } else { this->dec_func = NULL; } this->coder_obj = self; this->oid = 0; this->format = 0; rb_iv_set( self, "@name", Qnil ); }
static VALUE apply_actions(VALUE field, VALUE actions) { long j, actions_len = RARRAY_LEN(actions); long beg, len; VALUE num = 0, modi = 0; for (j = 0; j < actions_len; j++) { VALUE action = rb_ary_entry(actions, j); VALUE klass = rb_class_of(action); if (klass == rb_cRange) { /* copied from rb_str_aref */ len = rb_str_strlen(field); if (RTEST(rb_range_beg_len(action, &beg, &len, len, 0))) field = rb_str_substr(field, beg, len); } else if (klass == rb_cArray) { num = rb_str_to_inum(field, 10, 0); modi = rb_ary_entry(action, 1); if ( (FIXNUM_P(num) || TYPE(num) == T_BIGNUM && RBIGNUM_LEN(num) <= (SIZEOF_LONG/SIZEOF_BDIGITS) ) && FIXNUM_P(modi) && FIX2LONG(modi)) { long modl = NUM2LONG(modi); long numl = (NUM2LONG(num) / modl) * modl; char buf[30]; int wrtn = snprintf(buf, 30, RSTRING_PTR(rb_ary_entry(action, 0)), numl); if (wrtn < 30) { field = rb_str_new(buf, wrtn); continue; } } else { num = rb_funcall2(num, idDiv, 1, &modi); num = rb_funcall2(num, idMul, 1, &modi); } field = rb_str_format(1, &num, rb_ary_entry(action, 0)); } } return field; }
/* * call-seq: * DataView.new(buf) => DataView * DataView.new("buffer") => DataView * * Creates a new DataView instance. Both ArrayBuffer and data (String) constructors are supported. * * === Examples * buf = ArrayBuffer.new(8) => ArrayBuffer * view = DataView.new(buf) => DataView * * view = DataView.new(buf, 2) => DataView * view.byte_offset => 2 * view.byte_length => 6 * * view = DataView.new(buf, 2, 4) => DataView * view.byte_offset => 2 * view.byte_length => 2 * * view = DataView.new("buffer") => DataView * */ static VALUE rb_data_view_s_new(int argc, VALUE *argv, VALUE klass) { VALUE data_view; unsigned long new_byte_length; rb_data_view_t *view = NULL; VALUE obj, byte_offset, byte_length, buffer; new_byte_length = 0; rb_scan_args(argc, argv, "12", &obj, &byte_offset, &byte_length); data_view = Data_Make_Struct(klass, rb_data_view_t, rb_mark_data_view, rb_free_data_view, view); view->byte_offset = 0; view->byte_length = 0; if (rb_class_of(obj) == rb_cArrayBuffer) { GetArrayBuffer(obj); view->byte_length = buf->length; view->buf = obj; } else if (rb_type(obj) == T_STRING) { ArrayBufferEncode(obj); buffer = rb_alloc_array_buffer((unsigned long)RSTRING_LEN(obj), (void *)RSTRING_PTR(obj)); GetArrayBuffer(buffer); view->byte_length = buf->length; view->buf = buffer; } else { rb_raise(rb_eTypeError, "DataView constructor %s not supported.", RSTRING_PTR(rb_obj_as_string(obj))); } if (!NIL_P(byte_offset)) { Check_Type(byte_offset, T_FIXNUM); view->byte_offset = FIX2ULONG(byte_offset); if (view->byte_offset >= view->byte_length) rb_raise(rb_eRangeError, "Byte offset out of range."); } if (!NIL_P(byte_length)) { Check_Type(byte_length, T_FIXNUM); new_byte_length = FIX2ULONG(byte_length); if (new_byte_length > view->byte_length) rb_raise(rb_eRangeError, "Byte length out of range."); if ((view->byte_offset + new_byte_length) > view->byte_length) rb_raise(rb_eRangeError, "Byte offset / length is not aligned."); view->byte_length = new_byte_length; } view->byte_length -= view->byte_offset; rb_obj_call_init(data_view, 0, NULL); return data_view; }
VALUE Rice::detail:: method_data() { ID id; VALUE klass; if (!rb_frame_method_id_and_class(&id, &klass)) { rb_raise( rb_eRuntimeError, "Cannot get method id and class for function"); } if (rb_type(klass) == T_ICLASS) { klass = rb_class_of(klass); } VALUE store = rb_ivar_get(klass, RICE_ID); return (store == Qnil) ? Qnil : rb_ivar_get(store, id); }
static mustache_value_t* convert_value( VALUE rb_value, mustache_context_t* m_ctx) { switch (TYPE(rb_value)) { case T_OBJECT: return create_mustache_object(m_ctx, rb_value); case T_STRUCT: return create_mustache_object(m_ctx, rb_value); case T_HASH: return create_mustache_object(m_ctx, rb_value); case T_TRUE: return create_mustache_value(m_ctx, rb_str_new2("true")); case T_FALSE: return create_mustache_value(m_ctx, Qnil); case T_NONE: return create_mustache_value(m_ctx, Qnil); case T_NIL: return create_mustache_value(m_ctx, Qnil); case T_FLOAT: return create_mustache_value(m_ctx, rb_funcall(rb_value, rb_intern("to_s"), 0, 0)); case T_STRING: return create_mustache_value(m_ctx, rb_value); case T_FIXNUM: return create_mustache_value(m_ctx, rb_fix2str(rb_value, 10)); case T_BIGNUM: return create_mustache_value(m_ctx, rb_big2str(rb_value, 10)); case T_ARRAY: return create_mustache_list(m_ctx, rb_value); default: if (rb_class_of(rb_value) == rb_cProc) { return convert_value(rb_funcall(rb_value, rb_intern("call"), 0, 0), m_ctx); } return create_mustache_value(m_ctx, rb_any_to_s(rb_value)); } }
static gpointer marshall_value(CORBA_TypeCode tc, VALUE value, char *pool, int* pool_pos, int out) { while (tc->kind == CORBA_tk_alias) tc = tc->subtypes[0]; switch (tc->kind) { case CORBA_tk_wchar: case CORBA_tk_wstring: { rb_raise(eCorbaError, "Wide char unsupported"); break; } case CORBA_tk_char: case CORBA_tk_octet: { char *val = ALLOCATE_FOR(char); if(T_FIXNUM == TYPE(value)) { *val = (char)NUM2INT(value); } else if (cLong == rb_class_of(value)) { *val = (char)DATA_PTR(value); } else { rb_raise(rb_eTypeError, "wrong type argument %s (expected Fixnum or ORBit2::Long)", rb_obj_classname(value)); } return val; } case CORBA_tk_string: { Check_Type(value, T_STRING); char **val = ALLOCATE_FOR(char *); *val = CORBA_string_dup(STR(value)); return val; } case CORBA_tk_ushort: case CORBA_tk_short: { short *val = ALLOCATE_FOR(short); if(T_FIXNUM == TYPE(value)) { *(short *)(val) = (short)FIX2INT(value); } else if(cLong == rb_class_of(value)){ *(short *)(val) = (short)(long)DATA_PTR(value); } else { rb_raise(rb_eTypeError, "wrong type argument %s (expected Fixnum or ORBit2::Long)", rb_obj_classname(value)); } if(!out) return val; short **val_ptr = ALLOCATE_FOR(short *); *val_ptr = val; return val_ptr; } case CORBA_tk_enum: case CORBA_tk_long: case CORBA_tk_ulong: { long *val = ALLOCATE_FOR(long); if(T_FIXNUM == TYPE(value)) { *(long *)(val) = FIX2INT(value); } else if (cLong == rb_class_of(value)) { *(long *)(val) = (long)DATA_PTR(value); } else { rb_raise(rb_eTypeError, "wrong type argument %s (expected Fixnum or ORBit2::Long)", rb_obj_classname(value)); } if(!out) return val; long **val_ptr = ALLOCATE_FOR(long *); *val_ptr = val; return val_ptr; } case CORBA_tk_longlong: case CORBA_tk_ulonglong: { rb_raise(eCorbaError, "Long Long unsupported"); } case CORBA_tk_double: { double *val = ALLOCATE_FOR(double); if(T_FLOAT == TYPE(value)) { *val = RFLOAT(value)->value; } else if(T_FIXNUM == TYPE(value)) { *val = (double)NUM2INT(value); } else if(cLong = rb_class_of(value)) { *val = (double)(long)DATA_PTR(value); } else { rb_raise(rb_eTypeError, "wrong type argument %s (expected Float, Fixnum or ORBit2::Long)", rb_obj_classname(value)); } if(!out) return val; double **val_ptr = ALLOCATE_FOR(double *); *val_ptr = val; return val_ptr; } case CORBA_tk_longdouble: { rb_raise(eCorbaError, "Long double unsupported"); } case CORBA_tk_float: { Check_Type(value, T_FLOAT); float *val = ALLOCATE_FOR(float); *val = (float)RFLOAT(value)->value; if(!out) return val; float **val_ptr = ALLOCATE_FOR(float *); *val_ptr = val; return val_ptr; } case CORBA_tk_null: case CORBA_tk_void: { return NULL; break; } case CORBA_tk_any: { CORBA_any *encoded = ALLOCATE_FOR(CORBA_any); encoded->_type = TC_null; encoded->_value = NULL; encoded->_release = 0; if(T_FIXNUM == TYPE(value) || cLong == rb_class_of(value)) { encoded->_type = TC_CORBA_long; encoded->_value = ALLOCATE_FOR(long); if(T_FIXNUM == TYPE(value)) { *(long *)(encoded->_value) = FIX2INT(value); } else { *(long *)(encoded->_value) = (long)DATA_PTR(value); } } else if (T_STRING == TYPE(value)) { encoded->_type = TC_CORBA_string; encoded->_value = ALLOCATE_FOR(char *); *(char **)(encoded->_value) = STR(value); }
VALUE rb_obj_class(VALUE object) { return rb_class_real(rb_class_of(object)); }