static int frame_lines_i(st_data_t key, st_data_t val, st_data_t arg) { VALUE lines = (VALUE)arg; size_t weight = (size_t)val; size_t total = weight & (~(size_t)0 << (8*SIZEOF_SIZE_T/2)); weight -= total; total = total >> (8*SIZEOF_SIZE_T/2); rb_hash_aset(lines, INT2FIX(key), rb_ary_new3(2, ULONG2NUM(total), ULONG2NUM(weight))); return ST_CONTINUE; }
static VALUE qos_parse(VALUE self) { gdouble proportion; GstClockTimeDiff diff; GstClockTime timestamp; gst_event_parse_qos(RGST_EVENT(self), &proportion, &diff, ×tamp); return rb_ary_new3(3, DBL2NUM(proportion), LL2NUM(diff), ULL2NUM(timestamp)); }
void rb_trap_exit(void) { #ifndef MACOS_UNUSE_SIGNAL if (trap_list[0].cmd) { VALUE trap_exit = trap_list[0].cmd; trap_list[0].cmd = 0; rb_eval_cmd(trap_exit, rb_ary_new3(1, INT2FIX(0)), trap_list[0].safe); } #endif }
static VALUE rbclt_behaviour_rotate_get_bounds (VALUE self) { ClutterBehaviourRotate *brotate = CLUTTER_BEHAVIOUR_ROTATE (RVAL2GOBJ (self)); gdouble angle_start, angle_end; clutter_behaviour_rotate_get_bounds (brotate, &angle_start, &angle_end); return rb_ary_new3 (2, rb_float_new (angle_start), rb_float_new (angle_end)); }
static VALUE lazy_drop(VALUE obj, VALUE n) { long len = NUM2LONG(n); if (len < 0) { rb_raise(rb_eArgError, "attempt to drop negative size"); } return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj, lazy_drop_func, n), rb_ary_new3(1, n), lazy_drop_size); }
// // same as above, but reversed: // >> require 'fnmatch' // >> Globber.match_any_string('*hn', ['john', 'bill', 'bob']) // => true // >> Globber.match_any_string('*hn', ['jake', 'jim', 'sam']) // => false // static VALUE fnm_match_any_string(VALUE self, VALUE args) { // variable holders VALUE strings, pattern, flags, nargs; long len = RARRAY_LEN(args); // extract arguments if ( len > 3 || len < 2 ) { rb_raise(rb_eArgError, "Accepts either 2 or 3 arguments"); } else if ( len == 2 ) { pattern = rb_ary_entry(args, 0); strings = rb_ary_entry(args, 1); flags = INT2NUM(DEFAULT_FLAG); } else { pattern = rb_ary_entry(args, 0); strings = rb_ary_entry(args, 1); flags = rb_ary_entry(args, 2); } // sanity check_type(pattern, T_STRING, "input pattern"); check_type(flags , T_FIXNUM, "module flags"); check_type(strings, T_ARRAY , "string list"); int s_len = RARRAY_LEN( strings ); // these are the loop counter and the match tracker int i; VALUE match = Qfalse, string; // get a VALUE ptr to the first element VALUE * s_arr = RARRAY_PTR( strings ); // go through each element and try to match for ( i = 0 ; i < s_len ; ++i ) { // the current string string = s_arr[i]; // perform the actual matching match = fnm_match( self, rb_ary_new3(3, string, pattern, flags) ); // fnmatch returns 0 if glob match was found if ( match == Qtrue ) { return Qtrue; } } return Qfalse; }
static void signal_exec(VALUE cmd, int sig) { rb_proc_t *proc; VALUE signum = INT2FIX(sig); if (TYPE(cmd) == T_STRING) { rb_eval_cmd(cmd, rb_ary_new3(1, signum), trap_list[sig].safe); return; } GetProcPtr(cmd, proc); vm_invoke_proc(GET_THREAD(), proc, proc->block.self, 1, &signum, 0); }
VALUE oci8_server_release(VALUE self) { oci8_handle_t *h; OraText buf[1024]; ub4 version = 0; sword rv; Get_Handle(self, h); /* 0 */ rv = OCIServerRelease(h->hp, h->errhp, buf, sizeof(buf), h->type, &version); if (rv != OCI_SUCCESS) oci8_raise(h->errhp, rv, NULL); return rb_ary_new3(2, INT2FIX(version), rb_str_new2(buf)); }
static VALUE rg_size(VALUE self) { int rows, columns; gboolean result; GError *error = NULL; result = vte_pty_get_size(_SELF(self), &rows, &columns, &error); if (error) RAISE_GERROR(error); return rb_ary_new3(2, INT2NUM(rows), INT2NUM(columns)); }
static VALUE cr_surface_get_fallback_resolution (VALUE self) { double x_pixels_per_inch, y_pixels_per_inch; cairo_surface_get_fallback_resolution (_SELF, &x_pixels_per_inch, &y_pixels_per_inch); cr_surface_check_status (_SELF); return rb_ary_new3 (2, rb_float_new (x_pixels_per_inch), rb_float_new (y_pixels_per_inch)); }
#include "kgio.h" #include "my_fileno.h" static ID id_wait_rd, id_wait_wr; #if defined(HAVE_RB_TIME_INTERVAL) && defined(HAVE_RB_WAIT_FOR_SINGLE_FD) static int kgio_timedwait(VALUE self, VALUE timeout, int write_p) { struct timeval tv = rb_time_interval(timeout); int events = write_p ? RB_WAITFD_OUT : RB_WAITFD_IN; return rb_wait_for_single_fd(my_fileno(self), events, &tv); } #else /* ! (HAVE_RB_TIME_INTERVAL && HAVE_RB_WAIT_FOR_SINGLE_FD) */ static int kgio_timedwait(VALUE self, VALUE timeout, int write_p) { VALUE argv[4]; VALUE set = rb_ary_new3(1, self); argv[0] = write_p ? Qnil : set; argv[1] = write_p ? set : Qnil; argv[2] = Qnil; argv[3] = timeout; set = rb_funcall2(rb_cIO, rb_intern("select"), 4, argv); return NIL_P(set) ? 0 : 1; }
static VALUE rg_get_dest_row_at_pos(VALUE self, VALUE drag_x, VALUE drag_y) { GtkTreePath* path; GtkTreeViewDropPosition pos; gboolean ret; ret = gtk_tree_view_get_dest_row_at_pos(_SELF(self), NUM2INT(drag_x), NUM2INT(drag_y), &path, &pos); return ret ? rb_ary_new3(2, path ? GTKTREEPATH2RVAL(path) : Qnil, GENUM2RVAL(pos, GTK_TYPE_TREE_VIEW_DROP_POSITION)) : Qnil; }
/* * call-seq: * to_ary -> [hu1, hu2, ... ,hu7] * * Return values by Array. */ VALUE rb_to_ary(VALUE self) { CvHuMoments *hu_moments = CVHUMOMENTS(self); return rb_ary_new3(7, rb_float_new(hu_moments->hu1), rb_float_new(hu_moments->hu2), rb_float_new(hu_moments->hu3), rb_float_new(hu_moments->hu4), rb_float_new(hu_moments->hu5), rb_float_new(hu_moments->hu6), rb_float_new(hu_moments->hu7)); }
static VALUE segment_parse(VALUE self) { GstFormat format; gdouble rate; gint64 start_value, stop_value; gst_query_parse_segment(RVAL2GST_QUERY(self), &rate, &format, &start_value, &stop_value); return rb_ary_new3(4, rb_dbl2big(rate), GST_FORMAT2RVAL(format), LL2NUM(start_value), LL2NUM(stop_value)); }
static VALUE latency_parse(VALUE self) { GstClockTime min_latency; GstClockTime max_latency; gboolean live; gst_query_parse_latency(RVAL2GST_QUERY(self), &live, &min_latency, &max_latency); return rb_ary_new3(3, CBOOL2RVAL(live), ULL2NUM(min_latency), ULL2NUM(max_latency)); }
static VALUE seeking_parse(VALUE self) { GstFormat format; gboolean seekable; gint64 segment_start, segment_end; gst_query_parse_seeking(RVAL2GST_QUERY(self), &format, &seekable, &segment_start, &segment_end); return rb_ary_new3(4, GST_FORMAT2RVAL(format), CBOOL2RVAL(seekable), LL2NUM(segment_start), LL2NUM(segment_end)); }
static VALUE rbhtp_r_string_table( table_t* table ) { if ( table == NULL ) return Qnil; bstr k, v; VALUE r = rb_ary_new(); table_iterator_reset( table ); while ( ( k = table_iterator_next( table, &v ) ) != NULL ) { rb_ary_push( r, rb_ary_new3( 2, BSTR_TO_RSTR( k ), BSTR_TO_RSTR( v ) ) ); } return r; }
void Init_rsvg2(void) { VALUE RG_TARGET_NAMESPACE = rb_define_module("RSVG"); #if LIBRSVG_CHECK_VERSION(2, 9, 0) rsvg_init(); atexit(rsvg_term); #endif G_DEF_ERROR(RSVG_ERROR, "Error", RG_TARGET_NAMESPACE, rb_eRuntimeError, RSVG_TYPE_ERROR); rb_define_const(RG_TARGET_NAMESPACE, "BINDING_VERSION", rb_ary_new3(3, INT2FIX(RBRSVG_MAJOR_VERSION), INT2FIX(RBRSVG_MINOR_VERSION), INT2FIX(RBRSVG_MICRO_VERSION))); rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION", rb_ary_new3(3, INT2FIX(LIBRSVG_MAJOR_VERSION), INT2FIX(LIBRSVG_MINOR_VERSION), INT2FIX(LIBRSVG_MICRO_VERSION))); RG_DEF_SMETHOD(set_default_dpi, 1); RG_DEF_SMETHOD(set_default_dpi_x_y, 2); /* Convenience API */ RG_DEF_SMETHOD(pixbuf_from_file, 1); RG_DEF_SMETHOD(pixbuf_from_file_at_zoom, 3); RG_DEF_SMETHOD(pixbuf_from_file_at_size, 3); RG_DEF_SMETHOD(pixbuf_from_file_at_max_size, 3); RG_DEF_SMETHOD(pixbuf_from_file_at_zoom_with_max, 5); RG_DEF_SMETHOD_P(cairo_available, 0); Init_rsvg_handle(RG_TARGET_NAMESPACE); Init_rsvg_dimensiondata(RG_TARGET_NAMESPACE); }
/* * 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); }
/* Evaluate block with each element and its index. */ static VALUE r_mpfi_vector_each_element_with_index (VALUE self) { MPFIMatrix *ptr_self; VALUE ret; int i; RETURN_ENUMERATOR(self, 0, NULL); r_mpfi_get_matrix_struct(ptr_self, self); ret = Qnil; for (i = 0; i < ptr_self->size; i++) { volatile VALUE el = r_mpfi_make_new_fi_obj(ptr_self->data + i); ret = rb_yield(rb_ary_new3(2, el, INT2NUM(i))); } return ret; }
static VALUE device_keys(VALUE self) { gint i; VALUE ary = rb_ary_new(); GdkDeviceKey* keys = _SELF(self)->keys; for (i = 0; i < _SELF(self)->num_keys; i++){ rb_ary_push(ary, rb_ary_new3(2, UINT2NUM(keys[i].keyval), GFLAGS2RVAL(keys[i].modifiers, GDK_TYPE_MODIFIER_TYPE))); } return ary; }
static VALUE device_axes(VALUE self) { gint i; VALUE ary = rb_ary_new(); GdkDeviceAxis* axes = _SELF(self)->axes; for (i = 0; i < _SELF(self)->num_axes; i++){ rb_ary_push(ary, rb_ary_new3(3, GENUM2RVAL(axes[i].use, GDK_TYPE_AXIS_USE), rb_float_new(axes[i].min), rb_float_new(axes[i].max))); } return ary; }
static enum MqErrorE FactoryCreate( struct MqS * const tmpl, enum MqFactoryE create, struct MqFactoryS *item, struct MqS ** mqctxP ) { enum MqErrorE mqret = MQ_OK; struct MqS * mqctx = NULL; VALUE args; VALUE vtmpl; VALUE self; /* //struct MqS * const mqctx = tmpl; if (create == MQ_FACTORY_NEW_FORK) { //rb_thread_atfork(); } if (create == MQ_FACTORY_NEW_THREAD) { //RUBY_INIT_STACK; } */ // setup templ vtmpl = MqS2VAL(tmpl); // setup arguments args = rb_ary_new3(2, vtmpl, PTR2VAL(item->Create.data)); // call "new" self = rb_rescue2(sFactoryCall, args, sFactoryError, vtmpl, rb_eException, (VALUE)0); if (NIL_P(self)) { if (create == MQ_FACTORY_NEW_INIT) { mqret = MQ_ERROR; } else { mqret = MqErrorGetCode(tmpl); } } else { mqctx = VAL2MqS(self); //rb_gc_register_address((VALUE*)&mqctx->self); INCR_REG(self); if (create == MQ_FACTORY_NEW_INIT) { MqSetupDup(mqctx, tmpl); } } *mqctxP = mqctx; return mqret; }
rb_method_entry_t * rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_flag_t noex) { rb_thread_t *th; rb_control_frame_t *cfp; int line; rb_method_entry_t *me = rb_method_entry_make(klass, mid, type, 0, noex); rb_method_definition_t *def = ALLOC(rb_method_definition_t); me->def = def; def->type = type; def->original_id = mid; def->alias_count = 0; switch (type) { case VM_METHOD_TYPE_ISEQ: def->body.iseq = (rb_iseq_t *)opts; break; case VM_METHOD_TYPE_CFUNC: def->body.cfunc = *(rb_method_cfunc_t *)opts; break; case VM_METHOD_TYPE_ATTRSET: case VM_METHOD_TYPE_IVAR: def->body.attr.id = (ID)opts; def->body.attr.location = Qfalse; th = GET_THREAD(); cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp); if (cfp && (line = rb_vm_get_sourceline(cfp))) { VALUE location = rb_ary_new3(2, cfp->iseq->filename, INT2FIX(line)); def->body.attr.location = rb_ary_freeze(location); } break; case VM_METHOD_TYPE_BMETHOD: def->body.proc = (VALUE)opts; break; case VM_METHOD_TYPE_NOTIMPLEMENTED: def->body.cfunc.func = rb_f_notimplement; def->body.cfunc.argc = -1; break; case VM_METHOD_TYPE_OPTIMIZED: def->body.optimize_type = (enum method_optimized_type)opts; break; case VM_METHOD_TYPE_ZSUPER: case VM_METHOD_TYPE_UNDEF: break; default: rb_bug("rb_add_method: unsupported method type (%d)\n", type); } if (type != VM_METHOD_TYPE_UNDEF) { method_added(klass, mid); } return me; }
static void LibXML_validity_warning(void * ctxt, const char * msg, va_list ap) { if (rb_block_given_p()) { char buff[1024]; snprintf(buff, 1024, msg, ap); rb_yield(rb_ary_new3(2, rb_str_new2(buff), Qfalse)); } else { fprintf(stderr, "warning -- found validity error: "); fprintf(stderr, msg, ap); } }
VALUE zkrb_stat_to_rarray(const struct Stat* stat) { return rb_ary_new3(11, LL2NUM(stat->czxid), LL2NUM(stat->mzxid), LL2NUM(stat->ctime), LL2NUM(stat->mtime), INT2NUM(stat->version), INT2NUM(stat->cversion), INT2NUM(stat->aversion), LL2NUM(stat->ephemeralOwner), INT2NUM(stat->dataLength), INT2NUM(stat->numChildren), LL2NUM(stat->pzxid)); }
static VALUE cr_gradient_pattern_get_color_stop_rgba (VALUE self, VALUE index) { cairo_status_t status; double offset, red, green, blue, alpha; status = cairo_pattern_get_color_stop_rgba (_SELF (self), NUM2INT (index), &offset, &red, &green, &blue, &alpha); rb_cairo_check_status (status); return rb_ary_new3 (5, rb_float_new (offset), rb_float_new (red), rb_float_new (green), rb_float_new (blue), rb_float_new (alpha)); }
static VALUE rb_gsl_utrunc_accel(VALUE obj) { gsl_sum_levin_utrunc_workspace *w = NULL; double sum, err, sum_plain, *ptr; size_t terms_used, n, stride; ptr = get_vector_ptr(obj, &stride, &n); w = gsl_sum_levin_utrunc_alloc(n); gsl_sum_levin_utrunc_accel(ptr, n, w, &sum, &err); sum_plain = w->sum_plain; terms_used = w->terms_used; gsl_sum_levin_utrunc_free(w); return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), rb_float_new(sum_plain), INT2FIX(terms_used)); }
static VALUE mlink_get(VALUE obj) { struct mlink *lnkp; VALUE link, mark; Data_Get_Struct(obj, struct mlink, lnkp); link = lnkp->link; mark = link & 1 ? Qtrue : Qfalse ; link &= ~1; return rb_ary_new3(2, link, mark); }
static VALUE rg_translate_coordinates(VALUE self, VALUE dest_widget, VALUE src_x, VALUE src_y) { gint dest_x, dest_y; gboolean ret; VALUE result = Qnil; ret = gtk_widget_translate_coordinates(_SELF(self), _SELF(dest_widget), NUM2INT(src_x), NUM2INT(src_y), &dest_x, &dest_y); if (ret) result = rb_ary_new3(2, INT2FIX(dest_x), INT2FIX(dest_y)); return result; }