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