rubysl-dl 0.0.1 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d2c2566899a33959bd4bf3016f2aef1c68866fea
+  data.tar.gz: 46537741f8cde07062b521fa22e03b298e0aa0ef
+SHA512:
+  metadata.gz: fe5bd99974ce25b12954e0cf4c434760bb9afaa0819ad7c0305091d9446c8cee61b940be1cbd48b4d81433a7cb85fa153b56b35adb33c0ab9446f5dec7d4b080
+  data.tar.gz: aaff5817f2ab9fb93e6e628fef52e5641b11c4cfd1d10cede46018834d1c43ec62cac9b66a95181c6bdbbf33444fbfc3436fe326f79e18c95269f2bbc42fca52

data/.gitignore

@@ -15,4 +15,3 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.rbx

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
+script: bundle exec mspec spec
+rvm:
+  - rbx-nightly-18mode

data/README.md

@@ -1,4 +1,4 @@
-# RubySL::Dl
+# Rubysl::Dl
 
 TODO: Write a gem description
 
@@ -24,6 +24,6 @@ TODO: Write usage instructions here
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request

data/Rakefile

@@ -1,2 +1 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"

data/ext/rubysl/dl/depend

@@ -0,0 +1,46 @@
+LDSHARED_TEST = $(LDSHARED) $(LDFLAGS) test/test.o -o test/libtest.so $(LOCAL_LIBS)
+
+libtest.so: test/libtest.so
+
+test/libtest.so: test/test.o $(srcdir)/test/libtest.def
+	$(BUILD_RUBY) -rftools -e 'ARGV.each do|d|File.mkpath(File.dirname(d))end' $@
+	$(LDSHARED_TEST:dl.def=test/libtest.def)
+
+test/test.o: $(srcdir)/test/test.c
+	@$(BUILD_RUBY) -rftools -e 'File.mkpath(*ARGV)' test
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $(srcdir)/test/test.c -o $@
+
+test:: dl.so libtest.so force
+	$(BUILD_RUBY) -I. -I$(srcdir)/lib $(srcdir)/test/test.rb
+
+force:
+
+.PHONY: force test
+
+allclean: distclean
+	@rm -f $(CLEANFILES) $(DISTCLEANFILES)
+
+$(OBJS): ./dlconfig.h
+
+sym.o: ruby.h dl.h call.func
+
+dl.o: ruby.h dl.h callback.func cbtable.func
+
+ptr.o: ruby.h dl.h
+
+handle.o: ruby.h dl.h
+
+call.func: $(srcdir)/mkcall.rb ./dlconfig.rb
+	@echo "Generating call.func"
+	@$(BUILD_RUBY) $(srcdir)/mkcall.rb $@
+
+callback.func: $(srcdir)/mkcallback.rb ./dlconfig.rb
+	@echo "Generating callback.func"
+	@$(BUILD_RUBY) $(srcdir)/mkcallback.rb $@
+
+cbtable.func: $(srcdir)/mkcbtable.rb ./dlconfig.rb
+	@echo "Generating cbtable.func"
+	@$(BUILD_RUBY) $(srcdir)/mkcbtable.rb $@
+
+debug:
+	$(MAKE) CPPFLAGS="$(CPPFLAGS) -DDEBUG"

data/ext/rubysl/dl/dl.c

@@ -0,0 +1,742 @@
+/*
+ * $Id: dl.c 18479 2008-08-11 00:37:21Z shyouhei $
+ */
+
+#include "ruby.h"
+
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#else
+#include "rubyio.h"
+#endif
+
+#include <ctype.h>
+#include "dl.h"
+
+VALUE rb_mDL;
+VALUE rb_eDLError;
+VALUE rb_eDLTypeError;
+
+static VALUE DLFuncTable;
+static void *rb_dl_callback_table[CALLBACK_TYPES][MAX_CALLBACK];
+static ID id_call;
+
+static int
+rb_dl_scan_callback_args(long stack[], const char *proto,
+			 int *argc, VALUE argv[])
+{
+  int i;
+  long *sp;
+  VALUE val;
+
+  sp = stack;
+  for (i=1; proto[i]; i++) {
+    switch (proto[i]) {
+    case 'C':
+      {
+	char v;
+	v = (char)(*sp);
+	sp++;
+	val = INT2NUM(v);
+      }
+      break;
+    case 'H':
+      {
+	short v;
+	v = (short)(*sp);
+	sp++;
+	val = INT2NUM(v);
+      }
+      break;
+    case 'I':
+      {
+	int v;
+	v = (int)(*sp);
+	sp++;
+	val = INT2NUM(v);
+      }
+      break;
+    case 'L':
+      {
+	long v;
+	v = (long)(*sp);
+	sp++;
+	val = INT2NUM(v);
+      }
+      break;
+    case 'F':
+      {
+	float v;
+	memcpy(&v, sp, sizeof(float));
+	sp += sizeof(float)/sizeof(long);
+	val = rb_float_new(v);
+      }
+      break;
+    case 'D':
+      {
+	double v;
+	memcpy(&v, sp, sizeof(double));
+	sp += sizeof(double)/sizeof(long);
+	val = rb_float_new(v);
+      }
+      break;
+    case 'P':
+      {
+	void *v;
+	memcpy(&v, sp, sizeof(void*));
+	sp++;
+	val = rb_dlptr_new(v, 0, 0);
+      }
+      break;
+    case 'S':
+      {
+	char *v;
+	memcpy(&v, sp, sizeof(void*));
+	sp++;
+	val = rb_tainted_str_new2(v);
+      }
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unsupported type `%c'", proto[i]);
+      break;
+    }
+    argv[i-1] = val;
+  }
+  *argc = (i - 1);
+
+  return (*argc);
+}
+
+#include "callback.func"
+
+static void
+init_dl_func_table(){
+#include "cbtable.func"
+}
+
+void *
+dlmalloc(size_t size)
+{
+  DEBUG_CODE2({
+    void *ptr;
+
+    printf("dlmalloc(%d)",size);
+    ptr = xmalloc(size);
+    printf(":0x%x\n",ptr);
+    return ptr;
+  },
+  {
+    return xmalloc(size);
+  });
+}
+
+void *
+dlrealloc(void *ptr, size_t size)
+{
+  DEBUG_CODE({
+    printf("dlrealloc(0x%x,%d)\n",ptr,size);
+  });
+  return xrealloc(ptr, size);
+}
+
+void
+dlfree(void *ptr)
+{
+  DEBUG_CODE({
+    printf("dlfree(0x%x)\n",ptr);
+  });
+  xfree(ptr);
+}
+
+char*
+dlstrdup(const char *str)
+{
+  char *newstr;
+
+  newstr = (char*)dlmalloc(strlen(str)+1);
+  strcpy(newstr,str);
+
+  return newstr;
+}
+
+size_t
+dlsizeof(const char *cstr)
+{
+  size_t size;
+  int i, len, n, dlen;
+  char *d;
+
+  len  = strlen(cstr);
+  size = 0;
+  for (i=0; i<len; i++) {
+    n = 1;
+    if (isdigit(cstr[i+1])) {
+      dlen = 1;
+      while (isdigit(cstr[i+dlen])) { dlen ++; };
+      dlen --;
+      d = ALLOCA_N(char, dlen + 1);
+      strncpy(d, cstr + i + 1, dlen);
+      d[dlen] = '\0';
+      n = atoi(d);
+    }
+    else{
+      dlen = 0;
+    }
+
+    switch (cstr[i]) {
+    case 'I':
+      DLALIGN(0,size,INT_ALIGN);
+    case 'i':
+      size += sizeof(int) * n;
+      break;
+    case 'L':
+      DLALIGN(0,size,LONG_ALIGN);
+    case 'l':
+      size += sizeof(long) * n;
+      break;
+    case 'F':
+      DLALIGN(0,size,FLOAT_ALIGN);
+    case 'f':
+      size += sizeof(float) * n;
+      break;
+    case 'D':
+      DLALIGN(0,size,DOUBLE_ALIGN);
+    case 'd':
+      size += sizeof(double) * n;
+      break;
+    case 'C':
+    case 'c':
+      size += sizeof(char) * n;
+      break;
+    case 'H':
+      DLALIGN(0,size,SHORT_ALIGN);
+    case 'h':
+      size += sizeof(short) * n;
+      break;
+    case 'P':
+    case 'S':
+      DLALIGN(0,size,VOIDP_ALIGN);
+    case 'p':
+    case 's':
+      size += sizeof(void*) * n;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type '%c'", cstr[i]);
+      break;
+    }
+    i += dlen;
+  }
+
+  return size;
+}
+
+static float *
+c_farray(VALUE v, long *size)
+{
+  int i, len;
+  float *ary;
+  VALUE e;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(float) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    case T_FLOAT:
+      ary[i] = (float)(RFLOAT(e)->value);
+      break;
+    case T_NIL:
+      ary[i] = 0.0;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      break;
+    }
+  }
+
+  return ary;
+}
+
+static double *
+c_darray(VALUE v, long *size)
+{
+  int i, len;
+  double *ary;
+  VALUE e;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(double) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    case T_FLOAT:
+      ary[i] = (double)(RFLOAT(e)->value);
+      break;
+    case T_NIL:
+      ary[i] = 0.0;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      break;
+    }
+  }
+
+  return ary;
+}
+
+static long *
+c_larray(VALUE v, long *size)
+{
+  int i, len;
+  long *ary;
+  VALUE e;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(long) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    case T_FIXNUM:
+    case T_BIGNUM:
+      ary[i] = (long)(NUM2INT(e));
+      break;
+    case T_NIL:
+      ary[i] = 0;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      break;
+    }
+  }
+
+  return ary;
+}
+
+static int *
+c_iarray(VALUE v, long *size)
+{
+  int i, len;
+  int *ary;
+  VALUE e;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(int) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    case T_FIXNUM:
+    case T_BIGNUM:
+      ary[i] = (int)(NUM2INT(e));
+      break;
+    case T_NIL:
+      ary[i] = 0;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      break;
+    }
+  }
+
+  return ary;
+}
+
+static short *
+c_harray(VALUE v, long *size)
+{
+  int i, len;
+  short *ary;
+  VALUE e;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(short) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    case T_FIXNUM:
+    case T_BIGNUM:
+      ary[i] = (short)(NUM2INT(e));
+      break;
+    case T_NIL:
+      ary[i] = 0;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      break;
+    }
+  }
+
+  return ary;
+}
+
+static char *
+c_carray(VALUE v, long *size)
+{
+  int i, len;
+  char *ary;
+  VALUE e;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(char) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    case T_FIXNUM:
+    case T_BIGNUM:
+      ary[i] = (char)(NUM2INT(e));
+      break;
+    case T_NIL:
+      ary[i] = 0;
+      break;
+    default:
+      rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      break;
+    }
+  }
+
+  return ary;
+}
+
+static void *
+c_parray(VALUE v, long *size)
+{
+  int i, len;
+  void **ary;
+  VALUE e, tmp;
+
+  len = RARRAY_LEN(v);
+  *size = sizeof(void*) * len;
+  ary = dlmalloc(*size);
+  for (i=0; i < len; i++) {
+    e = rb_ary_entry(v, i);
+    switch (TYPE(e)) {
+    default:
+      tmp = rb_check_string_type(e);
+      if (NIL_P(tmp)) {
+	  rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+      }
+      e = tmp;
+      /* fall through */
+    case T_STRING:
+      rb_check_safe_str(e);
+      {
+	char *str, *src;
+	src = RSTRING(e)->ptr;
+	str = dlstrdup(src);
+	ary[i] = (void*)str;
+      }
+      break;
+    case T_NIL:
+      ary[i] = NULL;
+      break;
+    case T_DATA:
+      if (rb_obj_is_kind_of(e, rb_cDLPtrData)) {
+	struct ptr_data *pdata;
+	Data_Get_Struct(e, struct ptr_data, pdata);
+	ary[i] = (void*)(pdata->ptr);
+      }
+      else{
+        e = rb_funcall(e, rb_intern("to_ptr"), 0);
+        if (rb_obj_is_kind_of(e, rb_cDLPtrData)) {
+	  struct ptr_data *pdata;
+	  Data_Get_Struct(e, struct ptr_data, pdata);
+	  ary[i] = (void*)(pdata->ptr);
+	}
+	else{
+	  rb_raise(rb_eDLTypeError, "unexpected type of the element #%d", i);
+	}
+      }
+      break;
+    }
+  }
+
+  return ary;
+}
+
+void *
+rb_ary2cary(char t, VALUE v, long *size)
+{
+  int len;
+  VALUE val0;
+
+  val0 = rb_check_array_type(v);
+  if(NIL_P(val0)) {
+    rb_raise(rb_eDLTypeError, "an array is expected.");
+  }
+  v = val0;
+
+  len = RARRAY_LEN(v);
+  if (len == 0) {
+    return NULL;
+  }
+
+  if (!size) {
+    size = ALLOCA_N(long,1);
+  }
+
+  val0 = rb_ary_entry(v,0);
+  switch (TYPE(val0)) {
+  case T_FIXNUM:
+  case T_BIGNUM:
+    switch (t) {
+    case 'C': case 'c':
+      return (void*)c_carray(v,size);
+    case 'H': case 'h':
+      return (void*)c_harray(v,size);
+    case 'I': case 'i':
+      return (void*)c_iarray(v,size);
+    case 'L': case 'l': case 0:
+      return (void*)c_larray(v,size);
+    default:
+      rb_raise(rb_eDLTypeError, "type mismatch");
+    }
+  case T_STRING:
+    return (void*)c_parray(v,size);
+  case T_FLOAT:
+    switch (t) {
+    case 'F': case 'f':
+      return (void*)c_farray(v,size);
+    case 'D': case 'd': case 0:
+      return (void*)c_darray(v,size);
+    }
+    rb_raise(rb_eDLTypeError, "type mismatch");
+  case T_DATA:
+    if (rb_obj_is_kind_of(val0, rb_cDLPtrData)) {
+      return (void*)c_parray(v,size);
+    }
+    else{
+      val0 = rb_funcall(val0, rb_intern("to_ptr"), 0);
+      if (rb_obj_is_kind_of(val0, rb_cDLPtrData)) {
+        return (void*)c_parray(v,size);
+      }
+    }
+    rb_raise(rb_eDLTypeError, "type mismatch");
+  case T_NIL:
+    return (void*)c_parray(v, size);
+  default:
+    rb_raise(rb_eDLTypeError, "unsupported type");
+  }
+}
+
+VALUE
+rb_str_to_ptr(VALUE self)
+{
+  char *ptr;
+  int  len;
+  VALUE p;
+
+  len = RSTRING(self)->len;
+  ptr = (char*)dlmalloc(len + 1);
+  memcpy(ptr, RSTRING(self)->ptr, len);
+  ptr[len] = '\0';
+  p = rb_dlptr_new((void*)ptr,len,dlfree);
+  OBJ_INFECT(p, self);
+  return p;
+}
+
+VALUE
+rb_ary_to_ptr(int argc, VALUE argv[], VALUE self)
+{
+  void *ptr = 0;
+  VALUE t;
+  long size;
+
+  switch (rb_scan_args(argc, argv, "01", &t)) {
+  case 1:
+    ptr = rb_ary2cary(StringValuePtr(t)[0], self, &size);
+    break;
+  case 0:
+    ptr = rb_ary2cary(0, self, &size);
+    break;
+  }
+  if (ptr) {
+      VALUE p = rb_dlptr_new(ptr, size, dlfree);
+      OBJ_INFECT(p, self);
+      return p;
+  }
+  return Qnil;
+}
+
+VALUE
+rb_io_to_ptr(VALUE self)
+{
+  rb_io_t *fptr;
+  FILE     *fp;
+
+  GetOpenFile(self, fptr);
+  fp = fptr->f;
+
+  return fp ? rb_dlptr_new(fp, 0, 0) : Qnil;
+}
+
+VALUE
+rb_dl_dlopen(int argc, VALUE argv[], VALUE self)
+{
+  rb_secure(2);
+  return rb_class_new_instance(argc, argv, rb_cDLHandle);
+}
+
+VALUE
+rb_dl_malloc(VALUE self, VALUE size)
+{
+  rb_secure(4);
+  return rb_dlptr_malloc(DLNUM2LONG(size), dlfree);
+}
+
+VALUE
+rb_dl_strdup(VALUE self, VALUE str)
+{
+  SafeStringValue(str);
+  return rb_dlptr_new(strdup(RSTRING(str)->ptr), RSTRING(str)->len, dlfree);
+}
+
+static VALUE
+rb_dl_sizeof(VALUE self, VALUE str)
+{
+  return INT2NUM(dlsizeof(StringValuePtr(str)));
+}
+
+static VALUE
+rb_dl_callback(int argc, VALUE argv[], VALUE self)
+{
+  VALUE type, proc;
+  int rettype, entry, i;
+  char fname[127];
+
+  rb_secure(4);
+  proc = Qnil;
+  switch (rb_scan_args(argc, argv, "11", &type, &proc)) {
+  case 1:
+    if (rb_block_given_p()) {
+      proc = rb_block_proc();
+    }
+    else{
+      proc = Qnil;
+    }
+  default:
+    break;
+  }
+
+  StringValue(type);
+  switch (RSTRING(type)->ptr[0]) {
+  case '0':
+    rettype = 0x00;
+    break;
+  case 'C':
+    rettype = 0x01;
+    break;
+  case 'H':
+    rettype = 0x02;
+    break;
+  case 'I':
+    rettype = 0x03;
+    break;
+  case 'L':
+    rettype = 0x04;
+    break;
+  case 'F':
+    rettype = 0x05;
+    break;
+  case 'D':
+    rettype = 0x06;
+    break;
+  case 'P':
+    rettype = 0x07;
+    break;
+  default:
+    rb_raise(rb_eDLTypeError, "unsupported type `%c'", RSTRING(type)->ptr[0]);
+  }
+
+  entry = -1;
+  for (i=0; i < MAX_CALLBACK; i++) {
+    if (rb_hash_aref(DLFuncTable, rb_assoc_new(INT2NUM(rettype), INT2NUM(i))) == Qnil) {
+      entry = i;
+      break;
+    }
+  }
+  if (entry < 0) {
+    rb_raise(rb_eDLError, "too many callbacks are defined.");
+  }
+
+  rb_hash_aset(DLFuncTable,
+	       rb_assoc_new(INT2NUM(rettype),INT2NUM(entry)),
+	       rb_assoc_new(type,proc));
+  sprintf(fname, "rb_dl_callback_func_%d_%d", rettype, entry);
+  return rb_dlsym_new((void (*)())rb_dl_callback_table[rettype][entry],
+		      fname, RSTRING(type)->ptr);
+}
+
+static VALUE
+rb_dl_remove_callback(VALUE mod, VALUE sym)
+{
+  freefunc_t f;
+  int i, j;
+
+  rb_secure(4);
+  f = rb_dlsym2csym(sym);
+  for (i=0; i < CALLBACK_TYPES; i++) {
+    for (j=0; j < MAX_CALLBACK; j++) {
+      if (rb_dl_callback_table[i][j] == f) {
+	rb_hash_aset(DLFuncTable, rb_assoc_new(INT2NUM(i),INT2NUM(j)),Qnil);
+	break;
+      }
+    }
+  }
+  return Qnil;
+}
+
+void
+Init_dl()
+{
+  void Init_dlptr();
+  void Init_dlsym();
+  void Init_dlhandle();
+
+  id_call = rb_intern("call");
+
+  rb_mDL = rb_define_module("DL");
+
+  rb_eDLError = rb_define_class_under(rb_mDL, "DLError", rb_eStandardError);
+  rb_eDLTypeError = rb_define_class_under(rb_mDL, "DLTypeError", rb_eDLError);
+
+  DLFuncTable = rb_hash_new();
+  init_dl_func_table();
+  rb_define_const(rb_mDL, "FuncTable", DLFuncTable);
+
+  rb_define_const(rb_mDL, "RTLD_GLOBAL", INT2NUM(RTLD_GLOBAL));
+  rb_define_const(rb_mDL, "RTLD_LAZY",   INT2NUM(RTLD_LAZY));
+  rb_define_const(rb_mDL, "RTLD_NOW",    INT2NUM(RTLD_NOW));
+
+  rb_define_const(rb_mDL, "ALIGN_INT",   INT2NUM(ALIGN_INT));
+  rb_define_const(rb_mDL, "ALIGN_LONG",  INT2NUM(ALIGN_LONG));
+  rb_define_const(rb_mDL, "ALIGN_FLOAT", INT2NUM(ALIGN_FLOAT));
+  rb_define_const(rb_mDL, "ALIGN_SHORT", INT2NUM(ALIGN_SHORT));
+  rb_define_const(rb_mDL, "ALIGN_DOUBLE",INT2NUM(ALIGN_DOUBLE));
+  rb_define_const(rb_mDL, "ALIGN_VOIDP", INT2NUM(ALIGN_VOIDP));
+
+  rb_define_const(rb_mDL, "MAX_ARG", INT2NUM(MAX_ARG));
+  rb_define_const(rb_mDL, "DLSTACK", rb_tainted_str_new2(DLSTACK_METHOD));
+
+  rb_define_module_function(rb_mDL, "dlopen", rb_dl_dlopen, -1);
+  rb_define_module_function(rb_mDL, "callback", rb_dl_callback, -1);
+  rb_define_module_function(rb_mDL, "define_callback", rb_dl_callback, -1);
+  rb_define_module_function(rb_mDL, "remove_callback", rb_dl_remove_callback, 1);
+  rb_define_module_function(rb_mDL, "malloc", rb_dl_malloc, 1);
+  rb_define_module_function(rb_mDL, "strdup", rb_dl_strdup, 1);
+  rb_define_module_function(rb_mDL, "sizeof", rb_dl_sizeof, 1);
+
+  Init_dlptr();
+  Init_dlsym();
+  Init_dlhandle();
+
+  rb_define_const(rb_mDL, "FREE", rb_dlsym_new(dlfree, "free", "0P"));
+
+  rb_define_method(rb_cString, "to_ptr", rb_str_to_ptr, 0);
+  rb_define_method(rb_cArray, "to_ptr", rb_ary_to_ptr, -1);
+  rb_define_method(rb_cIO, "to_ptr", rb_io_to_ptr, 0);
+}