Ruby  1.9.3p448(2013-06-27revision41675)
cptr.c
Go to the documentation of this file.
1 /* -*- C -*-
2  * $Id: cptr.c 34604 2012-02-14 20:09:27Z naruse $
3  */
4 
5 #include <ruby/ruby.h>
6 #include <ruby/io.h>
7 #include <ctype.h>
8 #include "dl.h"
9 
11 
12 static inline freefunc_t
14 {
15  VALUE addrnum;
16  if (NIL_P(func)) {
17  *wrap = 0;
18  return NULL;
19  }
20  if (rb_dlcfunc_kind_p(func)) {
21  *wrap = func;
22  return (freefunc_t)(VALUE)RCFUNC_DATA(func)->ptr;
23  }
24  addrnum = rb_Integer(func);
25  *wrap = (addrnum != func) ? func : 0;
26  return (freefunc_t)(VALUE)NUM2PTR(addrnum);
27 }
28 
29 static ID id_to_ptr;
30 
31 static void
33 {
34  struct ptr_data *data = ptr;
35  if (data->wrap[0]) {
36  rb_gc_mark(data->wrap[0]);
37  }
38  if (data->wrap[1]) {
39  rb_gc_mark(data->wrap[1]);
40  }
41 }
42 
43 static void
45 {
46  struct ptr_data *data = ptr;
47  if (data->ptr) {
48  if (data->free) {
49  (*(data->free))(data->ptr);
50  }
51  }
52 }
53 
54 static size_t
55 dlptr_memsize(const void *ptr)
56 {
57  const struct ptr_data *data = ptr;
58  return data ? sizeof(*data) + data->size : 0;
59 }
60 
62  "dl/ptr",
64 };
65 
66 void
68 {
69  struct ptr_data *data;
70 
71  TypedData_Get_Struct(val, struct ptr_data, &dlptr_data_type, data);
72  OBJ_TAINT(val);
73 }
74 
75 VALUE
76 rb_dlptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
77 {
78  struct ptr_data *data;
79  VALUE val;
80 
81  rb_secure(4);
82  val = TypedData_Make_Struct(klass, struct ptr_data, &dlptr_data_type, data);
83  data->ptr = ptr;
84  data->free = func;
85  data->size = size;
86  dlptr_init(val);
87 
88  return val;
89 }
90 
91 VALUE
93 {
94  return rb_dlptr_new2(rb_cDLCPtr, ptr, size, func);
95 }
96 
97 VALUE
99 {
100  void *ptr;
101 
102  rb_secure(4);
103  ptr = ruby_xmalloc((size_t)size);
104  memset(ptr,0,(size_t)size);
105  return rb_dlptr_new(ptr, size, func);
106 }
107 
108 void *
110 {
111  struct ptr_data *data;
112  void *ptr;
113 
114  if (rb_obj_is_kind_of(val, rb_cDLCPtr)) {
115  TypedData_Get_Struct(val, struct ptr_data, &dlptr_data_type, data);
116  ptr = data->ptr;
117  }
118  else if (val == Qnil) {
119  ptr = NULL;
120  }
121  else{
122  rb_raise(rb_eTypeError, "DL::PtrData was expected");
123  }
124 
125  return ptr;
126 }
127 
128 static VALUE
130 {
131  VALUE obj;
132  struct ptr_data *data;
133 
134  rb_secure(4);
135  obj = TypedData_Make_Struct(klass, struct ptr_data, &dlptr_data_type, data);
136  data->ptr = 0;
137  data->size = 0;
138  data->free = 0;
139 
140  return obj;
141 }
142 
143 /*
144  * call-seq:
145  * DL::CPtr.new(address) => dl_cptr
146  * DL::CPtr.new(address, size) => dl_cptr
147  * DL::CPtr.new(address, size, freefunc) => dl_cptr
148  *
149  * Create a new pointer to +address+ with an optional +size+ and +freefunc+.
150  * +freefunc+ will be called when the instance is garbage collected.
151  */
152 static VALUE
154 {
155  VALUE ptr, sym, size, wrap = 0, funcwrap = 0;
156  struct ptr_data *data;
157  void *p = NULL;
158  freefunc_t f = NULL;
159  long s = 0;
160 
161  if (rb_scan_args(argc, argv, "12", &ptr, &size, &sym) >= 1) {
162  VALUE addrnum = rb_Integer(ptr);
163  if (addrnum != ptr) wrap = ptr;
164  p = NUM2PTR(addrnum);
165  }
166  if (argc >= 2) {
167  s = NUM2LONG(size);
168  }
169  if (argc >= 3) {
170  f = get_freefunc(sym, &funcwrap);
171  }
172 
173  if (p) {
174  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
175  if (data->ptr && data->free) {
176  /* Free previous memory. Use of inappropriate initialize may cause SEGV. */
177  (*(data->free))(data->ptr);
178  }
179  data->wrap[0] = wrap;
180  data->wrap[1] = funcwrap;
181  data->ptr = p;
182  data->size = s;
183  data->free = f;
184  }
185 
186  return Qnil;
187 }
188 
189 /*
190  * call-seq:
191  *
192  * DL::CPtr.malloc(size, freefunc = nil) => dl cptr instance
193  *
194  * Allocate +size+ bytes of memory and associate it with an optional
195  * +freefunc+ that will be called when the pointer is garbage collected.
196  * +freefunc+ must be an address pointing to a function or an instance of
197  * DL::CFunc
198  */
199 static VALUE
201 {
202  VALUE size, sym, obj, wrap = 0;
203  long s;
204  freefunc_t f;
205 
206  switch (rb_scan_args(argc, argv, "11", &size, &sym)) {
207  case 1:
208  s = NUM2LONG(size);
209  f = NULL;
210  break;
211  case 2:
212  s = NUM2LONG(size);
213  f = get_freefunc(sym, &wrap);
214  break;
215  default:
216  rb_bug("rb_dlptr_s_malloc");
217  }
218 
219  obj = rb_dlptr_malloc(s,f);
220  if (wrap) RPTR_DATA(obj)->wrap[1] = wrap;
221 
222  return obj;
223 }
224 
225 /*
226  * call-seq: to_i
227  *
228  * Returns the integer memory location of this DL::CPtr.
229  */
230 static VALUE
232 {
233  struct ptr_data *data;
234 
235  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
236  return PTR2NUM(data->ptr);
237 }
238 
239 /*
240  * call-seq: to_value
241  *
242  * Cast this CPtr to a ruby object.
243  */
244 static VALUE
246 {
247  struct ptr_data *data;
248  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
249  return (VALUE)(data->ptr);
250 }
251 
252 /*
253  * call-seq: ptr
254  *
255  * Returns a DL::CPtr that is a dereferenced pointer for this DL::CPtr.
256  * Analogous to the star operator in C.
257  */
258 VALUE
260 {
261  struct ptr_data *data;
262 
263  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
264  return rb_dlptr_new(*((void**)(data->ptr)),0,0);
265 }
266 
267 /*
268  * call-seq: ref
269  *
270  * Returns a DL::CPtr that is a reference pointer for this DL::CPtr.
271  * Analogous to the ampersand operator in C.
272  */
273 VALUE
275 {
276  struct ptr_data *data;
277 
278  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
279  return rb_dlptr_new(&(data->ptr),0,0);
280 }
281 
282 /*
283  * call-seq: null?
284  *
285  * Returns true if this is a null pointer.
286  */
287 VALUE
289 {
290  struct ptr_data *data;
291 
292  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
293  return data->ptr ? Qfalse : Qtrue;
294 }
295 
296 /*
297  * call-seq: free=(function)
298  *
299  * Set the free function for this pointer to the DL::CFunc in +function+.
300  */
301 static VALUE
303 {
304  struct ptr_data *data;
305 
306  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
307  data->free = get_freefunc(val, &data->wrap[1]);
308 
309  return Qnil;
310 }
311 
312 /*
313  * call-seq: free
314  *
315  * Get the free function for this pointer. Returns DL::CFunc or nil.
316  */
317 static VALUE
319 {
320  struct ptr_data *pdata;
321 
322  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, pdata);
323 
324  return rb_dlcfunc_new(pdata->free, DLTYPE_VOID, "free<anonymous>", CFUNC_CDECL);
325 }
326 
327 /*
328  * call-seq:
329  *
330  * ptr.to_s => string
331  * ptr.to_s(len) => string
332  *
333  * Returns the pointer contents as a string. When called with no arguments,
334  * this method will return the contents until the first NULL byte. When
335  * called with +len+, a string of +len+ bytes will be returned.
336  */
337 static VALUE
339 {
340  struct ptr_data *data;
341  VALUE arg1, val;
342  int len;
343 
344  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
345  switch (rb_scan_args(argc, argv, "01", &arg1)) {
346  case 0:
347  val = rb_tainted_str_new2((char*)(data->ptr));
348  break;
349  case 1:
350  len = NUM2INT(arg1);
351  val = rb_tainted_str_new((char*)(data->ptr), len);
352  break;
353  default:
354  rb_bug("rb_dlptr_to_s");
355  }
356 
357  return val;
358 }
359 
360 /*
361  * call-seq:
362  *
363  * ptr.to_str => string
364  * ptr.to_str(len) => string
365  *
366  * Returns the pointer contents as a string. When called with no arguments,
367  * this method will return the contents with the length of this pointer's
368  * +size+. When called with +len+, a string of +len+ bytes will be returned.
369  */
370 static VALUE
372 {
373  struct ptr_data *data;
374  VALUE arg1, val;
375  int len;
376 
377  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
378  switch (rb_scan_args(argc, argv, "01", &arg1)) {
379  case 0:
380  val = rb_tainted_str_new((char*)(data->ptr),data->size);
381  break;
382  case 1:
383  len = NUM2INT(arg1);
384  val = rb_tainted_str_new((char*)(data->ptr), len);
385  break;
386  default:
387  rb_bug("rb_dlptr_to_str");
388  }
389 
390  return val;
391 }
392 
393 /*
394  * call-seq: inspect
395  *
396  * Returns a string formatted with an easily readable representation of the
397  * internal state of the DL::CPtr
398  */
399 static VALUE
401 {
402  struct ptr_data *data;
403  char str[1024];
404 
405  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
406  snprintf(str, 1023, "#<%s:%p ptr=%p size=%ld free=%p>",
407  rb_class2name(CLASS_OF(self)), data, data->ptr, data->size, data->free);
408  return rb_str_new2(str);
409 }
410 
411 /*
412  * call-seq:
413  * ptr == other => true or false
414  * ptr.eql?(other) => true or false
415  *
416  * Returns true if +other+ wraps the same pointer, otherwise returns
417  * false.
418  */
419 VALUE
421 {
422  void *ptr1, *ptr2;
423 
424  if(!rb_obj_is_kind_of(other, rb_cDLCPtr)) return Qfalse;
425 
426  ptr1 = rb_dlptr2cptr(self);
427  ptr2 = rb_dlptr2cptr(other);
428 
429  return ptr1 == ptr2 ? Qtrue : Qfalse;
430 }
431 
432 /*
433  * call-seq:
434  * ptr <=> other => -1, 0, 1, or nil
435  *
436  * Returns -1 if less than, 0 if equal to, 1 if greater than +other+. Returns
437  * nil if +ptr+ cannot be compared to +other+.
438  */
439 static VALUE
441 {
442  void *ptr1, *ptr2;
444 
445  if(!rb_obj_is_kind_of(other, rb_cDLCPtr)) return Qnil;
446 
447  ptr1 = rb_dlptr2cptr(self);
448  ptr2 = rb_dlptr2cptr(other);
449  diff = (SIGNED_VALUE)ptr1 - (SIGNED_VALUE)ptr2;
450  if (!diff) return INT2FIX(0);
451  return diff > 0 ? INT2NUM(1) : INT2NUM(-1);
452 }
453 
454 /*
455  * call-seq:
456  * ptr + n => new cptr
457  *
458  * Returns a new DL::CPtr that has been advanced +n+ bytes.
459  */
460 static VALUE
462 {
463  void *ptr;
464  long num, size;
465 
466  ptr = rb_dlptr2cptr(self);
467  size = RPTR_DATA(self)->size;
468  num = NUM2LONG(other);
469  return rb_dlptr_new((char *)ptr + num, size - num, 0);
470 }
471 
472 /*
473  * call-seq:
474  * ptr - n => new cptr
475  *
476  * Returns a new DL::CPtr that has been moved back +n+ bytes.
477  */
478 static VALUE
480 {
481  void *ptr;
482  long num, size;
483 
484  ptr = rb_dlptr2cptr(self);
485  size = RPTR_DATA(self)->size;
486  num = NUM2LONG(other);
487  return rb_dlptr_new((char *)ptr - num, size + num, 0);
488 }
489 
490 /*
491  * call-seq:
492  * ptr[index] -> an_integer
493  * ptr[start, length] -> a_string
494  *
495  * Returns integer stored at _index_. If _start_ and _length_ are given,
496  * a string containing the bytes from _start_ of length _length_ will be
497  * returned.
498  */
499 VALUE
501 {
502  VALUE arg0, arg1;
503  VALUE retval = Qnil;
504  size_t offset, len;
505  struct ptr_data *data;
506 
507  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
508  if (!data->ptr) rb_raise(rb_eDLError, "NULL pointer dereference");
509  switch( rb_scan_args(argc, argv, "11", &arg0, &arg1) ){
510  case 1:
511  offset = NUM2ULONG(arg0);
512  retval = INT2NUM(*((char *)data->ptr + offset));
513  break;
514  case 2:
515  offset = NUM2ULONG(arg0);
516  len = NUM2ULONG(arg1);
517  retval = rb_tainted_str_new((char *)data->ptr + offset, len);
518  break;
519  default:
520  rb_bug("rb_dlptr_aref()");
521  }
522  return retval;
523 }
524 
525 /*
526  * call-seq:
527  * ptr[index] = int -> int
528  * ptr[start, length] = string or cptr or addr -> string or dl_cptr or addr
529  *
530  * Set the value at +index+ to +int+. Or, set the memory at +start+ until
531  * +length+ with the contents of +string+, the memory from +dl_cptr+, or the
532  * memory pointed at by the memory address +addr+.
533  */
534 VALUE
536 {
537  VALUE arg0, arg1, arg2;
538  VALUE retval = Qnil;
539  size_t offset, len;
540  void *mem;
541  struct ptr_data *data;
542 
543  TypedData_Get_Struct(self, struct ptr_data, &dlptr_data_type, data);
544  if (!data->ptr) rb_raise(rb_eDLError, "NULL pointer dereference");
545  switch( rb_scan_args(argc, argv, "21", &arg0, &arg1, &arg2) ){
546  case 2:
547  offset = NUM2ULONG(arg0);
548  ((char*)data->ptr)[offset] = NUM2UINT(arg1);
549  retval = arg1;
550  break;
551  case 3:
552  offset = NUM2ULONG(arg0);
553  len = NUM2ULONG(arg1);
554  if (RB_TYPE_P(arg2, T_STRING)) {
555  mem = StringValuePtr(arg2);
556  }
557  else if( rb_obj_is_kind_of(arg2, rb_cDLCPtr) ){
558  mem = rb_dlptr2cptr(arg2);
559  }
560  else{
561  mem = NUM2PTR(arg2);
562  }
563  memcpy((char *)data->ptr + offset, mem, len);
564  retval = arg2;
565  break;
566  default:
567  rb_bug("rb_dlptr_aset()");
568  }
569  return retval;
570 }
571 
572 /*
573  * call-seq: size=(size)
574  *
575  * Set the size of this pointer to +size+
576  */
577 static VALUE
579 {
580  RPTR_DATA(self)->size = NUM2LONG(size);
581  return size;
582 }
583 
584 /*
585  * call-seq: size
586  *
587  * Get the size of this pointer.
588  */
589 static VALUE
591 {
592  return LONG2NUM(RPTR_DATA(self)->size);
593 }
594 
595 /*
596  * call-seq:
597  * DL::CPtr.to_ptr(val) => cptr
598  * DL::CPtr[val] => cptr
599  *
600  * Get the underlying pointer for ruby object +val+ and return it as a
601  * DL::CPtr object.
602  */
603 static VALUE
605 {
606  VALUE ptr, wrap = val, vptr;
607 
608  if (RTEST(rb_obj_is_kind_of(val, rb_cIO))){
609  rb_io_t *fptr;
610  FILE *fp;
611  GetOpenFile(val, fptr);
612  fp = rb_io_stdio_file(fptr);
613  ptr = rb_dlptr_new(fp, 0, NULL);
614  }
615  else if (RTEST(rb_obj_is_kind_of(val, rb_cString))){
616  char *str = StringValuePtr(val);
617  ptr = rb_dlptr_new(str, RSTRING_LEN(val), NULL);
618  }
619  else if ((vptr = rb_check_funcall(val, id_to_ptr, 0, 0)) != Qundef){
620  if (rb_obj_is_kind_of(vptr, rb_cDLCPtr)){
621  ptr = vptr;
622  wrap = 0;
623  }
624  else{
625  rb_raise(rb_eDLError, "to_ptr should return a CPtr object");
626  }
627  }
628  else{
629  VALUE num = rb_Integer(val);
630  if (num == val) wrap = 0;
631  ptr = rb_dlptr_new(NUM2PTR(num), 0, NULL);
632  }
633  OBJ_INFECT(ptr, val);
634  if (wrap) RPTR_DATA(ptr)->wrap[0] = wrap;
635  return ptr;
636 }
637 
638 void
640 {
641  id_to_ptr = rb_intern("to_ptr");
642 
643  /* Document-class: DL::CPtr
644  *
645  * CPtr is a class to handle C pointers
646  *
647  */
653  rb_define_method(rb_cDLCPtr, "initialize", rb_dlptr_initialize, -1);
676 
677  /* Document-const: NULL
678  *
679  * A NULL pointer
680  */
681  rb_define_const(rb_mDL, "NULL", rb_dlptr_new(0, 0, 0));
682 }
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1276
static VALUE rb_dlptr_minus(VALUE self, VALUE other)
Definition: cptr.c:479
#define RSTRING_LEN(string)
Definition: generator.h:45
static long NUM2LONG(VALUE x)
Definition: ruby.h:510
int rb_dlcfunc_kind_p(VALUE func)
Definition: cfunc.c:139
VALUE rb_dlptr_eql(VALUE self, VALUE other)
Definition: cptr.c:420
freefunc_t free
Definition: dl.h:212
VALUE rb_mDL
Definition: dl.c:13
static VALUE rb_dlptr_s_malloc(int argc, VALUE argv[], VALUE klass)
Definition: cptr.c:200
void rb_bug(const char *fmt,...)
Definition: error.c:265
static VALUE rb_dlptr_to_i(VALUE self)
Definition: cptr.c:231
VALUE rb_cDLCPtr
Definition: cptr.c:10
#define NUM2INT(x)
Definition: ruby.h:536
#define NUM2UINT(x)
Definition: ruby.h:537
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
Definition: class.c:1342
VALUE rb_dlptr_new(void *ptr, long size, freefunc_t func)
Definition: cptr.c:92
#define CLASS_OF(v)
Definition: ruby.h:376
#define LONG2NUM(i)
Definition: cparse.c:72
#define Qtrue
Definition: ruby.h:366
Definition: io.h:53
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:840
static VALUE rb_dlptr_inspect(VALUE self)
Definition: cptr.c:400
VALUE rb_eTypeError
Definition: error.c:467
static VALUE INT2NUM(int v)
Definition: ruby.h:981
#define NUM2PTR(x)
Definition: dl.h:178
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition: class.c:514
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1574
static VALUE rb_dlptr_size_set(VALUE self, VALUE size)
Definition: cptr.c:578
static VALUE rb_dlptr_free_set(VALUE self, VALUE val)
Definition: cptr.c:302
VALUE rb_eDLError
Definition: dl.c:14
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Definition: object.c:525
VALUE rb_dlptr_aref(int argc, VALUE argv[], VALUE self)
Definition: cptr.c:500
VALUE rb_tainted_str_new2(const char *)
#define DLTYPE_VOID
Definition: dl.h:163
void rb_gc_mark(VALUE ptr)
Definition: gc.c:1762
#define GetOpenFile(obj, fp)
Definition: io.h:110
VALUE rb_dlptr_ptr(VALUE self)
Definition: cptr.c:259
static VALUE rb_dlptr_s_to_ptr(VALUE self, VALUE val)
Definition: cptr.c:604
#define sym(x)
Definition: date_core.c:3697
Win32OLEIDispatch * p
Definition: win32ole.c:778
#define RPTR_DATA(obj)
Definition: dl.h:218
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1353
VALUE rb_dlcfunc_new(void(*func)(), int type, const char *name, ID calltype)
Definition: cfunc.c:83
static void dlptr_free(void *ptr)
Definition: cptr.c:44
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1246
static void dlptr_mark(void *ptr)
Definition: cptr.c:32
#define snprintf
Definition: subst.h:6
#define NIL_P(v)
Definition: ruby.h:374
static VALUE rb_dlptr_to_value(VALUE self)
Definition: cptr.c:245
#define PTR2NUM(x)
Definition: dl.h:177
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:1923
static VALUE rb_dlptr_s_allocate(VALUE klass)
Definition: cptr.c:129
static VALUE rb_dlptr_plus(VALUE self, VALUE other)
Definition: cptr.c:461
int argc
Definition: ruby.c:120
#define Qfalse
Definition: ruby.h:365
VALUE rb_Integer(VALUE)
Definition: object.c:2192
VALUE rb_dlptr_malloc(long size, freefunc_t func)
Definition: cptr.c:98
static ID id_to_ptr
Definition: cptr.c:29
VALUE wrap[2]
Definition: dl.h:213
void * ptr
Definition: dl.h:210
void dlptr_init(VALUE val)
Definition: cptr.c:67
RUBY_EXTERN VALUE rb_cIO
Definition: ruby.h:1262
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:104
VALUE rb_check_funcall(VALUE, ID, int, VALUE *)
Definition: vm_eval.c:312
VALUE rb_dlptr_aset(int argc, VALUE argv[], VALUE self)
Definition: cptr.c:535
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1415
static VALUE rb_dlptr_to_s(int argc, VALUE argv[], VALUE self)
Definition: cptr.c:338
Definition: dl.h:209
unsigned long ID
Definition: ruby.h:89
#define NULL
#define Qnil
Definition: ruby.h:367
#define OBJ_TAINT(x)
Definition: ruby.h:964
unsigned long VALUE
Definition: ruby.h:88
const char * rb_class2name(VALUE)
Definition: variable.c:311
register unsigned int len
Definition: name2ctype.h:22210
static const rb_data_type_t dlptr_data_type
Definition: cptr.c:61
void * ruby_xmalloc(size_t size)
Definition: gc.c:857
int size
Definition: encoding.c:51
static freefunc_t get_freefunc(VALUE func, volatile VALUE *wrap)
Definition: cptr.c:13
#define INT2FIX(i)
Definition: ruby.h:225
static size_t dlptr_memsize(const void *ptr)
Definition: cptr.c:55
static VALUE rb_dlptr_free_get(VALUE self)
Definition: cptr.c:318
static VALUE rb_dlptr_initialize(int argc, VALUE argv[], VALUE self)
Definition: cptr.c:153
static VALUE rb_dlptr_size_get(VALUE self)
Definition: cptr.c:590
void * ptr
Definition: dl.h:198
#define NUM2ULONG(x)
Definition: ruby.h:515
#define RTEST(v)
Definition: ruby.h:373
#define T_STRING
Definition: ruby.h:418
#define OBJ_INFECT(x, s)
Definition: ruby.h:967
static Bigint * diff(Bigint *a, Bigint *b)
Definition: util.c:1413
#define TypedData_Make_Struct(klass, type, data_type, sval)
Definition: ruby.h:829
VALUE rb_dlptr_ref(VALUE self)
Definition: cptr.c:274
FILE * rb_io_stdio_file(rb_io_t *fptr)
Definition: io.c:6728
VALUE wrap
Definition: dl.h:202
void Init_dlptr(void)
Definition: cptr.c:639
#define RCFUNC_DATA(obj)
Definition: dl.h:217
#define StringValuePtr(v)
Definition: ruby.h:467
void(* freefunc_t)(void *)
Definition: dl.h:188
void rb_secure(int)
Definition: safe.c:79
VALUE rb_dlptr_null_p(VALUE self)
Definition: cptr.c:288
VALUE rb_tainted_str_new(const char *, long)
#define rb_intern(str)
static VALUE rb_dlptr_cmp(VALUE self, VALUE other)
Definition: cptr.c:440
#define Qundef
Definition: ruby.h:368
void * rb_dlptr2cptr(VALUE val)
Definition: cptr.c:109
static VALUE rb_dlptr_to_str(int argc, VALUE argv[], VALUE self)
Definition: cptr.c:371
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1209
VALUE rb_dlptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
Definition: cptr.c:76
VALUE rb_str_new2(const char *)
long size
Definition: dl.h:211
char ** argv
Definition: ruby.c:121
#define CFUNC_CDECL
Definition: dl.h:206
#define SIGNED_VALUE
Definition: ruby.h:90