int rb_proc_arity(VALUE self) { return (int)NUM2INT(rb_funcall(self, rb_intern("arity"), 0)); }
static VALUE t_set_rlimit_nofile (VALUE self, VALUE arg) { arg = (NIL_P(arg)) ? -1 : NUM2INT (arg); return INT2NUM (evma_set_rlimit_nofile (arg)); }
static VALUE rg_s_keyboard_grab(G_GNUC_UNUSED VALUE self, VALUE win, VALUE owner_events, VALUE time) { return GDKGRABSTATUS2RVAL(gdk_keyboard_grab(RVAL2GDKWINDOW(win), RVAL2CBOOL(owner_events), NUM2INT(time))); }
static VALUE rg_set_spacing(VALUE self, VALUE spacing) { pango_layout_set_spacing(_SELF(self), NUM2INT(spacing)); return self; }
/* call-seq: stmt.bind_param(key, value) * * Binds value to the named (or positional) placeholder. If +param+ is a * Fixnum, it is treated as an index for a positional placeholder. * Otherwise it is used as the name of the placeholder to bind to. * * See also #bind_params. */ static VALUE bind_param(VALUE self, VALUE key, VALUE value) { sqlite3StmtRubyPtr ctx; int status; int index; Data_Get_Struct(self, sqlite3StmtRuby, ctx); REQUIRE_OPEN_STMT(ctx); switch(TYPE(key)) { case T_SYMBOL: key = rb_funcall(key, rb_intern("to_s"), 0); case T_STRING: if(RSTRING_PTR(key)[0] != ':') key = rb_str_plus(rb_str_new2(":"), key); index = sqlite3_bind_parameter_index(ctx->st, StringValuePtr(key)); break; default: index = (int)NUM2INT(key); } if(index == 0) rb_raise(rb_path2class("SQLite3::Exception"), "no such bind parameter"); switch(TYPE(value)) { case T_STRING: if(CLASS_OF(value) == cSqlite3Blob #ifdef HAVE_RUBY_ENCODING_H || rb_enc_get_index(value) == rb_ascii8bit_encindex() #endif ) { status = sqlite3_bind_blob( ctx->st, index, (const char *)StringValuePtr(value), (int)RSTRING_LEN(value), SQLITE_TRANSIENT ); } else { #ifdef HAVE_RUBY_ENCODING_H if(!UTF8_P(value)) { VALUE db = rb_iv_get(self, "@connection"); VALUE encoding = rb_funcall(db, rb_intern("encoding"), 0); rb_encoding * enc = rb_to_encoding(encoding); value = rb_str_export_to_enc(value, enc); } #endif status = sqlite3_bind_text( ctx->st, index, (const char *)StringValuePtr(value), (int)RSTRING_LEN(value), SQLITE_TRANSIENT ); } break; case T_BIGNUM: #if SIZEOF_LONG < 8 if (RBIGNUM_LEN(value) * SIZEOF_BDIGITS <= 8) { status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)NUM2LL(value)); break; } #endif case T_FLOAT: status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value)); break; case T_FIXNUM: status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)FIX2LONG(value)); break; case T_NIL: status = sqlite3_bind_null(ctx->st, index); break; default: rb_raise(rb_eRuntimeError, "can't prepare %s", rb_class2name(CLASS_OF(value))); break; } CHECK(sqlite3_db_handle(ctx->st), status); return self; }
void * weechat_ruby_exec (struct t_plugin_script *script, int ret_type, const char *function, const char *format, void **argv) { VALUE rc, err; int ruby_error, i, argc, *ret_i; VALUE argv2[16]; void *ret_value; struct t_plugin_script *old_ruby_current_script; old_ruby_current_script = ruby_current_script; ruby_current_script = script; argc = 0; if (format && format[0]) { argc = strlen (format); for (i = 0; i < argc; i++) { switch (format[i]) { case 's': /* string */ argv2[i] = rb_str_new2 ((char *)argv[i]); break; case 'i': /* integer */ argv2[i] = INT2FIX (*((int *)argv[i])); break; case 'h': /* hash */ argv2[i] = weechat_ruby_hashtable_to_hash (argv[i]); break; } } } if (argc > 0) { rc = rb_protect_funcall ((VALUE) script->interpreter, rb_intern(function), &ruby_error, argc, argv2); } else { rc = rb_protect_funcall ((VALUE) script->interpreter, rb_intern(function), &ruby_error, 0, NULL); } if (ruby_error) { weechat_printf (NULL, weechat_gettext ("%s%s: unable to run function \"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, function); err = rb_gv_get("$!"); weechat_ruby_print_exception(err); return NULL; } if ((TYPE(rc) == T_STRING) && (ret_type == WEECHAT_SCRIPT_EXEC_STRING)) { if (StringValuePtr (rc)) ret_value = strdup (StringValuePtr (rc)); else ret_value = NULL; } else if ((TYPE(rc) == T_FIXNUM) && (ret_type == WEECHAT_SCRIPT_EXEC_INT)) { ret_i = malloc (sizeof (*ret_i)); if (ret_i) *ret_i = NUM2INT(rc); ret_value = ret_i; } else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE) { ret_value = weechat_ruby_hash_to_hashtable (rc, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); } else { weechat_printf (NULL, weechat_gettext ("%s%s: function \"%s\" must return a " "valid value"), weechat_prefix ("error"), RUBY_PLUGIN_NAME, function); ruby_current_script = old_ruby_current_script; return WEECHAT_RC_OK; } if (ret_value == NULL) { weechat_printf (NULL, weechat_gettext ("%s%s: not enough memory in function " "\"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, function); ruby_current_script = old_ruby_current_script; return NULL; } ruby_current_script = old_ruby_current_script; return ret_value; }
static VALUE rg_set_height(VALUE self, VALUE width) { pango_layout_set_height(_SELF(self), NUM2INT(width)); return self; }
VALUE method_set_mouse_rel(VALUE self, VALUE x, VALUE y){ XTestFakeRelativeMotionEvent(display, NUM2INT(x), NUM2INT(y), 0); XSync(display, 1); }
VALUE method_set_mouse_abs(VALUE self, VALUE x, VALUE y){ // XWarpPointer(display, None, None, 0, 0, 0, 0, NUM2INT(x), NUM2INT(y)); XTestFakeMotionEvent(display, screen, NUM2INT(x), NUM2INT(y), 0); XSync(display, 1); }
ASN1_TYPE* ossl_asn1_get_asn1type(VALUE obj) { ASN1_TYPE *ret; VALUE value, rflag; void *ptr; void (*free_func)(); long tag, flag; tag = ossl_asn1_default_tag(obj); value = ossl_asn1_get_value(obj); switch(tag){ case V_ASN1_BOOLEAN: ptr = (void*)(VALUE)obj_to_asn1bool(value); free_func = NULL; break; case V_ASN1_INTEGER: /* FALLTHROUGH */ case V_ASN1_ENUMERATED: ptr = obj_to_asn1int(value); free_func = ASN1_INTEGER_free; break; case V_ASN1_BIT_STRING: rflag = rb_attr_get(obj, rb_intern("@unused_bits")); flag = NIL_P(rflag) ? -1 : NUM2INT(rflag); ptr = obj_to_asn1bstr(value, flag); free_func = ASN1_BIT_STRING_free; break; case V_ASN1_NULL: ptr = obj_to_asn1null(value); free_func = ASN1_NULL_free; break; case V_ASN1_OCTET_STRING: /* FALLTHROUGH */ case V_ASN1_UTF8STRING: /* FALLTHROUGH */ case V_ASN1_NUMERICSTRING: /* FALLTHROUGH */ case V_ASN1_PRINTABLESTRING: /* FALLTHROUGH */ case V_ASN1_T61STRING: /* FALLTHROUGH */ case V_ASN1_VIDEOTEXSTRING: /* FALLTHROUGH */ case V_ASN1_IA5STRING: /* FALLTHROUGH */ case V_ASN1_GRAPHICSTRING: /* FALLTHROUGH */ case V_ASN1_ISO64STRING: /* FALLTHROUGH */ case V_ASN1_GENERALSTRING: /* FALLTHROUGH */ case V_ASN1_UNIVERSALSTRING: /* FALLTHROUGH */ case V_ASN1_BMPSTRING: ptr = obj_to_asn1str(value); free_func = ASN1_STRING_free; break; case V_ASN1_OBJECT: ptr = obj_to_asn1obj(value); free_func = ASN1_OBJECT_free; break; case V_ASN1_UTCTIME: ptr = obj_to_asn1utime(value); free_func = ASN1_TIME_free; break; case V_ASN1_GENERALIZEDTIME: ptr = obj_to_asn1gtime(value); free_func = ASN1_TIME_free; break; case V_ASN1_SET: /* FALLTHROUGH */ case V_ASN1_SEQUENCE: ptr = obj_to_asn1derstr(obj); free_func = ASN1_STRING_free; break; default: ossl_raise(eASN1Error, "unsupported ASN.1 type"); } if(!(ret = OPENSSL_malloc(sizeof(ASN1_TYPE)))){ if(free_func) free_func(ptr); ossl_raise(eASN1Error, "ASN1_TYPE alloc failure"); } memset(ret, 0, sizeof(ASN1_TYPE)); ASN1_TYPE_set(ret, tag, ptr); return ret; }
/** * grpc_rb_time_timeval creates a timeval from a ruby time object. * * This func is copied from ruby source, MRI/source/time.c, which is published * under the same license as the ruby.h, on which the entire extensions is * based. */ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) { gpr_timespec t; gpr_timespec *time_const; const char *tstr = interval ? "time interval" : "time"; const char *want = " want <secs from epoch>|<Time>|<GRPC::TimeConst.*>"; t.clock_type = GPR_CLOCK_REALTIME; switch (TYPE(time)) { case T_DATA: if (CLASS_OF(time) == grpc_rb_cTimeVal) { TypedData_Get_Struct(time, gpr_timespec, &grpc_rb_timespec_data_type, time_const); t = *time_const; } else if (CLASS_OF(time) == rb_cTime) { t.tv_sec = NUM2INT(rb_funcall(time, id_tv_sec, 0)); t.tv_nsec = NUM2INT(rb_funcall(time, id_tv_nsec, 0)); } else { rb_raise(rb_eTypeError, "bad input: (%s)->c_timeval, got <%s>,%s", tstr, rb_obj_classname(time), want); } break; case T_FIXNUM: t.tv_sec = FIX2LONG(time); if (interval && t.tv_sec < 0) rb_raise(rb_eArgError, "%s must be positive", tstr); t.tv_nsec = 0; break; case T_FLOAT: if (interval && RFLOAT_VALUE(time) < 0.0) rb_raise(rb_eArgError, "%s must be positive", tstr); else { double f, d; d = modf(RFLOAT_VALUE(time), &f); if (d < 0) { d += 1; f -= 1; } t.tv_sec = (int64_t)f; if (f != t.tv_sec) { rb_raise(rb_eRangeError, "%f out of Time range", RFLOAT_VALUE(time)); } t.tv_nsec = (int)(d * 1e9 + 0.5); } break; case T_BIGNUM: t.tv_sec = NUM2LONG(time); if (interval && t.tv_sec < 0) rb_raise(rb_eArgError, "%s must be positive", tstr); t.tv_nsec = 0; break; default: rb_raise(rb_eTypeError, "bad input: (%s)->c_timeval, got <%s>,%s", tstr, rb_obj_classname(time), want); break; } return t; }
static VALUE rg_unmark_day(VALUE self, VALUE day) { gtk_calendar_unmark_day(_SELF(self), NUM2INT(day)); return self; }
static VALUE ossl_ocspbres_add_status(VALUE self, VALUE cid, VALUE status, VALUE reason, VALUE revtime, VALUE thisupd, VALUE nextupd, VALUE ext) { OCSP_BASICRESP *bs; OCSP_SINGLERESP *single; OCSP_CERTID *id; int st, rsn; ASN1_TIME *ths, *nxt, *rev; int error, i, rstatus = 0; VALUE tmp; st = NUM2INT(status); rsn = NIL_P(status) ? 0 : NUM2INT(reason); if(!NIL_P(ext)){ /* All ary's members should be X509Extension */ Check_Type(ext, T_ARRAY); for (i = 0; i < RARRAY_LEN(ext); i++) OSSL_Check_Kind(RARRAY_PTR(ext)[i], cX509Ext); } error = 0; ths = nxt = rev = NULL; if(!NIL_P(revtime)){ tmp = rb_protect(rb_Integer, revtime, &rstatus); if(rstatus) goto err; rev = X509_gmtime_adj(NULL, NUM2INT(tmp)); } tmp = rb_protect(rb_Integer, thisupd, &rstatus); if(rstatus) goto err; ths = X509_gmtime_adj(NULL, NUM2INT(tmp)); tmp = rb_protect(rb_Integer, nextupd, &rstatus); if(rstatus) goto err; nxt = X509_gmtime_adj(NULL, NUM2INT(tmp)); GetOCSPBasicRes(self, bs); SafeGetOCSPCertId(cid, id); if(!(single = OCSP_basic_add1_status(bs, id, st, rsn, rev, ths, nxt))){ error = 1; goto err; } if(!NIL_P(ext)){ X509_EXTENSION *x509ext; sk_X509_EXTENSION_pop_free(single->singleExtensions, X509_EXTENSION_free); single->singleExtensions = NULL; for(i = 0; i < RARRAY_LEN(ext); i++){ x509ext = DupX509ExtPtr(RARRAY_PTR(ext)[i]); if(!OCSP_SINGLERESP_add_ext(single, x509ext, -1)){ X509_EXTENSION_free(x509ext); error = 1; goto err; } X509_EXTENSION_free(x509ext); } } err: ASN1_TIME_free(ths); ASN1_TIME_free(nxt); ASN1_TIME_free(rev); if(error) ossl_raise(eOCSPError, NULL); if(rstatus) rb_jump_tag(rstatus); return self; }
/* Method: ImageList#quantize(<number_colors<, colorspace<, dither<, tree_depth<, measure_error>>>>>) defaults: 256, Magick::RGBColorspace, true, 0, false Purpose: call QuantizeImages Returns: a new ImageList with quantized images. 'scene' is set to the same value as self.scene */ VALUE ImageList_quantize(int argc, VALUE *argv, VALUE self) { Image *images, *new_images; Image *new_image; QuantizeInfo quantize_info; ExceptionInfo exception; volatile VALUE new_imagelist, scene; GetQuantizeInfo(&quantize_info); switch (argc) { case 5: quantize_info.measure_error = (MagickBooleanType) RTEST(argv[4]); case 4: quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]); case 3: quantize_info.dither = (MagickBooleanType) RTEST(argv[2]); case 2: VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType); case 1: quantize_info.number_colors = NUM2ULONG(argv[0]); case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 5)", argc); break; } if (imagelist_length(self) == 0L) { rb_raise(rb_eArgError, "no images in this image list"); } // Convert image array to image sequence, clone image sequence. GetExceptionInfo(&exception); images = images_from_imagelist(self); new_images = CloneImageList(images, &exception); rm_split(images); rm_check_exception(&exception, new_images, DestroyOnError); (void) DestroyExceptionInfo(&exception); rm_ensure_result(new_images); (void) QuantizeImages(&quantize_info, new_images); rm_check_exception(&exception, new_images, DestroyOnError); // Create new ImageList object, convert mapped image sequence to images, // append to images array. new_imagelist = ImageList_new(); while ((new_image = ShiftImageList(&new_images))) { imagelist_push(new_imagelist, rm_image_new(new_image)); } // Set @scene in new ImageList object to same value as in self. scene = rb_iv_get(self, "@scene"); (void) rb_iv_set(new_imagelist, "@scene", scene); return new_imagelist; }
static VALUE rg_reparent(VALUE self, VALUE new_parent, VALUE x, VALUE y) { gdk_window_reparent(_SELF(self), _SELF(new_parent), NUM2INT(x), NUM2INT(y)); return self; }
static gint rb_cogl_texture_max_waste_param (VALUE value) { return NIL_P (value) ? 64 : NUM2INT (value); }
CIMCData sfcc_value_to_cimdata(VALUE value) { CIMCData data; memset(&data, 0, sizeof(CIMCData)); data.state = CIMC_goodValue; data.type = CIMC_null; switch (TYPE(value)) { case T_NIL: data.type = CIMC_null; data.state = CIMC_nullValue; break; case T_STRING: data.type = CIMC_string; data.value.string = cimcEnv->ft->newString(cimcEnv, to_charptr(value), NULL); break; case T_TRUE: data.type = CIMC_boolean; data.value.boolean = 1; break; case T_FALSE: data.type = CIMC_boolean; data.value.boolean = 0; break; case T_FIXNUM: data.type = CIMC_sint64; data.value.Long = NUM2INT(value); break; case T_FLOAT: data.type = CIMC_real64; data.value.real64 = NUM2DBL(value); break; case T_BIGNUM: data.type = CIMC_sint64; data.value.Long = NUM2LL(value); break; /* not yet supported case T_HASH: break; case T_SYMBOL: */ case T_ARRAY: { data.value.array = sfcc_rubyarray_to_cimcarray(value, &data.type); if (!data.value.array) { data.state = CIMC_badValue; } break; } case T_DATA: default: if (CLASS_OF(value) == cSfccCimString) { Data_Get_Struct(value, CIMCString, data.value.string); if (data.value.string == NULL) { /* packed a NULL pointer ? */ data.type = CIMC_null; data.state = CIMC_nullValue; } else { data.type = CIMC_string; } } else if (CLASS_OF(value) == cSfccCimData) { CIMCData *tmp; Data_Get_Struct(value, CIMCData, tmp); data = *tmp; } else if(CLASS_OF(value) == cSfccCimInstance) { rb_sfcc_instance *obj; Data_Get_Struct(value, rb_sfcc_instance, obj); data.value.inst = obj->inst; if (data.value.inst == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_instance; } } else if(CLASS_OF(value) == cSfccCimObjectPath) { rb_sfcc_object_path *obj; Data_Get_Struct(value, rb_sfcc_object_path, obj); data.value.ref = obj->op; if (data.value.ref == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_ref; } } else if(CLASS_OF(value) == cSfccCimEnumeration) { rb_sfcc_enumeration *obj; Data_Get_Struct(value, rb_sfcc_enumeration, obj); data.value.Enum = obj->enm; if (data.value.Enum == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_enumeration; } } else if (CLASS_OF(value) == cSfccCimClass) { Data_Get_Struct(value, CIMCClass, data.value.cls); if (data.value.cls == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_class; } } else { VALUE cname; const char *class_name; data.state = CIMC_badValue; data.type = CIMC_null; cname = rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0); class_name = to_charptr(cname); rb_raise(rb_eTypeError, "unsupported data type: %s", class_name); return data; } } return data; }
static VALUE math_ldexp(VALUE obj, VALUE x, VALUE n) { return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n))); }
int weechat_ruby_load (const char *filename) { char modname[64]; VALUE ruby_retcode, err, argv[1]; int ruby_error; struct stat buf; if (stat (filename, &buf) != 0) { weechat_printf (NULL, weechat_gettext ("%s%s: script \"%s\" not found"), weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename); return 0; } if ((weechat_ruby_plugin->debug >= 2) || !ruby_quiet) { weechat_printf (NULL, weechat_gettext ("%s: loading script \"%s\""), RUBY_PLUGIN_NAME, filename); } ruby_current_script = NULL; ruby_registered_script = NULL; snprintf (modname, sizeof(modname), "%s%d", MOD_NAME_PREFIX, ruby_num); ruby_num++; ruby_current_module = rb_define_module (modname); ruby_current_script_filename = filename; argv[0] = rb_str_new2 (filename); ruby_retcode = rb_protect_funcall (ruby_current_module, rb_intern ("load_eval_file"), &ruby_error, 1, argv); if (ruby_retcode == Qnil) { err = rb_gv_get("$!"); weechat_ruby_print_exception(err); return 0; } if (NUM2INT(ruby_retcode) != 0) { switch (NUM2INT(ruby_retcode)) { case 1: weechat_printf (NULL, weechat_gettext ("%s%s: unable to read file " "\"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename); break; case 2: weechat_printf (NULL, weechat_gettext ("%s%s: error while loading " "file \"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename); break; case 3: weechat_printf (NULL, weechat_gettext ("%s%s: function " "\"weechat_init\" is missing " "in file \"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename); break; } if (NUM2INT(ruby_retcode) == 2) { weechat_ruby_print_exception (rb_iv_get (ruby_current_module, "@load_eval_file_error")); } return 0; } (void) rb_protect_funcall (ruby_current_module, rb_intern ("weechat_init"), &ruby_error, 0, NULL); if (ruby_error) { weechat_printf (NULL, weechat_gettext ("%s%s: unable to eval function " "\"weechat_init\" in file \"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename); err = rb_gv_get("$!"); weechat_ruby_print_exception(err); if (ruby_current_script) { plugin_script_remove (weechat_ruby_plugin, &ruby_scripts, &last_ruby_script, ruby_current_script); ruby_current_script = NULL; } return 0; } if (!ruby_registered_script) { weechat_printf (NULL, weechat_gettext ("%s%s: function \"register\" not " "found (or failed) in file \"%s\""), weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename); return 0; } ruby_current_script = ruby_registered_script; rb_gc_register_address (ruby_current_script->interpreter); /* * set input/close callbacks for buffers created by this script * (to restore callbacks after upgrade) */ plugin_script_set_buffer_callbacks (weechat_ruby_plugin, ruby_scripts, ruby_current_script, &weechat_ruby_api_buffer_input_data_cb, &weechat_ruby_api_buffer_close_cb); (void) weechat_hook_signal_send ("ruby_script_loaded", WEECHAT_HOOK_SIGNAL_STRING, ruby_current_script->filename); return 1; }
VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){ igraph_t *graph; igraph_vector_t edge_v; VALUE vertex; VALUE directed; VALUE edges; VALUE attrs; VALUE v_ary; int vertex_n = 0; int current_vertex_id; int i; igraph_vector_ptr_t vertex_attr; igraph_vector_ptr_t edge_attr; igraph_i_attribute_record_t v_attr_rec; v_attr_rec.name = "__RUBY__"; v_attr_rec.type = IGRAPH_ATTRIBUTE_PY_OBJECT; v_attr_rec.value = (void*)rb_ary_new(); igraph_i_attribute_record_t e_attr_rec; e_attr_rec.name = "__RUBY__"; e_attr_rec.type = IGRAPH_ATTRIBUTE_PY_OBJECT; e_attr_rec.value = (void*)rb_ary_new(); rb_scan_args(argc,argv,"12", &edges, &directed, &attrs); //Initialize edge vector IGRAPH_FINALLY(igraph_vector_destroy,&edge_v); IGRAPH_FINALLY(igraph_vector_ptr_destroy,&vertex_attr); IGRAPH_FINALLY(igraph_vector_ptr_destroy,&edge_attr); IGRAPH_CHECK(igraph_vector_init_int(&edge_v,0)); IGRAPH_CHECK(igraph_vector_ptr_init(&vertex_attr,0)); IGRAPH_CHECK(igraph_vector_ptr_init(&edge_attr,0)); Data_Get_Struct(self, igraph_t, graph); v_ary = rb_ary_new(); if(!directed) IGRAPH_CHECK(igraph_to_undirected(graph,IGRAPH_TO_UNDIRECTED_COLLAPSE)); //Loop through objects in edge Array for (i=0; i<RARRAY_LEN(edges); i++) { vertex = RARRAY_PTR(edges)[i]; if(rb_ary_includes(v_ary,vertex)){ //If @vertices includes this vertex then look up the vertex number current_vertex_id = NUM2INT(rb_funcall(v_ary,rb_intern("index"),1,vertex)); } else { //Otherwise add to the list of vertices rb_ary_push(v_ary,vertex); current_vertex_id = vertex_n; vertex_n++; //Add object to list of vertex attributes rb_ary_push((VALUE)v_attr_rec.value,vertex); } IGRAPH_CHECK(igraph_vector_push_back(&edge_v,current_vertex_id)); if (i % 2){ if (attrs != Qnil){ rb_ary_push((VALUE)e_attr_rec.value,RARRAY_PTR(attrs)[i/2]); } else { rb_ary_push((VALUE)e_attr_rec.value,Qnil); } } } IGRAPH_CHECK(igraph_vector_ptr_push_back(&vertex_attr, &v_attr_rec)); IGRAPH_CHECK(igraph_vector_ptr_push_back(&edge_attr, &e_attr_rec)); if(igraph_vector_size(&edge_v) > 0){ IGRAPH_CHECK(igraph_add_vertices(graph,vertex_n,&vertex_attr)); IGRAPH_CHECK(igraph_add_edges(graph,&edge_v,&edge_attr)); } igraph_vector_destroy(&edge_v); igraph_vector_ptr_destroy(&vertex_attr); igraph_vector_ptr_destroy(&edge_attr); IGRAPH_FINALLY_CLEAN(3); return self; }
static VALUE rg_set_indent(VALUE self, VALUE indent) { pango_layout_set_indent(_SELF(self), NUM2INT(indent)); return self; }
static VALUE rg_move(VALUE self, VALUE x, VALUE y) { gdk_window_move(_SELF(self), NUM2INT(x), NUM2INT(y)); return self; }
static VALUE rg_get_line(VALUE self, VALUE line) { return PANGOLAYOUTLINE2RVAL(pango_layout_get_line(_SELF(self), NUM2INT(line))); }
static VALUE rg_resize(VALUE self, VALUE w, VALUE h) { gdk_window_resize(_SELF(self), NUM2INT(w), NUM2INT(h)); return self; }
static VALUE rg_create_watch(VALUE self, VALUE condition) { return BOXED2RVAL(g_io_create_watch(_SELF(self), NUM2INT(condition)), G_TYPE_SOURCE); }
static VALUE rg_move_resize(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h) { gdk_window_move_resize(_SELF(self), NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h)); return self; }
static VALUE rg_s_pointer_ungrab(VALUE self, VALUE time) { gdk_pointer_ungrab(NUM2INT(time)); return self; }
static VALUE rg_scroll(VALUE self, VALUE dx, VALUE dy) { gdk_window_scroll(_SELF(self), NUM2INT(dx), NUM2INT(dy)); return self; }
static VALUE rg_s_keyboard_ungrab(VALUE self, VALUE time) { gdk_keyboard_ungrab(NUM2INT(time)); return self; }
/* * Performs the transaction. * @param [Number] flag Transaction flags, default +RPM::TRANS_FLAG_NONE+ * @param [Number] filter Transaction filter, default +RPM::PROB_FILTER_NONE+ * @example * transaction.commit do |sig| * end * @yield [CallbackData] sig Transaction progress */ VALUE rpm_transaction_commit(int argc, VALUE* argv, VALUE trans) { #if RPM_VERSION_CODE < RPM_VERSION(4,1,0) rpmProblemSet probset; int flags = RPMTRANS_FLAG_NONE; int ignores = RPMPROB_FILTER_NONE; int rc; VALUE db; db = rb_ivar_get(trans, id_db); if (OBJ_FROZEN(db)) { rb_error_frozen("RPM::DB"); } switch (argc) { case 0: break; case 1: case 2: flags = NUM2INT(rb_Integer(argv[0])); if (argc == 2) { ignores = NUM2INT(rb_Integer(argv[1])); } break; default: rb_raise(rb_eArgError, "too many arguments(0..2)"); } if (rb_block_given_p() == Qtrue) rc = rpmRunTransactions(RPM_TRANSACTION(trans), transaction_callback, (void*)trans, NULL, &probset, flags, ignores); else{ VALUE keys; /* rpmcli.h:extern int packagesTotal; */ packagesTotal = 0; keys = rpm_transaction_keys(trans); if (!NIL_P(keys)) packagesTotal = NUM2INT(rb_funcall(keys,rb_intern("length"),0)); rc = rpmRunTransactions(RPM_TRANSACTION(trans), rpmShowProgress, (void*)((long)(INSTALL_HASH|INSTALL_LABEL)), NULL, &probset, flags, ignores); } if (probset != NULL) { VALUE list = rb_ary_new(); register int i; for (i = 0; i < probset->numProblems; i++) { rpmProblem prob = probset->probs + i; VALUE prb = rb_struct_new(rpm_sProblem, INT2NUM(prob->type), (VALUE)prob->key, rpm_package_new_from_header(prob->h), rb_str_new2(rpmProblemString(prob))); rb_ary_push(list, prb); } rb_ivar_set(trans, id_pl, list); } #else rpmps ps; int flags = RPMTRANS_FLAG_NONE; int ignores = RPMPROB_FILTER_NONE; int rc; VALUE db; db = rb_ivar_get(trans, id_db); if (OBJ_FROZEN(db)) { rb_error_frozen("RPM::DB"); } switch (argc) { case 0: break; case 1: case 2: flags = NUM2INT(rb_Integer(argv[0])); if (argc == 2) { ignores = NUM2INT(rb_Integer(argv[1])); } break; default: rb_raise(rb_eArgError, "too many arguments(0..2)"); } /* Drop added/available package indices and dependency sets. */ //rpmtsClean(RPM_TRANSACTION(trans)); // zaki: required? if (rb_block_given_p() == Qtrue) { rpmtsSetNotifyCallback(RPM_TRANSACTION(trans), (rpmCallbackFunction)transaction_callback,(void *)trans); }else{ VALUE keys; /* rpmcli.h:extern int rpmcliPackagesTotal; */ rpmcliPackagesTotal = 0; keys = rpm_transaction_keys(trans); if (!NIL_P(keys)) rpmcliPackagesTotal = NUM2INT(rb_funcall(keys,rb_intern("length"),0)); rpmtsSetNotifyCallback(RPM_TRANSACTION(trans), rpmShowProgress, (void*)((long)(INSTALL_HASH|INSTALL_LABEL))); } rc = rpmtsRun(RPM_TRANSACTION(trans), NULL, ignores); ps = rpmtsProblems(RPM_TRANSACTION(trans)); { VALUE list = rb_ary_new(); #ifdef RPMPS_OPAQUE rpmpsi psi = rpmpsInitIterator(ps); while (rpmpsNextIterator(psi) >= 0) { rpmProblem p = rpmpsGetProblem(psi); VALUE prb = rb_struct_new(rpm_sProblem, INT2NUM(rpmProblemGetType(p)), (VALUE)rpmProblemGetKey(p), package_new_from_NEVR( rpmProblemGetAltNEVR(p)+2 ), rb_str_new2(rpmProblemString(p))); rb_ary_push(list, prb); } #else if (ps != NULL && rpmpsNumProblems(ps) > 0) { register int i; for (i = 0; i < rpmpsNumProblems(ps); i++) { rpmProblem p = ps->probs + i; const char *altNEVR = (p->altNEVR ? p->altNEVR : "? ?altNEVR?"); VALUE prb = rb_struct_new(rpm_sProblem, INT2NUM(p->type), (VALUE)p->key, package_new_from_NEVR(altNEVR+2), rb_str_new2(rpmProblemString(p))); rb_ary_push(list, prb); } } #endif rb_ivar_set(trans, id_pl, list); } if (ps) ps = rpmpsFree(ps); #endif rb_ivar_set(trans, id_commited, Qtrue); rb_throw("abort", Qnil); return Qnil; /* NOT REACHED */ }