fiddle 1.0.9 → 1.1.1

data/ext/fiddle/fiddle.c

@@ -7,7 +7,7 @@ VALUE rb_eFiddleError;
 void Init_fiddle_pointer(void);
 void Init_fiddle_pinned(void);
 
-#ifdef FIDDLE_MEMORY_VIEW
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
 void Init_fiddle_memory_view(void);
 #endif
 
@@ -164,137 +164,193 @@ Init_fiddle(void)
      */
     rb_eFiddleDLError = rb_define_class_under(mFiddle, "DLError", rb_eFiddleError);
 
-    /* Document-const: TYPE_VOID
+    VALUE mFiddleTypes = rb_define_module_under(mFiddle, "Types");
+
+    /* Document-const: Fiddle::Types::VOID
      *
      * C type - void
      */
-    rb_define_const(mFiddle, "TYPE_VOID",      INT2NUM(TYPE_VOID));
+    rb_define_const(mFiddleTypes, "VOID",      INT2NUM(TYPE_VOID));
 
-    /* Document-const: TYPE_VOIDP
+    /* Document-const: Fiddle::Types::VOIDP
      *
      * C type - void*
      */
-    rb_define_const(mFiddle, "TYPE_VOIDP",     INT2NUM(TYPE_VOIDP));
+    rb_define_const(mFiddleTypes, "VOIDP",     INT2NUM(TYPE_VOIDP));
 
-    /* Document-const: TYPE_CHAR
+    /* Document-const: Fiddle::Types::CHAR
      *
      * C type - char
      */
-    rb_define_const(mFiddle, "TYPE_CHAR",      INT2NUM(TYPE_CHAR));
+    rb_define_const(mFiddleTypes, "CHAR",      INT2NUM(TYPE_CHAR));
 
-    /* Document-const: TYPE_SHORT
+    /* Document-const: Fiddle::Types::UCHAR
+     *
+     * C type - unsigned char
+     */
+    rb_define_const(mFiddleTypes, "UCHAR",      INT2NUM(TYPE_UCHAR));
+
+    /* Document-const: Fiddle::Types::SHORT
      *
      * C type - short
      */
-    rb_define_const(mFiddle, "TYPE_SHORT",     INT2NUM(TYPE_SHORT));
+    rb_define_const(mFiddleTypes, "SHORT",     INT2NUM(TYPE_SHORT));
 
-    /* Document-const: TYPE_INT
+    /* Document-const: Fiddle::Types::USHORT
+     *
+     * C type - unsigned short
+     */
+    rb_define_const(mFiddleTypes, "USHORT",     INT2NUM(TYPE_USHORT));
+
+    /* Document-const: Fiddle::Types::INT
      *
      * C type - int
      */
-    rb_define_const(mFiddle, "TYPE_INT",       INT2NUM(TYPE_INT));
+    rb_define_const(mFiddleTypes, "INT",       INT2NUM(TYPE_INT));
+
+    /* Document-const: Fiddle::Types::UINT
+     *
+     * C type - unsigned int
+     */
+    rb_define_const(mFiddleTypes, "UINT",       INT2NUM(TYPE_UINT));
+
+    /* Document-const: Fiddle::Types::LONG
+     *
+     * C type - long
+     */
+    rb_define_const(mFiddleTypes, "LONG",      INT2NUM(TYPE_LONG));
 
-    /* Document-const: TYPE_LONG
+    /* Document-const: Fiddle::Types::ULONG
      *
      * C type - long
      */
-    rb_define_const(mFiddle, "TYPE_LONG",      INT2NUM(TYPE_LONG));
+    rb_define_const(mFiddleTypes, "ULONG",      INT2NUM(TYPE_ULONG));
 
 #if HAVE_LONG_LONG
-    /* Document-const: TYPE_LONG_LONG
+    /* Document-const: Fiddle::Types::LONG_LONG
+     *
+     * C type - long long
+     */
+    rb_define_const(mFiddleTypes, "LONG_LONG", INT2NUM(TYPE_LONG_LONG));
+
+    /* Document-const: Fiddle::Types::ULONG_LONG
      *
      * C type - long long
      */
-    rb_define_const(mFiddle, "TYPE_LONG_LONG", INT2NUM(TYPE_LONG_LONG));
+    rb_define_const(mFiddleTypes, "ULONG_LONG", INT2NUM(TYPE_ULONG_LONG));
 #endif
 
 #ifdef TYPE_INT8_T
-    /* Document-const: TYPE_INT8_T
+    /* Document-const: Fiddle::Types::INT8_T
      *
      * C type - int8_t
      */
-    rb_define_const(mFiddle, "TYPE_INT8_T",    INT2NUM(TYPE_INT8_T));
+    rb_define_const(mFiddleTypes, "INT8_T",    INT2NUM(TYPE_INT8_T));
+
+    /* Document-const: Fiddle::Types::UINT8_T
+     *
+     * C type - uint8_t
+     */
+    rb_define_const(mFiddleTypes, "UINT8_T",    INT2NUM(TYPE_UINT8_T));
 #endif
 
 #ifdef TYPE_INT16_T
-    /* Document-const: TYPE_INT16_T
+    /* Document-const: Fiddle::Types::INT16_T
      *
      * C type - int16_t
      */
-    rb_define_const(mFiddle, "TYPE_INT16_T",   INT2NUM(TYPE_INT16_T));
+    rb_define_const(mFiddleTypes, "INT16_T",   INT2NUM(TYPE_INT16_T));
+
+    /* Document-const: Fiddle::Types::UINT16_T
+     *
+     * C type - uint16_t
+     */
+    rb_define_const(mFiddleTypes, "UINT16_T",   INT2NUM(TYPE_UINT16_T));
 #endif
 
 #ifdef TYPE_INT32_T
-    /* Document-const: TYPE_INT32_T
+    /* Document-const: Fiddle::Types::INT32_T
      *
      * C type - int32_t
      */
-    rb_define_const(mFiddle, "TYPE_INT32_T",   INT2NUM(TYPE_INT32_T));
+    rb_define_const(mFiddleTypes, "INT32_T",   INT2NUM(TYPE_INT32_T));
+
+    /* Document-const: Fiddle::Types::UINT32_T
+     *
+     * C type - uint32_t
+     */
+    rb_define_const(mFiddleTypes, "UINT32_T",   INT2NUM(TYPE_UINT32_T));
 #endif
 
 #ifdef TYPE_INT64_T
-    /* Document-const: TYPE_INT64_T
+    /* Document-const: Fiddle::Types::INT64_T
      *
      * C type - int64_t
      */
-    rb_define_const(mFiddle, "TYPE_INT64_T",   INT2NUM(TYPE_INT64_T));
+    rb_define_const(mFiddleTypes, "INT64_T",   INT2NUM(TYPE_INT64_T));
+
+    /* Document-const: Fiddle::Types::UINT64_T
+     *
+     * C type - uint64_t
+     */
+    rb_define_const(mFiddleTypes, "UINT64_T",   INT2NUM(TYPE_UINT64_T));
 #endif
 
-    /* Document-const: TYPE_FLOAT
+    /* Document-const: Fiddle::Types::FLOAT
      *
      * C type - float
      */
-    rb_define_const(mFiddle, "TYPE_FLOAT",     INT2NUM(TYPE_FLOAT));
+    rb_define_const(mFiddleTypes, "FLOAT",     INT2NUM(TYPE_FLOAT));
 
-    /* Document-const: TYPE_DOUBLE
+    /* Document-const: Fiddle::Types::DOUBLE
      *
      * C type - double
      */
-    rb_define_const(mFiddle, "TYPE_DOUBLE",    INT2NUM(TYPE_DOUBLE));
+    rb_define_const(mFiddleTypes, "DOUBLE",    INT2NUM(TYPE_DOUBLE));
 
 #ifdef HAVE_FFI_PREP_CIF_VAR
-    /* Document-const: TYPE_VARIADIC
+    /* Document-const: Fiddle::Types::VARIADIC
      *
      * C type - ...
      */
-    rb_define_const(mFiddle, "TYPE_VARIADIC",  INT2NUM(TYPE_VARIADIC));
+    rb_define_const(mFiddleTypes, "VARIADIC",  INT2NUM(TYPE_VARIADIC));
 #endif
 
-    /* Document-const: TYPE_CONST_STRING
+    /* Document-const: Fiddle::Types::CONST_STRING
      *
      * C type - const char* ('\0' terminated const char*)
      */
-    rb_define_const(mFiddle, "TYPE_CONST_STRING",  INT2NUM(TYPE_CONST_STRING));
+    rb_define_const(mFiddleTypes, "CONST_STRING",  INT2NUM(TYPE_CONST_STRING));
 
-    /* Document-const: TYPE_SIZE_T
+    /* Document-const: Fiddle::Types::SIZE_T
      *
      * C type - size_t
      */
-    rb_define_const(mFiddle, "TYPE_SIZE_T",   INT2NUM(TYPE_SIZE_T));
+    rb_define_const(mFiddleTypes, "SIZE_T",   INT2NUM(TYPE_SIZE_T));
 
-    /* Document-const: TYPE_SSIZE_T
+    /* Document-const: Fiddle::Types::SSIZE_T
      *
      * C type - ssize_t
      */
-    rb_define_const(mFiddle, "TYPE_SSIZE_T",   INT2NUM(TYPE_SSIZE_T));
+    rb_define_const(mFiddleTypes, "SSIZE_T",   INT2NUM(TYPE_SSIZE_T));
 
-    /* Document-const: TYPE_PTRDIFF_T
+    /* Document-const: Fiddle::Types::PTRDIFF_T
      *
      * C type - ptrdiff_t
      */
-    rb_define_const(mFiddle, "TYPE_PTRDIFF_T", INT2NUM(TYPE_PTRDIFF_T));
+    rb_define_const(mFiddleTypes, "PTRDIFF_T", INT2NUM(TYPE_PTRDIFF_T));
 
-    /* Document-const: TYPE_INTPTR_T
+    /* Document-const: Fiddle::Types::INTPTR_T
      *
      * C type - intptr_t
      */
-    rb_define_const(mFiddle, "TYPE_INTPTR_T",  INT2NUM(TYPE_INTPTR_T));
+    rb_define_const(mFiddleTypes, "INTPTR_T",  INT2NUM(TYPE_INTPTR_T));
 
-    /* Document-const: TYPE_UINTPTR_T
+    /* Document-const: Fiddle::Types::UINTPTR_T
      *
      * C type - uintptr_t
      */
-    rb_define_const(mFiddle, "TYPE_UINTPTR_T",  INT2NUM(TYPE_UINTPTR_T));
+    rb_define_const(mFiddleTypes, "UINTPTR_T",  INT2NUM(TYPE_UINTPTR_T));
 
     /* Document-const: ALIGN_VOIDP
      *
@@ -422,30 +478,60 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "SIZEOF_CHAR",  INT2NUM(sizeof(char)));
 
+    /* Document-const: SIZEOF_UCHAR
+     *
+     * size of a unsigned char
+     */
+    rb_define_const(mFiddle, "SIZEOF_UCHAR",  INT2NUM(sizeof(unsigned char)));
+
     /* Document-const: SIZEOF_SHORT
      *
      * size of a short
      */
     rb_define_const(mFiddle, "SIZEOF_SHORT", INT2NUM(sizeof(short)));
 
+    /* Document-const: SIZEOF_USHORT
+     *
+     * size of a unsigned short
+     */
+    rb_define_const(mFiddle, "SIZEOF_USHORT", INT2NUM(sizeof(unsigned short)));
+
     /* Document-const: SIZEOF_INT
      *
      * size of an int
      */
     rb_define_const(mFiddle, "SIZEOF_INT",   INT2NUM(sizeof(int)));
 
+    /* Document-const: SIZEOF_UINT
+     *
+     * size of an unsigned int
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT",   INT2NUM(sizeof(unsigned int)));
+
     /* Document-const: SIZEOF_LONG
      *
      * size of a long
      */
     rb_define_const(mFiddle, "SIZEOF_LONG",  INT2NUM(sizeof(long)));
 
+    /* Document-const: SIZEOF_ULONG
+     *
+     * size of a unsigned long
+     */
+    rb_define_const(mFiddle, "SIZEOF_ULONG",  INT2NUM(sizeof(unsigned long)));
+
 #if HAVE_LONG_LONG
     /* Document-const: SIZEOF_LONG_LONG
      *
      * size of a long long
      */
     rb_define_const(mFiddle, "SIZEOF_LONG_LONG",  INT2NUM(sizeof(LONG_LONG)));
+
+    /* Document-const: SIZEOF_ULONG_LONG
+     *
+     * size of a unsigned long long
+     */
+    rb_define_const(mFiddle, "SIZEOF_ULONG_LONG",  INT2NUM(sizeof(unsigned LONG_LONG)));
 #endif
 
     /* Document-const: SIZEOF_INT8_T
@@ -454,24 +540,48 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "SIZEOF_INT8_T",  INT2NUM(sizeof(int8_t)));
 
+    /* Document-const: SIZEOF_UINT8_T
+     *
+     * size of a uint8_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT8_T",  INT2NUM(sizeof(uint8_t)));
+
     /* Document-const: SIZEOF_INT16_T
      *
      * size of a int16_t
      */
     rb_define_const(mFiddle, "SIZEOF_INT16_T", INT2NUM(sizeof(int16_t)));
 
+    /* Document-const: SIZEOF_UINT16_T
+     *
+     * size of a uint16_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT16_T", INT2NUM(sizeof(uint16_t)));
+
     /* Document-const: SIZEOF_INT32_T
      *
      * size of a int32_t
      */
     rb_define_const(mFiddle, "SIZEOF_INT32_T", INT2NUM(sizeof(int32_t)));
 
+    /* Document-const: SIZEOF_UINT32_T
+     *
+     * size of a uint32_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT32_T", INT2NUM(sizeof(uint32_t)));
+
     /* Document-const: SIZEOF_INT64_T
      *
      * size of a int64_t
      */
     rb_define_const(mFiddle, "SIZEOF_INT64_T", INT2NUM(sizeof(int64_t)));
 
+    /* Document-const: SIZEOF_UINT64_T
+     *
+     * size of a uint64_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT64_T", INT2NUM(sizeof(uint64_t)));
+
     /* Document-const: SIZEOF_FLOAT
      *
      * size of a float
@@ -540,13 +650,37 @@ Init_fiddle(void)
     rb_define_module_function(mFiddle, "realloc", rb_fiddle_realloc, 2);
     rb_define_module_function(mFiddle, "free", rb_fiddle_free, 1);
 
+    /* Document-const: Qtrue
+     *
+     * The value of Qtrue
+     */
+    rb_define_const(mFiddle, "Qtrue", INT2NUM(Qtrue));
+
+    /* Document-const: Qfalse
+     *
+     * The value of Qfalse
+     */
+    rb_define_const(mFiddle, "Qfalse", INT2NUM(Qfalse));
+
+    /* Document-const: Qnil
+     *
+     * The value of Qnil
+     */
+    rb_define_const(mFiddle, "Qnil", INT2NUM(Qnil));
+
+    /* Document-const: Qundef
+     *
+     * The value of Qundef
+     */
+    rb_define_const(mFiddle, "Qundef", INT2NUM(Qundef));
+
     Init_fiddle_function();
     Init_fiddle_closure();
     Init_fiddle_handle();
     Init_fiddle_pointer();
     Init_fiddle_pinned();
 
-#ifdef FIDDLE_MEMORY_VIEW
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
     Init_fiddle_memory_view();
 #endif
 }

data/ext/fiddle/fiddle.h

@@ -12,6 +12,10 @@
 #include <sys/mman.h>
 #endif
 
+#if defined(HAVE_LINK_H)
+# include <link.h>
+#endif
+
 #if defined(HAVE_DLFCN_H)
 # include <dlfcn.h>
 # /* some stranger systems may not define all of these */
@@ -107,11 +111,16 @@
 #define TYPE_VOID  0
 #define TYPE_VOIDP 1
 #define TYPE_CHAR  2
+#define TYPE_UCHAR  -TYPE_CHAR
 #define TYPE_SHORT 3
+#define TYPE_USHORT -TYPE_SHORT
 #define TYPE_INT   4
+#define TYPE_UINT   -TYPE_INT
 #define TYPE_LONG  5
+#define TYPE_ULONG  -TYPE_LONG
 #if HAVE_LONG_LONG
 #define TYPE_LONG_LONG 6
+#define TYPE_ULONG_LONG -TYPE_LONG_LONG
 #endif
 #define TYPE_FLOAT 7
 #define TYPE_DOUBLE 8
@@ -119,11 +128,18 @@
 #define TYPE_CONST_STRING 10
 
 #define TYPE_INT8_T TYPE_CHAR
+#define TYPE_UINT8_T -TYPE_INT8_T
+
 #if SIZEOF_SHORT == 2
 # define TYPE_INT16_T TYPE_SHORT
 #elif SIZEOF_INT == 2
 # define TYPE_INT16_T TYPE_INT
 #endif
+
+#ifdef TYPE_INT16_T
+# define TYPE_UINT16_T -TYPE_INT16_T
+#endif
+
 #if SIZEOF_SHORT == 4
 # define TYPE_INT32_T TYPE_SHORT
 #elif SIZEOF_INT == 4
@@ -131,6 +147,11 @@
 #elif SIZEOF_LONG == 4
 # define TYPE_INT32_T TYPE_LONG
 #endif
+
+#ifdef TYPE_INT32_T
+#define TYPE_UINT32_T -TYPE_INT32_T
+#endif
+
 #if SIZEOF_INT == 8
 # define TYPE_INT64_T TYPE_INT
 #elif SIZEOF_LONG == 8
@@ -139,6 +160,10 @@
 # define TYPE_INT64_T TYPE_LONG_LONG
 #endif
 
+#ifdef TYPE_INT64_T
+#define TYPE_UINT64_T -TYPE_INT64_T
+#endif
+
 #ifndef TYPE_SSIZE_T
 # if SIZEOF_SIZE_T == SIZEOF_INT
 #   define TYPE_SSIZE_T TYPE_INT
@@ -189,14 +214,13 @@
 #define ALIGN_INT32_T ALIGN_OF(int32_t)
 #define ALIGN_INT64_T ALIGN_OF(int64_t)
 
-#ifdef HAVE_TYPE_RB_MEMORY_VIEW_T
-# define FIDDLE_MEMORY_VIEW
-#endif
-
 extern VALUE mFiddle;
 extern VALUE rb_eFiddleDLError;
 
 VALUE rb_fiddle_new_function(VALUE address, VALUE arg_types, VALUE ret_type);
 
+typedef void (*rb_fiddle_freefunc_t)(void*);
+VALUE rb_fiddle_ptr_new_wrap(void *ptr, long size, rb_fiddle_freefunc_t func, VALUE wrap0, VALUE wrap1);
+
 #endif
 /* vim: set noet sws=4 sw=4: */

data/ext/fiddle/handle.c

@@ -259,7 +259,21 @@ rb_fiddle_handle_to_i(VALUE self)
     struct dl_handle *fiddle_handle;
 
     TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
-    return PTR2NUM(fiddle_handle);
+    return PTR2NUM(fiddle_handle->ptr);
+}
+
+/*
+ * call-seq: to_ptr
+ *
+ * Returns the Fiddle::Pointer of this handle.
+ */
+static VALUE
+rb_fiddle_handle_to_ptr(VALUE self)
+{
+    struct dl_handle *fiddle_handle;
+
+    TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
+    return rb_fiddle_ptr_new_wrap(fiddle_handle->ptr, 0, 0, self, 0);
 }
 
 static VALUE fiddle_handle_sym(void *handle, VALUE symbol);
@@ -307,8 +321,10 @@ rb_fiddle_handle_s_sym(VALUE self, VALUE sym)
     return fiddle_handle_sym(RTLD_NEXT, sym);
 }
 
-static VALUE
-fiddle_handle_sym(void *handle, VALUE symbol)
+typedef void (*fiddle_void_func)(void);
+
+static fiddle_void_func
+fiddle_handle_find_func(void *handle, VALUE symbol)
 {
 #if defined(HAVE_DLERROR)
     const char *err;
@@ -316,13 +332,13 @@ fiddle_handle_sym(void *handle, VALUE symbol)
 #else
 # define CHECK_DLERROR
 #endif
-    void (*func)();
+    fiddle_void_func func;
     const char *name = StringValueCStr(symbol);
 
 #ifdef HAVE_DLERROR
     dlerror();
 #endif
-    func = (void (*)())(VALUE)dlsym(handle, name);
+    func = (fiddle_void_func)(VALUE)dlsym(handle, name);
     CHECK_DLERROR;
 #if defined(FUNC_STDCALL)
     if( !func ){
@@ -365,6 +381,53 @@ fiddle_handle_sym(void *handle, VALUE symbol)
 	xfree(name_n);
     }
 #endif
+
+    return func;
+}
+
+static VALUE
+rb_fiddle_handle_s_sym_defined(VALUE self, VALUE sym)
+{
+    fiddle_void_func func;
+
+    func = fiddle_handle_find_func(RTLD_NEXT, sym);
+
+    if( func ) {
+	return PTR2NUM(func);
+    }
+    else {
+	return Qnil;
+    }
+}
+
+static VALUE
+rb_fiddle_handle_sym_defined(VALUE self, VALUE sym)
+{
+    struct dl_handle *fiddle_handle;
+    fiddle_void_func func;
+
+    TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
+    if( ! fiddle_handle->open ){
+	rb_raise(rb_eFiddleDLError, "closed handle");
+    }
+
+    func = fiddle_handle_find_func(fiddle_handle->ptr, sym);
+
+    if( func ) {
+	return PTR2NUM(func);
+    }
+    else {
+	return Qnil;
+    }
+}
+
+static VALUE
+fiddle_handle_sym(void *handle, VALUE symbol)
+{
+    fiddle_void_func func;
+
+    func = fiddle_handle_find_func(handle, symbol);
+
     if( !func ){
 	rb_raise(rb_eFiddleDLError, "unknown symbol \"%"PRIsVALUE"\"", symbol);
     }
@@ -372,6 +435,48 @@ fiddle_handle_sym(void *handle, VALUE symbol)
     return PTR2NUM(func);
 }
 
+/*
+ * call-seq: file_name
+ *
+ * Returns the file name of this handle.
+ */
+static VALUE
+rb_fiddle_handle_file_name(VALUE self)
+{
+    struct dl_handle *fiddle_handle;
+
+    TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
+
+#if defined(HAVE_DLINFO) && defined(HAVE_CONST_RTLD_DI_LINKMAP)
+    {
+	struct link_map *lm = NULL;
+	int res = dlinfo(fiddle_handle->ptr, RTLD_DI_LINKMAP, &lm);
+	if (res == 0 && lm != NULL) {
+	    return rb_str_new_cstr(lm->l_name);
+	}
+	else {
+#if defined(HAVE_DLERROR)
+	    rb_raise(rb_eFiddleDLError, "could not get handle file name: %s", dlerror());
+#else
+	    rb_raise(rb_eFiddleDLError, "could not get handle file name");
+#endif
+	}
+    }
+#elif defined(HAVE_GETMODULEFILENAME)
+    {
+	char filename[MAX_PATH];
+	DWORD res = GetModuleFileName(fiddle_handle->ptr, filename, MAX_PATH);
+	if (res == 0) {
+	    rb_raise(rb_eFiddleDLError, "could not get handle file name: %s", dlerror());
+	}
+	return rb_str_new_cstr(filename);
+    }
+#else
+    (void)fiddle_handle;
+    return Qnil;
+#endif
+}
+
 void
 Init_fiddle_handle(void)
 {
@@ -412,6 +517,7 @@ Init_fiddle_handle(void)
     rb_cHandle = rb_define_class_under(mFiddle, "Handle", rb_cObject);
     rb_define_alloc_func(rb_cHandle, rb_fiddle_handle_s_allocate);
     rb_define_singleton_method(rb_cHandle, "sym", rb_fiddle_handle_s_sym, 1);
+    rb_define_singleton_method(rb_cHandle, "sym_defined?", rb_fiddle_handle_s_sym_defined, 1);
     rb_define_singleton_method(rb_cHandle, "[]", rb_fiddle_handle_s_sym,  1);
 
     /* Document-const: NEXT
@@ -466,9 +572,12 @@ Init_fiddle_handle(void)
 
     rb_define_method(rb_cHandle, "initialize", rb_fiddle_handle_initialize, -1);
     rb_define_method(rb_cHandle, "to_i", rb_fiddle_handle_to_i, 0);
+    rb_define_method(rb_cHandle, "to_ptr", rb_fiddle_handle_to_ptr, 0);
     rb_define_method(rb_cHandle, "close", rb_fiddle_handle_close, 0);
     rb_define_method(rb_cHandle, "sym",  rb_fiddle_handle_sym, 1);
     rb_define_method(rb_cHandle, "[]",  rb_fiddle_handle_sym,  1);
+    rb_define_method(rb_cHandle, "sym_defined?", rb_fiddle_handle_sym_defined, 1);
+    rb_define_method(rb_cHandle, "file_name", rb_fiddle_handle_file_name, 0);
     rb_define_method(rb_cHandle, "disable_close", rb_fiddle_handle_disable_close, 0);
     rb_define_method(rb_cHandle, "enable_close", rb_fiddle_handle_enable_close, 0);
     rb_define_method(rb_cHandle, "close_enabled?", rb_fiddle_handle_close_enabled_p, 0);

data/ext/fiddle/memory_view.c

@@ -1,10 +1,11 @@
+#include <fiddle.h>
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+
 #include <stdbool.h>
 #include <ruby/ruby.h>
 #include <ruby/encoding.h>
-
-#ifdef HAVE_RUBY_MEMORY_VIEW_H
-# include <ruby/memory_view.h>
-#endif
+#include <ruby/memory_view.h>
 
 #if SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
 #   define INTPTR2NUM LL2NUM
@@ -17,9 +18,6 @@
 #   define UINTPTR2NUM UINT2NUM
 #endif
 
-#include <fiddle.h>
-
-#ifdef FIDDLE_MEMORY_VIEW
 VALUE rb_cMemoryView = Qnil;
 
 struct memview_data {
@@ -320,4 +318,4 @@ Init_fiddle_memory_view(void)
     rb_define_method(rb_cMemoryView, "to_s", rb_fiddle_memview_to_s, 0);
 }
 
-#endif /* FIDDLE_MEMORY_VIEW */
+#endif /* HAVE_RUBY_MEMORY_VIEW_H */