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));
}
