fiddle 1.0.9 → 1.1.2

data/ext/fiddle/fiddle.c

@@ -1,3 +1,5 @@
+#include <stdbool.h>
+
 #include <fiddle.h>
 
 VALUE mFiddle;
@@ -7,7 +9,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
 
@@ -58,18 +60,16 @@ rb_fiddle_free(VALUE self, VALUE addr)
 /*
  * call-seq: Fiddle.dlunwrap(addr)
  *
- * Returns the hexadecimal representation of a memory pointer address +addr+
+ * Returns the Ruby object stored at the memory address +addr+
  *
  * Example:
  *
- *   lib = Fiddle.dlopen('/lib64/libc-2.15.so')
- *   => #<Fiddle::Handle:0x00000001342460>
- *
- *   lib['strcpy'].to_s(16)
- *   => "7f59de6dd240"
- *
- *   Fiddle.dlunwrap(Fiddle.dlwrap(lib['strcpy'].to_s(16)))
- *   => "7f59de6dd240"
+ *    x = Object.new
+ *    # => #<Object:0x0000000107c7d870>
+ *    Fiddle.dlwrap(x)
+ *    # => 4425504880
+ *    Fiddle.dlunwrap(_)
+ *    # => #<Object:0x0000000107c7d870>
  */
 VALUE
 rb_fiddle_ptr2value(VALUE self, VALUE addr)
@@ -80,15 +80,22 @@ rb_fiddle_ptr2value(VALUE self, VALUE addr)
 /*
  * call-seq: Fiddle.dlwrap(val)
  *
- * Returns a memory pointer of a function's hexadecimal address location +val+
+ * Returns the memory address of the Ruby object stored at +val+
  *
  * Example:
  *
- *   lib = Fiddle.dlopen('/lib64/libc-2.15.so')
- *   => #<Fiddle::Handle:0x00000001342460>
+ *    x = Object.new
+ *    # => #<Object:0x0000000107c7d870>
+ *    Fiddle.dlwrap(x)
+ *    # => 4425504880
+ *
+ * In the case +val+ is not a heap allocated object, this method will return
+ * the tagged pointer value.
+ *
+ * Example:
  *
- *   Fiddle.dlwrap(lib['strcpy'].to_s(16))
- *   => 25522520
+ *    Fiddle.dlwrap(123)
+ *    # => 247
  */
 static VALUE
 rb_fiddle_value2ptr(VALUE self, VALUE val)
@@ -164,137 +171,199 @@ 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: TYPE_LONG
+    /* Document-const: Fiddle::Types::LONG
      *
      * C type - long
      */
-    rb_define_const(mFiddle, "TYPE_LONG",      INT2NUM(TYPE_LONG));
+    rb_define_const(mFiddleTypes, "LONG",      INT2NUM(TYPE_LONG));
+
+    /* Document-const: Fiddle::Types::ULONG
+     *
+     * C 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: Fiddle::Types::BOOL
+     *
+     * C type - bool
+     */
+    rb_define_const(mFiddleTypes, "BOOL" , INT2NUM(TYPE_BOOL));
 
     /* Document-const: ALIGN_VOIDP
      *
@@ -400,6 +469,12 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "ALIGN_UINTPTR_T", INT2NUM(ALIGN_OF(uintptr_t)));
 
+    /* Document-const: ALIGN_BOOL
+     *
+     * The alignment size of a bool
+     */
+    rb_define_const(mFiddle, "ALIGN_BOOL", INT2NUM(ALIGN_OF(bool)));
+
     /* Document-const: WINDOWS
      *
      * Returns a boolean regarding whether the host is WIN32
@@ -422,30 +497,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 +559,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
@@ -520,6 +649,12 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "SIZEOF_CONST_STRING", INT2NUM(sizeof(const char*)));
 
+    /* Document-const: SIZEOF_BOOL
+     *
+     * size of a bool
+     */
+    rb_define_const(mFiddle, "SIZEOF_BOOL", INT2NUM(sizeof(bool)));
+
     /* Document-const: RUBY_FREE
      *
      * Address of the ruby_xfree() function
@@ -540,13 +675,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,23 +111,36 @@
 #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
-#if HAVE_LONG_LONG
+#define TYPE_ULONG  -TYPE_LONG
+#ifdef HAVE_LONG_LONG
 #define TYPE_LONG_LONG 6
+#define TYPE_ULONG_LONG -TYPE_LONG_LONG
 #endif
 #define TYPE_FLOAT 7
 #define TYPE_DOUBLE 8
 #define TYPE_VARIADIC 9
 #define TYPE_CONST_STRING 10
+#define TYPE_BOOL 11
 
 #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 +148,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 +161,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
@@ -171,7 +197,20 @@
 #endif
 #define TYPE_UINTPTR_T (-TYPE_INTPTR_T)
 
-#define ALIGN_OF(type) offsetof(struct {char align_c; type align_x;}, align_x)
+/* GCC releases before GCC 4.9 had a bug in _Alignof.  See GCC bug 52023
+   <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52023>.
+   clang versions < 8.0.0 have the same bug.  */
+#if defined(HAVE__ALIGNOF)
+# /* Autoconf detected availability of a sane `_Alignof()`. */
+# define ALIGN_OF(type) RB_GNUC_EXTENSION(_Alignof(type))
+#elif (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112 \
+     || (defined(__GNUC__) && __GNUC__ < 4 + (__GNUC_MINOR__ < 9) \
+         && !defined(__clang__)) \
+     || (defined(__clang__) && __clang_major__ < 8))
+# define ALIGN_OF(type) offsetof(struct {char align_c; type align_x;}, align_x)
+#else
+# define ALIGN_OF(type) _Alignof(type)
+#endif
 
 #define ALIGN_VOIDP  ALIGN_OF(void*)
 #define ALIGN_CHAR   ALIGN_OF(char)
@@ -189,14 +228,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/function.c

@@ -53,8 +53,13 @@ function_memsize(const void *p)
 }
 
 const rb_data_type_t function_data_type = {
-    "fiddle/function",
-    {0, deallocate, function_memsize,},
+    .wrap_struct_name = "fiddle/function",
+    .function = {
+        .dmark = 0,
+        .dfree = deallocate,
+        .dsize = function_memsize
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static VALUE