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)); }
static VALUE rd_die_new(rd_shared_data_t *sd, VALUE top, VALUE cu, Dwarf_Die die) { rd_die_t *rd_die; Dwarf_Off off; Dwarf_Half tag; Dwarf_Error err; VALUE obj; VALUE klass; chkerr1(dwarf_dieoffset(die, &off, &err), &err, Qnil); obj = rb_hash_aref(sd->off2die, LL2NUM(off)); if (!NIL_P(obj)) { return obj; } chkerr1(dwarf_tag(die, &tag, &err), &err, Qnil); klass = rb_hash_aref(rdwarf_tag2class, INT2FIX(tag)); if (NIL_P(klass)) { rb_raise(rb_eRuntimeError, "unknown tag %d\n", tag); } obj = rd_die_s_alloc(klass); rd_die = GetDie(obj); rd_die->shared_data = rd_shared_data_ref(sd); rd_die->die = die; rb_ivar_set(obj, id_at_top, top); rb_ivar_set(obj, id_at_cu, NIL_P(cu) ? obj : cu); rb_hash_aset(sd->off2die, LL2NUM(off), obj); return obj; }
static VALUE array_from_stat(const struct Stat* stat) { return rb_ary_new3(8, LL2NUM(stat->czxid), LL2NUM(stat->mzxid), LL2NUM(stat->ctime), LL2NUM(stat->mtime), INT2NUM(stat->version), INT2NUM(stat->cversion), INT2NUM(stat->aversion), LL2NUM(stat->ephemeralOwner)); }
static VALUE rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk, grn_id range_id, VALUE related_object, VALUE *rb_value) { grn_bool success = GRN_TRUE; switch (range_id) { case GRN_DB_VOID: *rb_value = rb_str_new(GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk)); break; case GRN_DB_BOOL: *rb_value = GRN_BOOL_VALUE(bulk) ? Qtrue : Qfalse; break; case GRN_DB_INT32: *rb_value = INT2NUM(GRN_INT32_VALUE(bulk)); break; case GRN_DB_UINT32: *rb_value = UINT2NUM(GRN_UINT32_VALUE(bulk)); break; case GRN_DB_INT64: *rb_value = LL2NUM(GRN_INT64_VALUE(bulk)); break; case GRN_DB_UINT64: *rb_value = ULL2NUM(GRN_UINT64_VALUE(bulk)); break; case GRN_DB_FLOAT: *rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk)); break; case GRN_DB_TIME: { int64_t time_value, sec, usec; time_value = GRN_TIME_VALUE(bulk); GRN_TIME_UNPACK(time_value, sec, usec); *rb_value = rb_funcall(rb_cTime, rb_intern("at"), 2, LL2NUM(sec), LL2NUM(usec)); } break; case GRN_DB_SHORT_TEXT: case GRN_DB_TEXT: case GRN_DB_LONG_TEXT: *rb_value = rb_grn_context_rb_string_new(context, GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk)); break; default: success = GRN_FALSE; break; } return success; }
static VALUE convert_parse(VALUE self) { GstFormat src_format, dest_format; gint64 src_value, dest_value; gst_query_parse_convert(RVAL2GST_QUERY(self), &src_format, &src_value, &dest_format, &dest_value); return rb_ary_new3(4, GST_FORMAT2RVAL(src_format), LL2NUM(src_value), RVAL2GST_FORMAT(dest_format), LL2NUM(dest_value)); }
/** Extract result information from the given result */ static VALUE rdo_mysql_result_info_new(MYSQL * conn, MYSQL_RES * res) { unsigned long long count = (res == NULL) ? 0 : mysql_num_rows(res); VALUE info = rb_hash_new(); rb_hash_aset(info, ID2SYM(rb_intern("count")), LL2NUM(count)); rb_hash_aset(info, ID2SYM(rb_intern("insert_id")), LL2NUM(mysql_insert_id(conn))); rb_hash_aset(info, ID2SYM(rb_intern("affected_rows")), LL2NUM(mysql_affected_rows(conn))); return info; }
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 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 buffersize_parse(VALUE self) { GstFormat format; gint64 minsize; gint64 maxsize; gboolean async; gst_event_parse_buffer_size(RGST_EVENT(self), &format, &minsize, &maxsize, &async); return rb_ary_new3(4, GST_FORMAT2RVAL(format), LL2NUM(minsize), LL2NUM(maxsize), CBOOL2RVAL(async)); }
VALUE FileWrapper::rb_get_size(VALUE self) { File *fl; Data_Get_Struct(self, File, fl); return LL2NUM(fl->get_size()); }
static VALUE newsegment_parse(VALUE self) { gboolean update; gdouble rate, applied_rate; GstFormat format; gint64 start, stop, position; gst_event_parse_new_segment_full(RGST_EVENT(self), &update, &rate, &applied_rate, &format, &start, &stop, &position); return rb_ary_new3(7, CBOOL2RVAL(update), DBL2NUM(update), DBL2NUM(rate), GST_FORMAT2RVAL(format), LL2NUM(start), LL2NUM(stop), LL2NUM(position)); }
/* Get the current file position */ static VALUE buffered_file_pos(VALUE self) { VALUE parent_pos = rb_call_super(0, NULL); long long ll_pos = NUM2LL(parent_pos); long buffer_length = RSTRING_LEN(rb_ivar_get(self, id_ivar_buffer)); long buffer_index = FIX2INT(rb_ivar_get(self, id_ivar_buffer_index)); return LL2NUM(ll_pos - (long long)(buffer_length - buffer_index)); }
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; } }
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 cQuery_searchcount(VALUE vself){ VALUE vqry; RDBQRY *qry; vqry = rb_iv_get(vself, RDBQRYVNDATA); Data_Get_Struct(vqry, RDBQRY, qry); return LL2NUM(tcrdbqrysearchcount(qry)); }
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; } }
static void process_ways(VALUE out, OSMPBF__PrimitiveGroup *group, OSMPBF__StringTable *string_table, int32_t ts_granularity) { unsigned j, k; size_t i = 0; for(i = 0; i < group->n_ways; i++) { OSMPBF__Way *way = group->ways[i]; int64_t delta_refs = 0; VALUE way_out = rb_hash_new(); rb_hash_aset(way_out, STR2SYM("id"), LL2NUM(way->id)); // Extract tags VALUE tags = rb_hash_new(); for(j = 0; j < way->n_keys; j++) { char *key = parse_binary_str(string_table->s[way->keys[j]]); char *value = parse_binary_str(string_table->s[way->vals[j]]); rb_hash_aset(tags, str_new(key), str_new(value)); free(key); free(value); } // Extract refs VALUE refs = rb_ary_new(); for(k = 0; k < way->n_refs; k++) { delta_refs += way->refs[k]; rb_ary_push(refs, LL2NUM(delta_refs)); } // Extract info if(way->info) add_info(way_out, way->info, string_table, ts_granularity); rb_hash_aset(way_out, STR2SYM("tags"), tags); rb_hash_aset(way_out, STR2SYM("refs"), refs); rb_ary_push(out, way_out); } }
/* call-seq: last_insert_row_id * * Obtains the unique row ID of the last row to be inserted by this Database * instance. */ static VALUE last_insert_row_id(VALUE self) { sqlite3RubyPtr ctx; Data_Get_Struct(self, sqlite3Ruby, ctx); REQUIRE_OPEN_DB(ctx); return LL2NUM(sqlite3_last_insert_rowid(ctx->db)); }
/* * Returns the array's pointer */ static VALUE pointer (VALUE self) { #if __x86_64__ return LL2NUM((long long) RARRAY_PTR(self)); #else return LONG2NUM((long) RARRAY_PTR(self)); #endif }
static VALUE rd_die_die_cu_offset(VALUE self) { rd_die_t *die = GetDie(self); Dwarf_Off off; Dwarf_Error err; chkerr1(dwarf_die_CU_offset(die->die, &off, &err), &err, self); return LL2NUM(off); }
static VALUE duration_parse(VALUE self) { GstFormat format; gint64 duration; gst_message_parse_duration(SELF(self), &format, &duration); return rb_ary_new3(2, GST_FORMAT2RVAL(format), LL2NUM(duration)); }
static VALUE segment_done_parse(VALUE self) { GstFormat format; gint64 position; gst_message_parse_segment_done(SELF(self), &format, &position); return rb_ary_new3(2, GST_FORMAT2RVAL(format), LL2NUM(position)); }
static inline VALUE timespec2num(const struct timespec *ts) { #ifdef HAVE_LONG_LONG if (!MUL_OVERFLOW_SIGNED_INTEGER_P(1000000000, (LONG_LONG)ts->tv_sec, LLONG_MIN, LLONG_MAX-999999999)) { return LL2NUM(ts->tv_nsec + 1000000000 * (LONG_LONG)ts->tv_sec); } #endif return rb_funcall(LONG2FIX(ts->tv_nsec), '+', 1, rb_funcall(LONG2FIX(1000000000), '*', 1, UINT2NUM(ts->tv_sec))); }
static VALUE seek_parse(VALUE self) { gdouble rate; GstFormat format; GstSeekFlags flags; GstSeekType start_type, stop_type; gint64 start, stop; gst_event_parse_seek(RGST_EVENT(self), &rate, &format, &flags, &start_type, &start, &stop_type, &stop); return rb_ary_new3(6, DBL2NUM(rate), GST_FORMAT2RVAL(format), GFLAGS2RVAL(start_type, GST_TYPE_SEEK_FLAGS), LL2NUM(start), GFLAGS2RVAL(stop_type, GST_TYPE_SEEK_FLAGS), LL2NUM(stop)); }
static VALUE latency_parse(VALUE self) { GstClockTime latency; gst_event_parse_latency(RGST_EVENT(self), &latency); return LL2NUM(latency); }
int ltns_parse_num(const char* payload, size_t length, VALUE* out) { char *end; long long parsed_val = strtoll(payload, &end, 10); if (end != (payload + length) || *end != LTNS_INTEGER) return FALSE; *out = LL2NUM(parsed_val); return TRUE; }
/* this is called only from a method_get_latest_event, so the hash is allocated on the proper thread stack */ VALUE zkrb_event_to_ruby(zkrb_event_t *event) { VALUE hash = rb_hash_new(); rb_hash_aset(hash, GET_SYM("req_id"), LL2NUM(event->req_id)); if (event->type != ZKRB_WATCHER) rb_hash_aset(hash, GET_SYM("rc"), INT2FIX(event->rc)); switch (event->type) { case ZKRB_DATA: { struct zkrb_data_completion *data_ctx = event->completion.data_completion; if (ZKRBDebugging) zkrb_print_stat(data_ctx->stat); rb_hash_aset(hash, GET_SYM("data"), data_ctx->data ? rb_str_new2(data_ctx->data) : Qnil); rb_hash_aset(hash, GET_SYM("stat"), data_ctx->stat ? zkrb_stat_to_rarray(data_ctx->stat) : Qnil); break; } case ZKRB_STAT: { struct zkrb_stat_completion *stat_ctx = event->completion.stat_completion; rb_hash_aset(hash, GET_SYM("stat"), stat_ctx->stat ? zkrb_stat_to_rarray(stat_ctx->stat) : Qnil); break; } case ZKRB_STRING: { struct zkrb_string_completion *string_ctx = event->completion.string_completion; rb_hash_aset(hash, GET_SYM("string"), string_ctx->value ? rb_str_new2(string_ctx->value) : Qnil); break; } case ZKRB_STRINGS: { struct zkrb_strings_completion *strings_ctx = event->completion.strings_completion; rb_hash_aset(hash, GET_SYM("strings"), strings_ctx->values ? zkrb_string_vector_to_ruby(strings_ctx->values) : Qnil); break; } case ZKRB_STRINGS_STAT: { struct zkrb_strings_stat_completion *strings_stat_ctx = event->completion.strings_stat_completion; rb_hash_aset(hash, GET_SYM("strings"), strings_stat_ctx->values ? zkrb_string_vector_to_ruby(strings_stat_ctx->values) : Qnil); rb_hash_aset(hash, GET_SYM("stat"), strings_stat_ctx->stat ? zkrb_stat_to_rarray(strings_stat_ctx->stat) : Qnil); break; } case ZKRB_ACL: { struct zkrb_acl_completion *acl_ctx = event->completion.acl_completion; rb_hash_aset(hash, GET_SYM("acl"), acl_ctx->acl ? zkrb_acl_vector_to_ruby(acl_ctx->acl) : Qnil); rb_hash_aset(hash, GET_SYM("stat"), acl_ctx->stat ? zkrb_stat_to_rarray(acl_ctx->stat) : Qnil); break; } case ZKRB_WATCHER: { struct zkrb_watcher_completion *watcher_ctx = event->completion.watcher_completion; rb_hash_aset(hash, GET_SYM("type"), INT2FIX(watcher_ctx->type)); rb_hash_aset(hash, GET_SYM("state"), INT2FIX(watcher_ctx->state)); rb_hash_aset(hash, GET_SYM("path"), watcher_ctx->path ? rb_str_new2(watcher_ctx->path) : Qnil); break; } case ZKRB_VOID: default: break; } return hash; }
static VALUE position_parse(VALUE self) { GstFormat format; gint64 cur; gst_query_parse_position(RVAL2GST_QUERY(self), &format, &cur); return rb_ary_new3(2, GST_FORMAT2RVAL(format), LL2NUM(cur)); }
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; }