cudaMemcpyKind rbcu_memcopy_kind(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 5; ++index) {
if (sym_id == rb_intern(Cuda_MemcpyKind[index])) {
return static_cast<cudaMemcpyKind>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid data type symbol (:%s) specified", RSTRING_PTR(str));
}
cudaSharedMemConfig rb_cu_shared_mem_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 9; ++index) {
if (sym_id == rb_intern(RbcudaSharedMemConfig_enum[index])) {
return static_cast<cudaSharedMemConfig>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid shared memory config symbol (:%s) specified", RSTRING_PTR(str));
}
cudaDeviceAttr rb_cudaDeviceAttr_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for(std::map<char*, size_t>::value_type& entry : RbcudaDeviceAttr_enum) {
if (sym_id == rb_intern(entry.first)) {
return static_cast<cudaDeviceAttr>(entry.second);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid cuda device attribute symbol (:%s) specified", RSTRING_PTR(str));
}
CUfunction_attribute rb_cu_function_attribute_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 9; ++index) {
if (sym_id == rb_intern(RbCUfunction_attribute_enum[index])) {
return static_cast<CUfunction_attribute>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid function attribute symbol (:%s) specified", RSTRING_PTR(str));
}
CUlimit rb_cu_limit_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 6; ++index) {
if (sym_id == rb_intern(RbCUlimit_enum[index])) {
return static_cast<CUlimit>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid Limit type symbol (:%s) specified", RSTRING_PTR(str));
}
CUevent_flags rb_cu_event_flags_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 4; ++index) {
if (sym_id == rb_intern(RbCUevent_flags_enum[index])) {
return static_cast<CUevent_flags>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid events symbol (:%s) specified", RSTRING_PTR(str));
}
CUarray_format rb_cuarray_format_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for(std::map<char*, size_t>::value_type& entry : RbCUarray_format_enum) {
if (sym_id == rb_intern(entry.first)) {
return static_cast<CUarray_format>(entry.second);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid CUresult type symbol (:%s) specified", RSTRING_PTR(str));
}
CUjitInputType rb_cu_jit_type_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 6; ++index) {
if (sym_id == rb_intern(RbCUjitInputType_enum[index])) {
return static_cast<CUjitInputType>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid jit option symbol (:%s) specified", RSTRING_PTR(str));
}
CUsharedconfig rb_cu_shared_config_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 3; ++index) {
if (sym_id == rb_intern(RbCUsharedconfig_enum[index])) {
return static_cast<CUsharedconfig>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid Shared config name symbol (:%s) specified", RSTRING_PTR(str));
}
cudaOutputMode_t rb_cuda_output_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for(std::map<char*, size_t>::value_type& entry : Cuda_OutputMode) {
if (sym_id == rb_intern(entry.first)) {
return static_cast<cudaOutputMode_t>(entry.second);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid matrix type symbol (:%s) specified", RSTRING_PTR(str));
}
cudaFuncCache rb_cu_function_cache_from_rbsymbol(VALUE sym) {
ID sym_id = SYM2ID(sym);
for (size_t index = 0; index < 3; ++index) {
if (sym_id == rb_intern(RbcudaFuncCache[index])) {
return static_cast<cudaFuncCache>(index);
}
}
VALUE str = rb_any_to_s(sym);
rb_raise(rb_eArgError, "invalid function cache symbol (:%s) specified", RSTRING_PTR(str));
}
/* :nodoc: */
static VALUE
name_err_mesg_to_str(VALUE obj, SEL sel)
{
VALUE *ptr, mesg;
Data_Get_Struct(obj, VALUE, ptr);
mesg = ptr[0];
if (NIL_P(mesg)) {
return Qnil;
}
else {
const char *desc = 0;
VALUE d = 0, args[3];
obj = ptr[1];
switch (TYPE(obj)) {
case T_NIL:
desc = "nil";
break;
case T_TRUE:
desc = "true";
break;
case T_FALSE:
desc = "false";
break;
default:
d = rb_protect(safe_inspect, obj, NULL);
if (NIL_P(d) || RSTRING_LEN(d) > 65) {
d = rb_any_to_s(obj);
}
desc = RSTRING_PTR(d);
break;
}
if (desc && desc[0] != '#') {
d = d ? rb_str_dup(d) : rb_str_new2(desc);
rb_str_cat2(d, ":");
rb_str_cat2(d, rb_obj_classname(obj));
}
args[0] = mesg;
args[1] = ptr[2];
args[2] = d;
mesg = rb_f_sprintf(3, args);
}
if (OBJ_TAINTED(obj)) {
OBJ_TAINT(mesg);
}
return mesg;
}
/* :nodoc: */
static VALUE
name_err_mesg_to_str(VALUE obj)
{
VALUE *ptr, mesg;
TypedData_Get_Struct(obj, VALUE, &name_err_mesg_data_type, ptr);
mesg = ptr[0];
if (NIL_P(mesg)) return Qnil;
else {
const char *desc = 0;
VALUE d = 0, args[NAME_ERR_MESG_COUNT];
int state = 0;
obj = ptr[1];
switch (obj) {
case Qnil:
desc = "nil";
break;
case Qtrue:
desc = "true";
break;
case Qfalse:
desc = "false";
break;
default:
d = rb_protect(rb_inspect, obj, &state);
if (state)
rb_set_errinfo(Qnil);
if (NIL_P(d) || RSTRING_LEN(d) > 65) {
d = rb_any_to_s(obj);
}
desc = RSTRING_PTR(d);
break;
}
if (desc && desc[0] != '#') {
d = d ? rb_str_dup(d) : rb_str_new2(desc);
rb_str_cat2(d, ":");
rb_str_append(d, rb_class_name(CLASS_OF(obj)));
}
args[0] = mesg;
args[1] = ptr[2];
args[2] = d;
mesg = rb_f_sprintf(NAME_ERR_MESG_COUNT, args);
}
return mesg;
}
/* :nodoc: */
static VALUE
name_err_mesg_to_str(VALUE obj)
{
VALUE *ptr, mesg;
TypedData_Get_Struct(obj, VALUE, &name_err_mesg_data_type, ptr);
mesg = ptr[0];
if (NIL_P(mesg)) return Qnil;
else {
const char *desc = 0;
VALUE d = 0, args[NAME_ERR_MESG_COUNT];
obj = ptr[1];
switch (TYPE(obj)) {
case T_NIL:
desc = "nil";
break;
case T_TRUE:
desc = "true";
break;
case T_FALSE:
desc = "false";
break;
default:
d = rb_protect(rb_inspect, obj, 0);
if (NIL_P(d) || RSTRING_LEN(d) > 65) {
d = rb_any_to_s(obj);
}
desc = RSTRING_PTR(d);
break;
}
if (desc && desc[0] != '#') {
d = d ? rb_str_dup(d) : rb_str_new2(desc);
rb_str_cat2(d, ":");
rb_str_cat2(d, rb_obj_classname(obj));
}
args[0] = mesg;
args[1] = ptr[2];
args[2] = d;
mesg = rb_f_sprintf(NAME_ERR_MESG_COUNT, args);
}
OBJ_INFECT(mesg, obj);
return mesg;
}
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));
}
}
VALUE
rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
long i;
VALUE e_keys;
VALUE v_keys;
switch(TYPE(expected)) {
case T_MODULE:
case T_CLASS:
return rb_obj_is_kind_of(value, expected) ? Qtrue : Qfalse;
case T_SYMBOL:
return rb_respond_to(value, rb_to_id(expected)) ? Qtrue : Qfalse;
case T_REGEXP:
return rb_reg_match( expected, rb_funcall(value, id_to_s, 0) ) != Qnil ? Qtrue : Qfalse;
case T_HASH:
if( !RB_TYPE_P(value, T_HASH) ) {
return Qfalse;
}
e_keys = rb_funcall(expected, id_keys, 0);
v_keys = rb_funcall(value, id_keys, 0);
if( !RTEST(rb_funcall(e_keys, id_eqeq, 1, v_keys)) ) {
return Qfalse;
}
for(i = 0; i < RARRAY_LEN(e_keys); i++) {
VALUE e_k = rb_ary_entry(e_keys, i);
VALUE e_v = rb_hash_aref(expected, e_k);
if(rb_rtype_valid(self, e_v, rb_hash_aref(value, e_k)) == Qfalse) {
return Qfalse;
}
}
return Qtrue;
case T_ARRAY:
for(i = 0; i < RARRAY_LEN(expected); i++) {
VALUE e = rb_ary_entry(expected, i);
VALUE valid = rb_rtype_valid(self, e, value);
if(valid == Qtrue) {
return Qtrue;
}
}
return Qfalse;
case T_TRUE:
return RTEST(value) ? Qtrue : Qfalse;
case T_FALSE:
return !RTEST(value) ? Qtrue : Qfalse;
case T_NIL:
return value == Qnil;
default:
if(rb_obj_is_kind_of(expected, rb_cRange)) {
return rb_funcall(expected, id_include, 1, value);
}
else if(rb_obj_is_kind_of(expected, rb_cProc)) {
return RTEST(rb_funcall(expected, id_call, 1, value)) ? Qtrue : Qfalse;
}
else if( RTEST(rb_obj_is_kind_of(expected, rb_cRtypeBehaviorBase)) ) {
return rb_funcall(expected, id_valid, 1, value);
}
else {
VALUE str = rb_any_to_s(expected);
rb_raise(rb_eRtypeTypeSignatureError, "Invalid type signature: Unknown type behavior %s", StringValueCStr(str));
return Qfalse;
}
}
}
static VALUE object_spec_rb_any_to_s(VALUE self, VALUE obj) {
return rb_any_to_s(obj);
}
