static int
ossl_asn1_tag_class(VALUE obj)
{
VALUE s;
int ret = -1;
s = ossl_asn1_get_tag_class(obj);
if(NIL_P(s)) ret = V_ASN1_UNIVERSAL;
else if(SYMBOL_P(s)){
if (SYM2ID(s) == sUNIVERSAL)
ret = V_ASN1_UNIVERSAL;
else if (SYM2ID(s) == sAPPLICATION)
ret = V_ASN1_APPLICATION;
else if (SYM2ID(s) == sCONTEXT_SPECIFIC)
ret = V_ASN1_CONTEXT_SPECIFIC;
else if (SYM2ID(s) == sPRIVATE)
ret = V_ASN1_PRIVATE;
}
if(ret < 0){
ossl_raise(eASN1Error, "invalid tag class");
}
return ret;
}
static VALUE
task_method_missing(int argc, VALUE *argv, VALUE self)
{
rb_task_t *task;
VALUE result;
GetTaskPtr(self, task);
/* synchronize */
while (!ptask_finished(task->ptask)) {
ptask_wait(task->ptask);
}
result = task->result;
/* TODO: free ptask */
return rb_funcall(result, SYM2ID(argv[0]), argc-1, argv+1);
}
static VALUE
rb_struct_aref_id(VALUE s, ID id)
{
VALUE members = rb_struct_members(s);
long i, len = RARRAY_LEN(members);
for (i=0; i<len; i++) {
if (SYM2ID(RARRAY_AREF(members, i)) == id) {
return RSTRUCT_GET(s, i);
}
}
rb_name_error(id, "no member '%s' in struct", rb_id2name(id));
UNREACHABLE;
}
static mrb_value
inject_op_i(mrb_state *mrb, mrb_value i, mrb_value p, int argc, mrb_value *argv)
{
mrb_value *memo = &p;
ENUM_WANT_SVALUE(mrb);
if (memo[0].tt == MRB_TT_FREE) {
memo[0] = i;
}
else {
memo[0] = mrb_funcall(mrb, memo[0], mrb_sym2name(mrb, SYM2ID(memo[1])), 1, i);
}
return mrb_nil_value();
}
/*
* call-seq:
* each_cons(n) {...}
* each_cons(n)
*
* Iterates the given block for each array of consecutive <n>
* elements. If no block is given, returns an enumerator.a
*
* e.g.:
* (1..10).each_cons(3) {|a| p a}
* # outputs below
* [1, 2, 3]
* [2, 3, 4]
* [3, 4, 5]
* [4, 5, 6]
* [5, 6, 7]
* [6, 7, 8]
* [7, 8, 9]
* [8, 9, 10]
*
*/
static VALUE
enum_each_cons(VALUE obj, VALUE n)
{
long size = NUM2LONG(n);
VALUE args[2];
if (size <= 0) rb_raise(rb_eArgError, "invalid size");
RETURN_ENUMERATOR(obj, 1, &n);
args[0] = rb_ary_new2(size);
args[1] = (VALUE)size;
rb_block_call(obj, SYM2ID(sym_each), 0, 0, each_cons_i, (VALUE)args);
return Qnil;
}
/*
* call-seq:
* xc.medialib_entry_property_set(id, key, value, *source) -> result
*
* Write info to the medialib at _id_. _source_ is an optional argument that
* describes where to write the mediainfo. If _source_ is omitted, the
* mediainfo is written to "client/<yourclient>" where <yourclient> is the
* name you specified in _Xmms::Client.new(name)_.
*/
static VALUE
c_medialib_entry_property_set (int argc, VALUE *argv, VALUE self)
{
VALUE tmp, key, value, src = Qnil;
RbXmmsClient *xmms = NULL;
xmmsc_result_t *res;
const char *ckey;
bool is_str = false;
uint32_t id;
int32_t ivalue;
Data_Get_Struct (self, RbXmmsClient, xmms);
CHECK_DELETED (xmms);
rb_scan_args (argc, argv, "31", &tmp, &key, &value, &src);
id = check_int32 (tmp);
Check_Type (key, T_SYMBOL);
if (!NIL_P (rb_check_string_type (value)))
is_str = true;
else
ivalue = check_int32 (value);
ckey = rb_id2name (SYM2ID (key));
if (NIL_P (src) && is_str)
res = xmmsc_medialib_entry_property_set_str (xmms->real, id,
ckey,
StringValuePtr (value));
else if (NIL_P (src))
res = xmmsc_medialib_entry_property_set_int (xmms->real, id,
ckey, ivalue);
else if (is_str)
res = xmmsc_medialib_entry_property_set_str_with_source (
xmms->real, id,
StringValuePtr (src),
ckey,
StringValuePtr (value));
else
res = xmmsc_medialib_entry_property_set_int_with_source (
xmms->real, id,
StringValuePtr (src),
ckey, ivalue);
return TO_XMMS_CLIENT_RESULT (self, res);
}
static mrb_value
inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur)
{
const char *cn = mrb_class_name(mrb, mrb_obj_class(mrb, s));
mrb_value members, str = mrb_str_new(mrb, "#<struct ", 9);
mrb_value *ptr, *ptr_members;
long i, len;
if (cn) {
mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, cn));
}
if (recur) {
return mrb_str_cat2(mrb, str, ":...>");
}
members = mrb_struct_members(mrb, s);
ptr_members = RARRAY_PTR(members);
ptr = RSTRUCT_PTR(s);
len = RSTRUCT_LEN(s);
for (i=0; i<len; i++) {
mrb_value slot;
mrb_sym id;
if (i > 0) {
mrb_str_cat2(mrb, str, ", ");
}
else if (cn) {
mrb_str_cat2(mrb, str, " ");
}
slot = ptr_members[i];
id = SYM2ID(slot);
if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
const char *name;
int len;
name = mrb_sym2name_len(mrb, id, &len);
mrb_str_append(mrb, str, mrb_str_new(mrb, name, len));
}
else {
mrb_str_append(mrb, str, mrb_inspect(mrb, slot));
}
mrb_str_cat2(mrb, str, "=");
mrb_str_append(mrb, str, mrb_inspect(mrb, ptr[i]));
}
mrb_str_cat2(mrb, str, ">");
return str;
}
void fortitude_append_to(VALUE object, VALUE rb_output, int for_attribute_value) {
ID to_s;
char buf[25];
long value;
int i;
VALUE new_string, array_element;
#ifdef CONST_ID
CONST_ID(to_s, "to_s");
#else
to_s = rb_intern("to_s");
#endif
switch (TYPE(object)) {
case T_STRING:
fortitude_escaped_strcpy(rb_output, RSTRING_PTR(object), for_attribute_value);
break;
case T_SYMBOL:
fortitude_escaped_strcpy(rb_output, rb_id2name(SYM2ID(object)), for_attribute_value);
break;
case T_ARRAY:
value = RARRAY_LEN(object);
for (i = 0; i < value; ++i) {
array_element = rb_ary_entry(object, i);
if (i > 0) {
rb_str_cat2(rb_output, " ");
}
fortitude_append_to(array_element, rb_output, for_attribute_value);
}
case T_NONE:
case T_NIL:
break;
case T_FIXNUM:
value = NUM2LONG(object);
sprintf(buf, "%ld", value);
rb_str_cat2(rb_output, buf);
break;
default:
new_string = rb_funcall(object, to_s, 0);
fortitude_escaped_strcpy(rb_output, RSTRING_PTR(new_string), for_attribute_value);
break;
}
}
// A :method_missing method for finding KObject properties in Ruby
static VALUE RubyKObjectMethodMissing(int argc, VALUE *argv, VALUE self)
{
SharedValue* dval = NULL;
Data_Get_Struct(self, SharedValue, dval);
SharedKObject object = (*dval)->ToObject();
// TODO: We should raise an exception instead
if (object.isNull())
return Qnil;
// This is the same error that ruby throws
if (argc == 0 || !SYMBOL_P(argv[0]))
{
rb_raise(rb_eArgError, "no id given");
}
// We need to determine the method that was invoked:
// store the method name and arguments in separate variables
VALUE r_name, args;
rb_scan_args(argc, argv, "1*", &r_name, &args);
const char* name = rb_id2name(SYM2ID(r_name));
// Check if this is an assignment
SharedValue value = object->Get(name);
if (name[strlen(name) - 1] == '=' && argc > 1)
{
char* mod_name = strdup(name);
mod_name[strlen(mod_name) - 1] = '\0';
value = RubyUtils::ToKrollValue(argv[1]);
object->Set(mod_name, value);
free(mod_name);
return argv[1];
}
else if (value->IsUndefined()) // raise a method missing error
{
VALUE selfString = rb_obj_as_string(self);
rb_raise(rb_eNoMethodError, "undefined method `%s' for %s",
name, RubyUtils::ToString(selfString));
}
else if (value->IsMethod()) // actually call a method
{
return RubyUtils::GenericKMethodCall(value->ToMethod(), args);
}
else // Plain old access
{
return RubyUtils::ToRubyValue(value);
}
}
static git_branch_t parse_branch_type(VALUE rb_filter)
{
ID id_filter;
Check_Type(rb_filter, T_SYMBOL);
id_filter = SYM2ID(rb_filter);
if (id_filter == rb_intern("local")) {
return GIT_BRANCH_LOCAL;
} else if (id_filter == rb_intern("remote")) {
return GIT_BRANCH_REMOTE;
} else {
rb_raise(rb_eTypeError,
"Invalid branch filter. Expected `:remote`, `:local` or `nil`");
}
}
yajl_gen_status
yajl_gen_value(yajl_gen gen, VALUE obj)
{
if (FIXNUM_P(obj))
return yajl_gen_integer(gen, NUM2LONG(obj));
else if (NIL_P(obj) || obj == Qundef)
return yajl_gen_null(gen);
else if (obj == Qtrue)
return yajl_gen_bool(gen, 1);
else if (obj == Qfalse)
return yajl_gen_bool(gen, 0);
else if (SYMBOL_P(obj))
return yajl_gen_format(gen, ":%s", rb_id2name(SYM2ID(obj)));
else
return yajl_gen_format(gen, "0x%x", obj);
}
// Convert symbol to interpolation method
int symbol_to_interpolation_filter(VALUE symbol) {
char const * name = rb_id2name(SYM2ID(symbol));
if (strcmp(name, "fast_bilinear") == 0) return SWS_FAST_BILINEAR;
if (strcmp(name, "bilinear") == 0) return SWS_BILINEAR;
if (strcmp(name, "bicubic") == 0) return SWS_BICUBIC;
if (strcmp(name, "x") == 0) return SWS_X;
if (strcmp(name, "point") == 0) return SWS_POINT;
if (strcmp(name, "area") == 0) return SWS_AREA;
if (strcmp(name, "bicublin") == 0) return SWS_BICUBLIN;
if (strcmp(name, "gauss") == 0) return SWS_GAUSS;
if (strcmp(name, "sinc") == 0) return SWS_SINC;
if (strcmp(name, "lanczos") == 0) return SWS_LANCZOS;
if (strcmp(name, "spline") == 0) return SWS_SPLINE;
return 0;
}
static DWORD
extract_flags_from_rb_array(VALUE flags_array)
{
VALUE flag_symbol;
DWORD flags;
flags = 0;
while ( RARRAY_LEN(flags_array) != 0 ) {
flag_symbol = rb_ary_pop(flags_array);
Check_Type(flag_symbol, T_SYMBOL);
flags |= id_to_flag( SYM2ID(flag_symbol) );
}
return flags;
}
/*
* call-seq:
* e.with_index {|(*args), idx| ... }
*
* Iterates the given block for each elements with an index, which
* start from 0.
*
*/
static VALUE
enumerator_with_index(VALUE obj)
{
struct enumerator *e = enumerator_ptr(obj);
VALUE memo = 0;
int argc = 0;
VALUE *argv = 0;
RETURN_ENUMERATOR(obj, 0, 0);
if (e->args) {
argc = RARRAY_LEN(e->args);
argv = RARRAY_PTR(e->args);
}
return rb_block_call(e->method, SYM2ID(sym_call), argc, argv,
enumerator_with_index_i, (VALUE)&memo);
}
static VALUE
rb_struct_s_members_m(VALUE klass)
{
VALUE members, ary;
VALUE *p, *pend;
members = rb_struct_s_members(klass);
ary = rb_ary_new2(RARRAY(members)->len);
p = RARRAY(members)->ptr; pend = p + RARRAY(members)->len;
while (p < pend) {
rb_ary_push(ary, rb_str_new2(rb_id2name(SYM2ID(*p))));
p++;
}
return ary;
}
static VALUE
rb_struct_aref_id(VALUE s, ID id)
{
VALUE members;
long i, len;
members = rb_struct_members(s);
len = RARRAY_LEN(members);
for (i=0; i<len; i++) {
if (SYM2ID(RARRAY_PTR(members)[i]) == id) {
return RSTRUCT_PTR(s)[i];
}
}
rb_name_error(id, "no member '%s' in struct", rb_id2name(id));
return Qnil; /* not reached */
}
static VALUE
make_struct(VALUE name, VALUE members, VALUE klass)
{
VALUE nstr, *ptr_members;
ID id;
long i, len;
OBJ_FREEZE(members);
if (NIL_P(name)) {
nstr = rb_class_new(klass);
rb_make_metaclass(nstr, RBASIC(klass)->klass);
rb_class_inherited(klass, nstr);
}
else {
/* old style: should we warn? */
name = rb_str_to_str(name);
id = rb_to_id(name);
if (!rb_is_const_id(id)) {
rb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name));
}
if (rb_const_defined_at(klass, id)) {
rb_warn("redefining constant Struct::%s", StringValuePtr(name));
rb_mod_remove_const(klass, ID2SYM(id));
}
nstr = rb_define_class_id_under(klass, id, klass);
}
rb_ivar_set(nstr, id_members, members);
rb_define_alloc_func(nstr, struct_alloc);
rb_define_singleton_method(nstr, "new", rb_class_new_instance, -1);
rb_define_singleton_method(nstr, "[]", rb_class_new_instance, -1);
rb_define_singleton_method(nstr, "members", rb_struct_s_members_m, 0);
ptr_members = RARRAY_PTR(members);
len = RARRAY_LEN(members);
for (i=0; i< len; i++) {
ID id = SYM2ID(ptr_members[i]);
if (i < N_REF_FUNC) {
rb_define_method_id(nstr, id, ref_func[i], 0);
}
else {
rb_define_method_id(nstr, id, rb_struct_ref, 0);
}
rb_define_method_id(nstr, rb_id_attrset(id), rb_struct_set, 1);
}
return nstr;
}
static VALUE m_missing(int argc, VALUE* argv, VALUE self)
{
bool assignment = false;
if (global_object.isNull())
return Qnil;
// store the method name and arguments in separate variables
VALUE method_name, args;
rb_scan_args(argc, argv, "1*", &method_name, &args);
char* name = strdup(rb_id2name(SYM2ID(method_name)));
// Check if this is an assignment
if (name[strlen(name) - 1] == '=')
{
name[strlen(name) - 1] = '\0';
assignment = true;
}
// If we can't find this property perhaps we should return
// the same property name except capitalized.
KValueRef v = global_object->Get(name);
if (v->IsUndefined())
{
name[0] = toupper(name[0]);
v = global_object->Get(name);
}
// Okay, maybe not
if (v->IsUndefined())
name[0] = tolower(name[0]);
VALUE rval;
if (assignment) // Assignment
{
rval = rb_ary_entry(args, 0);
KValueRef val = RubyUtils::ToKrollValue(rval);
global_object->Set(name, val);
}
else if (v->IsMethod()) // Method call
{
rval = RubyUtils::GenericKMethodCall(v->ToMethod(), args);
}
else // Plain old access
{
rval = RubyUtils::ToRubyValue(v);
}
return rval;
}
static VALUE
make_struct(VALUE name, VALUE members, VALUE klass)
{
VALUE nstr;
ID id;
long i;
OBJ_FREEZE(members);
if (NIL_P(name)) {
nstr = rb_class_new(klass);
rb_make_metaclass(nstr, RBASIC(klass)->klass);
rb_class_inherited(klass, nstr);
}
else {
char *cname = StringValuePtr(name);
id = rb_intern(cname);
if (!rb_is_const_id(id)) {
rb_name_error(id, "identifier %s needs to be constant", cname);
}
if (rb_const_defined_at(klass, id)) {
rb_warn("redefining constant Struct::%s", cname);
rb_mod_remove_const(klass, ID2SYM(id));
}
nstr = rb_define_class_under(klass, rb_id2name(id), klass);
}
rb_iv_set(nstr, "__size__", LONG2NUM(RARRAY(members)->len));
rb_iv_set(nstr, "__members__", members);
rb_define_alloc_func(nstr, struct_alloc);
rb_define_singleton_method(nstr, "new", rb_class_new_instance, -1);
rb_define_singleton_method(nstr, "[]", rb_class_new_instance, -1);
rb_define_singleton_method(nstr, "members", rb_struct_s_members_m, 0);
for (i=0; i< RARRAY(members)->len; i++) {
ID id = SYM2ID(RARRAY(members)->ptr[i]);
if (rb_is_local_id(id) || rb_is_const_id(id)) {
if (i<10) {
rb_define_method_id(nstr, id, ref_func[i], 0);
}
else {
rb_define_method_id(nstr, id, rb_struct_ref, 0);
}
rb_define_method_id(nstr, rb_id_attrset(id), rb_struct_set, 1);
}
}
return nstr;
}
static VALUE
taction_initialize(VALUE self, VALUE name, VALUE label, VALUE tooltip, VALUE stock_id)
{
const gchar *gstockid = NULL;
if (TYPE(stock_id) == T_SYMBOL){
gstockid = rb_id2name(SYM2ID(stock_id));
} else if (TYPE(stock_id) == T_STRING){
gstockid = RVAL2CSTR(stock_id);
}
G_INITIALIZE(self, gtk_toggle_action_new(RVAL2CSTR(name),
RVAL2CSTR(label),
NIL_P(tooltip) ? NULL : RVAL2CSTR(tooltip),
gstockid));
return Qnil;
}
static VALUE
buffer_update_cache(VALUE self)
{
GET_BUFFER();
if (buffer_dirty(self) == Qtrue) {
size_t old_num_items = buffer->num_items;
buffer->num_items = RARRAY_LEN(self);
buffer->type = SYM2ID(rb_funcall(self, id_data_type, 0));
buffer->member_size = FIX2INT(rb_hash_aref(rb_hTypes, ID2SYM(buffer->type)));
if (buffer->num_items != old_num_items) buffer_size_changed(buffer);
buffer->dirty = Qfalse;
return Qtrue;
}
return Qnil;
}
static VALUE
rg_initialize(VALUE self, VALUE name, VALUE label, VALUE tooltip, VALUE stock_id, VALUE value)
{
const gchar *gstock = NULL;
if (TYPE(stock_id) == T_STRING){
gstock = RVAL2CSTR(stock_id);
} else if (TYPE(stock_id) == T_SYMBOL) {
gstock = rb_id2name(SYM2ID(stock_id));
}
G_INITIALIZE(self, gtk_radio_action_new(RVAL2CSTR(name),
RVAL2CSTR(label),
NIL_P(tooltip) ? NULL : RVAL2CSTR(tooltip),
gstock,
NUM2INT(value)));
return Qnil;
}
SharedStringList KRubyHash::GetPropertyNames()
{
SharedStringList property_names = object->GetPropertyNames();
SharedStringList names(this->object->GetPropertyNames());
VALUE keys = rb_funcall(hash, rb_intern("keys"), 0);
for (int i = 0; i < RARRAY_LEN(keys); i++)
{
VALUE key = rb_ary_entry(keys, i);
if (TYPE(key) == T_SYMBOL)
names->push_back(new std::string(rb_id2name(SYM2ID(key))));
else if (TYPE(key) == T_STRING)
names->push_back(new std::string(StringValuePtr(key)));
}
return names;
}
static VALUE
cr_toy_font_face_initialize (int argc, VALUE *argv, VALUE self)
{
cairo_font_face_t *face;
VALUE rb_family, rb_slant, rb_weight;
const char *family;
cairo_font_slant_t slant;
cairo_font_weight_t weight;
rb_scan_args (argc, argv, "03", &rb_family, &rb_slant, &rb_weight);
if (NIL_P (rb_family))
{
family = "";
}
else if (rb_cairo__is_kind_of (rb_family, rb_cString))
{
family = RSTRING_PTR (rb_family);
}
else if (rb_cairo__is_kind_of (rb_family, rb_cSymbol))
{
family = rb_id2name (SYM2ID (rb_family));
}
else
{
rb_raise (rb_eArgError,
"family name should be nil, String or Symbol: %s",
rb_cairo__inspect (rb_family));
}
if (NIL_P (rb_slant))
slant = CAIRO_FONT_SLANT_NORMAL;
else
slant = RVAL2CRFONTSLANT (rb_slant);
if (NIL_P (rb_weight))
weight = CAIRO_FONT_WEIGHT_NORMAL;
else
weight = RVAL2CRFONTWEIGHT (rb_weight);
face = cairo_toy_font_face_create (family, slant, weight);
cr_font_face_check_status (face);
DATA_PTR (self) = face;
return Qnil;
}
static VALUE
esignal_init(int argc, VALUE *argv, VALUE self)
{
int argnum = 1;
VALUE sig = Qnil;
int signo;
const char *signm;
if (argc > 0) {
sig = rb_check_to_integer(argv[0], "to_int");
if (!NIL_P(sig)) argnum = 2;
else sig = argv[0];
}
rb_check_arity(argc, 1, argnum);
if (argnum == 2) {
signo = NUM2INT(sig);
if (signo < 0 || signo > NSIG) {
rb_raise(rb_eArgError, "invalid signal number (%d)", signo);
}
if (argc > 1) {
sig = argv[1];
}
else {
signm = signo2signm(signo);
if (signm) {
sig = rb_sprintf("SIG%s", signm);
}
else {
sig = rb_sprintf("SIG%u", signo);
}
}
}
else {
signm = SYMBOL_P(sig) ? rb_id2name(SYM2ID(sig)) : StringValuePtr(sig);
if (strncmp(signm, "SIG", 3) == 0) signm += 3;
signo = signm2signo(signm);
if (!signo) {
rb_raise(rb_eArgError, "unsupported name `SIG%s'", signm);
}
sig = rb_sprintf("SIG%s", signm);
}
rb_call_super(1, &sig);
rb_iv_set(self, "signo", INT2NUM(signo));
return self;
}
static VALUE
inspect_struct(VALUE s, VALUE dummy, int recur)
{
VALUE cname = rb_class_name(rb_obj_class(s));
VALUE members, str = rb_str_new2("#<struct ");
VALUE *ptr, *ptr_members;
long i, len;
char first = RSTRING_PTR(cname)[0];
if (recur || first != '#') {
rb_str_append(str, cname);
}
if (recur) {
return rb_str_cat2(str, ":...>");
}
members = rb_struct_members(s);
ptr_members = RARRAY_PTR(members);
ptr = RSTRUCT_PTR(s);
len = RSTRUCT_LEN(s);
for (i=0; i<len; i++) {
VALUE slot;
ID id;
if (i > 0) {
rb_str_cat2(str, ", ");
}
else if (first != '#') {
rb_str_cat2(str, " ");
}
slot = ptr_members[i];
id = SYM2ID(slot);
if (rb_is_local_id(id) || rb_is_const_id(id)) {
rb_str_append(str, rb_id2str(id));
}
else {
rb_str_append(str, rb_inspect(slot));
}
rb_str_cat2(str, "=");
rb_str_append(str, rb_inspect(ptr[i]));
}
rb_str_cat2(str, ">");
OBJ_INFECT(str, s);
return str;
}
static VALUE
gobj_set_property(VALUE self, VALUE prop_name, VALUE val)
{
GParamSpec* pspec;
const char* name;
if (SYMBOL_P(prop_name))
name = rb_id2name(SYM2ID(prop_name));
else
name = StringValuePtr(prop_name);
pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(RVAL2GOBJ(self)),
name);
if (!pspec)
rb_raise(eNoPropertyError, "No such property: %s", name);
else {
// FIXME: use rb_ensure to call g_value_unset()
RValueToGValueFunc setter = NULL;
GValue gval = {0,};
g_value_init(&gval, G_PARAM_SPEC_VALUE_TYPE(pspec));
{
VALUE table = rb_hash_aref(type_to_prop_setter_table,
INT2FIX(pspec->owner_type));
if (!NIL_P(table)){
VALUE obj = rb_hash_aref(table, rb_intern(g_param_spec_get_name(pspec)));
if (!NIL_P(obj))
Data_Get_Struct(obj, void, setter);
}
}
if (setter) {
setter(val, &gval);
} else {
rbgobj_rvalue_to_gvalue(val, &gval);
}
g_object_set_property(RVAL2GOBJ(self), name, &gval);
g_value_unset(&gval);
G_CHILD_SET(self, rb_intern(name), val);
return self;
}
}
mrb_sym
mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer)
{
mrb_value name;
name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern(mrb, "__classid__"));
if (mrb_nil_p(name)) {
struct csym_arg arg;
arg.c = c;
arg.sym = 0;
iv_foreach(mrb, outer->iv, csym_i, &arg);
return arg.sym;
}
return SYM2ID(name);
}
static VALUE
c_dict_has_key (VALUE self, VALUE key)
{
RbDict *dict = NULL;
xmmsv_dict_iter_t *it;
const char *ckey;
Check_Type (key, T_SYMBOL);
Data_Get_Struct (self, RbDict, dict);
ckey = rb_id2name (SYM2ID (key));
xmmsv_get_dict_iter (dict->real, &it);
return xmmsv_dict_iter_find (it, ckey) ? Qtrue : Qfalse;
}
int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
MessageHeader* self;
VALUE method_str;
char* name;
const upb_fielddef* f;
TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
if (!SYMBOL_P(key)) {
rb_raise(rb_eArgError,
"Expected symbols as hash keys in initialization map.");
}
method_str = rb_id2str(SYM2ID(key));
name = RSTRING_PTR(method_str);
f = upb_msgdef_ntofz(self->descriptor->msgdef, name);
if (f == NULL) {
rb_raise(rb_eArgError,
"Unknown field name '%s' in initialization map entry.", name);
}
if (is_map_field(f)) {
VALUE map;
if (TYPE(val) != T_HASH) {
rb_raise(rb_eArgError,
"Expected Hash object as initializer value for map field '%s'.", name);
}
map = layout_get(self->descriptor->layout, Message_data(self), f);
Map_merge_into_self(map, val);
} else if (upb_fielddef_label(f) == UPB_LABEL_REPEATED) {
VALUE ary;
if (TYPE(val) != T_ARRAY) {
rb_raise(rb_eArgError,
"Expected array as initializer value for repeated field '%s'.", name);
}
ary = layout_get(self->descriptor->layout, Message_data(self), f);
for (int i = 0; i < RARRAY_LEN(val); i++) {
RepeatedField_push(ary, rb_ary_entry(val, i));
}
} else {
layout_set(self->descriptor->layout, Message_data(self), f, val);
}
return 0;
}
