fiddle 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c38a3ad33297e304e12b74e0211d00a162ee82c7178e215ae93a9e2acf680365
-  data.tar.gz: 90de39682e0b7e088ae9a7570da2635e06c90b0eef90f3f060730bc7aed9b31c
+  metadata.gz: 53ccf1d87df1a91951377a4baf37bf13519b15a05dd4ae6f18789027ffa69a44
+  data.tar.gz: 59c667cd8a70043e46e517b77700565e481d0ea69c8f7e85a5a27f98914ed357
 SHA512:
-  metadata.gz: 4b14afde84eb5dc8330ff3a394ab1049b848dc57ba8ad41563348b89338825869a9ec2c8ca5b4a657d094f2bda580e7e351fcb15e58578945726cad6a21717a3
-  data.tar.gz: 4540fa620b2cce64fb1dd887512df98de2b277ad76476fd54396a8fe7583bcb2b5213b3cfed4868a61769b3813033f3ed72efbe3edd9c7b65ec6fc81e1f896f7
+  metadata.gz: a10f7c91bde1fe0b9d9c1cc57a0b0ea1c0001e59301496cb676893f0fc948bbae570a8c78ac523a84c43b977db17ff9c2c101e7154ece15ac2b66eb4cf561618
+  data.tar.gz: 41be31921c03c6a153f24bfda7753c706ad0d68602fc6b59f8fe2ebe4d54282e3c0e029ff327ac2aa17bca9e66ccb593d133b6534bd677169b1a99d16ad8bfc8

data/README.md

@@ -1,6 +1,6 @@
 # Fiddle
 
-[![Build Status](https://travis-ci.org/ruby/fiddle.svg?branch=master)](https://travis-ci.org/ruby/fiddle)
+[![CI](https://github.com/ruby/fiddle/actions/workflows/ci.yml/badge.svg)](https://github.com/ruby/fiddle/actions/workflows/ci.yml)
 
 A libffi wrapper for Ruby.
 

data/Rakefile

@@ -5,6 +5,18 @@ task :test do
   ruby("test/run.rb")
 end
 
+namespace :version do
+  desc "Bump version"
+  task :bump do
+    version_rb_path = "lib/fiddle/version.rb"
+    version_rb = File.read(version_rb_path).gsub(/VERSION = "(.+?)"/) do
+      version = $1
+      "VERSION = \"#{version.succ}\""
+    end
+    File.write(version_rb_path, version_rb)
+  end
+end
+
 require 'rake/extensiontask'
 Rake::ExtensionTask.new("fiddle")
 Rake::ExtensionTask.new("-test-/memory_view")

data/ext/fiddle/closure.c

@@ -130,6 +130,10 @@ with_gvl_callback(void *ptr)
 	    rb_ary_push(params, ULL2NUM(*(unsigned LONG_LONG *)x->args[i]));
 	    break;
 #endif
+	  case TYPE_CONST_STRING:
+	    rb_ary_push(params,
+                        rb_str_new_cstr(*((const char **)(x->args[i]))));
+	    break;
 	  default:
 	    rb_raise(rb_eRuntimeError, "closure args: %d", type);
         }
@@ -175,6 +179,10 @@ with_gvl_callback(void *ptr)
 	*(unsigned LONG_LONG *)x->resp = NUM2ULL(ret);
 	break;
 #endif
+      case TYPE_CONST_STRING:
+        /* Dangerous. Callback must keep reference of the String. */
+        *((const char **)(x->resp)) = StringValueCStr(ret);
+        break;
       default:
 	rb_raise(rb_eRuntimeError, "closure retval: %d", type);
     }
@@ -221,6 +229,7 @@ initialize(int rbargc, VALUE argv[], VALUE self)
 {
     VALUE ret;
     VALUE args;
+    VALUE normalized_args;
     VALUE abi;
     fiddle_closure * cl;
     ffi_cif * cif;
@@ -239,21 +248,26 @@ initialize(int rbargc, VALUE argv[], VALUE self)
 
     cl->argv = (ffi_type **)xcalloc(argc + 1, sizeof(ffi_type *));
 
+    normalized_args = rb_ary_new_capa(argc);
     for (i = 0; i < argc; i++) {
-        int type = NUM2INT(RARRAY_AREF(args, i));
-        cl->argv[i] = INT2FFI_TYPE(type);
+        VALUE arg = rb_fiddle_type_ensure(RARRAY_AREF(args, i));
+        rb_ary_push(normalized_args, arg);
+        cl->argv[i] = rb_fiddle_int_to_ffi_type(NUM2INT(arg));
     }
     cl->argv[argc] = NULL;
 
+    ret = rb_fiddle_type_ensure(ret);
     rb_iv_set(self, "@ctype", ret);
-    rb_iv_set(self, "@args", args);
+    rb_iv_set(self, "@args", normalized_args);
 
     cif = &cl->cif;
     pcl = cl->pcl;
 
-    result = ffi_prep_cif(cif, NUM2INT(abi), argc,
-                INT2FFI_TYPE(NUM2INT(ret)),
-		cl->argv);
+    result = ffi_prep_cif(cif,
+                          NUM2INT(abi),
+                          argc,
+                          rb_fiddle_int_to_ffi_type(NUM2INT(ret)),
+                          cl->argv);
 
     if (FFI_OK != result)
 	rb_raise(rb_eRuntimeError, "error prepping CIF %d", result);

data/ext/fiddle/conversions.h

@@ -24,7 +24,6 @@ typedef union
     void * pointer;        /* ffi_type_pointer */
 } fiddle_generic;
 
-/* Deprecated. Use rb_fiddle_*() version. */
 VALUE rb_fiddle_type_ensure(VALUE type);
 ffi_type * rb_fiddle_int_to_ffi_type(int type);
 void rb_fiddle_value_to_generic(int type, VALUE *src, fiddle_generic *dst);

data/ext/fiddle/extconf.rb

@@ -3,6 +3,47 @@ require 'mkmf'
 
 # :stopdoc:
 
+def gcc?
+  RbConfig::CONFIG["GCC"] == "yes"
+end
+
+def disable_optimization_build_flag(flags)
+  if gcc?
+    expanded_flags = RbConfig.expand(flags.dup)
+    optimization_option_pattern = /(^|\s)?-O\d(\s|$)?/
+    if optimization_option_pattern.match?(expanded_flags)
+      expanded_flags.gsub(optimization_option_pattern, '\\1-Og\\2')
+    else
+      flags + " -Og"
+    end
+  else
+    flags
+  end
+end
+
+def enable_debug_build_flag(flags)
+  if gcc?
+    expanded_flags = RbConfig.expand(flags.dup)
+    debug_option_pattern = /(^|\s)-g(?:gdb)?\d?(\s|$)/
+    if debug_option_pattern.match?(expanded_flags)
+      expanded_flags.gsub(debug_option_pattern, '\\1-ggdb3\\2')
+    else
+      flags + " -ggdb3"
+    end
+  else
+    flags
+  end
+end
+
+checking_for(checking_message("--enable-debug-build option")) do
+  enable_debug_build = enable_config("debug-build", false)
+  if enable_debug_build
+    $CFLAGS = disable_optimization_build_flag($CFLAGS)
+    $CFLAGS = enable_debug_build_flag($CFLAGS)
+  end
+  enable_debug_build
+end
+
 libffi_version = nil
 have_libffi = false
 bundle = enable_config('bundled-libffi')
@@ -146,6 +187,7 @@ else
 end
 
 have_header 'sys/mman.h'
+have_header 'link.h'
 
 if have_header "dlfcn.h"
   have_library "dl"
@@ -155,10 +197,14 @@ if have_header "dlfcn.h"
   end
 
   have_func "dlerror"
+  have_func "dlinfo"
+  have_const("RTLD_DI_LINKMAP", "dlfcn.h")
 elsif have_header "windows.h"
-  %w{ LoadLibrary FreeLibrary GetProcAddress }.each do |func|
+  %w{ LoadLibrary FreeLibrary GetProcAddress GetModuleFileName }.each do |func|
     abort "missing function #{func}" unless have_func(func)
   end
+
+  have_library "ws2_32"
 end
 
 have_const('FFI_STDCALL', ffi_header)
@@ -179,10 +225,6 @@ types.each do |type, signed|
   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)')

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
 
@@ -546,7 +546,7 @@ Init_fiddle(void)
     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 */
@@ -189,14 +193,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

@@ -375,10 +375,18 @@ function_call(int argc, VALUE argv[], VALUE self)
         (void)rb_thread_call_without_gvl(nogvl_ffi_call, &args, 0, 0);
     }
 
-    rb_funcall(mFiddle, rb_intern("last_error="), 1, INT2NUM(errno));
+    {
+        int errno_keep = errno;
 #if defined(_WIN32)
-    rb_funcall(mFiddle, rb_intern("win32_last_error="), 1, INT2NUM(errno));
+        DWORD error = WSAGetLastError();
+        int socket_error = WSAGetLastError();
+        rb_funcall(mFiddle, rb_intern("win32_last_error="), 1,
+                   ULONG2NUM(error));
+        rb_funcall(mFiddle, rb_intern("win32_last_socket_error="), 1,
+                   INT2NUM(socket_error));
 #endif
+        rb_funcall(mFiddle, rb_intern("last_error="), 1, INT2NUM(errno_keep));
+    }
 
     ALLOCV_END(alloc_buffer);
 

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);
@@ -372,6 +386,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)
 {
@@ -466,9 +522,11 @@ 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, "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,9 +1,11 @@
-#include <stdbool.h>
-#include <ruby/ruby.h>
+#include <fiddle.h>
 
 #ifdef HAVE_RUBY_MEMORY_VIEW_H
-# include <ruby/memory_view.h>
-#endif
+
+#include <stdbool.h>
+#include <ruby/ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/memory_view.h>
 
 #if SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
 #   define INTPTR2NUM LL2NUM
@@ -16,9 +18,6 @@
 #   define UINTPTR2NUM UINT2NUM
 #endif
 
-#include <fiddle.h>
-
-#ifdef FIDDLE_MEMORY_VIEW
 VALUE rb_cMemoryView = Qnil;
 
 struct memview_data {
@@ -35,12 +34,25 @@ fiddle_memview_mark(void *ptr)
 }
 
 static void
-fiddle_memview_free(void *ptr)
+fiddle_memview_release(struct memview_data *data)
 {
-    struct memview_data *data = ptr;
+    if (NIL_P(data->view.obj)) return;
+
     rb_memory_view_release(&data->view);
-    if (data->members)
+    data->view.obj = Qnil;
+    data->view.byte_size = 0;
+    if (data->members) {
         xfree(data->members);
+        data->members = NULL;
+        data->n_members = 0;
+    }
+}
+
+static void
+fiddle_memview_free(void *ptr)
+{
+    struct memview_data *data = ptr;
+    fiddle_memview_release(data);
     xfree(ptr);
 }
 
@@ -62,11 +74,32 @@ 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->view.byte_size = 0;
     data->members = NULL;
     data->n_members = 0;
     return obj;
 }
 
+static VALUE
+rb_fiddle_memview_release(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;
+    fiddle_memview_release(data);
+    return Qnil;
+}
+
+static VALUE
+rb_fiddle_memview_s_export(VALUE klass, VALUE target)
+{
+    ID id_new;
+    CONST_ID(id_new, "new");
+    VALUE memview = rb_funcall(klass, id_new, 1, target);
+    return rb_ensure(rb_yield, memview, rb_fiddle_memview_release, memview);
+}
+
 static VALUE
 rb_fiddle_memview_initialize(VALUE obj, VALUE target)
 {
@@ -74,6 +107,7 @@ rb_fiddle_memview_initialize(VALUE obj, VALUE target)
     TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
 
     if (!rb_memory_view_get(target, &data->view, 0)) {
+        data->view.obj = Qnil;
         rb_raise(rb_eArgError, "Unable to get a memory view from %+"PRIsVALUE, target);
     }
 
@@ -233,12 +267,44 @@ rb_fiddle_memview_aref(int argc, VALUE *argv, VALUE obj)
     return rb_memory_view_extract_item_members(ptr, data->members, data->n_members);
 }
 
+static VALUE
+rb_fiddle_memview_to_s(VALUE self)
+{
+    struct memview_data *data;
+    const char *raw_data;
+    long byte_size;
+    VALUE string;
+
+    TypedData_Get_Struct(self,
+                         struct memview_data,
+                         &fiddle_memview_data_type,
+                         data);
+
+    if (NIL_P(data->view.obj)) {
+        raw_data = NULL;
+        byte_size = 0;
+    } else {
+        raw_data = data->view.data;
+        byte_size = data->view.byte_size;
+    }
+
+    string = rb_enc_str_new_static(raw_data, byte_size, rb_ascii8bit_encoding());
+    {
+        ID id_memory_view;
+        CONST_ID(id_memory_view, "memory_view");
+        rb_ivar_set(string, id_memory_view, self);
+    }
+    return rb_obj_freeze(string);
+}
+
 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_singleton_method(rb_cMemoryView, "export", rb_fiddle_memview_s_export, 1);
     rb_define_method(rb_cMemoryView, "initialize", rb_fiddle_memview_initialize, 1);
+    rb_define_method(rb_cMemoryView, "release", rb_fiddle_memview_release, 0);
     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);
@@ -249,6 +315,7 @@ Init_fiddle_memory_view(void)
     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);
+    rb_define_method(rb_cMemoryView, "to_s", rb_fiddle_memview_to_s, 0);
 }
 
-#endif /* FIDDLE_MEMORY_VIEW */
+#endif /* HAVE_RUBY_MEMORY_VIEW_H */

data/ext/fiddle/pointer.c

@@ -6,13 +6,13 @@
 #include <ruby/ruby.h>
 #include <ruby/io.h>
 
+#include <ctype.h>
+#include <fiddle.h>
+
 #ifdef HAVE_RUBY_MEMORY_VIEW_H
 # include <ruby/memory_view.h>
 #endif
 
-#include <ctype.h>
-#include <fiddle.h>
-
 #ifdef PRIsVALUE
 # define RB_OBJ_CLASSNAME(obj) rb_obj_class(obj)
 # define RB_OBJ_STRING(obj) (obj)
@@ -24,7 +24,7 @@
 
 VALUE rb_cPointer;
 
-typedef void (*freefunc_t)(void*);
+typedef rb_fiddle_freefunc_t freefunc_t;
 
 struct ptr_data {
     void *ptr;
@@ -92,7 +92,7 @@ static const rb_data_type_t fiddle_ptr_data_type = {
     {fiddle_ptr_mark, fiddle_ptr_free, fiddle_ptr_memsize,},
 };
 
-#ifdef FIDDLE_MEMORY_VIEW
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
 static struct ptr_data *
 fiddle_ptr_check_memory_view(VALUE obj)
 {
@@ -125,7 +125,7 @@ static const rb_memory_view_entry_t fiddle_ptr_memory_view_entry = {
 #endif
 
 static VALUE
-rb_fiddle_ptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
+rb_fiddle_ptr_new2(VALUE klass, void *ptr, long size, freefunc_t func, VALUE wrap0, VALUE wrap1)
 {
     struct ptr_data *data;
     VALUE val;
@@ -135,14 +135,22 @@ rb_fiddle_ptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
     data->free = func;
     data->freed = false;
     data->size = size;
+    data->wrap[0] = wrap0;
+    data->wrap[1] = wrap1;
 
     return val;
 }
 
+VALUE
+rb_fiddle_ptr_new_wrap(void *ptr, long size, freefunc_t func, VALUE wrap0, VALUE wrap1)
+{
+    return rb_fiddle_ptr_new2(rb_cPointer, ptr, size, func, wrap0, wrap1);
+}
+
 static VALUE
 rb_fiddle_ptr_new(void *ptr, long size, freefunc_t func)
 {
-    return rb_fiddle_ptr_new2(rb_cPointer, ptr, size, func);
+    return rb_fiddle_ptr_new2(rb_cPointer, ptr, size, func, 0, 0);
 }
 
 static VALUE
@@ -152,7 +160,7 @@ rb_fiddle_ptr_malloc(VALUE klass, long size, freefunc_t func)
 
     ptr = ruby_xmalloc((size_t)size);
     memset(ptr,0,(size_t)size);
-    return rb_fiddle_ptr_new2(klass, ptr, size, func);
+    return rb_fiddle_ptr_new2(klass, ptr, size, func, 0, 0);
 }
 
 static void *
@@ -770,6 +778,7 @@ rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
     }
     else if (RTEST(rb_obj_is_kind_of(val, rb_cString))){
 	char *str = StringValuePtr(val);
+        wrap = val;
 	ptr = rb_fiddle_ptr_new(str, RSTRING_LEN(val), NULL);
     }
     else if ((vptr = rb_check_funcall(val, id_to_ptr, 0, 0)) != Qundef){
@@ -832,7 +841,7 @@ 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
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
     rb_memory_view_register(rb_cPointer, &fiddle_ptr_memory_view_entry);
 #endif
 

data/fiddle.gemspec

@@ -56,11 +56,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/fiddle/extconf.rb"]
 
-  spec.required_ruby_version = ">= 2.3.0"
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rake-compiler"
+  spec.required_ruby_version = ">= 2.5.0"
 
   spec.metadata["msys2_mingw_dependencies"] = "libffi"
 end

data/lib/fiddle/cparser.rb

@@ -148,9 +148,11 @@ module Fiddle
     #
     def parse_ctype(ty, tymap=nil)
       tymap ||= {}
-      case ty
-      when Array
+      if ty.is_a?(Array)
         return [parse_ctype(ty[0], tymap), ty[1]]
+      end
+      ty = ty.gsub(/\Aconst\s+/, "")
+      case ty
       when 'void'
         return TYPE_VOID
       when /\A(?:(?:signed\s+)?long\s+long(?:\s+int\s+)?|int64_t)(?:\s+\w+)?\z/

data/lib/fiddle/function.rb

@@ -19,5 +19,11 @@ module Fiddle
     def to_i
       ptr.to_i
     end
+
+    # Turn this function in to a proc
+    def to_proc
+      this = self
+      lambda { |*args| this.call(*args) }
+    end
   end
 end

data/lib/fiddle/struct.rb

@@ -13,6 +13,58 @@ module Fiddle
       CStructEntity
     end
 
+    def self.offsetof(name, members, types) # :nodoc:
+      offset = 0
+      worklist = name.split('.')
+      this_type = self
+      while search_name = worklist.shift
+        index = 0
+        member_index = members.index(search_name)
+
+        unless member_index
+          # Possibly a sub-structure
+          member_index = members.index { |member_name, _|
+            member_name == search_name
+          }
+          return unless member_index
+        end
+
+        types.each { |type, count = 1|
+          orig_offset = offset
+          if type.respond_to?(:entity_class)
+            align = type.alignment
+            type_size = type.size
+          else
+            align = PackInfo::ALIGN_MAP[type]
+            type_size = PackInfo::SIZE_MAP[type]
+          end
+
+          # Unions shouldn't advance the offset
+          if this_type.entity_class == CUnionEntity
+            type_size = 0
+          end
+
+          offset = PackInfo.align(orig_offset, align)
+
+          if worklist.empty?
+            return offset if index == member_index
+          else
+            if index == member_index
+              subtype = types[member_index]
+              members = subtype.members
+              types = subtype.types
+              this_type = subtype
+              break
+            end
+          end
+
+          offset += (type_size * count)
+          index += 1
+        }
+      end
+      nil
+    end
+
     def each
       return enum_for(__function__) unless block_given?
 
@@ -75,6 +127,10 @@ module Fiddle
     def CUnion.entity_class
       CUnionEntity
     end
+
+    def self.offsetof(name, members, types) # :nodoc:
+      0
+    end
   end
 
   # Wrapper for arrays within a struct
@@ -172,6 +228,21 @@ module Fiddle
         define_method(:to_i){ @entity.to_i }
         define_singleton_method(:types) { types }
         define_singleton_method(:members) { members }
+
+        # Return the offset of a struct member given its name.
+        # For example:
+        #
+        #     MyStruct = struct [
+        #       "int64_t i",
+        #       "char c",
+        #     ]
+        #
+        #     MyStruct.offsetof("i") # => 0
+        #     MyStruct.offsetof("c") # => 8
+        #
+        define_singleton_method(:offsetof) { |name|
+          klass.offsetof(name, members, types)
+        }
         members.each{|name|
           name = name[0] if name.is_a?(Array) # name is a nested struct
           next if method_defined?(name)

data/lib/fiddle/types.rb

@@ -27,28 +27,29 @@ module Fiddle
   # * WORD
   module Win32Types
     def included(m) # :nodoc:
+      # https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types
       m.module_eval{
-        typealias "DWORD", "unsigned long"
-        typealias "PDWORD", "unsigned long *"
-        typealias "DWORD32", "unsigned long"
-        typealias "DWORD64", "unsigned long long"
-        typealias "WORD", "unsigned short"
-        typealias "PWORD", "unsigned short *"
+        typealias "ATOM", "WORD"
         typealias "BOOL", "int"
-        typealias "ATOM", "int"
         typealias "BYTE", "unsigned char"
-        typealias "PBYTE", "unsigned char *"
+        typealias "DWORD", "unsigned long"
+        typealias "DWORD32", "uint32_t"
+        typealias "DWORD64", "uint64_t"
+        typealias "HANDLE", "PVOID"
+        typealias "HDC", "HANDLE"
+        typealias "HINSTANCE", "HANDLE"
+        typealias "HWND", "HANDLE"
+        typealias "LPCSTR", "const char *"
+        typealias "LPSTR", "char *"
+        typealias "PBYTE", "BYTE *"
+        typealias "PDWORD", "DWORD *"
+        typealias "PHANDLE", "HANDLE *"
+        typealias "PVOID", "void *"
+        typealias "PWORD", "WORD *"
+        typealias "UCHAR", "unsigned char"
         typealias "UINT", "unsigned int"
         typealias "ULONG", "unsigned long"
-        typealias "UCHAR", "unsigned char"
-        typealias "HANDLE", "uintptr_t"
-        typealias "PHANDLE", "void*"
-        typealias "PVOID", "void*"
-        typealias "LPCSTR", "char*"
-        typealias "LPSTR", "char*"
-        typealias "HINSTANCE", "unsigned int"
-        typealias "HDC", "unsigned int"
-        typealias "HWND", "unsigned int"
+        typealias "WORD", "unsigned short"
       }
     end
     module_function :included

data/lib/fiddle/version.rb

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

data/lib/fiddle.rb

@@ -17,6 +17,18 @@ module Fiddle
     def self.win32_last_error= error
       Thread.current[:__FIDDLE_WIN32_LAST_ERROR__] = error
     end
+
+    # Returns the last win32 socket +Error+ of the current executing
+    # +Thread+ or nil if none
+    def self.win32_last_socket_error
+      Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__]
+    end
+
+    # Sets the last win32 socket +Error+ of the current executing
+    # +Thread+ to +error+
+    def self.win32_last_socket_error= error
+      Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__] = error
+    end
   end
 
   # Returns the last +Error+ of the current executing +Thread+ or nil if none

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fiddle
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - Aaron Patterson
@@ -9,50 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-23 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2021-10-22 00:00:00.000000000 Z
+dependencies: []
 description: A libffi wrapper for Ruby.
 email:
 - aaron@tenderlovemaking.com
@@ -111,14 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.2
+rubygems_version: 3.3.0.dev
 signing_key: 
 specification_version: 4
 summary: A libffi wrapper for Ruby.