void print_tree(VALUE tree)
{
if(NIL_P(tree)) printf("()");
else if(FALSE_P(tree)) printf("#f");
else if(TRUE_P(tree)) printf("#t");
else if(FIXNUM_P(tree)) printf("%ld", FIX2INT(tree));
else if(SYMBOL_P(tree)) printf("%s", SYMBOL_NAME(tree));
else if(CLOSURE_P(tree)) printf("#<closure>");
else if(MACRO_P(tree)) printf("#<macro>");
else if(NATIVE_PROCEDURE_P(tree)) printf("#<subr>");
else if (PAIR_P(tree))
{
printf("(");
while(1)
{
print_tree(CAR(tree));
tree = CDR(tree);
if(NIL_P(tree)) break;
if(DIRECTVAL_P(tree) || SYMBOL_P(tree) || CLOSURE_P(tree) || MACRO_P(tree) || NATIVE_PROCEDURE_P(tree))
{
printf(" . ");
print_tree(tree);
break;
}
printf(" ");
}
printf(")");
}
else
{
fprintf(stderr, "print error");
exit(1);
}
}
static VALUE
ossl_asn1_initialize(VALUE self, SEL sel, int argc, VALUE *argv)
{
VALUE value, tag, tagging, tag_class;
rb_scan_args(argc, argv, "13", &value, &tag, &tagging, &tag_class);
if(argc > 1){
if(NIL_P(tag))
ossl_raise(eASN1Error, "must specify tag number");
if(NIL_P(tagging))
tagging = ID2SYM(sEXPLICIT);
if(!SYMBOL_P(tagging))
ossl_raise(eASN1Error, "invalid tag default");
if(NIL_P(tag_class))
tag_class = ID2SYM(sCONTEXT_SPECIFIC);
if(!SYMBOL_P(tag_class))
ossl_raise(eASN1Error, "invalid tag class");
if(SYM2ID(tagging) == sIMPLICIT && NUM2INT(tag) > 31)
ossl_raise(eASN1Error, "tag number for Universal too large");
}
else{
tag = INT2NUM(ossl_asn1_default_tag(self));
tagging = Qnil;
tag_class = ID2SYM(sUNIVERSAL);
}
ossl_asn1_set_tag(self, tag);
ossl_asn1_set_value(self, value);
ossl_asn1_set_tagging(self, tagging);
ossl_asn1_set_tag_class(self, tag_class);
return self;
}
int
rb_strhash_cmp(VALUE *s1,VALUE *s2)
{
int s1_hash = SYMBOL_P(*s1) ? rb_sym_strhash(s1) : rb_str_strhash(s1);
int s2_hash = SYMBOL_P(*s2) ? rb_sym_strhash(s2) : rb_str_strhash(s2);
if (s1_hash == s2_hash) return 0;
if (s1_hash > s2_hash) return 1;
return -1;
}
static VALUE
rg_set_child_property(VALUE self, VALUE child,
VALUE prop_name, VALUE val)
{
GParamSpec* pspec;
const char* name;
if (SYMBOL_P(prop_name)) {
name = rb_id2name(SYM2ID(prop_name));
} else {
StringValue(prop_name);
name = StringValuePtr(prop_name);
}
pspec = goo_canvas_item_class_find_child_property(G_OBJECT_GET_CLASS(RVAL2GOBJ(self)), name);
if (!pspec)
rb_raise(rb_eRuntimeError, "No such child property: %s", name);
#define _SET_PROP_FOR_TYPE(gtype, ctype, val) \
case gtype: \
goo_canvas_item_set_child_properties(SELF(self), SELF(child), name, (ctype)(val), NULL); \
break;
switch (G_TYPE_FUNDAMENTAL(G_PARAM_SPEC_VALUE_TYPE(pspec))) {
_SET_PROP_FOR_TYPE(G_TYPE_CHAR, gchar, NUM2INT(val));
_SET_PROP_FOR_TYPE(G_TYPE_UCHAR, guchar, NUM2INT(val));
_SET_PROP_FOR_TYPE(G_TYPE_BOOLEAN, gboolean, RTEST(val));
_SET_PROP_FOR_TYPE(G_TYPE_INT, gint, NUM2INT(val));
_SET_PROP_FOR_TYPE(G_TYPE_UINT, guint, NUM2UINT(val));
_SET_PROP_FOR_TYPE(G_TYPE_LONG, glong, NUM2LONG(val));
_SET_PROP_FOR_TYPE(G_TYPE_ULONG, gulong, NUM2ULONG(val));
_SET_PROP_FOR_TYPE(G_TYPE_INT64, gint64, rbglib_num_to_int64(val));
_SET_PROP_FOR_TYPE(G_TYPE_UINT64, guint64, rbglib_num_to_uint64(val));
_SET_PROP_FOR_TYPE(G_TYPE_ENUM, gint, rbgobj_get_enum(val, G_PARAM_SPEC_VALUE_TYPE(pspec)));
_SET_PROP_FOR_TYPE(G_TYPE_FLAGS, guint, rbgobj_get_flags(val, G_PARAM_SPEC_VALUE_TYPE(pspec)));
_SET_PROP_FOR_TYPE(G_TYPE_FLOAT, gfloat, NUM2DBL(val));
_SET_PROP_FOR_TYPE(G_TYPE_DOUBLE, gdouble, NUM2DBL(val));
case G_TYPE_STRING:
{
if (SYMBOL_P(val))
val = rb_funcall(val, rb_intern("to_s"), 0);
goo_canvas_item_set_child_properties(SELF(self), SELF(child), name, StringValuePtr(val), NULL);
break;
}
default:
g_warning("rb_goo_canvas_item_set_child_property: unsupported type: %s\n", g_type_name(G_PARAM_SPEC_VALUE_TYPE(pspec)));
return Qnil;
}
#undef _SET_PROP_FOR_TYPE
G_CHILD_ADD(child, val);
return self;
}
/*
* call-seq:
* Struct.new( [aString] [, aSym]+> ) -> StructClass
* StructClass.new(arg, ...) -> obj
* StructClass[arg, ...] -> obj
*
* Creates a new class, named by <i>aString</i>, containing accessor
* methods for the given symbols. If the name <i>aString</i> is
* omitted, an anonymous structure class will be created. Otherwise,
* the name of this struct will appear as a constant in class
* <code>Struct</code>, so it must be unique for all
* <code>Struct</code>s in the system and should start with a capital
* letter. Assigning a structure class to a constant effectively gives
* the class the name of the constant.
*
* <code>Struct::new</code> returns a new <code>Class</code> object,
* which can then be used to create specific instances of the new
* structure. The number of actual parameters must be
* less than or equal to the number of attributes defined for this
* class; unset parameters default to <code>nil</code>. Passing too many
* parameters will raise an <code>ArgumentError</code>.
*
* The remaining methods listed in this section (class and instance)
* are defined for this generated class.
*
* # Create a structure with a name in Struct
* Struct.new("Customer", :name, :address) #=> Struct::Customer
* Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main">
*
* # Create a structure named by its constant
* Customer = Struct.new(:name, :address) #=> Customer
* Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main">
*/
static mrb_value
mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
{
mrb_value name, rest;
mrb_value *pargv;
int argcnt;
long i;
mrb_value b, st;
mrb_sym id;
mrb_value *argv;
int argc;
name = mrb_nil_value();
rest = mrb_nil_value();
mrb_get_args(mrb, "*&", &argv, &argc, &b);
if (argc == 0) { /* special case to avoid crash */
rest = mrb_ary_new(mrb);
}
else {
if (argc > 0) name = argv[0];
if (argc > 1) rest = argv[1];
if (mrb_type(rest) == MRB_TT_ARRAY) {
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
mrb_ary_unshift(mrb, rest, name);
name = mrb_nil_value();
}
}
else {
pargv = &argv[1];
argcnt = argc-1;
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
name = mrb_nil_value();
pargv = &argv[0];
argcnt++;
}
rest = mrb_ary_new_from_values(mrb, argcnt, pargv);
}
for (i=0; i<RARRAY_LEN(rest); i++) {
id = mrb_to_id(mrb, RARRAY_PTR(rest)[i]);
RARRAY_PTR(rest)[i] = mrb_symbol_value(id);
}
}
st = make_struct(mrb, name, rest, struct_class(mrb));
if (!mrb_nil_p(b)) {
mrb_funcall(mrb, b, "call", 1, &st);
}
return st;
}
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;
}
if (argc < 1 || argnum < argc) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)",
argc, 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);
}
if (SYMBOL_P(sig)) {
sig = rb_str_new2(signm);
}
}
rb_call_super(1, &sig);
rb_iv_set(self, "signo", INT2NUM(signo));
return self;
}
static VALUE
range_each(VALUE range, SEL sel)
{
VALUE beg, end;
RETURN_ENUMERATOR(range, 0, 0);
beg = RANGE_BEG(range);
end = RANGE_END(range);
if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */
long lim = FIX2LONG(end);
long i;
if (!EXCL(range))
lim += 1;
for (i = FIX2LONG(beg); i < lim; i++) {
rb_yield(LONG2FIX(i));
RETURN_IF_BROKEN();
}
}
else if (SYMBOL_P(beg) && SYMBOL_P(end)) { /* symbols are special */
VALUE args[2];
args[0] = rb_sym_to_s(end);
args[1] = EXCL(range) ? Qtrue : Qfalse;
rb_objc_block_call(rb_sym_to_s(beg), selUpto, 2, args, sym_each_i, 0);
}
else {
VALUE tmp = rb_check_string_type(beg);
if (!NIL_P(tmp)) {
VALUE args[2];
args[0] = end;
args[1] = EXCL(range) ? Qtrue : Qfalse;
rb_objc_block_call(beg, selUpto, 2, args, rb_yield, 0);
}
else {
if (!discrete_object_p(beg)) {
rb_raise(rb_eTypeError, "can't iterate from %s",
rb_obj_classname(beg));
}
range_each_func(range, each_i, NULL);
}
}
return range;
}
/*
* call-seq:
* Struct.new( [aString] [, aSym]+> ) -> StructClass
* StructClass.new(arg, ...) -> obj
* StructClass[arg, ...] -> obj
*
* Creates a new class, named by <i>aString</i>, containing accessor
* methods for the given symbols. If the name <i>aString</i> is
* omitted, an anonymous structure class will be created. Otherwise,
* the name of this struct will appear as a constant in class
* <code>Struct</code>, so it must be unique for all
* <code>Struct</code>s in the system and should start with a capital
* letter. Assigning a structure class to a constant effectively gives
* the class the name of the constant.
*
* <code>Struct::new</code> returns a new <code>Class</code> object,
* which can then be used to create specific instances of the new
* structure. The number of actual parameters must be
* less than or equal to the number of attributes defined for this
* class; unset parameters default to <code>nil</code>. Passing too many
* parameters will raise an <code>ArgumentError</code>.
*
* The remaining methods listed in this section (class and instance)
* are defined for this generated class.
*
* # Create a structure with a name in Struct
* Struct.new("Customer", :name, :address) #=> Struct::Customer
* Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main">
*
* # Create a structure named by its constant
* Customer = Struct.new(:name, :address) #=> Customer
* Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main">
*/
static mrb_value
mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
{
mrb_value name, rest;
mrb_value *pargv;
int argcnt;
long i;
mrb_value b, st;
mrb_sym id;
mrb_value *argv;
int argc;
name = mrb_nil_value();
rest = mrb_nil_value();
mrb_get_args(mrb, "&*", &b, &argv, &argc);
if (argc > 0) name = argv[0];
if (argc > 1) rest = argv[1];
//mrb_scan_args(argc, argv, "1*", &name, &rest);
if (mrb_type(rest) == MRB_TT_ARRAY) {
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
mrb_ary_unshift(mrb, rest, name);
name = mrb_nil_value();
}
for (i=0; i<RARRAY_LEN(rest); i++) {
id = mrb_to_id(mrb, RARRAY_PTR(rest)[i]);
RARRAY_PTR(rest)[i] = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id));
}
}
else {
pargv = &argv[1];
argcnt = argc-1;
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
//mrb_ary_unshift(mrb, rest, name);
name = mrb_nil_value();
pargv = &argv[0];
argcnt++;
}
rest = mrb_ary_new_from_values(mrb, pargv, argcnt);
}
st = make_struct(mrb, name, rest, struct_class(mrb));
if (!mrb_nil_p(b)) {
mrb_funcall(mrb, b, "call", 1, &st);
}
return st;
}
static VALUE
rg_style_get_property(VALUE self, VALUE prop_name)
{
GParamSpec* pspec = NULL;
const char* name;
if (SYMBOL_P(prop_name)) {
name = rb_id2name(SYM2ID(prop_name));
} else {
name = RVAL2CSTR(prop_name);
}
pspec = gtk_widget_class_find_style_property((GtkWidgetClass*)g_type_class_ref(RVAL2GTYPE(self)), name);
if (!pspec)
rb_raise(rb_eval_string("GLib::NoPropertyError"), "No such property: %s", name);
else {
// FIXME: use rb_ensure to call g_value_unset()
GValue gval = G_VALUE_INIT;
VALUE ret;
g_value_init(&gval, G_PARAM_SPEC_VALUE_TYPE(pspec));
gtk_widget_style_get_property(GTK_WIDGET(RVAL2GOBJ(self)), name, &gval);
ret = GVAL2RVAL(&gval);
g_value_unset(&gval);
return ret;
}
}
static VALUE
rg_s_style_property(VALUE self, VALUE property_name)
{
GtkWidgetClass* oclass;
const char* name;
GParamSpec* prop;
VALUE result;
if (SYMBOL_P(property_name)) {
name = rb_id2name(SYM2ID(property_name));
} else {
name = RVAL2CSTR(property_name);
}
oclass = (GtkWidgetClass*)g_type_class_ref(CLASS2GTYPE(self));
prop = gtk_widget_class_find_style_property(oclass, name);
if (!prop){
g_type_class_unref(oclass);
rb_raise(rb_eval_string("GLib::NoPropertyError"), "no such property: %s", name);
}
result = GOBJ2RVAL(prop);
g_type_class_unref(oclass);
return result;
}
static VALUE
tvc_set_attributes(VALUE self, VALUE renderer, VALUE attributes)
{
GtkTreeViewColumn *tvc;
GtkCellRenderer *grenderer;
const gchar *name;
int i, col;
VALUE ary, val;
Check_Type(attributes, T_HASH);
tvc = _SELF(self);
grenderer = RVAL2CELLRENDERER(renderer);
gtk_tree_view_column_clear_attributes(tvc, grenderer);
ary = rb_funcall(attributes, rb_intern("to_a"), 0);
for (i = 0; i < RARRAY_LEN(ary); i++) {
val = RARRAY_PTR(RARRAY_PTR(ary)[i])[0];
if (SYMBOL_P(val)) {
name = rb_id2name(SYM2ID(val));
} else {
name = RVAL2CSTR(val);
}
col = NUM2INT(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]);
gtk_tree_view_column_add_attribute(tvc, grenderer, name, col);
}
return self;
}
void *tcl_gateway( void )
{
char **argp, *(args[102]);
Tcl_CmdInfo *info;
Tcl_Interp *interp;
char temp[1000], *d;
int i, rc;
assert( arg_count_reg <= 100 );
info = (Tcl_CmdInfo *)PTR_TO_DATAPTR(LEXREF0(0));
interp = (Tcl_Interp *)OBJ_TO_RAW_PTR(LEXREF0(1));
d = temp;
argp = args;
*argp++ = (char *)string_text( LEXREF0(2) );
for (i=0; i<arg_count_reg; i++)
{
obj arg;
arg = reg_ref(i);
if (STRING_P(arg))
{
*argp++ = (char *)string_text(arg);
}
else if (OBJ_ISA_FIXNUM(arg))
{
*argp++ = d;
sprintf( d, "%d", fx2int(arg) );
d += strlen(d) + 1;
}
else if (SYMBOL_P(arg))
{
*argp++ = (char *)symbol_text(arg);
}
else
{
scheme_error( "tcl_gateway: ~s invalid", 1, arg );
}
}
*argp++ = NULL;
Tcl_ResetResult( interp );
rc = info->proc( info->clientData,
interp,
arg_count_reg + 1,
args );
if (rc)
{
REG0 = make_string( interp->result );
REG1 = int2fx( rc );
RETURN(2);
}
else
{
if (interp->result[0])
REG0 = make_string( interp->result );
else
REG0 = TRUE_OBJ;
RETURN1();
}
}
VALUE
rb_singleton_class(VALUE obj)
{
VALUE klass;
if (FIXNUM_P(obj) || SYMBOL_P(obj)) {
rb_raise(rb_eTypeError, "can't define singleton");
}
if (rb_special_const_p(obj)) {
SPECIAL_SINGLETON(Qnil, rb_cNilClass);
SPECIAL_SINGLETON(Qfalse, rb_cFalseClass);
SPECIAL_SINGLETON(Qtrue, rb_cTrueClass);
rb_bug("unknown immediate %ld", obj);
}
DEFER_INTS;
if (FL_TEST(RBASIC(obj)->klass, FL_SINGLETON) &&
rb_iv_get(RBASIC(obj)->klass, "__attached__") == obj) {
klass = RBASIC(obj)->klass;
}
else {
klass = rb_make_metaclass(obj, RBASIC(obj)->klass);
}
if (OBJ_TAINTED(obj)) {
OBJ_TAINT(klass);
}
else {
FL_UNSET(klass, FL_TAINT);
}
if (OBJ_FROZEN(obj)) OBJ_FREEZE(klass);
ALLOW_INTS;
return klass;
}
VALUE
rb_singleton_class(VALUE obj)
{
if (FIXNUM_P(obj) || SYMBOL_P(obj) || FIXFLOAT_P(obj)) {
rb_raise(rb_eTypeError, "can't define singleton");
}
if (rb_special_const_p(obj)) {
SPECIAL_SINGLETON(Qnil, rb_cNilClass);
SPECIAL_SINGLETON(Qfalse, rb_cFalseClass);
SPECIAL_SINGLETON(Qtrue, rb_cTrueClass);
rb_bug("unknown immediate %ld", obj);
}
VALUE klass;
switch (TYPE(obj)) {
case T_CLASS:
case T_MODULE:
// FIXME we should really create a new metaclass here.
klass = *(VALUE *)obj;
break;
default:
klass = rb_make_metaclass(obj, RBASIC(obj)->klass);
break;
}
return klass;
}
/*
* Document-method: offset
*
* call-seq:
* mtch.offset(n) => array
* mtch.offset => array
* mtch.offset(symbol) => array
*
* Returns a two-element array containing the beginning and ending offsets of
* the <em>n</em>th match.
*
* m = ORegexp.new( '(.)(.)(\d+)(\d)' ).match("THX1138.")
* m.offset(0) #=> [1, 7]
* m.offset(4) #=> [6, 7]
*
* If no arguments are given, the offsets of the entire
* sequence are returned.
*
* m = ORegexp.new( '(.)(.)(\d+)(\d)' ).match("THX1138.")
* m.offset #=> [1, 7]
*
* If the argument is a symbol, then the offsets of the
* corresponding named group are returned, or <code>nil</code>
* if the group does not exist.
*
* m = ORegexp.new( '(?<begin>^.*?)(?<middle>\d)(?<end>.*)' ).match("THX1138")
* m.end(:middle) #=> [3, 4]
*/
static VALUE
og_oniguruma_match_offset(int argc, VALUE *argv, VALUE self)
{
VALUE idx, first, k, nargv[2];
rb_scan_args(argc, argv, "0*", &idx);
first = rb_ary_entry(idx, 0);
if (SYMBOL_P(first)) {
k = og_oniguruma_match_to_index(self, first);
if (!NIL_P(k)) {
nargv[0] = k;
nargv[1] = (VALUE)NULL;
return rb_funcall3(self, rb_intern("offset_without_oniguruma"), 1, nargv);
} else
return Qnil;
} else if (RARRAY(idx)->len == 0) {
nargv[0] = INT2FIX(0);
nargv[1] = (VALUE)NULL;
return rb_funcall3(self, rb_intern("offset_without_oniguruma"), 1, nargv);
}
return rb_funcall3(self, rb_intern("offset_without_oniguruma"), RARRAY(idx)->len, RARRAY(idx)->ptr);
}
static VALUE
gobj_s_property(VALUE self, VALUE property_name)
{
GObjectClass* oclass;
const char* name;
GParamSpec* prop;
VALUE result;
if (SYMBOL_P(property_name))
name = rb_id2name(SYM2ID(property_name));
else
name = StringValuePtr(property_name);
oclass = g_type_class_ref(CLASS2GTYPE(self));
prop = g_object_class_find_property(oclass, name);
if (!prop){
g_type_class_unref(oclass);
rb_raise(eNoPropertyError, "No such property: %s", name);
}
result = GOBJ2RVAL(prop);
g_type_class_unref(oclass);
return result;
}
static VALUE
_params_setup(VALUE arg, struct param_setup_arg *param_setup_arg)
{
guint index;
VALUE name, val;
GParamSpec* pspec;
index = param_setup_arg->index;
if (index >= param_setup_arg->param_size)
rb_raise(rb_eArgError, "too many parameters");
name = rb_ary_entry(arg, 0);
val = rb_ary_entry(arg, 1);
if (SYMBOL_P(name))
param_setup_arg->params[index].name = rb_id2name(SYM2ID(name));
else
param_setup_arg->params[index].name = StringValuePtr(name);
pspec = g_object_class_find_property(
param_setup_arg->gclass,
param_setup_arg->params[index].name);
if (!pspec)
rb_raise(rb_eArgError, "No such property: %s",
param_setup_arg->params[index].name);
g_value_init(&(param_setup_arg->params[index].value),
G_PARAM_SPEC_VALUE_TYPE(pspec));
rbgobj_rvalue_to_gvalue(val, &(param_setup_arg->params[index].value));
param_setup_arg->index++;
return Qnil;
}
static VALUE
rbgio_gasyncinitiable_new_async_parameters_initialize(VALUE key_value,
struct rbgio_gasyncinitable_new_async_data *data)
{
VALUE key, value;
GParamSpec *spec;
if (data->index >= data->n_parameters)
rb_raise(rb_eArgError,
"too many parameters (%d >= %d)",
data->index, data->n_parameters);
key = rb_ary_entry(key_value, 0);
value = rb_ary_entry(key_value, 1);
data->parameters[data->index].name = SYMBOL_P(key) ?
rb_id2name(SYM2ID(key)) :
StringValuePtr(key);
spec = g_object_class_find_property(data->gclass,
data->parameters[data->index].name);
if (spec == NULL)
rb_raise(rb_eArgError,
"%s: no such property",
data->parameters[data->index].name);
g_value_init(&(data->parameters[data->index].value),
G_PARAM_SPEC_VALUE_TYPE(spec));
rbgobj_rvalue_to_gvalue(value, &(data->parameters[data->index].value));
data->index++;
return Qnil;
}
static VALUE
console_key_pressed_p(VALUE io, VALUE k)
{
int vk = -1;
if (FIXNUM_P(k)) {
vk = NUM2UINT(k);
}
else {
const struct vktable *t;
const char *kn;
if (SYMBOL_P(k)) {
k = rb_sym2str(k);
kn = RSTRING_PTR(k);
}
else {
kn = StringValuePtr(k);
}
t = console_win32_vk(kn, RSTRING_LEN(k));
if (!t || (vk = (short)t->vk) == -1) {
rb_raise(rb_eArgError, "unknown virtual key code: % "PRIsVALUE, k);
}
}
return GetKeyState(vk) & 0x80 ? Qtrue : Qfalse;
}
static int
ossl_pkcs7_sym2typeid(VALUE sym)
{
int i, ret = Qnil;
const char *s;
size_t l;
static const struct {
char name[20];
int nid;
} p7_type_tab[] = {
{ "signed", NID_pkcs7_signed },
{ "data", NID_pkcs7_data },
{ "signedAndEnveloped", NID_pkcs7_signedAndEnveloped },
{ "enveloped", NID_pkcs7_enveloped },
{ "encrypted", NID_pkcs7_encrypted },
{ "digest", NID_pkcs7_digest },
};
if (SYMBOL_P(sym)) sym = rb_sym2str(sym);
else StringValue(sym);
RSTRING_GETMEM(sym, s, l);
for(i = 0; ; i++){
if(i == numberof(p7_type_tab))
ossl_raise(ePKCS7Error, "unknown type \"%"PRIsVALUE"\"", sym);
if(strlen(p7_type_tab[i].name) != l) continue;
if(strcmp(p7_type_tab[i].name, s) == 0){
ret = p7_type_tab[i].nid;
break;
}
}
return ret;
}
static inline void
vm_send_optimize(rb_control_frame_t * const reg_cfp, NODE ** const mn,
rb_num_t * const flag, rb_num_t * const num,
ID * const id, const VALUE klass)
{
if (*mn && nd_type((*mn)->nd_body) == NODE_CFUNC) {
NODE *node = (*mn)->nd_body;
extern VALUE rb_f_send(int argc, VALUE *argv, VALUE recv);
if (node->nd_cfnc == rb_f_send) {
int i = *num - 1;
VALUE sym = TOPN(i);
*id = SYMBOL_P(sym) ? SYM2ID(sym) : rb_to_id(sym);
/* shift arguments */
if (i > 0) {
MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
}
*mn = rb_method_node(klass, *id);
*num -= 1;
DEC_SP(1);
*flag |= VM_CALL_FCALL_BIT;
}
}
}
const char *
rb_builtin_class_name(VALUE x)
{
const char *etype;
if (NIL_P(x)) {
etype = "nil";
}
else if (FIXNUM_P(x)) {
etype = "Fixnum";
}
else if (SYMBOL_P(x)) {
etype = "Symbol";
}
else if (RB_TYPE_P(x, T_TRUE)) {
etype = "true";
}
else if (RB_TYPE_P(x, T_FALSE)) {
etype = "false";
}
else {
etype = rb_obj_classname(x);
}
return etype;
}
int unwrapenum(const VALUE &arg, const std::string& name)
{
enumregistertype::iterator it = enumregister.find(name);
if(it != enumregister.end())
{
enumtype* etype = it->second;
if(NIL_P(arg))
return etype->defaults;
else if(SYMBOL_P(arg))
{
ID id(SYM2ID(arg));
for(enumtype::value_type::iterator it2 = etype->values.begin();
it2 != etype->values.end();
++it2)
{
if(it2->second == id)
return it2->first;
}
rb_raise(rb_eTypeError,"%s is not a %s-Enum.",rb_id2name(id),etype->name.c_str());
}else if(rb_obj_is_kind_of(arg,rb_cArray) )
{
int result = 0;
size_t count = RARRAY_LEN(arg);
for(size_t i = 0; i < count; ++i)
result = result | unwrapenum(RARRAY_AREF(arg,i),name);
}else
return NUM2INT(arg);
}
return 0;
}
/*
* call-seq:
* GMP::RandState.new()
* GMP::RandState.new(:mt) #=> uses gmp_randinit_mt
* GMP::RandState.new(:lc_2exp, a, c, m2exp) #=> uses gmp_randinit_lc_2exp
* GMP::RandState.new(:lc_2exp_size, size) #=> uses gmp_randinit_lc_2exp_size
*
* Initializes a new Random State object. Multiple GMP::RandState objects can
* be instantiated. They may use different generators and the states
* are kept separate.
*/
VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass)
{
MP_RANDSTATE *rs_val;
VALUE rs;
VALUE algorithm, arg2, arg3, arg4;
ID algorithm_id = rb_intern("default");
MP_INT *a_val;
unsigned long c_val, m2exp_val;
unsigned long size_val;
int free_a_val = 0;
ID default_algorithm = rb_intern("default");
ID mt_algorithm = rb_intern("mt");
ID lc_2exp_algorithm = rb_intern("lc_2exp");
ID lc_2exp_size_algorithm = rb_intern("lc_2exp_size");
(void)klass;
mprandstate_make_struct(rs, rs_val);
rb_scan_args(argc, argv, "04", &algorithm, &arg2, &arg3, &arg4);
if (NIL_P(algorithm)) { algorithm_id = rb_intern("default"); } /* default value */
if (SYMBOL_P(algorithm)) { algorithm_id = rb_to_id(algorithm); }
if (algorithm_id == default_algorithm ||
algorithm_id == mt_algorithm) {
if (argc > 1)
rb_raise(rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);
gmp_randinit_default(rs_val);
} else if (algorithm_id == lc_2exp_algorithm) {
if (argc != 4)
rb_raise(rb_eArgError, "wrong # of arguments (%d for 4)", argc);
if (GMPZ_P(arg2)) {
mpz_get_struct(arg2, a_val);
} else if (FIXNUM_P(arg2)) {
mpz_temp_alloc(a_val);
mpz_init_set_ui(a_val, FIX2INT(arg2));
free_a_val = 1;
} else if (BIGNUM_P(arg2)) {
mpz_temp_from_bignum(a_val, arg2);
free_a_val = 1;
} else {
typeerror_as(ZXB, "b");
}
c_val = NUM2LONG(arg3);
m2exp_val = NUM2LONG(arg4);
gmp_randinit_lc_2exp(rs_val, a_val, c_val, m2exp_val);
} else if (algorithm_id == lc_2exp_size_algorithm) {
if (argc != 2)
rb_raise(rb_eArgError, "wrong # of arguments (%d for 2)", argc);
size_val = NUM2LONG(arg2);
if (size_val > 128)
rb_raise(rb_eArgError, "size must be within [0..128]");
if (gmp_randinit_lc_2exp_size (rs_val, size_val) == 0)
rb_raise(rb_eArgError, "could not gmp_randinit_lc_2exp_size with %lu", size_val);
}
if (free_a_val) { mpz_temp_free(a_val); }
rb_obj_call_init(rs, argc, argv);
return rs;
}
static VALUE
actiongroup_add_radio_actions(int argc, VALUE *argv, VALUE self)
{
VALUE entries, value, proc;
guint i;
guint n_entries;
GtkRadioActionEntry* gentries;
rb_scan_args(argc, argv, "12", &entries, &value, &proc);
if (NIL_P(value)) value = -1;
if (NIL_P(proc) && rb_block_given_p()){
proc = rb_block_proc();
G_RELATIVE(self, proc);
}
n_entries = (guint)RARRAY_LEN(entries);
gentries = g_new0(GtkRadioActionEntry, n_entries);
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]);
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;
gentries[i].value = NUM2INT(RARRAY_PTR(entry)[5]);
}
gtk_action_group_add_radio_actions(_SELF(self), gentries,
n_entries, NUM2INT(value),
G_CALLBACK(activate_radio_action),
(gpointer)proc);
g_free(gentries);
return self;
}
static VALUE
interface_s_property(VALUE self, VALUE property_name)
{
gpointer ginterface;
const char* name;
GParamSpec* prop;
VALUE result;
GType gtype = CLASS2GTYPE(self);
if (SYMBOL_P(property_name))
name = rb_id2name(SYM2ID(property_name));
else
name = StringValuePtr(property_name);
if (!G_TYPE_IS_INTERFACE(gtype))
rb_raise(rb_eTypeError, "%s isn't interface module", rb_class2name(self));
/* XXX: g_type_default_interface_ref(G_TYPE_INTERFACE) causes SEGV. */
if (gtype == G_TYPE_INTERFACE) {
rb_raise(rb_const_get(mGLib, rb_intern("NoPropertyError")),
"No such property: %s", name);
}
ginterface = g_type_default_interface_ref(gtype);
prop = g_object_interface_find_property(ginterface, name);
if (!prop){
g_type_default_interface_unref(ginterface);
rb_raise(rb_const_get(mGLib, rb_intern("NoPropertyError")),
"No such property: %s", name);
}
result = GOBJ2RVAL(prop);
g_type_default_interface_unref(ginterface);
return result;
}
static VALUE
id2ref(VALUE obj, SEL sel, VALUE objid)
{
#if SIZEOF_LONG == SIZEOF_VOIDP
#define NUM2PTR(x) NUM2ULONG(x)
#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
#define NUM2PTR(x) NUM2ULL(x)
#endif
VALUE ptr;
void *p0;
rb_secure(4);
ptr = NUM2PTR(objid);
p0 = (void *)ptr;
if (ptr == Qtrue) return Qtrue;
if (ptr == Qfalse) return Qfalse;
if (ptr == Qnil) return Qnil;
if (FIXNUM_P(ptr) || SYMBOL_P(ptr))
return ptr;
if (auto_zone_is_valid_pointer(__auto_zone, p0)) {
auto_memory_type_t type =
auto_zone_get_layout_type(__auto_zone, p0);
if ((type == AUTO_OBJECT_SCANNED || type == AUTO_OBJECT_UNSCANNED)
&& (NATIVE((VALUE)p0)
|| (BUILTIN_TYPE(p0) < T_FIXNUM && BUILTIN_TYPE(p0) != T_ICLASS)))
return (VALUE)p0;
}
rb_raise(rb_eRangeError, "%p is not id value", p0);
}
int
rb_enc_get_index(VALUE obj)
{
int i = -1;
VALUE tmp;
if (SPECIAL_CONST_P(obj)) {
if (!SYMBOL_P(obj)) return -1;
obj = rb_sym2str(obj);
}
switch (BUILTIN_TYPE(obj)) {
case T_STRING:
case T_SYMBOL:
case T_REGEXP:
i = enc_get_index_str(obj);
break;
case T_FILE:
tmp = rb_funcallv(obj, rb_intern("internal_encoding"), 0, 0);
if (NIL_P(tmp)) {
tmp = rb_funcallv(obj, rb_intern("external_encoding"), 0, 0);
}
if (is_obj_encoding(tmp)) {
i = enc_check_encoding(tmp);
}
break;
case T_DATA:
if (is_data_encoding(obj)) {
i = enc_check_encoding(obj);
}
break;
default:
break;
}
return i;
}
static VALUE
ptrace_continue(VALUE self, ptrace_request request, VALUE data)
{
pid_t pid = get_pid(self);
long ret;
long sig = 0;
#ifdef DEBUG
fprintf(stderr, "%s: pid: %d\n", __func__, pid);
#endif
if (FIXNUM_P(data)) {
sig = FIX2LONG(data);
#ifdef DEBUG
fprintf(stderr, "%s: fixnum: %ld\n", __func__, sig);
#endif
}
else if (SYMBOL_P(data)) {
sig = signo_symbol_to_int(data);
#ifdef DEBUG
fprintf(stderr, "%s: symbol: %ld\n", __func__, sig);
#endif
}
else {
rb_raise(rb_eRuntimeError, "unknown data");
}
CALL_PTRACE(ret, request, pid, 0, (void *)sig);
return Qnil;
}
static VALUE rb_czmq_ctx_socket(VALUE obj, VALUE type)
{
VALUE socket;
int socket_type;
struct nogvl_socket_args args;
zmq_sock_wrapper *sock = NULL;
errno = 0;
ZmqGetContext(obj);
if (TYPE(type) != T_FIXNUM && TYPE(type) != T_SYMBOL) rb_raise(rb_eTypeError, "wrong socket type %s (expected Fixnum or Symbol)", RSTRING_PTR(rb_obj_as_string(type)));
socket_type = FIX2INT((SYMBOL_P(type)) ? rb_const_get_at(rb_mZmq, rb_to_id(type)) : type);
socket = Data_Make_Struct(rb_czmq_ctx_socket_klass(socket_type), zmq_sock_wrapper, rb_czmq_mark_sock, rb_czmq_free_sock_gc, sock);
args.ctx = ctx->ctx;
args.type = socket_type;
sock->socket = (void*)rb_thread_blocking_region(rb_czmq_nogvl_socket_new, (void *)&args, RUBY_UBF_IO, 0);
ZmqAssertObjOnAlloc(sock->socket, sock);
#ifndef HAVE_RB_THREAD_BLOCKING_REGION
sock->str_buffer = zlist_new();
sock->frame_buffer = zlist_new();
sock->msg_buffer = zlist_new();
#endif
sock->handler = Qnil;
sock->flags = 0;
sock->ctx = ctx->ctx;
sock->verbose = FALSE;
sock->state = ZMQ_SOCKET_PENDING;
sock->endpoint = Qnil;
sock->thread = rb_thread_current();
sock->recv_timeout = ZMQ_SOCKET_DEFAULT_TIMEOUT;
sock->send_timeout = ZMQ_SOCKET_DEFAULT_TIMEOUT;
rb_obj_call_init(socket, 0, NULL);
return socket;
}
