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