Class: Fiddle::Pointer
- Inherits:
-
Object
- Object
- Fiddle::Pointer
- Defined in:
- pointer.c,
pointer.c
Overview
Fiddle::Pointer is a class to handle C pointers
Direct Known Subclasses
Class Method Summary collapse
-
.[] ⇒ Object
Get the underlying pointer for ruby object
val
and return it as a Fiddle::Pointer object. -
.Fiddle::Pointer.malloc(size, freefunc = nil) ⇒ Object
Allocate
size
bytes of memory and associate it with an optionalfreefunc
that will be called when the pointer is garbage collected. -
.to_ptr ⇒ Object
Get the underlying pointer for ruby object
val
and return it as a Fiddle::Pointer object.
Instance Method Summary collapse
-
#+(n) ⇒ Object
Returns a new pointer instance that has been advanced
n
bytes. -
#ptr ⇒ Object
Returns a new Fiddle::Pointer instance that is a dereferenced pointer for this pointer.
-
#-(n) ⇒ Object
Returns a new pointer instance that has been moved back
n
bytes. -
#ref ⇒ Object
Returns a new Fiddle::Pointer instance that is a reference pointer for this pointer.
-
#<=>(other) ⇒ -1, ...
Returns -1 if less than, 0 if equal to, 1 if greater than
other
. -
#== ⇒ Object
Returns true if
other
wraps the same pointer, otherwise returns false. -
#[] ⇒ Object
Returns integer stored at index.
-
#[]= ⇒ Object
Set the value at
index
toint
. -
#eql? ⇒ Boolean
Returns true if
other
wraps the same pointer, otherwise returns false. -
#free ⇒ Fiddle::Function
Get the free function for this pointer.
-
#free=(function) ⇒ Object
Set the free function for this pointer to
function
in the given Fiddle::Function. -
#initialize ⇒ Object
constructor
Create a new pointer to
address
with an optionalsize
andfreefunc
. -
#inspect ⇒ Object
Returns a string formatted with an easily readable representation of the internal state of the pointer.
-
#null? ⇒ Boolean
Returns
true
if this is a null pointer. -
#ptr ⇒ Object
Returns a new Fiddle::Pointer instance that is a dereferenced pointer for this pointer.
-
#ref ⇒ Object
Returns a new Fiddle::Pointer instance that is a reference pointer for this pointer.
-
#size ⇒ Object
Get the size of this pointer.
-
#size=(size) ⇒ Object
Set the size of this pointer to
size
. -
#to_i ⇒ Object
Returns the integer memory location of this pointer.
-
#to_i ⇒ Object
Returns the integer memory location of this pointer.
-
#to_s ⇒ Object
Returns the pointer contents as a string.
-
#to_str ⇒ Object
Returns the pointer contents as a string.
-
#to_value ⇒ Object
Cast this pointer to a ruby object.
Constructor Details
#Fiddle::Pointer.new(address) ⇒ Object #new(address, size) ⇒ Object #new(address, size, freefunc) ⇒ Object
Create a new pointer to address
with an optional size
and freefunc
.
freefunc
will be called when the instance is garbage collected.
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 |
# File 'pointer.c', line 151
static VALUE
rb_fiddle_ptr_initialize(int argc, VALUE argv[], VALUE self)
{
VALUE ptr, sym, size, wrap = 0, funcwrap = 0;
struct ptr_data *data;
void *p = NULL;
freefunc_t f = NULL;
long s = 0;
if (rb_scan_args(argc, argv, "12", &ptr, &size, &sym) >= 1) {
VALUE addrnum = rb_Integer(ptr);
if (addrnum != ptr) wrap = ptr;
p = NUM2PTR(addrnum);
}
if (argc >= 2) {
s = NUM2LONG(size);
}
if (argc >= 3) {
f = get_freefunc(sym, &funcwrap);
}
if (p) {
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
if (data->ptr && data->free) {
/* Free previous memory. Use of inappropriate initialize may cause SEGV. */
(*(data->free))(data->ptr);
}
data->wrap[0] = wrap;
data->wrap[1] = funcwrap;
data->ptr = p;
data->size = s;
data->free = f;
}
return Qnil;
}
|
Class Method Details
.Fiddle::Pointer ⇒ Object .to_ptr(val) ⇒ Object
Get the underlying pointer for ruby object val
and return it as a Fiddle::Pointer object.
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 |
# File 'pointer.c', line 637
static VALUE
rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
{
VALUE ptr, wrap = val, vptr;
if (RTEST(rb_obj_is_kind_of(val, rb_cIO))){
rb_io_t *fptr;
FILE *fp;
GetOpenFile(val, fptr);
fp = rb_io_stdio_file(fptr);
ptr = rb_fiddle_ptr_new(fp, 0, NULL);
}
else if (RTEST(rb_obj_is_kind_of(val, rb_cString))){
char *str = StringValuePtr(val);
ptr = rb_fiddle_ptr_new(str, RSTRING_LEN(val), NULL);
}
else if ((vptr = rb_check_funcall(val, id_to_ptr, 0, 0)) != Qundef){
if (rb_obj_is_kind_of(vptr, rb_cPointer)){
ptr = vptr;
wrap = 0;
}
else{
rb_raise(rb_eFiddleError, "to_ptr should return a Fiddle::Pointer object");
}
}
else{
VALUE num = rb_Integer(val);
if (num == val) wrap = 0;
ptr = rb_fiddle_ptr_new(NUM2PTR(num), 0, NULL);
}
OBJ_INFECT(ptr, val);
if (wrap) RPTR_DATA(ptr)->wrap[0] = wrap;
return ptr;
}
|
.Fiddle::Pointer.malloc(size, freefunc = nil) ⇒ Object
Allocate size
bytes of memory and associate it with an optional freefunc
that will be called when the pointer is garbage collected.
freefunc
must be an address pointing to a function or an instance of Fiddle::Function
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 |
# File 'pointer.c', line 199
static VALUE
rb_fiddle_ptr_s_malloc(int argc, VALUE argv[], VALUE klass)
{
VALUE size, sym, obj, wrap = 0;
long s;
freefunc_t f;
switch (rb_scan_args(argc, argv, "11", &size, &sym)) {
case 1:
s = NUM2LONG(size);
f = NULL;
break;
case 2:
s = NUM2LONG(size);
f = get_freefunc(sym, &wrap);
break;
default:
rb_bug("rb_fiddle_ptr_s_malloc");
}
obj = rb_fiddle_ptr_malloc(s,f);
if (wrap) RPTR_DATA(obj)->wrap[1] = wrap;
return obj;
}
|
.Fiddle::Pointer ⇒ Object .to_ptr(val) ⇒ Object
Get the underlying pointer for ruby object val
and return it as a Fiddle::Pointer object.
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 |
# File 'pointer.c', line 637
static VALUE
rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
{
VALUE ptr, wrap = val, vptr;
if (RTEST(rb_obj_is_kind_of(val, rb_cIO))){
rb_io_t *fptr;
FILE *fp;
GetOpenFile(val, fptr);
fp = rb_io_stdio_file(fptr);
ptr = rb_fiddle_ptr_new(fp, 0, NULL);
}
else if (RTEST(rb_obj_is_kind_of(val, rb_cString))){
char *str = StringValuePtr(val);
ptr = rb_fiddle_ptr_new(str, RSTRING_LEN(val), NULL);
}
else if ((vptr = rb_check_funcall(val, id_to_ptr, 0, 0)) != Qundef){
if (rb_obj_is_kind_of(vptr, rb_cPointer)){
ptr = vptr;
wrap = 0;
}
else{
rb_raise(rb_eFiddleError, "to_ptr should return a Fiddle::Pointer object");
}
}
else{
VALUE num = rb_Integer(val);
if (num == val) wrap = 0;
ptr = rb_fiddle_ptr_new(NUM2PTR(num), 0, NULL);
}
OBJ_INFECT(ptr, val);
if (wrap) RPTR_DATA(ptr)->wrap[0] = wrap;
return ptr;
}
|
Instance Method Details
#+(n) ⇒ Object
Returns a new pointer instance that has been advanced n
bytes.
491 492 493 494 495 496 497 498 499 500 501 |
# File 'pointer.c', line 491
static VALUE
rb_fiddle_ptr_plus(VALUE self, VALUE other)
{
void *ptr;
long num, size;
ptr = rb_fiddle_ptr2cptr(self);
size = RPTR_DATA(self)->size;
num = NUM2LONG(other);
return rb_fiddle_ptr_new((char *)ptr + num, size - num, 0);
}
|
#ptr ⇒ Object
Returns a new Fiddle::Pointer instance that is a dereferenced pointer for this pointer.
Analogous to the star operator in C.
260 261 262 263 264 265 266 267 |
# File 'pointer.c', line 260
static VALUE
rb_fiddle_ptr_ptr(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return rb_fiddle_ptr_new(*((void**)(data->ptr)),0,0);
}
|
#-(n) ⇒ Object
Returns a new pointer instance that has been moved back n
bytes.
509 510 511 512 513 514 515 516 517 518 519 |
# File 'pointer.c', line 509
static VALUE
rb_fiddle_ptr_minus(VALUE self, VALUE other)
{
void *ptr;
long num, size;
ptr = rb_fiddle_ptr2cptr(self);
size = RPTR_DATA(self)->size;
num = NUM2LONG(other);
return rb_fiddle_ptr_new((char *)ptr - num, size + num, 0);
}
|
#ref ⇒ Object
Returns a new Fiddle::Pointer instance that is a reference pointer for this pointer.
Analogous to the ampersand operator in C.
277 278 279 280 281 282 283 284 |
# File 'pointer.c', line 277
static VALUE
rb_fiddle_ptr_ref(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return rb_fiddle_ptr_new(&(data->ptr),0,0);
}
|
#<=>(other) ⇒ -1, ...
Returns -1 if less than, 0 if equal to, 1 if greater than other
.
Returns nil if ptr
cannot be compared to other
.
470 471 472 473 474 475 476 477 478 479 480 481 482 483 |
# File 'pointer.c', line 470
static VALUE
rb_fiddle_ptr_cmp(VALUE self, VALUE other)
{
void *ptr1, *ptr2;
SIGNED_VALUE diff;
if(!rb_obj_is_kind_of(other, rb_cPointer)) return Qnil;
ptr1 = rb_fiddle_ptr2cptr(self);
ptr2 = rb_fiddle_ptr2cptr(other);
diff = (SIGNED_VALUE)ptr1 - (SIGNED_VALUE)ptr2;
if (!diff) return INT2FIX(0);
return diff > 0 ? INT2NUM(1) : INT2NUM(-1);
}
|
#==(other) ⇒ Boolean #eql?(other) ⇒ Boolean
Returns true if other
wraps the same pointer, otherwise returns false.
449 450 451 452 453 454 455 456 457 458 459 460 |
# File 'pointer.c', line 449
static VALUE
rb_fiddle_ptr_eql(VALUE self, VALUE other)
{
void *ptr1, *ptr2;
if(!rb_obj_is_kind_of(other, rb_cPointer)) return Qfalse;
ptr1 = rb_fiddle_ptr2cptr(self);
ptr2 = rb_fiddle_ptr2cptr(other);
return ptr1 == ptr2 ? Qtrue : Qfalse;
}
|
#[](index) ⇒ Integer #[](start, length) ⇒ String
Returns integer stored at index.
If start and length are given, a string containing the bytes from start of length will be returned.
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 |
# File 'pointer.c', line 531
static VALUE
rb_fiddle_ptr_aref(int argc, VALUE argv[], VALUE self)
{
VALUE arg0, arg1;
VALUE retval = Qnil;
size_t offset, len;
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
if (!data->ptr) rb_raise(rb_eFiddleError, "NULL pointer dereference");
switch( rb_scan_args(argc, argv, "11", &arg0, &arg1) ){
case 1:
offset = NUM2ULONG(arg0);
retval = INT2NUM(*((char *)data->ptr + offset));
break;
case 2:
offset = NUM2ULONG(arg0);
len = NUM2ULONG(arg1);
retval = rb_tainted_str_new((char *)data->ptr + offset, len);
break;
default:
rb_bug("rb_fiddle_ptr_aref()");
}
return retval;
}
|
#[]=(index) ⇒ Integer #[]=(start, length) ⇒ String
Set the value at index
to int
.
Or, set the memory at start
until length
with the contents of string
, the memory from dl_cptr
, or the memory pointed at by the memory address addr
.
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 |
# File 'pointer.c', line 568
static VALUE
rb_fiddle_ptr_aset(int argc, VALUE argv[], VALUE self)
{
VALUE arg0, arg1, arg2;
VALUE retval = Qnil;
size_t offset, len;
void *mem;
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
if (!data->ptr) rb_raise(rb_eFiddleError, "NULL pointer dereference");
switch( rb_scan_args(argc, argv, "21", &arg0, &arg1, &arg2) ){
case 2:
offset = NUM2ULONG(arg0);
((char*)data->ptr)[offset] = NUM2UINT(arg1);
retval = arg1;
break;
case 3:
offset = NUM2ULONG(arg0);
len = NUM2ULONG(arg1);
if (RB_TYPE_P(arg2, T_STRING)) {
mem = StringValuePtr(arg2);
}
else if( rb_obj_is_kind_of(arg2, rb_cPointer) ){
mem = rb_fiddle_ptr2cptr(arg2);
}
else{
mem = NUM2PTR(arg2);
}
memcpy((char *)data->ptr + offset, mem, len);
retval = arg2;
break;
default:
rb_bug("rb_fiddle_ptr_aset()");
}
return retval;
}
|
#==(other) ⇒ Boolean #eql?(other) ⇒ Boolean
Returns true if other
wraps the same pointer, otherwise returns false.
449 450 451 452 453 454 455 456 457 458 459 460 |
# File 'pointer.c', line 449
static VALUE
rb_fiddle_ptr_eql(VALUE self, VALUE other)
{
void *ptr1, *ptr2;
if(!rb_obj_is_kind_of(other, rb_cPointer)) return Qfalse;
ptr1 = rb_fiddle_ptr2cptr(self);
ptr2 = rb_fiddle_ptr2cptr(other);
return ptr1 == ptr2 ? Qtrue : Qfalse;
}
|
#free ⇒ Fiddle::Function
Get the free function for this pointer.
Returns a new instance of Fiddle::Function.
See Fiddle::Function.new
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 |
# File 'pointer.c', line 326
static VALUE
rb_fiddle_ptr_free_get(VALUE self)
{
struct ptr_data *pdata;
VALUE address;
VALUE arg_types;
VALUE ret_type;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, pdata);
if (!pdata->free)
return Qnil;
address = PTR2NUM(pdata->free);
ret_type = INT2NUM(TYPE_VOID);
arg_types = rb_ary_new();
rb_ary_push(arg_types, INT2NUM(TYPE_VOIDP));
return rb_fiddle_new_function(address, arg_types, ret_type);
}
|
#free=(function) ⇒ Object
Set the free function for this pointer to function
in the given Fiddle::Function.
306 307 308 309 310 311 312 313 314 315 |
# File 'pointer.c', line 306
static VALUE
rb_fiddle_ptr_free_set(VALUE self, VALUE val)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
data->free = get_freefunc(val, &data->wrap[1]);
return Qnil;
}
|
#inspect ⇒ Object
Returns a string formatted with an easily readable representation of the internal state of the pointer.
429 430 431 432 433 434 435 436 437 438 439 |
# File 'pointer.c', line 429
static VALUE
rb_fiddle_ptr_inspect(VALUE self)
{
struct ptr_data *data;
char str[1024];
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
snprintf(str, 1023, "#<%s:%p ptr=%p size=%ld free=%p>",
rb_class2name(CLASS_OF(self)), data, data->ptr, data->size, data->free);
return rb_str_new2(str);
}
|
#null? ⇒ Boolean
Returns true
if this is a null pointer.
291 292 293 294 295 296 297 298 |
# File 'pointer.c', line 291
static VALUE
rb_fiddle_ptr_null_p(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return data->ptr ? Qfalse : Qtrue;
}
|
#ptr ⇒ Object
Returns a new Fiddle::Pointer instance that is a dereferenced pointer for this pointer.
Analogous to the star operator in C.
260 261 262 263 264 265 266 267 |
# File 'pointer.c', line 260
static VALUE
rb_fiddle_ptr_ptr(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return rb_fiddle_ptr_new(*((void**)(data->ptr)),0,0);
}
|
#ref ⇒ Object
Returns a new Fiddle::Pointer instance that is a reference pointer for this pointer.
Analogous to the ampersand operator in C.
277 278 279 280 281 282 283 284 |
# File 'pointer.c', line 277
static VALUE
rb_fiddle_ptr_ref(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return rb_fiddle_ptr_new(&(data->ptr),0,0);
}
|
#size ⇒ Object
Get the size of this pointer.
623 624 625 626 627 |
# File 'pointer.c', line 623
static VALUE
rb_fiddle_ptr_size_get(VALUE self)
{
return LONG2NUM(RPTR_DATA(self)->size);
}
|
#size=(size) ⇒ Object
Set the size of this pointer to size
611 612 613 614 615 616 |
# File 'pointer.c', line 611
static VALUE
rb_fiddle_ptr_size_set(VALUE self, VALUE size)
{
RPTR_DATA(self)->size = NUM2LONG(size);
return size;
}
|
#to_i ⇒ Object
Returns the integer memory location of this pointer.
230 231 232 233 234 235 236 237 |
# File 'pointer.c', line 230
static VALUE
rb_fiddle_ptr_to_i(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return PTR2NUM(data->ptr);
}
|
#to_i ⇒ Object
Returns the integer memory location of this pointer.
230 231 232 233 234 235 236 237 |
# File 'pointer.c', line 230
static VALUE
rb_fiddle_ptr_to_i(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return PTR2NUM(data->ptr);
}
|
#to_s ⇒ String #to_s(len) ⇒ String
Returns the pointer contents as a string.
When called with no arguments, this method will return the contents until the first NULL byte.
When called with len
, a string of len
bytes will be returned.
See to_str
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 |
# File 'pointer.c', line 362
static VALUE
rb_fiddle_ptr_to_s(int argc, VALUE argv[], VALUE self)
{
struct ptr_data *data;
VALUE arg1, val;
int len;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
switch (rb_scan_args(argc, argv, "01", &arg1)) {
case 0:
val = rb_tainted_str_new2((char*)(data->ptr));
break;
case 1:
len = NUM2INT(arg1);
val = rb_tainted_str_new((char*)(data->ptr), len);
break;
default:
rb_bug("rb_fiddle_ptr_to_s");
}
return val;
}
|
#to_str ⇒ String #to_str(len) ⇒ String
Returns the pointer contents as a string.
When called with no arguments, this method will return the contents with the length of this pointer’s size
.
When called with len
, a string of len
bytes will be returned.
See to_s
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 |
# File 'pointer.c', line 400
static VALUE
rb_fiddle_ptr_to_str(int argc, VALUE argv[], VALUE self)
{
struct ptr_data *data;
VALUE arg1, val;
int len;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
switch (rb_scan_args(argc, argv, "01", &arg1)) {
case 0:
val = rb_tainted_str_new((char*)(data->ptr),data->size);
break;
case 1:
len = NUM2INT(arg1);
val = rb_tainted_str_new((char*)(data->ptr), len);
break;
default:
rb_bug("rb_fiddle_ptr_to_str");
}
return val;
}
|
#to_value ⇒ Object
Cast this pointer to a ruby object.
244 245 246 247 248 249 250 |
# File 'pointer.c', line 244
static VALUE
rb_fiddle_ptr_to_value(VALUE self)
{
struct ptr_data *data;
TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
return (VALUE)(data->ptr);
}
|