static VALUE t_get_idle_time (VALUE self, VALUE from)
{
try{
uint64_t current_time = evma_get_current_loop_time();
uint64_t time = evma_get_last_activity_time(NUM2ULONG (from));
if (current_time != 0 && time != 0) {
if (time >= current_time)
return ULONG2NUM(0);
else {
uint64_t diff = current_time - time;
float seconds = diff / (1000.0*1000.0);
return rb_float_new(seconds);
}
return Qnil;
}
} catch (std::runtime_error e) {
rb_raise (EM_eConnectionError, "%s", e.what());
}
return Qnil;
}
static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE port, VALUE database, VALUE socket, VALUE flags) {
struct nogvl_connect_args args;
GET_CLIENT(self);
args.host = NIL_P(host) ? "localhost" : StringValuePtr(host);
args.unix_socket = NIL_P(socket) ? NULL : StringValuePtr(socket);
args.port = NIL_P(port) ? 3306 : NUM2INT(port);
args.user = NIL_P(user) ? NULL : StringValuePtr(user);
args.passwd = NIL_P(pass) ? NULL : StringValuePtr(pass);
args.db = NIL_P(database) ? NULL : StringValuePtr(database);
args.mysql = wrapper->client;
args.client_flag = NUM2ULONG(flags);
if (rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0) == Qfalse) {
// unable to connect
return rb_raise_mysql2_error(wrapper);
}
return self;
}
VALUE cntheory_binomial(VALUE self, VALUE operand1, VALUE operand2)
{
basic_struct *cresult;
VALUE result;
basic cbasic_operand1;
basic_new_stack(cbasic_operand1);
sympify(operand1, cbasic_operand1);
unsigned long cbasic_operand2;
cbasic_operand2 = NUM2ULONG(operand2);
cresult = basic_new_heap();
ntheory_binomial(cresult, cbasic_operand1, cbasic_operand2);
result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL, cbasic_free_heap,
cresult);
basic_free_stack(cbasic_operand1);
return result;
}
/*
* @overload [](id)
* @param [Integer] id
* @return [Ray::GL::Vertex, Ray::Vertex] The vertex at the given index.
*/
static
VALUE ray_gl_buffer_get(VALUE self, VALUE i) {
say_buffer *buf = ray_rb2buffer(self);
size_t size = say_buffer_get_size(buf);
size_t index = NUM2ULONG(i);
if (index >= size)
return Qnil;
VALUE klass = rb_iv_get(self, "@vertex_type");
VALUE object = rb_funcall(klass, RAY_METH("allocate"), 0);
size_t byte_size = NUM2INT(rb_iv_get(klass, "@vertex_type_size"));
void *ptr = NULL;
Data_Get_Struct(object, void, ptr);
memcpy(ptr, say_buffer_get_vertex(buf, index), byte_size);
return object;
}
static VALUE rb_delta_bytes_compress(VALUE self, VALUE rvalues) {
int rlen = RARRAY_LEN(rvalues);
int offset = 0;
uint8_t *dest = (uint8_t*)calloc(5 * rlen, sizeof(uint8_t));
uint32_t previous = 0;
for (int i = 0; i < rlen; i++) {
uint32_t value = NUM2ULONG(rb_ary_entry(rvalues, i));
offset += varint_write_unsigned(value - previous, dest + offset);
previous = value;
}
VALUE rary = rb_ary_new2(offset);
for (int i = 0; i < offset; i++) {
rb_ary_push(rary, INT2NUM(dest[i]));
}
free(dest);
return rary;
}
/**
* initialize
**/
static VALUE
t_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE ary_element;
root_node root;
unsigned long i, len;
Data_Get_Struct(self, struct _root_node, root);
if (argc == 1 && TYPE(argv[0]) == T_ARRAY) {
len = RARRAY_LEN(argv[0]);
for(i = 0; i < len; i++) {
ary_element = rb_ary_entry(argv[0], i);
if ((TYPE(ary_element) == T_FIXNUM) && VALID_MIN_VALUE <= ary_element && VALID_MAX_VALUE >= ary_element) {
add_num(root, NUM2ULONG(ary_element));
}
}
}
return self;
}
/**
* sample
**/
static VALUE t_sample(int argc, VALUE *argv, VALUE self)
{
root_node root;
VALUE array;
unsigned long sample_count = 1UL;
Data_Get_Struct(self, struct _root_node, root);
if (argc == 1 && TYPE(argv[0]) == T_FIXNUM) {
sample_count = NUM2ULONG(argv[0]);
if (sample_count < 1UL || sample_count > root->size) sample_count = 1UL;
}
array = rb_ary_new2(sample_count);
if (sample_count == root->size) {
to_array(root, array);
} else if (root->size) {
sample(root, array, sample_count);
}
return array;
}
static VALUE rb_ReadConsoleOutputAttribute( VALUE self, VALUE hConsoleOutput,
VALUE len, VALUE x, VALUE y )
{
HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );
COORD coords;
DWORD nofread;
unsigned short abuffer[80*999*sizeof(unsigned short)];
char cbuffer[80*999];
unsigned i = 0;
coords.X= NUM2UINT( x );
coords.Y= NUM2UINT( y );
if (ReadConsoleOutputAttribute(handle, abuffer, NUM2UINT(len),
coords,&nofread))
{
for(i=0;i<nofread;++i) {
cbuffer[i]=(char)abuffer[i];
}
return rb_str_new( cbuffer, nofread );
}
return rb_getWin32Error();
}
static VALUE
rg_s_define_class(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
{
VALUE rb_class;
VALUE rb_gtype, rb_name, rb_module;
VALUE rb_options, rb_parent, rb_size;
GType gtype;
rb_scan_args(argc, argv, "31", &rb_gtype, &rb_name, &rb_module, &rb_options);
rbg_scan_options(rb_options,
"parent", &rb_parent,
"size", &rb_size,
NULL);
gtype = NUM2ULONG(rb_to_int(rb_gtype));
rb_class = G_DEF_CLASS_WITH_PARENT(gtype, RVAL2CSTR(rb_name),
rb_module, rb_parent);
if (!NIL_P(rb_size)) {
rb_iv_set(rb_class, "@size", rb_size);
}
return rb_class;
}
static VALUE
rg_s_define_error(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
{
VALUE rb_domain, rb_name, rb_module;
VALUE rb_options, rb_parent, rb_gtype;
GQuark domain;
const gchar *name;
GType gtype = G_TYPE_INVALID;
rb_scan_args(argc, argv, "31",
&rb_domain, &rb_name, &rb_module, &rb_options);
rbg_scan_options(rb_options,
"parent", &rb_parent,
"gtype", &rb_gtype,
NULL);
if (RB_TYPE_P(rb_domain, RUBY_T_STRING)) {
domain = g_quark_from_string(RVAL2CSTR(rb_domain));
if (domain == 0) {
rb_raise(rb_eArgError,
"invalid domain name: <%s>",
rbg_inspect(rb_domain));
}
} else {
domain = NUM2UINT(rb_domain);
}
name = RVAL2CSTR(rb_name);
if (NIL_P(rb_parent)) {
rb_parent = rb_eStandardError;
}
if (!NIL_P(rb_gtype)) {
gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
}
return G_DEF_ERROR(domain, name, rb_module, rb_parent, gtype);
}
static VALUE t_get_peer_cert (VALUE self, VALUE signature)
{
VALUE ret = Qnil;
#ifdef WITH_SSL
X509 *cert = NULL;
BUF_MEM *buf;
BIO *out;
cert = evma_get_peer_cert (NUM2ULONG (signature));
if (cert != NULL) {
out = BIO_new(BIO_s_mem());
PEM_write_bio_X509(out, cert);
BIO_get_mem_ptr(out, &buf);
ret = rb_str_new(buf->data, buf->length);
X509_free(cert);
BIO_free(out);
}
#endif
return ret;
}
/**
* Generate the next object id.
*/
VALUE rb_bson_object_id_generator_next(int argc, VALUE* args, VALUE self)
{
char bytes[12];
uint32_t t;
uint32_t c;
uint16_t pid = BSON_UINT16_TO_BE(getpid());
if (argc == 0 || (argc == 1 && *args == Qnil)) {
t = BSON_UINT32_TO_BE((int) time(NULL));
}
else {
t = BSON_UINT32_TO_BE(NUM2ULONG(rb_funcall(*args, rb_intern("to_i"), 0)));
}
c = BSON_UINT32_TO_BE(rb_bson_object_id_counter << 8);
memcpy(&bytes, &t, 4);
memcpy(&bytes[4], rb_bson_machine_id_hash, 3);
memcpy(&bytes[7], &pid, 2);
memcpy(&bytes[9], (unsigned char*) &c, 3);
rb_bson_object_id_counter++;
return rb_str_new(bytes, 12);
}
/*
* IO.pread(fd, length, offset)
*
* This is similar to the IO.read method, except that it reads from a given
* position in the file without changing the file pointer. And unlike IO.read,
* the +fd+, +length+ and +offset+ arguments are all mandatory.
*/
static VALUE s_io_pread(VALUE klass, VALUE fd, VALUE nbyte, VALUE offset){
struct pread_args args;
VALUE str;
ssize_t nread;
args.fd = NUM2INT(fd);
args.nbyte = NUM2ULONG(nbyte);
args.offset = NUM2OFFT(offset);
str = rb_str_new(NULL, args.nbyte);
args.buf = RSTRING_PTR(str);
#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
nread = (ssize_t)rb_thread_call_without_gvl((void*)nogvl_pread, &args, RUBY_UBF_IO, 0);
#else
nread = (ssize_t)rb_thread_blocking_region(nogvl_pread, &args, RUBY_UBF_IO, 0);
#endif
if (nread == -1)
rb_sys_fail("pread");
if ((size_t)nread != args.nbyte)
rb_str_set_len(str, nread);
return str;
}
static VALUE t_paused_p (VALUE self, VALUE signature)
{
return evma_is_paused(NUM2ULONG (signature)) ? Qtrue : Qfalse;
}
static VALUE t_resume (VALUE self, VALUE signature)
{
return evma_resume(NUM2ULONG (signature)) ? Qtrue : Qfalse;
}
static VALUE t_set_notify_writable (VALUE self, VALUE signature, VALUE mode)
{
evma_set_notify_writable(NUM2ULONG (signature), mode == Qtrue);
return Qnil;
}
static VALUE t_is_notify_writable (VALUE self, VALUE signature)
{
return evma_is_notify_writable(NUM2ULONG (signature)) ? Qtrue : Qfalse;
}
/*********************
t_get_file_descriptor
*********************/
static VALUE t_get_file_descriptor (VALUE self, VALUE signature)
{
return INT2NUM(evma_get_file_descriptor (NUM2ULONG (signature)));
}
static VALUE t_send_data (VALUE self, VALUE signature, VALUE data, VALUE data_length)
{
int b = evma_send_data_to_connection (NUM2ULONG (signature), StringValuePtr (data), FIX2INT (data_length));
return INT2NUM (b);
}
static VALUE t_close_connection (VALUE self, VALUE signature, VALUE after_writing)
{
evma_close_connection (NUM2ULONG (signature), ((after_writing == Qtrue) ? 1 : 0));
return Qnil;
}
static long
rbffi_GetLongValue(int idx, VALUE* argv, FunctionType* fnInfo)
{
VALUE value = argv[idx];
NativeType nativeType = fnInfo->nativeParameterTypes[idx];
int type = TYPE(value);
switch (nativeType) {
case NATIVE_INT8:
return getSignedInt(value, type, -128, 127, "char", fnInfo->rbEnums);
case NATIVE_INT16:
return getSignedInt(value, type, -0x8000, 0x7fff, "short", fnInfo->rbEnums);
case NATIVE_INT32:
case NATIVE_ENUM:
return getSignedInt(value, type, -0x80000000, 0x7fffffff, "int", fnInfo->rbEnums);
case NATIVE_BOOL:
if (type != T_TRUE && type != T_FALSE) {
rb_raise(rb_eTypeError, "Expected a Boolean parameter");
}
return RTEST(value) ? 1 : 0;
case NATIVE_UINT8:
return getUnsignedInt(value, type, 0xff, "unsigned char");
case NATIVE_UINT16:
return getUnsignedInt(value, type, 0xffff, "unsigned short");
case NATIVE_UINT32:
/* Special handling/checking for unsigned 32 bit integers */
return getUnsignedInt32(value, type);
case NATIVE_LONG:
return NUM2LONG(value);
case NATIVE_ULONG:
return NUM2ULONG(value);
#ifdef __x86_64__
case NATIVE_INT64:
if (type != T_FIXNUM && type != T_BIGNUM) {
rb_raise(rb_eTypeError, "Expected an Integer parameter");
}
return NUM2LL(value);
case NATIVE_UINT64:
if (type != T_FIXNUM && type != T_BIGNUM) {
rb_raise(rb_eTypeError, "Expected an Integer parameter");
}
return NUM2ULL(value);
#endif
case NATIVE_STRING:
return (intptr_t) getString(value, type);
case NATIVE_POINTER:
case NATIVE_BUFFER_IN:
case NATIVE_BUFFER_OUT:
case NATIVE_BUFFER_INOUT:
return (intptr_t) getPointer(value, type);
default:
rb_raise(rb_eTypeError, "unsupported integer type %d", nativeType);
return 0;
}
}
static VALUE t_get_comm_inactivity_timeout (VALUE self, VALUE signature)
{
return rb_float_new(evma_get_comm_inactivity_timeout(NUM2ULONG (signature)));
}
static VALUE t_start_tls (VALUE self, VALUE signature)
{
evma_start_tls (NUM2ULONG (signature));
return Qnil;
}
static VALUE t_unwatch_filename (VALUE self, VALUE sig)
{
evma_unwatch_filename(NUM2ULONG (sig));
return Qnil;
}
static VALUE t_unwatch_pid (VALUE self, VALUE sig)
{
evma_unwatch_pid(NUM2ULONG (sig));
return Qnil;
}
static VALUE t_report_connection_error_status (VALUE self, VALUE signature)
{
int b = evma_report_connection_error_status (NUM2ULONG (signature));
return INT2NUM (b);
}
static VALUE t_get_pending_connect_timeout (VALUE self, VALUE signature)
{
return rb_float_new(evma_get_pending_connect_timeout(NUM2ULONG (signature)));
}
static VALUE t_detach_fd (VALUE self, VALUE signature)
{
return INT2NUM(evma_detach_fd (NUM2ULONG (signature)));
}
void
rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTypes,
FFIStorage* paramStorage, void** ffiValues,
VALUE* callbackParameters, int callbackCount, VALUE enums)
{
VALUE callbackProc = Qnil;
FFIStorage* param = ¶mStorage[0];
int i, argidx, cbidx, argCount;
if (paramCount != -1 && paramCount != argc) {
if (argc == (paramCount - 1) && callbackCount == 1 && rb_block_given_p()) {
callbackProc = rb_block_proc();
} else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, paramCount);
}
}
argCount = paramCount != -1 ? paramCount : argc;
for (i = 0, argidx = 0, cbidx = 0; i < argCount; ++i) {
int type = argidx < argc ? TYPE(argv[argidx]) : T_NONE;
ffiValues[i] = param;
switch (paramTypes[i]) {
case NATIVE_INT8:
param->s8 = getSignedInt(argv[argidx++], type, -128, 127, "char", Qnil);
ADJ(param, INT8);
break;
case NATIVE_INT16:
param->s16 = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short", Qnil);
ADJ(param, INT16);
break;
case NATIVE_INT32:
case NATIVE_ENUM:
param->s32 = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int", enums);
ADJ(param, INT32);
break;
case NATIVE_BOOL:
if (type != T_TRUE && type != T_FALSE) {
rb_raise(rb_eTypeError, "wrong argument type (expected a boolean parameter)");
}
param->s8 = argv[argidx++] == Qtrue;
ADJ(param, INT8);
break;
case NATIVE_UINT8:
param->u8 = getUnsignedInt(argv[argidx++], type, 0xff, "unsigned char");
ADJ(param, INT8);
break;
case NATIVE_UINT16:
param->u16 = getUnsignedInt(argv[argidx++], type, 0xffff, "unsigned short");
ADJ(param, INT16);
break;
case NATIVE_UINT32:
/* Special handling/checking for unsigned 32 bit integers */
param->u32 = getUnsignedInt32(argv[argidx++], type);
ADJ(param, INT32);
break;
case NATIVE_INT64:
if (type != T_FIXNUM && type != T_BIGNUM) {
rb_raise(rb_eTypeError, "Expected an Integer parameter");
}
param->i64 = NUM2LL(argv[argidx]);
ADJ(param, INT64);
++argidx;
break;
case NATIVE_UINT64:
if (type != T_FIXNUM && type != T_BIGNUM) {
rb_raise(rb_eTypeError, "Expected an Integer parameter");
}
param->u64 = NUM2ULL(argv[argidx]);
ADJ(param, INT64);
++argidx;
break;
case NATIVE_LONG:
*(ffi_sarg *) param = NUM2LONG(argv[argidx]);
ADJ(param, LONG);
++argidx;
break;
case NATIVE_ULONG:
*(ffi_arg *) param = NUM2ULONG(argv[argidx]);
ADJ(param, LONG);
++argidx;
break;
case NATIVE_FLOAT32:
if (type != T_FLOAT && type != T_FIXNUM) {
rb_raise(rb_eTypeError, "Expected a Float parameter");
}
param->f32 = (float) NUM2DBL(argv[argidx]);
ADJ(param, FLOAT32);
++argidx;
break;
case NATIVE_FLOAT64:
if (type != T_FLOAT && type != T_FIXNUM) {
rb_raise(rb_eTypeError, "Expected a Float parameter");
}
param->f64 = NUM2DBL(argv[argidx]);
ADJ(param, FLOAT64);
++argidx;
break;
case NATIVE_STRING:
param->ptr = getString(argv[argidx++], type);
ADJ(param, ADDRESS);
break;
case NATIVE_POINTER:
case NATIVE_BUFFER_IN:
case NATIVE_BUFFER_OUT:
case NATIVE_BUFFER_INOUT:
param->ptr = getPointer(argv[argidx++], type);
ADJ(param, ADDRESS);
break;
case NATIVE_FUNCTION:
case NATIVE_CALLBACK:
if (callbackProc != Qnil) {
param->ptr = callback_param(callbackProc, callbackParameters[cbidx++]);
} else {
param->ptr = callback_param(argv[argidx], callbackParameters[cbidx++]);
++argidx;
}
ADJ(param, ADDRESS);
break;
case NATIVE_STRUCT:
ffiValues[i] = getPointer(argv[argidx++], type);
break;
default:
rb_raise(rb_eArgError, "Invalid parameter type: %d", paramTypes[i]);
}
}
}
static VALUE t_send_datagram (VALUE self, VALUE signature, VALUE data, VALUE data_length, VALUE address, VALUE port)
{
int b = evma_send_datagram (NUM2ULONG (signature), StringValuePtr (data), FIX2INT (data_length), StringValuePtr(address), FIX2INT(port));
return INT2NUM (b);
}
