/* call-seq:
* window.setSize( new_width, new_height )
*
* Change the size of the rendering region of the window.
*/
static VALUE Window_SetSize( VALUE self, VALUE aWidth, VALUE aHeight )
{
sf::Window *object = NULL;
Data_Get_Struct( self, sf::Window, object );
object->SetSize( FIX2UINT( aWidth ), FIX2UINT( aHeight ) );
return Qnil;
}
/*
* call-seq:
* OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, username = nil, password = nil, dbname = nil) -> connection pool
* OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, connect_string) -> connection pool
*
* Creates a connection pool.
*
* <i>conn_min</i> specifies the minimum number of connections in the
* connection pool. Valid values are 0 and higher.
*
* <i>conn_max</i> specifies the maximum number of connections that
* can be opened to the database. Once this value is reached, no more
* connections are opened. Valid values are 1 and higher.
*
* <i>conn_incr</i> allows the application to set the next increment
* for connections to be opened to the database if the current number
* of connections are less than <i>conn_max</i>. Valid values are 0
* and higher.
*
* <i>username</i> and <i>password</i> are required to establish an
* implicit primary session. When both are nil, external
* authentication is used.
*
* <i>dbname</i> specifies the database server to connect to.
*
* If the number of arguments is four, <i>username</i>,
* <i>password</i> and <i>dbname</i> are extracted from the fourth
* argument <i>connect_string</i>. The syntax is "username/password" or
* "username/password@dbname".
*/
static VALUE oci8_cpool_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE conn_min;
VALUE conn_max;
VALUE conn_incr;
VALUE username;
VALUE password;
VALUE dbname;
oci8_cpool_t *cpool = DATA_PTR(self);
OraText *pool_name;
sb4 pool_name_len;
sword rv;
/* check arguments */
rb_scan_args(argc, argv, "42", &conn_min, &conn_max, &conn_incr,
&username, &password, &dbname);
Check_Type(conn_min, T_FIXNUM);
Check_Type(conn_max, T_FIXNUM);
Check_Type(conn_incr, T_FIXNUM);
if (argc == 4) {
VALUE mode;
VALUE conn_str = username;
OCI8SafeStringValue(conn_str);
oci8_do_parse_connect_string(conn_str, &username, &password, &dbname, &mode);
if (!NIL_P(mode)) {
rb_raise(rb_eArgError, "invalid connect string \"%s\": Connection pooling doesn't support sysdba and sysoper privileges.", RSTRING_PTR(conn_str));
}
} else {
if (!NIL_P(username)) {
OCI8SafeStringValue(username);
}
if (!NIL_P(password)) {
OCI8SafeStringValue(password);
}
if (!NIL_P(dbname)) {
OCI8SafeStringValue(dbname);
}
}
rv = OCIHandleAlloc(oci8_envhp, &cpool->base.hp.ptr, OCI_HTYPE_CPOOL, 0, NULL);
if (rv != OCI_SUCCESS)
oci8_env_raise(oci8_envhp, rv);
cpool->base.type = OCI_HTYPE_CPOOL;
oci_lc(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp,
&pool_name, &pool_name_len,
NIL_P(dbname) ? NULL : RSTRING_ORATEXT(dbname),
NIL_P(dbname) ? 0 : RSTRING_LEN(dbname),
FIX2UINT(conn_min), FIX2UINT(conn_max),
FIX2UINT(conn_incr),
NIL_P(username) ? NULL : RSTRING_ORATEXT(username),
NIL_P(username) ? 0 : RSTRING_LEN(username),
NIL_P(password) ? NULL : RSTRING_ORATEXT(password),
NIL_P(password) ? 0 : RSTRING_LEN(password),
OCI_DEFAULT));
cpool->pool_name = rb_str_new(TO_CHARPTR(pool_name), pool_name_len);
rb_str_freeze(cpool->pool_name);
return Qnil;
}
/*
* Document-method: PinkTrace::StringArray.decode
* call-seq:
* PinkTrace::StringArray.decode(pid, arg, index, [[maxlen=-1], [bitness=PinkTrace::Bitness::DEFAULT]]) -> String or nil
*
* This function decodes the member of the string array pointed by the address
* +arg+. The +index+ argument specifies the index of the member in the string
* array.
*
* Note: If the string array member was NULL, this function returns nil.
*/
VALUE
pinkrb_decode_strarray(int argc, VALUE *argv, VALUE mod)
{
bool nil;
pid_t pid;
unsigned bit, ind;
long arg;
int maxlen;
char *str;
VALUE vpid, varg, vind, vmax, vbit, vret;
switch (rb_scan_args(argc, argv, "32", &vpid, &varg, &vind, &vmax, &vbit)) {
case 3:
maxlen = -1;
bit = PINKTRACE_BITNESS_DEFAULT;
break;
case 4:
maxlen = NUM2INT(vmax);
bit = PINKTRACE_BITNESS_DEFAULT;
break;
case 5:
maxlen = NUM2INT(vmax);
bit = FIX2UINT(vbit);
break;
default:
abort();
}
pid = NUM2PIDT(vpid);
arg = NUM2LONG(varg);
ind = FIX2UINT(vind);
if (maxlen < 0) {
/* Use pink_decode_string_array_member_persistent() */
errno = 0;
str = pink_decode_string_array_member_persistent(pid, bit, arg, ind);
if (!str) {
if (errno)
rb_sys_fail("pink_decode_string_array_member_persistent()");
return Qnil;
}
vret = rb_str_new2(str);
free(str);
return vret;
}
/* Use pink_decode_string_array_member() */
str = ALLOC_N(char, maxlen);
if (!pink_decode_string_array_member(pid, bit, arg, ind, str, maxlen, &nil))
rb_sys_fail("pink_decode_string_array_member()");
if (nil) {
free(str);
return Qnil;
}
vret = rb_str_new2(str);
if (str)
free(str);
return vret;
}
/*
* PhysicsFS::File#read obj_size, num_objects
*
* Read *objCount* objects which are *objSize* each.
* return String instance containing raw data or nil if failure.
* #length of string will reflect real number of objects read.
*/
VALUE physfs_file_read (VALUE self, VALUE objSize, VALUE objCount)
{
int objRead;
void *buffer;
VALUE result;
PHYSFS_File *file;
Data_Get_Struct (self, PHYSFS_File, file);
if (file == 0)
return Qnil; //wasted file - no read possible
buffer = malloc (FIX2UINT(objSize) * FIX2UINT(objCount));
if (buffer == 0)
return Qnil;
objRead = PHYSFS_read (file, buffer, FIX2UINT(objSize), FIX2UINT(objCount));
if (objRead == -1)
{
free (buffer);
return Qnil;
}
result = rb_str_new (buffer, objRead * FIX2UINT(objSize));
free (buffer);
return result;
}
static VALUE
rg_add(VALUE self, VALUE target, VALUE flags, VALUE info)
{
gtk_target_list_add(_SELF(self), RVAL2ATOM(target),
FIX2UINT(flags), FIX2UINT(info));
return self;
}
/* call-seq:
* window.setCursorPosition( new_x, new_y )
*
* Change the position of the mouse cursor.
*/
static VALUE Window_SetCursorPosition( VALUE self, VALUE aX, VALUE aY )
{
sf::Window *object = NULL;
Data_Get_Struct( self, sf::Window, object );
object->SetCursorPosition( FIX2UINT( aX ), FIX2UINT( aY ) );
return Qnil;
}
/*
* call-seq:
* session_begin(cred, mode)
*
* <b>internal use only</b>
*
* Begins the session by the OCI function OCISessionBegin().
*/
static VALUE oci8_session_begin(VALUE self, VALUE cred, VALUE mode)
{
oci8_svcctx_t *svcctx = DATA_PTR(self);
if (svcctx->logoff_strategy != &complex_logoff) {
rb_raise(rb_eRuntimeError, "Use this method only for the service context handle created by OCI8#server_handle().");
}
if (svcctx->state & OCI8_STATE_SESSION_BEGIN_WAS_CALLED) {
rb_raise(rb_eRuntimeError, "Could not use this method twice.");
}
/* check arguments */
Check_Type(cred, T_FIXNUM);
Check_Type(mode, T_FIXNUM);
/* begin session */
oci_lc(OCISessionBegin_nb(svcctx, svcctx->base.hp.ptr, oci8_errhp,
svcctx->usrhp, FIX2UINT(cred),
FIX2UINT(mode)));
oci_lc(OCIAttrSet(svcctx->base.hp.ptr, OCI_HTYPE_SVCCTX,
svcctx->usrhp, 0, OCI_ATTR_SESSION,
oci8_errhp));
svcctx->state |= OCI8_STATE_SESSION_BEGIN_WAS_CALLED;
return Qnil;
}
void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options)
{
if (!NIL_P(rb_options)) {
VALUE rb_value;
Check_Type(rb_options, T_HASH);
rb_value = rb_hash_aref(rb_options, CSTR2SYM("rename_threshold"));
if (!NIL_P(rb_value)) {
Check_Type(rb_value, T_FIXNUM);
opts->rename_threshold = FIX2UINT(rb_value);
}
rb_value = rb_hash_aref(rb_options, CSTR2SYM("target_limit"));
if (!NIL_P(rb_value)) {
Check_Type(rb_value, T_FIXNUM);
opts->target_limit = FIX2UINT(rb_value);
}
rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
if (!NIL_P(rb_value)) {
ID id_favor;
Check_Type(rb_value, T_SYMBOL);
id_favor = SYM2ID(rb_value);
if (id_favor == rb_intern("normal")) {
opts->file_favor = GIT_MERGE_FILE_FAVOR_NORMAL;
} else if (id_favor == rb_intern("ours")) {
opts->file_favor = GIT_MERGE_FILE_FAVOR_OURS;
} else if (id_favor == rb_intern("theirs")) {
opts->file_favor = GIT_MERGE_FILE_FAVOR_THEIRS;
} else if (id_favor == rb_intern("union")) {
opts->file_favor = GIT_MERGE_FILE_FAVOR_UNION;
} else {
rb_raise(rb_eTypeError,
"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
}
}
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("renames")))) {
opts->flags |= GIT_MERGE_FIND_RENAMES;
}
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("fail_on_conflict")))) {
opts->flags |= GIT_MERGE_FAIL_ON_CONFLICT;
}
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("skip_reuc")))) {
opts->flags |= GIT_MERGE_SKIP_REUC;
}
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("no_recursive")))) {
opts->flags |= GIT_MERGE_NO_RECURSIVE;
}
}
}
/* call-seq:
* window.size=( vector2 )
*
* Change the size of the rendering region of the window.
*/
static VALUE Window_SetSize2( VALUE self, VALUE anArgument )
{
VALUE argument = Vector2_ForceType( anArgument );
sf::Window *object = NULL;
Data_Get_Struct( self, sf::Window, object );
VALUE argumentX = Vector2_GetX( argument );
VALUE argumentY = Vector2_GetY( argument );
object->SetSize( FIX2UINT( argumentX ), FIX2UINT( argumentY ) );
return Qnil;
}
/* call-seq:
* fill( color )
* fill( color, start [, length] )
* fill( color, range )
* fill { |index| block }
* fill( start [, length] ) { |index| block }
* fill( range ) { |index| block }
*
* Set the selected LEDs to the given `color`. The `color` msut be given as a
* 24-bit RGB value. You can also supply a block that receives an LED index and
* returns a 24-bit RGB color.
*
* Examples:
* leds.fill( 0x00FF00 )
* leds.fill( 0xFF0000, 2, 2 )
* leds.fill( 0x0000FF, (4...8) )
* leds.fill { |i| 256 << i }
*
* Returns this PixelPi::Leds instance.
*/
static VALUE
pp_leds_fill( int argc, VALUE* argv, VALUE self )
{
ws2811_t *ledstring = pp_leds_struct( self );
ws2811_channel_t channel = ledstring->channel[0];
ws2811_led_t color = 0;
VALUE item, arg1, arg2, v;
long ii, beg = 0, end = 0, len = 0;
int block_p = 0;
if (rb_block_given_p()) {
block_p = 1;
rb_scan_args( argc, argv, "02", &arg1, &arg2 );
argc += 1;
} else {
rb_scan_args( argc, argv, "12", &item, &arg1, &arg2 );
color = FIX2UINT(item);
}
switch (argc) {
case 1:
beg = 0;
len = channel.count;
break;
case 2:
if (rb_range_beg_len(arg1, &beg, &len, channel.count, 1)) {
break;
}
/* fall through */
case 3:
beg = NIL_P(arg1) ? 0 : NUM2LONG(arg1);
if (beg < 0) {
beg = channel.count + beg;
if (beg < 0) beg = 0;
}
len = NIL_P(arg2) ? channel.count - beg : NUM2LONG(arg2);
break;
}
if (len < 0) return self;
end = beg + len;
end = MIN((long) channel.count, end);
for (ii=beg; ii<end; ii++) {
if (block_p) {
v = rb_yield(INT2NUM(ii));
color = FIX2UINT(v);
}
channel.leds[ii] = color;
}
return self;
}
static VALUE
rcl_mem_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_mem_info mi = FIX2UINT(param_name);
cl_mem m = MemoryPtr(self);
intptr_t param_value;
cl_int res = clGetMemObjectInfo(m, mi, sizeof(intptr_t), ¶m_value, NULL);
CHECK_AND_RAISE(res);
switch (mi) {
case CL_MEM_TYPE:
case CL_MEM_FLAGS:
case CL_MEM_SIZE:
case CL_MEM_MAP_COUNT:
case CL_MEM_REFERENCE_COUNT:
return UINT2NUM(param_value);
case CL_MEM_HOST_PTR: // CHECK: Should be wrapped to a HostPoiner? MappedPointer? No.
return ULONG2NUM(param_value);
case CL_MEM_CONTEXT:
return RContext((cl_context)param_value);
default:
break;
}
return Qnil;
}
/**
* :call-seq:
* <span class="name">eeread</span> <span class="arguments">(addr) -> integer</span>
*
* Returns an EEPROM byte.
*/
static VALUE rb_blink1_eeread(VALUE self, VALUE addr) {
struct Blink1Instance *ins;
uint8_t val = 0;
Data_Get_Struct(self, struct Blink1Instance, ins);
blink1_eeread(ins->dev, FIX2UINT(addr), &val);
return UINT2NUM(val);
}
/* call-seq:
* brightness = 128 # value between 0 and 255
*
* Set the pixel brightness. This is a value between 0 and 255. All pixels will
* be scaled by this value. The hue is not affected; only the luminosity is
* affected.
*
* Returns the new brightness.
*/
static VALUE
pp_leds_brightness_set( VALUE self, VALUE brightness )
{
ws2811_t *ledstring = pp_leds_struct( self );
ledstring->channel[0].brightness = (FIX2UINT(brightness) & 0xff);
return brightness;
}
/*
* @overload read(count, is_stderr: false, timeout: -1)
* Read data from a channel.
* @since 0.1.0
* @param [Fixnum] count The count of bytes to be read.
* @param [Boolean] is_stderr Read from the stderr flow or not.
* @param [Fixnum] timeout A timeout in seconds. +-1+ means infinite timeout.
* @return [String] Data read from the channel.
* @see http://api.libssh.org/stable/group__libssh__channel.html
* ssh_channel_read_timeout
*/
static VALUE m_read(int argc, VALUE *argv, VALUE self) {
ChannelHolder *holder;
VALUE count, opts;
const ID table[] = {id_stderr, id_timeout};
VALUE kwvals[sizeof(table) / sizeof(*table)];
struct nogvl_read_args args;
VALUE ret;
TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
rb_scan_args(argc, argv, "10:", &count, &opts);
Check_Type(count, T_FIXNUM);
rb_get_kwargs(opts, table, 0, 2, kwvals);
if (kwvals[0] == Qundef) {
args.is_stderr = 0;
} else {
args.is_stderr = RTEST(kwvals[0]) ? 1 : 0;
}
if (kwvals[1] == Qundef) {
args.timeout = -1;
} else {
Check_Type(kwvals[1], T_FIXNUM);
args.timeout = FIX2INT(kwvals[1]);
}
args.channel = holder->channel;
args.count = FIX2UINT(count);
args.buf = ALLOC_N(char, args.count);
rb_thread_call_without_gvl(nogvl_read, &args, RUBY_UBF_IO, NULL);
ret = rb_utf8_str_new(args.buf, args.rc);
ruby_xfree(args.buf);
return ret;
}
// ----------------------------------------
// Update the texture coordinates when a new image is chosen.
VALUE Ashton_ParticleEmitter_set_image(VALUE self, VALUE image)
{
EMITTER();
emitter->rb_image = image;
// Pixel size of image.
emitter->width = NUM2UINT(rb_funcall(image, rb_intern("width"), 0));
emitter->height = NUM2UINT(rb_funcall(image, rb_intern("height"), 0));
// Fill the array with all the same coords (won't be used if the image changes dynamically).
VALUE tex_info = rb_funcall(image, rb_intern("gl_tex_info"), 0);
emitter->texture_info.id = FIX2UINT(rb_funcall(tex_info, rb_intern("tex_name"), 0));
emitter->texture_info.left = NUM2DBL(rb_funcall(tex_info, rb_intern("left"), 0));
emitter->texture_info.right = NUM2DBL(rb_funcall(tex_info, rb_intern("right"), 0));
emitter->texture_info.top = NUM2DBL(rb_funcall(tex_info, rb_intern("top"), 0));
emitter->texture_info.bottom = NUM2DBL(rb_funcall(tex_info, rb_intern("bottom"), 0));
write_texture_coords_for_all_particles(emitter->texture_coords_array,
&emitter->texture_info,
emitter->max_particles);
// Push whole array to graphics card.
glBindBufferARB(GL_ARRAY_BUFFER_ARB, emitter->vbo_id);
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, emitter->texture_coords_array_offset,
sizeof(Vertex2d) * VERTICES_IN_PARTICLE * emitter->max_particles,
emitter->texture_coords_array);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
return image;
}
VALUE JoystickWrapper::rb_get_axis_name(VALUE self, VALUE stick_num, VALUE axis_num)
{
Joystick *joy;
Data_Get_Struct(self, Joystick, joy);
return rb_str_new2(joy->get_axis_name(FIX2INT(stick_num), FIX2UINT(axis_num)));
}
/*
* call-seq:
* Kernel#info(CL_KERNEL_FUNCTION_NAME)
*
* Wrapps +clGetKernelInfo()+.
*/
static VALUE
rcl_kernel_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_kernel k = KernelPtr(self);
cl_kernel_info ki = FIX2UINT(param_name);
char param_value[128];
size_t sz_ret;
cl_int res = clGetKernelInfo(k, ki, 128, param_value, &sz_ret);
CHECK_AND_RAISE(res);
switch (ki) {
case CL_KERNEL_FUNCTION_NAME:
return rb_str_new2(param_value);
case CL_KERNEL_NUM_ARGS:
case CL_KERNEL_REFERENCE_COUNT:
return UINT2NUM((*(cl_uint *)param_value));
case CL_KERNEL_CONTEXT:
return RContext(*(cl_context *)param_value);
case CL_KERNEL_PROGRAM:
return RProgram(*(cl_program *)param_value);
default:
break;
}
return Qnil;
}
static void
tcp_getaddr(struct addrinfo *hints, struct sockaddr_storage *addr,
VALUE ip, VALUE port)
{
int rc;
struct addrinfo *res;
const char *ipname = StringValuePtr(ip);
char ipport[6];
unsigned uport;
if (TYPE(port) != T_FIXNUM)
rb_raise(rb_eTypeError, "port must be a non-negative integer");
uport = FIX2UINT(port);
rc = snprintf(ipport, sizeof(ipport), "%u", uport);
if (rc >= (int)sizeof(ipport) || rc <= 0)
rb_raise(rb_eArgError, "invalid TCP port: %u", uport);
memset(hints, 0, sizeof(struct addrinfo));
hints->ai_family = AF_UNSPEC;
hints->ai_socktype = SOCK_STREAM;
hints->ai_protocol = IPPROTO_TCP;
/* disallow non-deterministic DNS lookups */
hints->ai_flags = AI_NUMERICHOST;
rc = getaddrinfo(ipname, ipport, hints, &res);
if (rc != 0)
rb_raise(rb_eArgError, "getaddrinfo(%s:%s): %s",
ipname, ipport, gai_strerror(rc));
/* copy needed data and free ASAP to avoid needing rb_ensure */
hints->ai_family = res->ai_family;
hints->ai_addrlen = res->ai_addrlen;
memcpy(addr, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
}
/* call-seq:
* window.setFramerateLimit( new_limit )
*
* Limit the framerate to a maximum fixed frequency.
*
* If a limit is set, the window will use a small delay after each call to Display() to ensure that the current frame
* lasted long enough to match the framerate limit.
*/
static VALUE Window_SetFramerateLimit( VALUE self, VALUE aLimit )
{
sf::Window *object = NULL;
Data_Get_Struct( self, sf::Window, object );
object->SetFramerateLimit( FIX2UINT( aLimit ) );
return Qnil;
}
static VALUE
rcl_mem_image_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_image_info ii = FIX2UINT(param_name);
cl_mem m = MemoryPtr(self);
cl_image_format imgfmt;
cl_int res = clGetImageInfo(m, ii, sizeof(cl_image_format), (void *)&imgfmt, NULL);
CHECK_AND_RAISE(res);
switch (ii) {
case CL_IMAGE_FORMAT:
return RImageFormat(&imgfmt);
case CL_IMAGE_ELEMENT_SIZE:
case CL_IMAGE_ROW_PITCH:
case CL_IMAGE_SLICE_PITCH:
case CL_IMAGE_WIDTH:
case CL_IMAGE_HEIGHT:
case CL_IMAGE_DEPTH:
return ULONG2NUM(*(size_t *)&imgfmt);
}
return Qnil;
}
/*
* call-seq:
* server_attach(dbname, mode)
*
* <b>internal use only</b>
*
* Attachs to the server by the OCI function OCIServerAttach().
*/
static VALUE oci8_server_attach(VALUE self, VALUE dbname, VALUE mode)
{
oci8_svcctx_t *svcctx = oci8_get_svcctx(self);
if (svcctx->logoff_strategy != &complex_logoff) {
rb_raise(rb_eRuntimeError, "Use this method only for the service context handle created by OCI8#server_handle().");
}
if (svcctx->state & OCI8_STATE_SERVER_ATTACH_WAS_CALLED) {
rb_raise(rb_eRuntimeError, "Could not use this method twice.");
}
/* check arguments */
if (!NIL_P(dbname)) {
OCI8SafeStringValue(dbname);
}
Check_Type(mode, T_FIXNUM);
/* attach to the server */
oci_lc(OCIServerAttach_nb(svcctx, svcctx->srvhp, oci8_errhp,
NIL_P(dbname) ? NULL : RSTRING_ORATEXT(dbname),
NIL_P(dbname) ? 0 : RSTRING_LEN(dbname),
FIX2UINT(mode)));
oci_lc(OCIAttrSet(svcctx->base.hp.ptr, OCI_HTYPE_SVCCTX,
svcctx->srvhp, 0, OCI_ATTR_SERVER,
oci8_errhp));
svcctx->state |= OCI8_STATE_SERVER_ATTACH_WAS_CALLED;
return self;
}
static VALUE erlix_uint_init(VALUE self,VALUE fix){
ErlixTerm* euint;
unsigned int i=FIX2UINT(fix);
Data_Get_Struct(self,ErlixTerm,euint);
euint->term=erl_mk_uint(i);
return self;
}
static VALUE
test_fix2uint(VALUE obj, VALUE num)
{
char buf[128];
sprintf(buf, "%u", FIX2UINT(num));
return rb_str_new_cstr(buf);
}
static VALUE tcp_connect(VALUE klass, VALUE ip, VALUE port, int io_wait)
{
struct addrinfo hints;
struct sockaddr_storage addr;
int rc;
struct addrinfo *res;
VALUE sock;
const char *ipname = StringValuePtr(ip);
char ipport[6];
unsigned uport = FIX2UINT(port);
rc = snprintf(ipport, sizeof(ipport), "%u", uport);
if (rc >= (int)sizeof(ipport) || rc <= 0)
rb_raise(rb_eArgError, "invalid TCP port: %u", uport);
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
/* disallow non-deterministic DNS lookups */
hints.ai_flags = AI_NUMERICHOST;
rc = getaddrinfo(ipname, ipport, &hints, &res);
if (rc != 0)
rb_raise(rb_eArgError, "getaddrinfo(%s:%s): %s",
ipname, ipport, gai_strerror(rc));
/* copy needed data and free ASAP to avoid needing rb_ensure */
hints.ai_family = res->ai_family;
hints.ai_addrlen = res->ai_addrlen;
memcpy(&addr, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
return my_connect(klass, io_wait, hints.ai_family,
&addr, hints.ai_addrlen);
}
/*
* PhysicsFS::File#write buffer, obj_size, num_objects
*
* return nil on failure or number of objects written.
*/
VALUE physfs_file_write (VALUE self, VALUE buf, VALUE objSize, VALUE objCount)
{
int result;
PHYSFS_File *file;
Data_Get_Struct (self, PHYSFS_File, file);
if (file == 0)
return Qnil;
result = PHYSFS_write (file, STR2CSTR(buf),
FIX2UINT(objSize), FIX2UINT(objCount));
if (result == -1)
return Qnil;
return INT2FIX(result);
}
/*
* call-seq:
* Kernel#workgroup_info(Device, CL_KERNEL_WORK_GROUP_SIZE)
*
* Wrapps +clGetKernelWorkGroupInfo()+.
*
* deivce - A Device object. Can be +nil+ if there is only single device
* is used by the context to which the receiver belongs.
* param_name - The information to query.
*/
static VALUE
rcl_kernel_workgroup_info(VALUE self, VALUE device, VALUE param_name)
{
EXPECT_RCL_TYPE(device, Device);
EXPECT_RCL_CONST(param_name);
cl_kernel k = KernelPtr(self);
cl_device_id dev = NIL_P(device) ? NULL : DevicePtr(device);
cl_kernel_work_group_info kwi = FIX2UINT(param_name);
size_t param_value[3];
cl_uint res = clGetKernelWorkGroupInfo(k, dev, kwi, sizeof(size_t) * 3, param_value, NULL);
CHECK_AND_RAISE(res);
VALUE ret = Qnil;
switch (kwi) {
case CL_KERNEL_WORK_GROUP_SIZE:
case CL_KERNEL_LOCAL_MEM_SIZE:
#ifdef CL_VERSION_1_1
case CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
#endif
return ULONG2NUM(param_value[0]);
case CL_KERNEL_COMPILE_WORK_GROUP_SIZE:
ret = rb_ary_new2(3);
for (int i = 0; i < 3; i++) {
rb_ary_push(ret, ULONG2NUM(param_value[i]));
}
return ret;
default:
break;
}
return Qnil;
}
/*
* call-seq:
* reinitialize(min, max, incr)
*
* Changes the the number of minimum connections, the number of
* maximum connections and the connection increment parameter.
*/
static VALUE oci8_cpool_reinitialize(VALUE self, VALUE conn_min, VALUE conn_max, VALUE conn_incr)
{
oci8_cpool_t *cpool = DATA_PTR(self);
OraText *pool_name;
sb4 pool_name_len;
/* check arguments */
Check_Type(conn_min, T_FIXNUM);
Check_Type(conn_max, T_FIXNUM);
Check_Type(conn_incr, T_FIXNUM);
oci_lc(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp,
&pool_name, &pool_name_len, NULL, 0,
FIX2UINT(conn_min), FIX2UINT(conn_max),
FIX2UINT(conn_incr),
NULL, 0, NULL, 0, OCI_CPOOL_REINITIALIZE));
return self;
}
static VALUE Parameter_init(VALUE self, VALUE n, VALUE index)
{
Check_Type(n, T_DATA);
Check_Type(index, T_FIXNUM);
vx_node node = (vx_node)DATA_PTR(n);
vx_parameter param = vxGetParameterByIndex(node, FIX2UINT(index));
DATA_PTR(self) = (void *)param;
return Qnil;
}
static VALUE
trace_stop_span(VALUE self, VALUE span, VALUE time) {
sky_trace_t* trace;
My_Struct(trace, sky_trace_t, consumed_trace_msg);
CHECK_NUMERIC(time);
CHECK_TYPE(span, T_FIXNUM);
if (sky_have_memprof()) {
sky_trace_span_add_uint_annotation(trace, FIX2UINT(span), 1, sky_consume_allocations());
}
CHECK_FFI(
sky_trace_span_done(trace, FIX2UINT(span), NUM2ULL(time)),
"native Trace#stop_span failed");
return Qnil;
}
sf::RenderTarget* rbRenderTarget::ToSFML( VALUE aValue )
{
aValue = rbMacros::ToRuby( aValue, rbRenderTarget::Module );
char* compensationPtr = reinterpret_cast< char* >( DATA_PTR( aValue ) );
unsigned int ptrOffset = 0;
VALUE offset = rb_iv_get( aValue, "@__internal__render_target_offset" );
if( offset != Qnil )
ptrOffset = FIX2UINT( offset );
return reinterpret_cast< sf::RenderTarget* >( compensationPtr + ptrOffset );
}
