fiddle 1.0.1 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6273f6abe03da289f77f31e82b7d43fcb99e7144f096319306e91e6d0bc33659
-  data.tar.gz: de279d21f060c1726c701adc9dba5518bb85b179d3ac4dfd716b995948147163
+  metadata.gz: c38a3ad33297e304e12b74e0211d00a162ee82c7178e215ae93a9e2acf680365
+  data.tar.gz: 90de39682e0b7e088ae9a7570da2635e06c90b0eef90f3f060730bc7aed9b31c
 SHA512:
-  metadata.gz: 7afc807eaa5b363d2687027ec7c4d2fffc7779286359095e96a266feb7cdbb0bf6addd8b58b5cb41cff9f1ef86764381828e172b63017cc7567d237f46c9c502
-  data.tar.gz: 8d4cb60138cabdff92524750189ae8024faef07e16d21b9b2b10b7a7bfc7e04913bd61dd1f8482feacbb50b5b9a6f2a4e0f2515f62a6a9c32e6bb3f9ff631bc6
+  metadata.gz: 4b14afde84eb5dc8330ff3a394ab1049b848dc57ba8ad41563348b89338825869a9ec2c8ca5b4a657d094f2bda580e7e351fcb15e58578945726cad6a21717a3
+  data.tar.gz: 4540fa620b2cce64fb1dd887512df98de2b277ad76476fd54396a8fe7583bcb2b5213b3cfed4868a61769b3813033f3ed72efbe3edd9c7b65ec6fc81e1f896f7

data/Rakefile

@@ -7,5 +7,6 @@ end
 
 require 'rake/extensiontask'
 Rake::ExtensionTask.new("fiddle")
+Rake::ExtensionTask.new("-test-/memory_view")
 
 task :default => [:compile, :test]

data/ext/fiddle/conversions.c

@@ -22,6 +22,18 @@ rb_fiddle_type_ensure(VALUE type)
         ID long_id;
 #ifdef TYPE_LONG_LONG
         ID long_long_id;
+#endif
+#ifdef TYPE_INT8_T
+        ID int8_t_id;
+#endif
+#ifdef TYPE_INT16_T
+        ID int16_t_id;
+#endif
+#ifdef TYPE_INT32_T
+        ID int32_t_id;
+#endif
+#ifdef TYPE_INT64_T
+        ID int64_t_id;
 #endif
         ID float_id;
         ID double_id;
@@ -40,6 +52,18 @@ rb_fiddle_type_ensure(VALUE type)
         RUBY_CONST_ID(long_id, "long");
 #ifdef TYPE_LONG_LONG
         RUBY_CONST_ID(long_long_id, "long_long");
+#endif
+#ifdef TYPE_INT8_T
+        RUBY_CONST_ID(int8_t_id, "int8_t");
+#endif
+#ifdef TYPE_INT16_T
+        RUBY_CONST_ID(int16_t_id, "int16_t");
+#endif
+#ifdef TYPE_INT32_T
+        RUBY_CONST_ID(int32_t_id, "int32_t");
+#endif
+#ifdef TYPE_INT64_T
+        RUBY_CONST_ID(int64_t_id, "int64_t");
 #endif
         RUBY_CONST_ID(float_id, "float");
         RUBY_CONST_ID(double_id, "double");
@@ -72,6 +96,26 @@ rb_fiddle_type_ensure(VALUE type)
         else if (type_id == long_long_id) {
             return INT2NUM(TYPE_LONG_LONG);
         }
+#endif
+#ifdef TYPE_INT8_T
+        else if (type_id == int8_t_id) {
+            return INT2NUM(TYPE_INT8_T);
+        }
+#endif
+#ifdef TYPE_INT16_T
+        else if (type_id == int16_t_id) {
+            return INT2NUM(TYPE_INT16_T);
+        }
+#endif
+#ifdef TYPE_INT32_T
+        else if (type_id == int32_t_id) {
+            return INT2NUM(TYPE_INT32_T);
+        }
+#endif
+#ifdef TYPE_INT64_T
+        else if (type_id == int64_t_id) {
+            return INT2NUM(TYPE_INT64_T);
+        }
 #endif
         else if (type_id == float_id) {
             return INT2NUM(TYPE_FLOAT);
@@ -220,7 +264,7 @@ value_to_generic(int type, VALUE src, fiddle_generic *dst)
 {
     /* src isn't safe from GC when type is TYPE_CONST_STRING and src
      * isn't String. */
-    return rb_fiddle_value_to_generic(type, &src, dst);
+    rb_fiddle_value_to_generic(type, &src, dst);
 }
 
 VALUE

data/ext/fiddle/depend

@@ -76,6 +76,8 @@ handle.o: conversions.h
 handle.o: fiddle.h
 handle.o: function.h
 handle.o: handle.c
+memory_view.o: fiddle.h
+memory_view.o: memory_view.c
 pointer.o: closure.h
 pointer.o: conversions.h
 pointer.o: fiddle.h

data/ext/fiddle/extconf.rb

@@ -137,8 +137,10 @@ else
   have_func('ffi_closure_alloc', ffi_header)
 end
 
-if libffi
-  $defs << "-DHAVE_FFI_PREP_CIF_VAR"
+if libffi_version
+  if (libffi_version <=> [3, 0, 11]) >= 0
+    $defs << "-DHAVE_FFI_PREP_CIF_VAR"
+  end
 else
   have_func('ffi_prep_cif_var', ffi_header)
 end
@@ -172,14 +174,19 @@ types.each do |type, signed|
     if signed
       check_signedness(type.downcase, "stddef.h")
     end
+  else
+    check_signedness(type.downcase, "stddef.h")
   end
 end
 
+if have_header("ruby/memory_view.h")
+  have_type("rb_memory_view_t", ["ruby/memory_view.h"])
+end
+
 if libffi
   $LOCAL_LIBS.prepend("./#{libffi.a} ").strip! # to exts.mk
   $INCFLAGS.gsub!(/-I#{libffi.dir}/, '-I$(LIBFFI_DIR)')
 end
-$INCFLAGS << " -I$(top_srcdir)"
 create_makefile 'fiddle' do |conf|
   if !libffi
     next conf << "LIBFFI_CLEAN = none\n"

data/ext/fiddle/fiddle.c

@@ -7,6 +7,10 @@ VALUE rb_eFiddleError;
 void Init_fiddle_pointer(void);
 void Init_fiddle_pinned(void);
 
+#ifdef FIDDLE_MEMORY_VIEW
+void Init_fiddle_memory_view(void);
+#endif
+
 /*
  * call-seq: Fiddle.malloc(size)
  *
@@ -204,6 +208,38 @@ Init_fiddle(void)
     rb_define_const(mFiddle, "TYPE_LONG_LONG", INT2NUM(TYPE_LONG_LONG));
 #endif
 
+#ifdef TYPE_INT8_T
+    /* Document-const: TYPE_INT8_T
+     *
+     * C type - int8_t
+     */
+    rb_define_const(mFiddle, "TYPE_INT8_T",    INT2NUM(TYPE_INT8_T));
+#endif
+
+#ifdef TYPE_INT16_T
+    /* Document-const: TYPE_INT16_T
+     *
+     * C type - int16_t
+     */
+    rb_define_const(mFiddle, "TYPE_INT16_T",   INT2NUM(TYPE_INT16_T));
+#endif
+
+#ifdef TYPE_INT32_T
+    /* Document-const: TYPE_INT32_T
+     *
+     * C type - int32_t
+     */
+    rb_define_const(mFiddle, "TYPE_INT32_T",   INT2NUM(TYPE_INT32_T));
+#endif
+
+#ifdef TYPE_INT64_T
+    /* Document-const: TYPE_INT64_T
+     *
+     * C type - int64_t
+     */
+    rb_define_const(mFiddle, "TYPE_INT64_T",   INT2NUM(TYPE_INT64_T));
+#endif
+
     /* Document-const: TYPE_FLOAT
      *
      * C type - float
@@ -298,6 +334,30 @@ Init_fiddle(void)
     rb_define_const(mFiddle, "ALIGN_LONG_LONG",  INT2NUM(ALIGN_LONG_LONG));
 #endif
 
+    /* Document-const: ALIGN_INT8_T
+     *
+     * The alignment size of a int8_t
+     */
+    rb_define_const(mFiddle, "ALIGN_INT8_T",  INT2NUM(ALIGN_INT8_T));
+
+    /* Document-const: ALIGN_INT16_T
+     *
+     * The alignment size of a int16_t
+     */
+    rb_define_const(mFiddle, "ALIGN_INT16_T", INT2NUM(ALIGN_INT16_T));
+
+    /* Document-const: ALIGN_INT32_T
+     *
+     * The alignment size of a int32_t
+     */
+    rb_define_const(mFiddle, "ALIGN_INT32_T", INT2NUM(ALIGN_INT32_T));
+
+    /* Document-const: ALIGN_INT64_T
+     *
+     * The alignment size of a int64_t
+     */
+    rb_define_const(mFiddle, "ALIGN_INT64_T", INT2NUM(ALIGN_INT64_T));
+
     /* Document-const: ALIGN_FLOAT
      *
      * The alignment size of a float
@@ -388,6 +448,30 @@ Init_fiddle(void)
     rb_define_const(mFiddle, "SIZEOF_LONG_LONG",  INT2NUM(sizeof(LONG_LONG)));
 #endif
 
+    /* Document-const: SIZEOF_INT8_T
+     *
+     * size of a int8_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_INT8_T",  INT2NUM(sizeof(int8_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_INT32_T
+     *
+     * size of a int32_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_INT32_T", INT2NUM(sizeof(int32_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_FLOAT
      *
      * size of a float
@@ -461,5 +545,9 @@ Init_fiddle(void)
     Init_fiddle_handle();
     Init_fiddle_pointer();
     Init_fiddle_pinned();
+
+#ifdef FIDDLE_MEMORY_VIEW
+    Init_fiddle_memory_view();
+#endif
 }
 /* vim: set noet sws=4 sw=4: */

data/ext/fiddle/fiddle.h

@@ -58,38 +58,38 @@
 # error "CHAR_BIT not supported"
 #endif
 
-# if SIZEOF_SHORT == 2
-#  define ffi_type_ushort ffi_type_uint16
-#  define ffi_type_sshort ffi_type_sint16
-# elif SIZEOF_SHORT == 4
-#  define ffi_type_ushort ffi_type_uint32
-#  define ffi_type_sshort ffi_type_sint32
-# else
-#  error "short size not supported"
-# endif
+#if SIZEOF_SHORT == 2
+# define ffi_type_ushort ffi_type_uint16
+# define ffi_type_sshort ffi_type_sint16
+#elif SIZEOF_SHORT == 4
+# define ffi_type_ushort ffi_type_uint32
+# define ffi_type_sshort ffi_type_sint32
+#else
+# error "short size not supported"
+#endif
 
-# if SIZEOF_INT == 2
-#  define ffi_type_uint	ffi_type_uint16
-#  define ffi_type_sint	ffi_type_sint16
-# elif SIZEOF_INT == 4
-#  define ffi_type_uint	ffi_type_uint32
-#  define ffi_type_sint	ffi_type_sint32
-# elif SIZEOF_INT == 8
-#  define ffi_type_uint	ffi_type_uint64
-#  define ffi_type_sint	ffi_type_sint64
-# else
-#  error "int size not supported"
-# endif
+#if SIZEOF_INT == 2
+# define ffi_type_uint	ffi_type_uint16
+# define ffi_type_sint	ffi_type_sint16
+#elif SIZEOF_INT == 4
+# define ffi_type_uint	ffi_type_uint32
+# define ffi_type_sint	ffi_type_sint32
+#elif SIZEOF_INT == 8
+# define ffi_type_uint	ffi_type_uint64
+# define ffi_type_sint	ffi_type_sint64
+#else
+# error "int size not supported"
+#endif
 
-# if SIZEOF_LONG == 4
-#  define ffi_type_ulong ffi_type_uint32
-#  define ffi_type_slong ffi_type_sint32
-# elif SIZEOF_LONG == 8
-#  define ffi_type_ulong ffi_type_uint64
-#  define ffi_type_slong ffi_type_sint64
-# else
-#  error "long size not supported"
-# endif
+#if SIZEOF_LONG == 4
+# define ffi_type_ulong ffi_type_uint32
+# define ffi_type_slong ffi_type_sint32
+#elif SIZEOF_LONG == 8
+# define ffi_type_ulong ffi_type_uint64
+# define ffi_type_slong ffi_type_sint64
+#else
+# error "long size not supported"
+#endif
 
 #if HAVE_LONG_LONG
 # if SIZEOF_LONG_LONG == 8
@@ -118,6 +118,27 @@
 #define TYPE_VARIADIC 9
 #define TYPE_CONST_STRING 10
 
+#define TYPE_INT8_T TYPE_CHAR
+#if SIZEOF_SHORT == 2
+# define TYPE_INT16_T TYPE_SHORT
+#elif SIZEOF_INT == 2
+# define TYPE_INT16_T TYPE_INT
+#endif
+#if SIZEOF_SHORT == 4
+# define TYPE_INT32_T TYPE_SHORT
+#elif SIZEOF_INT == 4
+# define TYPE_INT32_T TYPE_INT
+#elif SIZEOF_LONG == 4
+# define TYPE_INT32_T TYPE_LONG
+#endif
+#if SIZEOF_INT == 8
+# define TYPE_INT64_T TYPE_INT
+#elif SIZEOF_LONG == 8
+# define TYPE_INT64_T TYPE_LONG
+#elif defined(TYPE_LONG_LONG)
+# define TYPE_INT64_T TYPE_LONG_LONG
+#endif
+
 #ifndef TYPE_SSIZE_T
 # if SIZEOF_SIZE_T == SIZEOF_INT
 #   define TYPE_SSIZE_T TYPE_INT
@@ -153,8 +174,8 @@
 #define ALIGN_OF(type) offsetof(struct {char align_c; type align_x;}, align_x)
 
 #define ALIGN_VOIDP  ALIGN_OF(void*)
-#define ALIGN_SHORT  ALIGN_OF(short)
 #define ALIGN_CHAR   ALIGN_OF(char)
+#define ALIGN_SHORT  ALIGN_OF(short)
 #define ALIGN_INT    ALIGN_OF(int)
 #define ALIGN_LONG   ALIGN_OF(long)
 #if HAVE_LONG_LONG
@@ -163,6 +184,15 @@
 #define ALIGN_FLOAT  ALIGN_OF(float)
 #define ALIGN_DOUBLE ALIGN_OF(double)
 
+#define ALIGN_INT8_T  ALIGN_OF(int8_t)
+#define ALIGN_INT16_T ALIGN_OF(int16_t)
+#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;
 

data/ext/fiddle/function.c

@@ -77,18 +77,6 @@ rb_fiddle_new_function(VALUE address, VALUE arg_types, VALUE ret_type)
     return rb_class_new_instance(3, argv, cFiddleFunction);
 }
 
-static int
-parse_keyword_arg_i(VALUE key, VALUE value, VALUE self)
-{
-    if (key == ID2SYM(rb_intern("name"))) {
-	rb_iv_set(self, "@name", value);
-    } else {
-	rb_raise(rb_eArgError, "unknown keyword: %"PRIsVALUE,
-		 RB_OBJ_STRING(key));
-    }
-    return ST_CONTINUE;
-}
-
 static VALUE
 normalize_argument_types(const char *name,
                          VALUE arg_types,
@@ -134,15 +122,40 @@ static VALUE
 initialize(int argc, VALUE argv[], VALUE self)
 {
     ffi_cif * cif;
-    VALUE ptr, arg_types, ret_type, abi, kwds;
+    VALUE ptr, arg_types, ret_type, abi, kwargs;
+    VALUE name = Qnil;
+    VALUE need_gvl = Qfalse;
     int c_ret_type;
     bool is_variadic = false;
     ffi_abi c_ffi_abi;
     void *cfunc;
 
-    rb_scan_args(argc, argv, "31:", &ptr, &arg_types, &ret_type, &abi, &kwds);
+    rb_scan_args(argc, argv, "31:", &ptr, &arg_types, &ret_type, &abi, &kwargs);
     rb_iv_set(self, "@closure", ptr);
 
+    if (!NIL_P(kwargs)) {
+        enum {
+            kw_name,
+            kw_need_gvl,
+            kw_max_,
+        };
+        static ID kw[kw_max_];
+        VALUE args[kw_max_];
+        if (!kw[0]) {
+            kw[kw_name] = rb_intern_const("name");
+            kw[kw_need_gvl] = rb_intern_const("need_gvl");
+        }
+        rb_get_kwargs(kwargs, kw, 0, kw_max_, args);
+        if (args[kw_name] != Qundef) {
+            name = args[kw_name];
+        }
+        if (args[kw_need_gvl] != Qundef) {
+            need_gvl = args[kw_need_gvl];
+        }
+    }
+    rb_iv_set(self, "@name", name);
+    rb_iv_set(self, "@need_gvl", need_gvl);
+
     ptr = rb_Integer(ptr);
     cfunc = NUM2PTR(ptr);
     PTR2NUM(cfunc);
@@ -170,8 +183,6 @@ initialize(int argc, VALUE argv[], VALUE self)
     rb_iv_set(self, "@abi", abi);
     rb_iv_set(self, "@is_variadic", is_variadic ? Qtrue : Qfalse);
 
-    if (!NIL_P(kwds)) rb_hash_foreach(kwds, parse_keyword_arg_i, self);
-
     TypedData_Get_Struct(self, ffi_cif, &function_data_type, cif);
     cif->arg_types = NULL;
 
@@ -205,6 +216,7 @@ function_call(int argc, VALUE argv[], VALUE self)
     VALUE arg_types;
     VALUE cPointer;
     VALUE is_variadic;
+    VALUE need_gvl;
     int n_arg_types;
     int n_fixed_args = 0;
     int n_call_args = 0;
@@ -218,6 +230,7 @@ function_call(int argc, VALUE argv[], VALUE self)
     arg_types = rb_iv_get(self, "@argument_types");
     cPointer = rb_const_get(mFiddle, rb_intern("Pointer"));
     is_variadic = rb_iv_get(self, "@is_variadic");
+    need_gvl = rb_iv_get(self, "@need_gvl");
 
     n_arg_types = RARRAY_LENINT(arg_types);
     n_fixed_args = n_arg_types;
@@ -355,7 +368,12 @@ function_call(int argc, VALUE argv[], VALUE self)
     args.values[i_call] = NULL;
     args.fn = (void(*)(void))NUM2PTR(cfunc);
 
-    (void)rb_thread_call_without_gvl(nogvl_ffi_call, &args, 0, 0);
+    if (RTEST(need_gvl)) {
+        ffi_call(args.cif, args.fn, &(args.retval), args.values);
+    }
+    else {
+        (void)rb_thread_call_without_gvl(nogvl_ffi_call, &args, 0, 0);
+    }
 
     rb_funcall(mFiddle, rb_intern("last_error="), 1, INT2NUM(errno));
 #if defined(_WIN32)
@@ -433,6 +451,10 @@ Init_fiddle_function(void)
      * Caller must ensure the underlying function is called in a
      * thread-safe manner if running in a multi-threaded process.
      *
+     * Note that it is not thread-safe to use this method to
+     * directly or indirectly call many Ruby C-extension APIs unless
+     * you don't pass +need_gvl: true+ to Fiddle::Function#new.
+     *
      * For an example see Fiddle::Function
      *
      */
@@ -440,13 +462,20 @@ Init_fiddle_function(void)
 
     /*
      * Document-method: new
-     * call-seq: new(ptr, args, ret_type, abi = DEFAULT)
+     * call-seq: new(ptr,
+     *               args,
+     *               ret_type,
+     *               abi = DEFAULT,
+     *               name: nil,
+     *               need_gvl: false)
      *
      * Constructs a Function object.
      * * +ptr+ is a referenced function, of a Fiddle::Handle
      * * +args+ is an Array of arguments, passed to the +ptr+ function
      * * +ret_type+ is the return type of the function
      * * +abi+ is the ABI of the function
+     * * +name+ is the name of the function
+     * * +need_gvl+ is whether GVL is needed to call the function
      *
      */
     rb_define_method(cFiddleFunction, "initialize", initialize, -1);

data/ext/fiddle/memory_view.c

@@ -0,0 +1,254 @@
+#include <stdbool.h>
+#include <ruby/ruby.h>
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+# include <ruby/memory_view.h>
+#endif
+
+#if SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
+#   define INTPTR2NUM LL2NUM
+#   define UINTPTR2NUM ULL2NUM
+#elif SIZEOF_INTPTR_T == SIZEOF_LONG
+#   define INTPTR2NUM LONG2NUM
+#   define UINTPTR2NUM ULONG2NUM
+#else
+#   define INTPTR2NUM INT2NUM
+#   define UINTPTR2NUM UINT2NUM
+#endif
+
+#include <fiddle.h>
+
+#ifdef FIDDLE_MEMORY_VIEW
+VALUE rb_cMemoryView = Qnil;
+
+struct memview_data {
+    rb_memory_view_t view;
+    rb_memory_view_item_component_t *members;
+    size_t n_members;
+};
+
+static void
+fiddle_memview_mark(void *ptr)
+{
+    const struct memview_data *data = ptr;
+    rb_gc_mark(data->view.obj);
+}
+
+static void
+fiddle_memview_free(void *ptr)
+{
+    struct memview_data *data = ptr;
+    rb_memory_view_release(&data->view);
+    if (data->members)
+        xfree(data->members);
+    xfree(ptr);
+}
+
+static size_t
+fiddle_memview_memsize(const void *ptr)
+{
+    const struct memview_data *data = ptr;
+    return sizeof(*data) + sizeof(rb_memory_view_item_component_t)*data->n_members + (size_t)data->view.byte_size;
+}
+
+static const rb_data_type_t fiddle_memview_data_type = {
+    "fiddle/memory_view",
+    {fiddle_memview_mark, fiddle_memview_free, fiddle_memview_memsize,},
+};
+
+static VALUE
+rb_fiddle_memview_s_allocate(VALUE klass)
+{
+    struct memview_data *data;
+    VALUE obj = TypedData_Make_Struct(klass, struct memview_data, &fiddle_memview_data_type, data);
+    data->view.obj = Qnil;
+    data->members = NULL;
+    data->n_members = 0;
+    return obj;
+}
+
+static VALUE
+rb_fiddle_memview_initialize(VALUE obj, VALUE target)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (!rb_memory_view_get(target, &data->view, 0)) {
+        rb_raise(rb_eArgError, "Unable to get a memory view from %+"PRIsVALUE, target);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_fiddle_memview_get_obj(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    return data->view.obj;
+}
+
+static VALUE
+rb_fiddle_memview_get_byte_size(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return SSIZET2NUM(data->view.byte_size);
+}
+
+static VALUE
+rb_fiddle_memview_get_readonly(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return data->view.readonly ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_fiddle_memview_get_format(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return data->view.format == NULL ? Qnil : rb_str_new_cstr(data->view.format);
+}
+
+static VALUE
+rb_fiddle_memview_get_item_size(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return SSIZET2NUM(data->view.item_size);
+}
+
+static VALUE
+rb_fiddle_memview_get_ndim(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return SSIZET2NUM(data->view.ndim);
+}
+
+static VALUE
+rb_fiddle_memview_get_shape(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    if (data->view.shape == NULL) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    VALUE shape = rb_ary_new_capa(ndim);
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        rb_ary_push(shape, SSIZET2NUM(data->view.shape[i]));
+    }
+    return shape;
+}
+
+static VALUE
+rb_fiddle_memview_get_strides(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    if (data->view.strides == NULL) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    VALUE strides = rb_ary_new_capa(ndim);
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        rb_ary_push(strides, SSIZET2NUM(data->view.strides[i]));
+    }
+    return strides;
+}
+
+static VALUE
+rb_fiddle_memview_get_sub_offsets(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    if (data->view.sub_offsets == NULL) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    VALUE sub_offsets = rb_ary_new_capa(ndim);
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        rb_ary_push(sub_offsets, SSIZET2NUM(data->view.sub_offsets[i]));
+    }
+    return sub_offsets;
+}
+
+static VALUE
+rb_fiddle_memview_aref(int argc, VALUE *argv, VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    if (argc != ndim) {
+        rb_raise(rb_eIndexError, "wrong number of index (%d for %"PRIdSIZE")", argc, ndim);
+    }
+
+    VALUE indices_v = 0;
+    ssize_t *indices = ALLOCV_N(ssize_t, indices_v, ndim);
+
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        ssize_t x = NUM2SSIZET(argv[i]);
+        indices[i] = x;
+    }
+
+    uint8_t *ptr = rb_memory_view_get_item_pointer(&data->view, indices);
+    ALLOCV_END(indices_v);
+
+    if (data->view.format == NULL) {
+        return INT2FIX(*ptr);
+    }
+
+    if (!data->members) {
+        const char *err;
+        if (rb_memory_view_parse_item_format(data->view.format, &data->members, &data->n_members, &err) < 0) {
+            rb_raise(rb_eRuntimeError, "Unable to recognize item format at %"PRIdSIZE" in \"%s\"",
+                     err - data->view.format, data->view.format);
+        }
+    }
+
+    return rb_memory_view_extract_item_members(ptr, data->members, data->n_members);
+}
+
+void
+Init_fiddle_memory_view(void)
+{
+    rb_cMemoryView = rb_define_class_under(mFiddle, "MemoryView", rb_cObject);
+    rb_define_alloc_func(rb_cMemoryView, rb_fiddle_memview_s_allocate);
+    rb_define_method(rb_cMemoryView, "initialize", rb_fiddle_memview_initialize, 1);
+    rb_define_method(rb_cMemoryView, "obj", rb_fiddle_memview_get_obj, 0);
+    rb_define_method(rb_cMemoryView, "byte_size", rb_fiddle_memview_get_byte_size, 0);
+    rb_define_method(rb_cMemoryView, "readonly?", rb_fiddle_memview_get_readonly, 0);
+    rb_define_method(rb_cMemoryView, "format", rb_fiddle_memview_get_format, 0);
+    rb_define_method(rb_cMemoryView, "item_size", rb_fiddle_memview_get_item_size, 0);
+    rb_define_method(rb_cMemoryView, "ndim", rb_fiddle_memview_get_ndim, 0);
+    rb_define_method(rb_cMemoryView, "shape", rb_fiddle_memview_get_shape, 0);
+    rb_define_method(rb_cMemoryView, "strides", rb_fiddle_memview_get_strides, 0);
+    rb_define_method(rb_cMemoryView, "sub_offsets", rb_fiddle_memview_get_sub_offsets, 0);
+    rb_define_method(rb_cMemoryView, "[]", rb_fiddle_memview_aref, -1);
+}
+
+#endif /* FIDDLE_MEMORY_VIEW */

data/ext/fiddle/pointer.c

@@ -5,6 +5,11 @@
 #include <stdbool.h>
 #include <ruby/ruby.h>
 #include <ruby/io.h>
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+# include <ruby/memory_view.h>
+#endif
+
 #include <ctype.h>
 #include <fiddle.h>
 
@@ -87,6 +92,38 @@ static const rb_data_type_t fiddle_ptr_data_type = {
     {fiddle_ptr_mark, fiddle_ptr_free, fiddle_ptr_memsize,},
 };
 
+#ifdef FIDDLE_MEMORY_VIEW
+static struct ptr_data *
+fiddle_ptr_check_memory_view(VALUE obj)
+{
+    struct ptr_data *data;
+    TypedData_Get_Struct(obj, struct ptr_data, &fiddle_ptr_data_type, data);
+    if (data->ptr == NULL || data->size == 0) return NULL;
+    return data;
+}
+
+static bool
+fiddle_ptr_memory_view_available_p(VALUE obj)
+{
+    return fiddle_ptr_check_memory_view(obj) != NULL;
+}
+
+static bool
+fiddle_ptr_get_memory_view(VALUE obj, rb_memory_view_t *view, int flags)
+{
+    struct ptr_data *data = fiddle_ptr_check_memory_view(obj);
+    rb_memory_view_init_as_byte_array(view, obj, data->ptr, data->size, true);
+
+    return true;
+}
+
+static const rb_memory_view_entry_t fiddle_ptr_memory_view_entry = {
+    fiddle_ptr_get_memory_view,
+    NULL,
+    fiddle_ptr_memory_view_available_p
+};
+#endif
+
 static VALUE
 rb_fiddle_ptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
 {
@@ -795,6 +832,10 @@ Init_fiddle_pointer(void)
     rb_define_method(rb_cPointer, "size", rb_fiddle_ptr_size_get, 0);
     rb_define_method(rb_cPointer, "size=", rb_fiddle_ptr_size_set, 1);
 
+#ifdef FIDDLE_MEMORY_VIEW
+    rb_memory_view_register(rb_cPointer, &fiddle_ptr_memory_view_entry);
+#endif
+
     /*  Document-const: NULL
      *
      * A NULL pointer

data/fiddle.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{A libffi wrapper for Ruby.}
   spec.description   = %q{A libffi wrapper for Ruby.}
   spec.homepage      = "https://github.com/ruby/fiddle"
-  spec.license       = "BSD-2-Clause"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
 
   spec.files         = [
     "LICENSE.txt",
@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
     "ext/fiddle/function.c",
     "ext/fiddle/function.h",
     "ext/fiddle/handle.c",
+    "ext/fiddle/memory_view.c",
     "ext/fiddle/pinned.c",
     "ext/fiddle/pointer.c",
     "ext/fiddle/win32/fficonfig.h",

data/lib/fiddle/cparser.rb

@@ -153,47 +153,85 @@ module Fiddle
         return [parse_ctype(ty[0], tymap), ty[1]]
       when 'void'
         return TYPE_VOID
-      when /^(?:(?:signed\s+)?long\s+long(?:\s+int\s+)?|int64_t)(?:\s+\w+)?$/
-        if( defined?(TYPE_LONG_LONG) )
-          return TYPE_LONG_LONG
-        else
+      when /\A(?:(?:signed\s+)?long\s+long(?:\s+int\s+)?|int64_t)(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_LONG_LONG)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-      when /^(?:unsigned\s+long\s+long(?:\s+int\s+)?|uint64_t)(?:\s+\w+)?$/
-        if( defined?(TYPE_LONG_LONG) )
-          return -TYPE_LONG_LONG
-        else
+        return TYPE_LONG_LONG
+      when /\A(?:unsigned\s+long\s+long(?:\s+int\s+)?|uint64_t)(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_LONG_LONG)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-      when /^(?:signed\s+)?long(?:\s+int\s+)?(?:\s+\w+)?$/
+        return -TYPE_LONG_LONG
+      when /\A(?:signed\s+)?long(?:\s+int\s+)?(?:\s+\w+)?\z/
         return TYPE_LONG
-      when /^unsigned\s+long(?:\s+int\s+)?(?:\s+\w+)?$/
+      when /\Aunsigned\s+long(?:\s+int\s+)?(?:\s+\w+)?\z/
         return -TYPE_LONG
-      when /^(?:signed\s+)?int(?:\s+\w+)?$/
+      when /\A(?:signed\s+)?int(?:\s+\w+)?\z/
         return TYPE_INT
-      when /^(?:unsigned\s+int|uint)(?:\s+\w+)?$/
+      when /\A(?:unsigned\s+int|uint)(?:\s+\w+)?\z/
         return -TYPE_INT
-      when /^(?:signed\s+)?short(?:\s+int\s+)?(?:\s+\w+)?$/
+      when /\A(?:signed\s+)?short(?:\s+int\s+)?(?:\s+\w+)?\z/
         return TYPE_SHORT
-      when /^unsigned\s+short(?:\s+int\s+)?(?:\s+\w+)?$/
+      when /\Aunsigned\s+short(?:\s+int\s+)?(?:\s+\w+)?\z/
         return -TYPE_SHORT
-      when /^(?:signed\s+)?char(?:\s+\w+)?$/
+      when /\A(?:signed\s+)?char(?:\s+\w+)?\z/
         return TYPE_CHAR
-      when /^unsigned\s+char(?:\s+\w+)?$/
+      when /\Aunsigned\s+char(?:\s+\w+)?\z/
         return  -TYPE_CHAR
-      when /^float(?:\s+\w+)?$/
+      when /\Aint8_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT8_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return TYPE_INT8_T
+      when /\Auint8_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT8_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return -TYPE_INT8_T
+      when /\Aint16_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT16_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return TYPE_INT16_T
+      when /\Auint16_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT16_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return -TYPE_INT16_T
+      when /\Aint32_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT32_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return TYPE_INT32_T
+      when /\Auint32_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT32_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return -TYPE_INT32_T
+      when /\Aint64_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT64_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return TYPE_INT64_T
+      when /\Auint64_t(?:\s+\w+)?\z/
+        unless Fiddle.const_defined?(:TYPE_INT64_T)
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+        return -TYPE_INT64_T
+      when /\Afloat(?:\s+\w+)?\z/
         return TYPE_FLOAT
-      when /^double(?:\s+\w+)?$/
+      when /\Adouble(?:\s+\w+)?\z/
         return TYPE_DOUBLE
-      when /^size_t(?:\s+\w+)?$/
+      when /\Asize_t(?:\s+\w+)?\z/
         return TYPE_SIZE_T
-      when /^ssize_t(?:\s+\w+)?$/
+      when /\Assize_t(?:\s+\w+)?\z/
         return TYPE_SSIZE_T
-      when /^ptrdiff_t(?:\s+\w+)?$/
+      when /\Aptrdiff_t(?:\s+\w+)?\z/
         return TYPE_PTRDIFF_T
-      when /^intptr_t(?:\s+\w+)?$/
+      when /\Aintptr_t(?:\s+\w+)?\z/
         return TYPE_INTPTR_T
-      when /^uintptr_t(?:\s+\w+)?$/
+      when /\Auintptr_t(?:\s+\w+)?\z/
         return TYPE_UINTPTR_T
       when /\*/, /\[[\s\d]*\]/
         return TYPE_VOIDP
@@ -213,7 +251,7 @@ module Fiddle
 
     def split_arguments(arguments, sep=',')
       return [] if arguments.strip == 'void'
-      arguments.scan(/([\w\*\s]+\(\*\w*\)\(.*?\)|[\w\*\s\[\]]+|\.\.\.)(?:#{sep}\s*|$)/).collect {|m| m[0]}
+      arguments.scan(/([\w\*\s]+\(\*\w*\)\(.*?\)|[\w\*\s\[\]]+|\.\.\.)(?:#{sep}\s*|\z)/).collect {|m| m[0]}
     end
 
     def compact(signature)

data/lib/fiddle/function.rb

@@ -10,6 +10,11 @@ module Fiddle
     # The name of this function
     attr_reader :name
 
+    # Whether GVL is needed to call this function
+    def need_gvl?
+      @need_gvl
+    end
+
     # The integer memory location of this function
     def to_i
       ptr.to_i

data/lib/fiddle/version.rb

@@ -1,3 +1,3 @@
 module Fiddle
-  VERSION = "1.0.1"
+  VERSION = "1.0.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fiddle
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.6
 platform: ruby
 authors:
 - Aaron Patterson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-17 00:00:00.000000000 Z
+date: 2020-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,6 +79,7 @@ files:
 - ext/fiddle/function.c
 - ext/fiddle/function.h
 - ext/fiddle/handle.c
+- ext/fiddle/memory_view.c
 - ext/fiddle/pinned.c
 - ext/fiddle/pointer.c
 - ext/fiddle/win32/fficonfig.h
@@ -98,6 +99,7 @@ files:
 - lib/fiddle/version.rb
 homepage: https://github.com/ruby/fiddle
 licenses:
+- Ruby
 - BSD-2-Clause
 metadata:
   msys2_mingw_dependencies: libffi
@@ -116,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
+rubygems_version: 3.2.2
 signing_key: 
 specification_version: 4
 summary: A libffi wrapper for Ruby.