AccessClass::AccessClass(RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos) { setClassName(className.to<QByteArray>()); protect([&] { rb_check_array_type(methodInfos); rb_check_array_type(signalInfos); rb_check_array_type(propertyInfos); }); for (int i = 0; i < RARRAY_LEN(VALUE(methodInfos)); ++i) { RubyValue info = RARRAY_AREF(VALUE(methodInfos), i); auto nameSym = info.send("name"); addMethod(nameSym.to<QByteArray>(), nameSym.toID(), info.send("params").to<QList<QByteArray>>()); } for (int i = 0; i < RARRAY_LEN(VALUE(signalInfos)); ++i) { RubyValue info = RARRAY_AREF(VALUE(signalInfos), i); auto nameSym = info.send("name"); addSignal(nameSym.to<QByteArray>(), nameSym.toID(), info.send("params").to<QList<QByteArray>>()); } for (int i = 0; i < RARRAY_LEN(VALUE(propertyInfos)); ++i) { RubyValue info = RARRAY_AREF(VALUE(propertyInfos), i); addProperty(info.send("name").to<QByteArray>(), info.send("getter").toID(), info.send("setter").toID(), Property::Flag::Readable | Property::Flag::Writable, true, info.send("notifier").toID()); } }
static VALUE rhash_create(VALUE klass, SEL sel, int argc, VALUE *argv) { if (argc == 1) { VALUE tmp = rhash_try_convert(Qnil, 0, argv[0]); if (!NIL_P(tmp)) { VALUE hash = rhash_alloc(klass, 0); if (IS_RHASH(tmp)) { GC_WB(&RHASH(hash)->tbl, st_copy(RHASH(tmp)->tbl)); } else { VALUE keys = rb_hash_keys(tmp); for (long i = 0, count = RARRAY_LEN(keys); i < count; i++) { VALUE key = RARRAY_AT(keys, i); VALUE val = rb_hash_lookup(tmp, key); rhash_aset(hash, 0, key, val); } } return hash; } tmp = rb_check_array_type(argv[0]); if (!NIL_P(tmp)) { VALUE hash = rhash_alloc(klass, 0); for (int i = 0; i < RARRAY_LEN(tmp); ++i) { VALUE v = rb_check_array_type(RARRAY_AT(tmp, i)); if (NIL_P(v)) { continue; } const long len = RARRAY_LEN(v); if (len < 1 || 2 < len) { continue; } rhash_aset(hash, 0, RARRAY_AT(v, 0), RARRAY_AT(v, 1)); } return hash; } } if (argc % 2 != 0) { rb_raise(rb_eArgError, "odd number of arguments for Hash"); } VALUE hash = rhash_alloc(klass, 0); for (int i = 0; i < argc; i += 2) { rb_hash_aset(hash, argv[i], argv[i + 1]); } return hash; }
/** Takes a Ruby array of Ruby Symbols and computes the C * alpm_siglevel_t from it. Raises an exception if `ary' * doesn’t respond to #to_ary. */ alpm_siglevel_t siglevel_from_ruby(VALUE ary) { alpm_siglevel_t level = 0; if (!(RTEST(ary = rb_check_array_type(ary)))) { /* Single = intended */ VALUE str = rb_inspect(level); rb_raise(rb_eTypeError, "Not an array (#to_ary): %s", StringValuePtr(str)); return Qnil; } if (rb_ary_includes(ary, STR2SYM("package"))) level |= ALPM_SIG_PACKAGE; if (rb_ary_includes(ary, STR2SYM("package_optional"))) level |= ALPM_SIG_PACKAGE_OPTIONAL; if (rb_ary_includes(ary, STR2SYM("package_marginal_ok"))) level |= ALPM_SIG_PACKAGE_MARGINAL_OK; if (rb_ary_includes(ary, STR2SYM("package_unknown_ok"))) level |= ALPM_SIG_PACKAGE_UNKNOWN_OK; if (rb_ary_includes(ary, STR2SYM("database"))) level |= ALPM_SIG_DATABASE; if (rb_ary_includes(ary, STR2SYM("database_optional"))) level |= ALPM_SIG_DATABASE_OPTIONAL; if (rb_ary_includes(ary, STR2SYM("database_marginal_ok"))) level |= ALPM_SIG_DATABASE_MARGINAL_OK; if (rb_ary_includes(ary, STR2SYM("database_unknown_ok"))) level |= ALPM_SIG_DATABASE_UNKNOWN_OK; if (rb_ary_includes(ary, STR2SYM("package_set"))) level |= ALPM_SIG_PACKAGE_SET; if (rb_ary_includes(ary, STR2SYM("package_trust_set"))) level |= ALPM_SIG_PACKAGE_TRUST_SET; if (rb_ary_includes(ary, STR2SYM("use_default"))) level |= ALPM_SIG_USE_DEFAULT; return level; }
static VALUE lazy_zip(int argc, VALUE *argv, VALUE obj) { VALUE ary, v; long i; rb_block_call_func *func = lazy_zip_arrays_func; if (rb_block_given_p()) { return rb_call_super(argc, argv); } ary = rb_ary_new2(argc); for (i = 0; i < argc; i++) { v = rb_check_array_type(argv[i]); if (NIL_P(v)) { for (; i < argc; i++) { if (!rb_respond_to(argv[i], id_each)) { rb_raise(rb_eTypeError, "wrong argument type %s (must respond to :each)", rb_obj_classname(argv[i])); } } ary = rb_ary_new4(argc, argv); func = lazy_zip_func; break; } rb_ary_push(ary, v); } return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj, func, ary), ary, lazy_receiver_size); }
/** call-seq: time = time Set the timestamp as removal condition. Parameters: [time] an integer, for specifying ticks, or a tuple of splat of seconds and nanoseconds Normally used with the flags +SND_SEQ_REMOVE_TIME_AFTER+ or +SND_SEQ_REMOVE_TIME_BEFORE+. See RRTS::Driver::AlsaRemoveClass_i#condition=. */ static VALUE wrap_snd_seq_remove_events_set_time(int argc, VALUE *argv, VALUE v_rmp) { snd_seq_remove_events_t *rmp; Data_Get_Struct(v_rmp, snd_seq_remove_events_t, rmp); VALUE v_sec, v_nsec; rb_scan_args(argc, argv, "11", &v_sec, &v_nsec); snd_seq_timestamp_t time; if (NIL_P(v_nsec)) { if (FIXNUM_P(v_sec)) time.tick = NUM2UINT(v_sec); else { v_sec = rb_check_array_type(v_sec); if (!RTEST(v_sec)) RAISE_MIDI_ERROR_FMT0("API call error: bad time format"); time.time.tv_sec = NUM2UINT(rb_ary_entry(v_sec, 0)); time.time.tv_nsec = NUM2UINT(rb_ary_entry(v_sec, 1)); } } else { time.time.tv_sec = NUM2UINT(v_sec); time.time.tv_nsec = NUM2UINT(v_nsec); } snd_seq_remove_events_set_time(rmp, &time); return Qnil; }
VALUE RObj_to_ruby(VALUE self, VALUE args){ int conv; VALUE obj; SEXP robj; args = rb_check_array_type(args); if (RARRAY_LEN(args) > 1){ rb_raise(rb_eArgError,"Too many arguments in to_ruby\n"); } if (RARRAY_LEN(args) == 0){ conv = NUM2INT(rb_iv_get(RSRUBY,"@default_mode")); } else { conv = NUM2INT(rb_ary_entry(args,0)); } if (conv <= -2 || conv > TOP_MODE) { rb_raise(rb_eArgError, "Wrong mode\n"); return Qnil; } if (conv < 0) conv = TOP_MODE; Data_Get_Struct(self, struct SEXPREC, robj); obj = to_ruby_with_mode(robj, conv); return obj; }
VALUE rb_yield_splat(VALUE values) { VALUE tmp = rb_check_array_type(values); if (NIL_P(tmp)) { rb_raise(rb_eArgError, "not an array"); } return rb_vm_yield(RARRAY_LENINT(tmp), RARRAY_PTR(tmp)); }
VALUE rb_yield_splat(VALUE values) { VALUE tmp = rb_check_array_type(values); volatile VALUE v; if (NIL_P(tmp)) { rb_raise(rb_eArgError, "not an array"); } v = rb_yield_0(RARRAY_LEN(tmp), RARRAY_PTR(tmp)); return v; }
/* Convert a sequence of (name, value) pairs to arguments to an R function call */ int make_argl(VALUE args, SEXP *e) { SEXP rvalue; int i; VALUE pair, name, value; //Ensure we have an array args = rb_check_array_type(args); for (i=0; i<RARRAY_LEN(args); i++) { pair = rb_ary_entry(args, i); pair = rb_check_array_type(pair); if(RARRAY_LEN(pair) != 2) rb_raise(rb_eArgError,"Misformed argument in lcall\n"); /* Name must be a string. If it is empty string '' then no name*/ name = rb_ary_entry(pair, 0); name = StringValue(name); name = rb_funcall(rb_const_get(rb_cObject, rb_intern("RSRuby")), rb_intern("convert_method_name"),1,name); /* Value can be anything. */ value = rb_ary_entry(pair, 1); rvalue = ruby_to_R(value); /* Add parameter value to call */ SETCAR(*e, rvalue); /* Add name (if present) */ if (RSTRING_LEN(name) > 0) { SET_TAG(*e, Rf_install(RSTRING_PTR(name))); } /* Move index to new end of call */ *e = CDR(*e); } return 1; }
void _mp4v2_write_chapters(MP4V2Handles *handle) { VALUE self = handle->self; MP4FileHandle mp4v2 = handle->file; VALUE chapters = rb_check_array_type(GET(chapters)), chapter, title; double last_stamp = 0, stamp; MP4Chapter_t *chaps; uint32_t count = 0; switch(TYPE(chapters)) { case T_ARRAY: RARRAY_ALL_INSTANCE(chapters, rb_cChapter, chapter); // Make chapters go in order of timestamp rb_ary_sort_bang(chapters); count = RARRAY_LEN(chapters); chaps = handle->chapters = (MP4Chapter_t *)malloc(sizeof(MP4Chapter_t) * count); if (!chaps) { rb_raise(rb_eNoMemError, "unable to save all changes to file"); } for (uint32_t i = 0; i < count; i++) { // Calculate the duration of chapter from previous timestamp and current chapter = rb_ary_entry(chapters, i); stamp = NUM2DBL(rb_funcall(rb_ivar_get(chapter, rb_intern("@timestamp")), rb_intern("milliseconds"), 0)); chaps[i].duration = stamp - last_stamp; last_stamp = stamp; // Get the title of the chapter title = rb_encode_utf8(rb_ivar_get(chapter, rb_intern("@title"))); if (RSTRING_LEN(title) > MP4V2_CHAPTER_TITLE_MAX) { rb_raise(rb_eStandardError, "chapter title '%s' is too long, it should be at most %d bytes", RSTRING_PTR(title), MP4V2_CHAPTER_TITLE_MAX); } memcpy(chaps[i].title, RSTRING_PTR(title), RSTRING_LEN(title)+1); } if (count > 0) { MP4SetChapters(mp4v2, chaps, count, MP4ChapterTypeAny); } else { MP4DeleteChapters(mp4v2, MP4ChapterTypeAny); } free(chaps); handle->chapters = NULL; break; case T_NIL: MP4DeleteChapters(mp4v2, MP4ChapterTypeAny); break; default:; } }
/* * Returns the #dirname and the #basename in an Array. * * See File.split. */ static VALUE path_split(VALUE self) { VALUE str = get_strpath(self); VALUE ary, dirname, basename; ary = rb_funcall(rb_cFile, rb_intern("split"), 1, str); ary = rb_check_array_type(ary); dirname = rb_ary_entry(ary, 0); basename = rb_ary_entry(ary, 1); dirname = rb_class_new_instance(1, &dirname, rb_obj_class(self)); basename = rb_class_new_instance(1, &basename, rb_obj_class(self)); return rb_ary_new3(2, dirname, basename); }
static inline int args_check_block_arg0(struct args_info *args, rb_thread_t *th) { VALUE ary = Qnil; if (args->rest && RARRAY_LEN(args->rest) == 1) { VALUE arg0 = RARRAY_AREF(args->rest, 0); ary = rb_check_array_type(arg0); } else if (args->argc == 1) { VALUE arg0 = args->argv[0]; ary = rb_check_array_type(arg0); args->argv[0] = arg0; /* see: https://bugs.ruby-lang.org/issues/8484 */ } if (!NIL_P(ary)) { args->rest = ary; args->rest_index = 0; args->argc = 0; return TRUE; } return FALSE; }
static VALUE lazy_flat_map_to_ary(VALUE obj, VALUE yielder) { VALUE ary = rb_check_array_type(obj); if (NIL_P(ary)) { rb_funcall(yielder, id_yield, 1, obj); } else { long i; for (i = 0; i < RARRAY_LEN(ary); i++) { rb_funcall(yielder, id_yield, 1, RARRAY_AREF(ary, i)); } } return Qnil; }
static VALUE lazy_flat_map_to_ary(VALUE obj) { NODE *memo = RNODE(obj); VALUE ary = rb_check_array_type(memo->u1.value); if (NIL_P(ary)) { rb_funcall(memo->u2.value, id_yield, 1, memo->u1.value); } else { long i; for (i = 0; i < RARRAY_LEN(ary); i++) { rb_funcall(memo->u2.value, id_yield, 1, RARRAY_PTR(ary)[i]); } } return Qnil; }
VALUE RObj_lcall(VALUE self, VALUE args){ SEXP exp, e, res; SEXP r_obj; int conv, default_mode; VALUE obj; //Ensure we have an array args = rb_check_array_type(args); // A SEXP with the function to call and the arguments PROTECT(exp = allocVector(LANGSXP, RARRAY_LEN(args)+1)); e = exp; Data_Get_Struct(self, struct SEXPREC, r_obj); SETCAR(e, r_obj); e = CDR(e); // Add the arguments to the SEXP if (!make_argl(args, &e)) { UNPROTECT(1); return Qnil; } // Evaluate PROTECT(res = do_eval_expr(exp)); if (!res) { UNPROTECT(2); return Qnil; } default_mode = NUM2INT(rb_iv_get(RSRUBY,"@default_mode")); // Convert if (default_mode < 0){ conv = NUM2INT(rb_iv_get(self,"@conversion")); } else { conv = default_mode; } obj = to_ruby_with_mode(res, conv); UNPROTECT(2); return obj; }
GimpParam * rb2GimpParams (VALUE rbparams, gint *count) { rbparams = rb_check_array_type(rbparams); int num = RARRAY_LEN(RARRAY(rbparams)); VALUE *arr = RARRAY_PTR(RARRAY(rbparams)); GimpParam *params = g_new(GimpParam, num); int i; for (i=0; i<num; i++) params[i] = rb2GimpParam(arr[i]); *count = (gint)num; return params; }
Carr * r2carr(VALUE value) { Carr *M = NULL; int rows = RARRAY_LEN(value); if (rows > 0) { VALUE colzero = rb_ary_entry(value, 0); colzero = rb_check_array_type(colzero); if (!NIL_P(colzero)) { rb_raise(rb_eTypeError, "Matrix two dimensional instead of one"); } M = carr_new(rows); int i; for (i=0;i<rows;++i) { VALUE val = rb_ary_entry(value, i); M->data[i] = NUM2DBL(val); } } return M; }
/** call-seq: time_real = sec, nsec For removing events based on this specified realtime. It is also possible to pass a tuple as single argument. See RRTS::Driver::AlsaRemoveClass_i#condition=. */ static VALUE ARE_set_time_real(int argc, VALUE *argv, VALUE v_rmp) { snd_seq_remove_events_t *rmp; Data_Get_Struct(v_rmp, snd_seq_remove_events_t, rmp); VALUE v_sec, v_nsec; rb_scan_args(argc, argv, "11", &v_sec, &v_nsec); if (NIL_P(v_nsec)) { v_sec = rb_check_array_type(v_sec); if (!RTEST(v_sec)) RAISE_MIDI_ERROR_FMT0("API call error: realtime needs sec+nsec tuple"); v_nsec = rb_ary_entry(v_sec, 1); v_sec = rb_ary_entry(v_sec, 0); } snd_seq_timestamp_t time; time.time.tv_sec = NUM2UINT(v_sec); time.time.tv_nsec = NUM2UINT(v_nsec); snd_seq_remove_events_set_time(rmp, &time); return Qnil; }
int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv){ VALUE vertex; VALUE tmp; VALUE i; tmp = rb_check_array_type(va); if(NIL_P(tmp)) rb_raise(cIGraphError, "Array expected\n"); //Initialize edge vector //igraph_vector_init_int(nv,0); for (i=0; i<RARRAY_LEN(va); i++) { vertex = RARRAY_PTR(va)[i]; igraph_vector_push_back(nv,cIGraph_get_vertex_id(graph, vertex)); } return 0; }
// Wrappers for matrix class Cmat * r2cmat(VALUE value) { Cmat *M = NULL; int rows = RARRAY_LEN(value); int cols = 0; if (rows > 0) { VALUE colzero = rb_ary_entry(value, 0); colzero = rb_check_array_type(colzero); if (NIL_P(colzero)) { rb_raise(rb_eTypeError, "Matrix one dimensional instead of two"); } cols = RARRAY_LEN(colzero); M = cmat_new(rows,cols); int i,j; for (i=0;i<rows;++i) { VALUE col = rb_ary_entry(value, i); for (j=0;j<cols;++j) { M->data[i][j] = NUM2DBL(rb_ary_entry(col, j)); } } } return M; }
/** * call-seq: * servers=( ary ) * * Replace the list of servers for this database with the * given one. * * === Parameters * [servers] * An array of URLs. */ static VALUE set_servers(VALUE self, VALUE ary) { alpm_db_t* p_db = NULL; alpm_list_t* servers = NULL; int i; Data_Get_Struct(self, alpm_db_t, p_db); if (!RTEST(ary = rb_check_array_type(ary))) { /* Single = intended */ rb_raise(rb_eTypeError, "Argument is no array (#to_ary)"); return Qnil; } for(i=0; i < RARRAY_LEN(ary); i++) { VALUE url = rb_ary_entry(ary, i); servers = alpm_list_add(servers, StringValuePtr(url)); } alpm_db_set_servers(p_db, servers); alpm_list_free(servers); return ary; }
static gpointer rb2gimp_array (GimpPDBArgType type, VALUE rbarr) { rbarr = rb_check_array_type(rbarr); int count = RARRAY_LEN(RARRAY(rbarr)); VALUE *arr = RARRAY_PTR(RARRAY(rbarr)); int i; gint32 *int32arr; gint16 *int16arr; gdouble *floatarr; gchar **stringarr; switch (type) { case GIMP_PDB_INT32ARRAY: int32arr = g_new(gint32, count); for(i=0; i<count; i++) int32arr[i] = (gint32)NUM2INT(arr[i]); return int32arr; case GIMP_PDB_INT16ARRAY: int16arr = g_new(gint16, count); for(i=0; i<count; i++) int16arr[i] = (gint16)NUM2INT(arr[i]); return int16arr; case GIMP_PDB_FLOATARRAY: floatarr = g_new(gdouble, count); for(i=0; i<count; i++) floatarr[i] = (gdouble)NUM2DBL(arr[i]); return floatarr; case GIMP_PDB_STRINGARRAY: stringarr = g_new(gchar *, count); for(i=0; i<count; i++) stringarr[i] = g_strdup(StringValuePtr(arr[i])); return stringarr; default: rb_bug("Bad type value in convert_array()"); } }
static VALUE deque_init(int argc, VALUE *argv, VALUE self) { int len, i; VALUE ary; if(argc == 0) { return self; } else if(argc > 1) { rb_raise(rb_eArgError, "wrong number of arguments"); } else { ary = rb_check_array_type(argv[0]); if(!NIL_P(ary)) { len = RARRAY_LEN(ary); for (i = 0; i < len; i++) { deque_push_back(self, RARRAY_PTR(ary)[i]); } } } return self; }
//lcall method that is safe to call during RSRuby initialisation VALUE RObj_init_lcall(VALUE self, VALUE args){ SEXP exp, e, res; SEXP r_obj; VALUE obj; //Ensure we have an array args = rb_check_array_type(args); // A SEXP with the function to call and the arguments PROTECT(exp = allocVector(LANGSXP, RARRAY_LEN(args)+1)); e = exp; Data_Get_Struct(self, struct SEXPREC, r_obj); SETCAR(e, r_obj); e = CDR(e); // Add the arguments to the SEXP if (!make_argl(args, &e)) { UNPROTECT(1); return Qnil; } // Evaluate PROTECT(res = do_eval_expr(exp)); if (!res) { UNPROTECT(2); return Qnil; } obj = to_ruby_with_mode(res, BASIC_CONVERSION); UNPROTECT(2); return obj; }
VALUE rb_grn_check_convert_to_array (VALUE object) { return rb_check_array_type(object); }
static inline int vm_yield_setup_block_args(rb_thread_t *th, const rb_iseq_t * iseq, int orig_argc, VALUE *argv, const rb_block_t *blockptr) { int i; int argc = orig_argc; const int m = iseq->argc; VALUE ary, arg0; int opt_pc = 0; th->mark_stack_len = argc; /* * yield [1, 2] * => {|a|} => a = [1, 2] * => {|a, b|} => a, b = [1, 2] */ arg0 = argv[0]; if (!(iseq->arg_simple & 0x02) && /* exclude {|a|} */ (m + iseq->arg_post_len) > 0 && /* this process is meaningful */ argc == 1 && !NIL_P(ary = rb_check_array_type(arg0))) { /* rhs is only an array */ th->mark_stack_len = argc = RARRAY_LENINT(ary); CHECK_STACK_OVERFLOW(th->cfp, argc); MEMCPY(argv, RARRAY_PTR(ary), VALUE, argc); } else { argv[0] = arg0; } for (i=argc; i<m; i++) { argv[i] = Qnil; } if (iseq->arg_rest == -1 && iseq->arg_opts == 0) { const int arg_size = iseq->arg_size; if (arg_size < argc) { /* * yield 1, 2 * => {|a|} # truncate */ th->mark_stack_len = argc = arg_size; } } else { int r = iseq->arg_rest; if (iseq->arg_post_len || iseq->arg_opts) { /* TODO: implement simple version for (iseq->arg_post_len==0 && iseq->arg_opts > 0) */ opt_pc = vm_yield_setup_block_args_complex(th, iseq, argc, argv); } else { if (argc < r) { /* yield 1 * => {|a, b, *r|} */ for (i=argc; i<r; i++) { argv[i] = Qnil; } argv[r] = rb_ary_new(); } else { argv[r] = rb_ary_new4(argc-r, &argv[r]); } } th->mark_stack_len = iseq->arg_size; } /* {|&b|} */ if (iseq->arg_block != -1) { VALUE procval = Qnil; if (blockptr) { if (blockptr->proc == 0) { procval = rb_vm_make_proc(th, blockptr, rb_cProc); } else { procval = blockptr->proc; } } argv[iseq->arg_block] = procval; } th->mark_stack_len = 0; return opt_pc; }
static VALUE so_check_array_type(VALUE self, VALUE ary) { return rb_check_array_type(ary); }