void handle_features_reply( uint64_t datapath_id, uint32_t transaction_id, uint32_t n_buffers, uint8_t n_tables, uint32_t capabilities, uint32_t actions, const list_element *phy_ports, void *controller ) { if ( rb_respond_to( ( VALUE ) controller, rb_intern( "features_reply" ) ) == Qfalse ) { return; } VALUE attributes = rb_hash_new(); rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( transaction_id ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "n_buffers" ) ), UINT2NUM( n_buffers ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "n_tables" ) ), UINT2NUM( n_tables ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "capabilities" ) ), UINT2NUM( capabilities ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "actions" ) ), UINT2NUM( actions ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "ports" ) ), ports_from( phy_ports ) ); VALUE features_reply = rb_funcall( cFeaturesReply, rb_intern( "new" ), 1, attributes ); rb_funcall( ( VALUE ) controller, rb_intern( "features_reply" ), 2, ULL2NUM( datapath_id ), features_reply ); }
static VALUE texthash_for(VALUE self, VALUE file) { int nbpoints, i; VALUE list; VALUE point_class; TxtHashPoint *points = ph_texthash(StringValuePtr(file), &nbpoints); point_class = rb_const_get(self, rb_intern("TextHashPoint")); list = rb_ary_new2((long)nbpoints); for(i = 0; i < nbpoints; i++) { VALUE point; VALUE args[2]; args[0] = ULL2NUM(points[i].hash); args[1] = ULL2NUM(points[i].index); point = rb_class_new_instance(2, args, point_class); rb_ary_push(list, point); } free(points); return list; }
void Init_limits(void) { VALUE mLimits; mLimits = rb_define_module("Limits"); rb_define_const(mLimits, "CHAR_BIT", INT2FIX(CHAR_BIT)); rb_define_const(mLimits, "MB_LEN_MAX", INT2FIX(MB_LEN_MAX)); rb_define_const(mLimits, "CHAR_MAX", INT2FIX(CHAR_MAX)); rb_define_const(mLimits, "CHAR_MIN", INT2FIX(CHAR_MIN)); rb_define_const(mLimits, "UCHAR_MAX", INT2FIX(UCHAR_MAX)); rb_define_const(mLimits, "SHRT_MAX", INT2FIX(SHRT_MAX)); rb_define_const(mLimits, "SHRT_MIN", INT2FIX(SHRT_MIN)); rb_define_const(mLimits, "USHRT_MAX", INT2FIX(USHRT_MAX)); rb_define_const(mLimits, "INT_MAX", INT2FIX(INT_MAX)); rb_define_const(mLimits, "INT_MIN", INT2FIX(INT_MIN)); rb_define_const(mLimits, "UINT_MAX", INT2FIX(UINT_MAX)); rb_define_const(mLimits, "LONG_MAX", LL2NUM(LONG_MAX)); rb_define_const(mLimits, "LONG_MIN", LL2NUM(LONG_MIN)); rb_define_const(mLimits, "ULONG_MAX", ULL2NUM(ULONG_MAX)); rb_define_const(mLimits, "LLONG_MAX", LL2NUM(LLONG_MAX)); rb_define_const(mLimits, "LLONG_MIN", LL2NUM(LLONG_MIN)); rb_define_const(mLimits, "ULLONG_MAX", ULL2NUM(ULLONG_MAX)); }
void handle_flow_removed( uint64_t datapath_id, flow_removed message ) { VALUE controller = ( VALUE ) message.user_data; if ( rb_respond_to( controller, rb_intern( "flow_removed" ) ) == Qfalse ) { return; } VALUE attributes = rb_hash_new(); rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( message.transaction_id ) ); VALUE match_obj = rb_eval_string( "Match.new" ); rb_funcall( match_obj, rb_intern( "replace" ), 1, Data_Wrap_Struct( cFlowRemoved, NULL, NULL, &message.match ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "match" ) ), match_obj ); rb_hash_aset( attributes, ID2SYM( rb_intern( "cookie" ) ), ULL2NUM( message.cookie ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "priority" ) ), UINT2NUM( message.priority ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "reason" ) ), UINT2NUM( message.reason ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "duration_sec" ) ), UINT2NUM( message.duration_sec ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "duration_nsec" ) ), UINT2NUM( message.duration_nsec ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "idle_timeout" ) ), UINT2NUM( message.idle_timeout ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "packet_count" ) ), ULL2NUM( message.packet_count ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "byte_count" ) ), ULL2NUM( message.byte_count ) ); VALUE r_message = rb_funcall( cFlowRemoved, rb_intern( "new" ), 1, attributes ); rb_funcall( controller, rb_intern( "flow_removed" ), 2, ULL2NUM( datapath_id ), r_message ); }
VALUE murmur3_x64_128_s_rawdigest(int argc, VALUE *argv, VALUE klass) { uint64_t out[2]; _murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x64_128); return rb_assoc_new(ULL2NUM(out[0]), ULL2NUM(out[1])); }
static void unpack_aggregate_multipart_reply( VALUE r_attributes, void *data ) { assert( data ); const struct ofp_aggregate_stats_reply *aggregate_stats = data; HASH_SET( r_attributes, "packet_count", ULL2NUM( aggregate_stats->packet_count ) ); HASH_SET( r_attributes, "byte_count", ULL2NUM( aggregate_stats->byte_count ) ); HASH_SET( r_attributes, "flow_count", UINT2NUM( aggregate_stats->flow_count ) ); }
void arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_arithmetic_resp_t *resp) { struct context_st *ctx = (struct context_st *)cookie; struct bucket_st *bucket = ctx->bucket; VALUE cas, key, val, *rv = ctx->rv, exc, res; ID o; ctx->nqueries--; key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey); strip_key_prefix(bucket, key); cas = resp->v.v0.cas > 0 ? ULL2NUM(resp->v.v0.cas) : Qnil; o = ctx->arith > 0 ? sym_increment : sym_decrement; exc = cb_check_error(error, "failed to perform arithmetic operation", key); if (exc != Qnil) { rb_ivar_set(exc, id_iv_cas, cas); rb_ivar_set(exc, id_iv_operation, o); if (bucket->async) { if (bucket->on_error_proc != Qnil) { cb_proc_call(bucket->on_error_proc, 3, o, key, exc); } else { if (NIL_P(bucket->exception)) { bucket->exception = exc; } } } if (NIL_P(ctx->exception)) { ctx->exception = cb_gc_protect(bucket, exc); } } val = ULL2NUM(resp->v.v0.value); if (bucket->async) { /* asynchronous */ if (ctx->proc != Qnil) { res = rb_class_new_instance(0, NULL, cResult); rb_ivar_set(res, id_iv_error, exc); rb_ivar_set(res, id_iv_operation, o); rb_ivar_set(res, id_iv_key, key); rb_ivar_set(res, id_iv_value, val); rb_ivar_set(res, id_iv_cas, cas); cb_proc_call(ctx->proc, 1, res); } } else { /* synchronous */ if (NIL_P(exc)) { if (ctx->extended) { rb_hash_aset(*rv, key, rb_ary_new3(2, val, cas)); } else { rb_hash_aset(*rv, key, val); } } } if (ctx->nqueries == 0) { cb_gc_unprotect(bucket, ctx->proc); } (void)handle; }
static void unpack_table_multipart_reply( VALUE r_attributes, void *data ) { assert( data ); const struct ofp_table_stats *table_stats = data; HASH_SET( r_attributes, "table_id", UINT2NUM( table_stats->table_id ) ); HASH_SET( r_attributes, "active_count", UINT2NUM( table_stats->active_count ) ); HASH_SET( r_attributes, "lookup_count", ULL2NUM( table_stats->lookup_count ) ); HASH_SET( r_attributes, "matched_count", ULL2NUM( table_stats->matched_count ) ); }
void handle_barrier_reply( uint64_t datapath_id, uint32_t transaction_id, void *user_data ) { VALUE controller = ( VALUE ) user_data; if ( rb_respond_to( controller, rb_intern( "barrier_reply" ) ) == Qfalse ) { return; } VALUE barrier_reply = rb_funcall( cBarrierReply, rb_intern( "new" ), 2, ULL2NUM( datapath_id ), UINT2NUM( transaction_id ) ); rb_funcall( controller, rb_intern( "barrier_reply" ), 2, ULL2NUM( datapath_id ), barrier_reply ); }
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)); }
void rbffi_Pointer_Init(VALUE moduleFFI) { VALUE rbNullAddress = ULL2NUM(0); rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass); rb_global_variable(&rbffi_PointerClass); rb_define_alloc_func(rbffi_PointerClass, ptr_allocate); rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1); rb_define_method(rbffi_PointerClass, "initialize_copy", ptr_initialize_copy, 1); rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0); rb_define_method(rbffi_PointerClass, "to_s", ptr_inspect, 0); rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1); rb_define_method(rbffi_PointerClass, "slice", ptr_slice, 2); rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0); rb_define_method(rbffi_PointerClass, "address", ptr_address, 0); rb_define_alias(rbffi_PointerClass, "to_i", "address"); rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1); rb_define_method(rbffi_PointerClass, "order", ptr_order, -1); rb_define_method(rbffi_PointerClass, "autorelease=", ptr_autorelease, 1); rb_define_method(rbffi_PointerClass, "autorelease?", ptr_autorelease_p, 0); rb_define_method(rbffi_PointerClass, "free", ptr_free, 0); rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass); rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton); }
/* * Method: data * * Gets the internal data stored in the entry. The data depends of the type * of the entry: * * Gst::IndexEntry::ID: the description of the ID, as a String. * * Gst::IndexEntry::ASSOCIATION: an Array that contains the number of associations, a Gst::Format, the value of the format and the association flags (see Gst::Index::AssocFlags). * * Gst::IndexEntry::FORMAT: an Array that contains a Gst::Format and its value. * * Gst::IndexEntry::OBJECt: not yet implemented. * * Returns: the internal data of the entry. */ static VALUE rg_data (VALUE self) { GstIndexEntry *entry; VALUE data; entry = RGST_INDEX_ENTRY (self); switch (entry->type) { case GST_INDEX_ENTRY_ID: data = CSTR2RVAL (entry->data.id.description); break; case GST_INDEX_ENTRY_ASSOCIATION: data = rb_ary_new (); rb_ary_push (data, INT2FIX (entry->data.assoc.nassocs)); rb_ary_push (data, RGST_FORMAT_NEW (entry->data.assoc.assocs->format)); rb_ary_push (data, ULL2NUM (entry->data.assoc.assocs->value)); rb_ary_push (data, GFLAGS2RVAL (entry->data.assoc.flags, GST_TYPE_ASSOC_FLAGS)); break; case GST_INDEX_ENTRY_FORMAT: data = rb_ary_new (); rb_ary_push (data, RGST_FORMAT_NEW (entry->data.format.format)); rb_ary_push (data, CSTR2RVAL (entry->data.format.key)); break; case GST_INDEX_ENTRY_OBJECT: /* TODO */ default: data = Qnil; } return data; }
VALUE port_from( const struct ofp_phy_port *phy_port, uint64_t datapath_id ) { VALUE attributes = rb_hash_new(); rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "number" ) ), UINT2NUM( phy_port->port_no ) ); VALUE hw_addr = rb_funcall( rb_eval_string( "Pio::Mac" ), rb_intern( "new" ), 1, ULL2NUM( mac_to_uint64( phy_port->hw_addr ) ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "hw_addr" ) ), hw_addr ); rb_hash_aset( attributes, ID2SYM( rb_intern( "name" ) ), rb_str_new2( phy_port->name ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "config" ) ), UINT2NUM( phy_port->config ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "state" ) ), UINT2NUM( phy_port->state ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "curr" ) ), UINT2NUM( phy_port->curr ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "advertised" ) ), UINT2NUM( phy_port->advertised ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "supported" ) ), UINT2NUM( phy_port->supported ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "peer" ) ), UINT2NUM( phy_port->peer ) ); return rb_funcall( cPort, rb_intern( "new" ), 1, attributes ); }
void observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_observe_resp_t *resp) { struct context_st *ctx = (struct context_st *)cookie; struct bucket_st *bucket = ctx->bucket; VALUE key, res, *rv = ctx->rv; if (resp->v.v0.key) { key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey); ctx->exception = cb_check_error(error, "failed to execute observe request", key); if (ctx->exception) { cb_gc_protect(bucket, ctx->exception); } res = rb_class_new_instance(0, NULL, cResult); rb_ivar_set(res, id_iv_completed, Qfalse); rb_ivar_set(res, id_iv_error, ctx->exception); rb_ivar_set(res, id_iv_operation, sym_observe); rb_ivar_set(res, id_iv_key, key); rb_ivar_set(res, id_iv_cas, ULL2NUM(resp->v.v0.cas)); rb_ivar_set(res, id_iv_from_master, resp->v.v0.from_master ? Qtrue : Qfalse); rb_ivar_set(res, id_iv_time_to_persist, ULONG2NUM(resp->v.v0.ttp)); rb_ivar_set(res, id_iv_time_to_replicate, ULONG2NUM(resp->v.v0.ttr)); switch (resp->v.v0.status) { case LCB_OBSERVE_FOUND: rb_ivar_set(res, id_iv_status, sym_found); break; case LCB_OBSERVE_PERSISTED: rb_ivar_set(res, id_iv_status, sym_persisted); break; case LCB_OBSERVE_NOT_FOUND: rb_ivar_set(res, id_iv_status, sym_not_found); break; default: rb_ivar_set(res, id_iv_status, Qnil); } if (bucket->async) { /* asynchronous */ if (ctx->proc != Qnil) { cb_proc_call(ctx->proc, 1, res); } } else { /* synchronous */ if (NIL_P(ctx->exception)) { VALUE stats = rb_hash_aref(*rv, key); if (NIL_P(stats)) { stats = rb_ary_new(); rb_hash_aset(*rv, key, stats); } rb_ary_push(stats, res); } } } else { if (bucket->async && ctx->proc != Qnil) { res = rb_class_new_instance(0, NULL, cResult); rb_ivar_set(res, id_iv_completed, Qtrue); cb_proc_call(ctx->proc, 1, res); } ctx->nqueries--; cb_gc_unprotect(bucket, ctx->proc); } (void)handle; }
void ruby_libvirt_typed_params_to_hash(void *voidparams, int i, VALUE hash) { virTypedParameterPtr params = (virTypedParameterPtr)voidparams; VALUE val; switch (params[i].type) { case VIR_TYPED_PARAM_INT: val = INT2NUM(params[i].value.i); break; case VIR_TYPED_PARAM_UINT: val = UINT2NUM(params[i].value.ui); break; case VIR_TYPED_PARAM_LLONG: val = LL2NUM(params[i].value.l); break; case VIR_TYPED_PARAM_ULLONG: val = ULL2NUM(params[i].value.ul); break; case VIR_TYPED_PARAM_DOUBLE: val = rb_float_new(params[i].value.d); break; case VIR_TYPED_PARAM_BOOLEAN: val = (params[i].value.b == 0) ? Qfalse : Qtrue; break; case VIR_TYPED_PARAM_STRING: val = rb_str_new2(params[i].value.s); break; default: rb_raise(rb_eArgError, "Invalid parameter type"); } rb_hash_aset(hash, rb_str_new2(params[i].field), val); }
static VALUE value_from_default(const upb_fielddef *field) { switch (upb_fielddef_type(field)) { case UPB_TYPE_FLOAT: return DBL2NUM(upb_fielddef_defaultfloat(field)); case UPB_TYPE_DOUBLE: return DBL2NUM(upb_fielddef_defaultdouble(field)); case UPB_TYPE_BOOL: return upb_fielddef_defaultbool(field) ? Qtrue : Qfalse; case UPB_TYPE_MESSAGE: return Qnil; case UPB_TYPE_ENUM: { const upb_enumdef *enumdef = upb_fielddef_enumsubdef(field); int32_t num = upb_fielddef_defaultint32(field); const char *label = upb_enumdef_iton(enumdef, num); if (label) { return ID2SYM(rb_intern(label)); } else { return INT2NUM(num); } } case UPB_TYPE_INT32: return INT2NUM(upb_fielddef_defaultint32(field)); case UPB_TYPE_INT64: return LL2NUM(upb_fielddef_defaultint64(field));; case UPB_TYPE_UINT32: return UINT2NUM(upb_fielddef_defaultuint32(field)); case UPB_TYPE_UINT64: return ULL2NUM(upb_fielddef_defaultuint64(field)); case UPB_TYPE_STRING: case UPB_TYPE_BYTES: { size_t size; const char *str = upb_fielddef_defaultstr(field, &size); return rb_str_new(str, size); } default: return Qnil; } }
static int servlet_run(lua_State *l) { VALUE servlet = (VALUE)lua_touserdata(l, lua_upvalueindex(1)); VALUE ptr = ULL2NUM((unsigned long long)l); rb_funcall(servlet, rb_intern("call"), 1, ptr); return 0; }
VALUE layout_get_default(const upb_fielddef *field) { switch (upb_fielddef_type(field)) { case UPB_TYPE_FLOAT: return DBL2NUM(upb_fielddef_defaultfloat(field)); case UPB_TYPE_DOUBLE: return DBL2NUM(upb_fielddef_defaultdouble(field)); case UPB_TYPE_BOOL: return upb_fielddef_defaultbool(field) ? Qtrue : Qfalse; case UPB_TYPE_MESSAGE: return Qnil; case UPB_TYPE_ENUM: { const upb_enumdef *enumdef = upb_fielddef_enumsubdef(field); int32_t num = upb_fielddef_defaultint32(field); const char *label = upb_enumdef_iton(enumdef, num); if (label) { return ID2SYM(rb_intern(label)); } else { return INT2NUM(num); } } case UPB_TYPE_INT32: return INT2NUM(upb_fielddef_defaultint32(field)); case UPB_TYPE_INT64: return LL2NUM(upb_fielddef_defaultint64(field));; case UPB_TYPE_UINT32: return UINT2NUM(upb_fielddef_defaultuint32(field)); case UPB_TYPE_UINT64: return ULL2NUM(upb_fielddef_defaultuint64(field)); case UPB_TYPE_STRING: case UPB_TYPE_BYTES: { size_t size; const char *str = upb_fielddef_defaultstr(field, &size); VALUE str_rb = rb_str_new(str, size); rb_enc_associate(str_rb, (upb_fielddef_type(field) == UPB_TYPE_BYTES) ? kRubyString8bitEncoding : kRubyStringUtf8Encoding); rb_obj_freeze(str_rb); return str_rb; } default: return Qnil; } }
VALUE native_slot_get(upb_fieldtype_t type, VALUE type_class, const void* memory) { switch (type) { case UPB_TYPE_FLOAT: return DBL2NUM(DEREF(memory, float)); case UPB_TYPE_DOUBLE: return DBL2NUM(DEREF(memory, double)); case UPB_TYPE_BOOL: return DEREF(memory, int8_t) ? Qtrue : Qfalse; case UPB_TYPE_STRING: case UPB_TYPE_BYTES: case UPB_TYPE_MESSAGE: return DEREF(memory, VALUE); case UPB_TYPE_ENUM: { int32_t val = DEREF(memory, int32_t); VALUE symbol = enum_lookup(type_class, INT2NUM(val)); if (symbol == Qnil) { return INT2NUM(val); } else { return symbol; } } case UPB_TYPE_INT32: return INT2NUM(DEREF(memory, int32_t)); case UPB_TYPE_INT64: return LL2NUM(DEREF(memory, int64_t)); case UPB_TYPE_UINT32: return UINT2NUM(DEREF(memory, uint32_t)); case UPB_TYPE_UINT64: return ULL2NUM(DEREF(memory, uint64_t)); default: return Qnil; } }
void handle_switch_disconnected( uint64_t datapath_id, void *user_data ) { VALUE controller = ( VALUE ) user_data; if ( rb_respond_to( controller, rb_intern( "switch_disconnected" ) ) == Qfalse ) { return; } rb_funcall( controller, rb_intern( "switch_disconnected" ), 1, ULL2NUM( datapath_id ) ); }
static VALUE image_hash_for(VALUE self, VALUE _filename) { char * filename = StringValuePtr(_filename); ulong64 hash; if (-1 == ph_dct_imagehash(filename, hash)) { rb_raise(rb_eRuntimeError, "Unknown pHash error"); } return ULL2NUM(hash); }
static VALUE packet_in_datapath_id( VALUE self ) { packet_in *cpacket; Data_Get_Struct( self, packet_in, cpacket ); return ULL2NUM( cpacket->datapath_id ); }
VALUE method_disk(VALUE self, VALUE path) { VALUE disk = Qnil; struct statfs stat; if (statfs(StringValueCStr(path), &stat) != -1) { disk = rb_hash_new(); rb_hash_aset(disk, SYM_TYPE, ID2SYM(rb_intern(stat.f_fstypename))); rb_hash_aset(disk, SYM_ORIGIN, rb_str_new(stat.f_mntfromname, strlen(stat.f_mntfromname))); rb_hash_aset(disk, SYM_MOUNT, rb_str_new(stat.f_mntonname, strlen(stat.f_mntonname))); rb_hash_aset(disk, SYM_FREE_BYTES, ULL2NUM(stat.f_bfree * stat.f_bsize)); rb_hash_aset(disk, SYM_AVAILABLE_BYTES, ULL2NUM(stat.f_bavail * stat.f_bsize)); rb_hash_aset(disk, SYM_USED_BYTES, ULL2NUM((stat.f_blocks - stat.f_bfree) * stat.f_bsize)); rb_hash_aset(disk, SYM_TOTAL_BYTES, ULL2NUM(stat.f_blocks * stat.f_bsize)); } return disk; }
/** * call-seq: * interval.stop_instant -> Integer * * The integer representing the stop instant of the Interval. This value * is not useful on its own. It is a platform dependent value. */ VALUE hitimes_interval_stop_instant( VALUE self ) { hitimes_interval_t *i; Data_Get_Struct( self, hitimes_interval_t, i ); return ULL2NUM( i->stop_instant ); }
static VALUE rb_mysql_client_thread_id(VALUE self) { unsigned long retVal; GET_CLIENT(self); REQUIRE_OPEN_DB(wrapper); retVal = mysql_thread_id(wrapper->client); return ULL2NUM(retVal); }
static VALUE prof_measure_allocations(VALUE self) { #if defined(HAVE_LONG_LONG) return ULL2NUM(measure_allocations()); #else return ULONG2NUM(measure_allocations()); #endif }
/* * call-seq: ptr.address * @return [Numeric] pointer's base address * Return +self+'s base address (alias: #to_i). */ static VALUE ptr_address(VALUE self) { Pointer* ptr; Data_Get_Struct(self, Pointer, ptr); return ULL2NUM((uintptr_t) ptr->memory.address); }
VALUE na_address(VALUE self) { struct NARRAY *ary; void * ptr; VALUE ret; GetNArray(self,ary); ptr = ary->ptr; ret = ULL2NUM( sizeof(ptr) == 4 ? (unsigned long long int) (unsigned long int) ptr : (unsigned long long int) ptr ); return ret; }
void handle_openflow_error( uint64_t datapath_id, uint32_t transaction_id, uint16_t type, uint16_t code, buffer *body, void *user_data ) { VALUE controller = ( VALUE ) user_data; if ( rb_respond_to( controller, rb_intern( "openflow_error" ) ) == Qfalse ) { return; } VALUE attributes = rb_hash_new(); rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( transaction_id ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "type" ) ), UINT2NUM( type ) ); rb_hash_aset( attributes, ID2SYM( rb_intern( "code" ) ), UINT2NUM( code ) ); switch ( type ) { case OFPET_HELLO_FAILED: case OFPET_BAD_REQUEST: case OFPET_BAD_ACTION: case OFPET_FLOW_MOD_FAILED: case OFPET_PORT_MOD_FAILED: case OFPET_QUEUE_OP_FAILED: { if ( body != NULL ) { if ( body->length ) { rb_hash_aset( attributes, ID2SYM( rb_intern( "data" ) ), rb_str_new( body->data, ( long ) body->length ) ); } } } break; default: critical( "Un-handled error type ( type = %u ),", type ); break; } VALUE openflow_error = rb_funcall( cOpenflowError, rb_intern( "new" ), 1, attributes ); rb_funcall( controller, rb_intern( "openflow_error" ), 2, ULL2NUM( datapath_id ), openflow_error ); }
static VALUE rd_attr_raw_value(VALUE self) { rd_attr_t *attr = GetAttr(self); Dwarf_Half form; Dwarf_Error err; union { Dwarf_Addr addr; Dwarf_Off off; Dwarf_Unsigned udata; Dwarf_Signed sdata; Dwarf_Bool bool; char *str; } val; VALUE top; chkerr1(dwarf_whatform(attr->attr, &form, &err), &err, self); switch (form) { case DW_FORM_addr: chkerr1(dwarf_formaddr(attr->attr, &val.addr, &err), &err, self); return ULL2NUM(val.addr); case DW_FORM_ref1: case DW_FORM_ref2: case DW_FORM_ref4: case DW_FORM_ref8: case DW_FORM_ref_udata: chkerr1(dwarf_global_formref(attr->attr, &val.off, &err), &err, self); top = rb_ivar_get(self, id_at_top); return rdwarf_die_at(top, LL2NUM(val.off)); case DW_FORM_data1: case DW_FORM_data2: case DW_FORM_data4: case DW_FORM_data8: case DW_FORM_udata: chkerr1(dwarf_formudata(attr->attr, &val.udata, &err), &err, self); return ULL2NUM(val.udata); case DW_FORM_sdata: chkerr1(dwarf_formsdata(attr->attr, &val.sdata, &err), &err, self); return LL2NUM(val.sdata); case DW_FORM_flag: chkerr1(dwarf_formflag(attr->attr, &val.bool, &err), &err, self); return val.bool ? Qtrue : Qfalse; case DW_FORM_strp: case DW_FORM_string: chkerr1(dwarf_formstring(attr->attr, &val.str, &err), &err, self); return rb_str_new_cstr(val.str); } return sym_unsupported_type; }