fiddle 1.0.9 → 1.1.2

data/ext/fiddle/handle.c

@@ -50,8 +50,13 @@ fiddle_handle_memsize(const void *ptr)
 }
 
 static const rb_data_type_t fiddle_handle_data_type = {
-    "fiddle/handle",
-    {0, fiddle_handle_free, fiddle_handle_memsize,},
+    .wrap_struct_name = "fiddle/handle",
+    .function = {
+        .dmark = 0,
+        .dfree = fiddle_handle_free,
+        .dsize = fiddle_handle_memsize
+    },
+    .flags = RUBY_TYPED_WB_PROTECTED,
 };
 
 /*
@@ -259,7 +264,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 +326,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 +337,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 +386,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 +440,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 +522,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 +577,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 */

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;
@@ -88,11 +88,16 @@ fiddle_ptr_memsize(const void *ptr)
 }
 
 static const rb_data_type_t fiddle_ptr_data_type = {
-    "fiddle/pointer",
-    {fiddle_ptr_mark, fiddle_ptr_free, fiddle_ptr_memsize,},
+    .wrap_struct_name = "fiddle/pointer",
+    .function = {
+        .dmark = fiddle_ptr_mark,
+        .dfree = fiddle_ptr_free,
+        .dsize = fiddle_ptr_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
-#ifdef FIDDLE_MEMORY_VIEW
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
 static struct ptr_data *
 fiddle_ptr_check_memory_view(VALUE obj)
 {
@@ -125,7 +130,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 +140,22 @@ rb_fiddle_ptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
     data->free = func;
     data->freed = false;
     data->size = size;
+    RB_OBJ_WRITE(val, &data->wrap[0], wrap0);
+    RB_OBJ_WRITE(val, &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 +165,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 *
@@ -227,8 +240,8 @@ rb_fiddle_ptr_initialize(int argc, VALUE argv[], VALUE self)
 	    /* Free previous memory. Use of inappropriate initialize may cause SEGV. */
 	    (*(data->free))(data->ptr);
 	}
-	data->wrap[0] = wrap;
-	data->wrap[1] = funcwrap;
+	RB_OBJ_WRITE(self, &data->wrap[0], wrap);
+	RB_OBJ_WRITE(self, &data->wrap[1], funcwrap);
 	data->ptr  = p;
 	data->size = s;
 	data->free = f;
@@ -306,7 +319,7 @@ rb_fiddle_ptr_s_malloc(int argc, VALUE argv[], VALUE klass)
     }
 
     obj = rb_fiddle_ptr_malloc(klass, s,f);
-    if (wrap) RPTR_DATA(obj)->wrap[1] = wrap;
+    if (wrap) RB_OBJ_WRITE(obj, &RPTR_DATA(obj)->wrap[1], wrap);
 
     if (rb_block_given_p()) {
         if (!f) {
@@ -787,10 +800,37 @@ rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
 	if (num == val) wrap = 0;
 	ptr = rb_fiddle_ptr_new(NUM2PTR(num), 0, NULL);
     }
-    if (wrap) RPTR_DATA(ptr)->wrap[0] = wrap;
+    if (wrap) RB_OBJ_WRITE(ptr, &RPTR_DATA(ptr)->wrap[0], wrap);
     return ptr;
 }
 
+/*
+ * call-seq:
+ *    Fiddle::Pointer.read(address, len)     => string
+ *
+ * Or read the memory at address +address+ with length +len+ and return a
+ * string with that memory
+ */
+
+static VALUE
+rb_fiddle_ptr_read_mem(VALUE klass, VALUE address, VALUE len)
+{
+    return rb_str_new((char *)NUM2PTR(address), NUM2ULONG(len));
+}
+
+/*
+ * call-seq:
+ *    Fiddle::Pointer.write(address, str)
+ *
+ * Write bytes in +str+ to the location pointed to by +address+.
+ */
+static VALUE
+rb_fiddle_ptr_write_mem(VALUE klass, VALUE addr, VALUE str)
+{
+    memcpy(NUM2PTR(addr), StringValuePtr(str), RSTRING_LEN(str));
+    return str;
+}
+
 void
 Init_fiddle_pointer(void)
 {
@@ -807,6 +847,8 @@ Init_fiddle_pointer(void)
     rb_define_singleton_method(rb_cPointer, "malloc", rb_fiddle_ptr_s_malloc, -1);
     rb_define_singleton_method(rb_cPointer, "to_ptr", rb_fiddle_ptr_s_to_ptr, 1);
     rb_define_singleton_method(rb_cPointer, "[]", rb_fiddle_ptr_s_to_ptr, 1);
+    rb_define_singleton_method(rb_cPointer, "read", rb_fiddle_ptr_read_mem, 2);
+    rb_define_singleton_method(rb_cPointer, "write", rb_fiddle_ptr_write_mem, 2);
     rb_define_method(rb_cPointer, "initialize", rb_fiddle_ptr_initialize, -1);
     rb_define_method(rb_cPointer, "free=", rb_fiddle_ptr_free_set, 1);
     rb_define_method(rb_cPointer, "free",  rb_fiddle_ptr_free_get, 0);
@@ -833,7 +875,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/ext/fiddle/win32/libffi-config.rb

@@ -23,7 +23,7 @@ until ARGV.empty?
   end
 end
 
-IO.foreach("#{srcdir}/configure.ac") do |line|
+File.foreach("#{srcdir}/configure.ac") do |line|
   if /^AC_INIT\((.*)\)/ =~ line
     version = $1.split(/,\s*/)[1]
     version.gsub!(/\A\[|\]\z/, '')
@@ -38,11 +38,11 @@ conf['TARGET'] = /^x64/ =~ host ? "X86_WIN64" : "X86_WIN32"
 FileUtils.mkdir_p([builddir, "#{builddir}/include", "#{builddir}/src/x86"])
 FileUtils.cp("#{basedir}/fficonfig.h", ".", preserve: true)
 
-hdr = IO.binread("#{srcdir}/include/ffi.h.in")
+hdr = File.binread("#{srcdir}/include/ffi.h.in")
 hdr.gsub!(/@(\w+)@/) {conf[$1] || $&}
 hdr.gsub!(/^(#if\s+)@\w+@/, '\10')
-IO.binwrite("#{builddir}/include/ffi.h", hdr)
+File.binwrite("#{builddir}/include/ffi.h", hdr)
 
-mk = IO.binread("#{basedir}/libffi.mk.tmpl")
+mk = File.binread("#{basedir}/libffi.mk.tmpl")
 mk.gsub!(/@(\w+)@/) {conf[$1] || $&}
-IO.binwrite("Makefile", mk)
+File.binwrite("Makefile", mk)

data/fiddle.gemspec

@@ -20,15 +20,12 @@ Gem::Specification.new do |spec|
     "LICENSE.txt",
     "README.md",
     "Rakefile",
-    "bin/downloader.rb",
-    "bin/extlibs.rb",
     "ext/fiddle/closure.c",
     "ext/fiddle/closure.h",
     "ext/fiddle/conversions.c",
     "ext/fiddle/conversions.h",
     "ext/fiddle/depend",
     "ext/fiddle/extconf.rb",
-    "ext/fiddle/extlibs",
     "ext/fiddle/fiddle.c",
     "ext/fiddle/fiddle.h",
     "ext/fiddle/function.c",
@@ -56,11 +53,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/closure.rb

@@ -1,6 +1,31 @@
 # frozen_string_literal: true
 module Fiddle
   class Closure
+    class << self
+      # Create a new closure. If a block is given, the created closure
+      # is automatically freed after the given block is executed.
+      #
+      # The all given arguments are passed to Fiddle::Closure.new. So
+      # using this method without block equals to Fiddle::Closure.new.
+      #
+      # == Example
+      #
+      #   Fiddle::Closure.create(TYPE_INT, [TYPE_INT]) do |closure|
+      #     # closure is freed automatically when this block is finished.
+      #   end
+      def create(*args)
+        if block_given?
+          closure = new(*args)
+          begin
+            yield(closure)
+          ensure
+            closure.free
+          end
+        else
+          new(*args)
+        end
+      end
+    end
 
     # the C type of the return of the FFI closure
     attr_reader :ctype

data/lib/fiddle/cparser.rb

@@ -164,23 +164,35 @@ module Fiddle
         unless Fiddle.const_defined?(:TYPE_LONG_LONG)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-        return -TYPE_LONG_LONG
-      when /\A(?:signed\s+)?long(?:\s+int\s+)?(?:\s+\w+)?\z/
+        return TYPE_ULONG_LONG
+      when /\Aunsigned\s+long(?:\s+int\s+)?(?:\s+\w+)?\z/,
+           /\Aunsigned\s+int\s+long(?:\s+\w+)?\z/,
+           /\Along(?:\s+int)?\s+unsigned(?:\s+\w+)?\z/,
+           /\Aint\s+unsigned\s+long(?:\s+\w+)?\z/,
+           /\A(?:int\s+)?long\s+unsigned(?:\s+\w+)?\z/
+        return TYPE_ULONG
+      when /\A(?:signed\s+)?long(?:\s+int\s+)?(?:\s+\w+)?\z/,
+           /\A(?:signed\s+)?int\s+long(?:\s+\w+)?\z/,
+           /\Along(?:\s+int)?\s+signed(?:\s+\w+)?\z/
         return TYPE_LONG
-      when /\Aunsigned\s+long(?:\s+int\s+)?(?:\s+\w+)?\z/
-        return -TYPE_LONG
+      when /\Aunsigned\s+short(?:\s+int\s+)?(?:\s+\w+)?\z/,
+           /\Aunsigned\s+int\s+short(?:\s+\w+)?\z/,
+           /\Ashort(?:\s+int)?\s+unsigned(?:\s+\w+)?\z/,
+           /\Aint\s+unsigned\s+short(?:\s+\w+)?\z/,
+           /\A(?:int\s+)?short\s+unsigned(?:\s+\w+)?\z/
+        return TYPE_USHORT
+      when /\A(?:signed\s+)?short(?:\s+int\s+)?(?:\s+\w+)?\z/,
+           /\A(?:signed\s+)?int\s+short(?:\s+\w+)?\z/,
+           /\Aint\s+(?:signed\s+)?short(?:\s+\w+)?\z/
+        return TYPE_SHORT
       when /\A(?:signed\s+)?int(?:\s+\w+)?\z/
         return TYPE_INT
       when /\A(?:unsigned\s+int|uint)(?:\s+\w+)?\z/
-        return -TYPE_INT
-      when /\A(?:signed\s+)?short(?:\s+int\s+)?(?:\s+\w+)?\z/
-        return TYPE_SHORT
-      when /\Aunsigned\s+short(?:\s+int\s+)?(?:\s+\w+)?\z/
-        return -TYPE_SHORT
+        return TYPE_UINT
       when /\A(?:signed\s+)?char(?:\s+\w+)?\z/
         return TYPE_CHAR
       when /\Aunsigned\s+char(?:\s+\w+)?\z/
-        return  -TYPE_CHAR
+        return  TYPE_UCHAR
       when /\Aint8_t(?:\s+\w+)?\z/
         unless Fiddle.const_defined?(:TYPE_INT8_T)
           raise(RuntimeError, "unsupported type: #{ty}")
@@ -190,7 +202,7 @@ module Fiddle
         unless Fiddle.const_defined?(:TYPE_INT8_T)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-        return -TYPE_INT8_T
+        return TYPE_UINT8_T
       when /\Aint16_t(?:\s+\w+)?\z/
         unless Fiddle.const_defined?(:TYPE_INT16_T)
           raise(RuntimeError, "unsupported type: #{ty}")
@@ -200,7 +212,7 @@ module Fiddle
         unless Fiddle.const_defined?(:TYPE_INT16_T)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-        return -TYPE_INT16_T
+        return TYPE_UINT16_T
       when /\Aint32_t(?:\s+\w+)?\z/
         unless Fiddle.const_defined?(:TYPE_INT32_T)
           raise(RuntimeError, "unsupported type: #{ty}")
@@ -210,7 +222,7 @@ module Fiddle
         unless Fiddle.const_defined?(:TYPE_INT32_T)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-        return -TYPE_INT32_T
+        return TYPE_UINT32_T
       when /\Aint64_t(?:\s+\w+)?\z/
         unless Fiddle.const_defined?(:TYPE_INT64_T)
           raise(RuntimeError, "unsupported type: #{ty}")
@@ -220,7 +232,7 @@ module Fiddle
         unless Fiddle.const_defined?(:TYPE_INT64_T)
           raise(RuntimeError, "unsupported type: #{ty}")
         end
-        return -TYPE_INT64_T
+        return TYPE_UINT64_T
       when /\Afloat(?:\s+\w+)?\z/
         return TYPE_FLOAT
       when /\Adouble(?:\s+\w+)?\z/
@@ -235,6 +247,8 @@ module Fiddle
         return TYPE_INTPTR_T
       when /\Auintptr_t(?:\s+\w+)?\z/
         return TYPE_UINTPTR_T
+      when "bool"
+        return TYPE_BOOL
       when /\*/, /\[[\s\d]*\]/
         return TYPE_VOIDP
       when "..."

data/lib/fiddle/import.rb

@@ -119,6 +119,8 @@ module Fiddle
           return SIZEOF_VOIDP
         when TYPE_CONST_STRING
           return SIZEOF_CONST_STRING
+        when TYPE_BOOL
+          return SIZEOF_BOOL
         else
           if defined?(TYPE_LONG_LONG) and
             ty == TYPE_LONG_LONG

data/lib/fiddle/pack.rb

@@ -11,25 +11,36 @@ module Fiddle
       TYPE_LONG  => ALIGN_LONG,
       TYPE_FLOAT => ALIGN_FLOAT,
       TYPE_DOUBLE => ALIGN_DOUBLE,
-      -TYPE_CHAR  => ALIGN_CHAR,
-      -TYPE_SHORT => ALIGN_SHORT,
-      -TYPE_INT   => ALIGN_INT,
-      -TYPE_LONG  => ALIGN_LONG,
+      TYPE_UCHAR  => ALIGN_CHAR,
+      TYPE_USHORT => ALIGN_SHORT,
+      TYPE_UINT   => ALIGN_INT,
+      TYPE_ULONG  => ALIGN_LONG,
+      TYPE_BOOL   => ALIGN_BOOL,
     }
 
     PACK_MAP = {
-      TYPE_VOIDP => "l!",
+      TYPE_VOIDP => "L!",
       TYPE_CHAR  => "c",
       TYPE_SHORT => "s!",
       TYPE_INT   => "i!",
       TYPE_LONG  => "l!",
       TYPE_FLOAT => "f",
       TYPE_DOUBLE => "d",
-      -TYPE_CHAR  => "c",
-      -TYPE_SHORT => "s!",
-      -TYPE_INT   => "i!",
-      -TYPE_LONG  => "l!",
+      TYPE_UCHAR  => "C",
+      TYPE_USHORT => "S!",
+      TYPE_UINT   => "I!",
+      TYPE_ULONG  => "L!",
     }
+    case SIZEOF_BOOL
+    when SIZEOF_CHAR
+      PACK_MAP[TYPE_BOOL] = PACK_MAP[TYPE_UCHAR]
+    when SIZEOF_SHORT
+      PACK_MAP[TYPE_BOOL] = PACK_MAP[TYPE_USHORT]
+    when SIZEOF_INT
+      PACK_MAP[TYPE_BOOL] = PACK_MAP[TYPE_UINT]
+    when SIZEOF_LONG
+      PACK_MAP[TYPE_BOOL] = PACK_MAP[TYPE_ULONG]
+    end
 
     SIZE_MAP = {
       TYPE_VOIDP => SIZEOF_VOIDP,
@@ -39,16 +50,18 @@ module Fiddle
       TYPE_LONG  => SIZEOF_LONG,
       TYPE_FLOAT => SIZEOF_FLOAT,
       TYPE_DOUBLE => SIZEOF_DOUBLE,
-      -TYPE_CHAR  => SIZEOF_CHAR,
-      -TYPE_SHORT => SIZEOF_SHORT,
-      -TYPE_INT   => SIZEOF_INT,
-      -TYPE_LONG  => SIZEOF_LONG,
+      TYPE_UCHAR  => SIZEOF_CHAR,
+      TYPE_USHORT => SIZEOF_SHORT,
+      TYPE_UINT   => SIZEOF_INT,
+      TYPE_ULONG  => SIZEOF_LONG,
+      TYPE_BOOL   => SIZEOF_BOOL,
     }
     if defined?(TYPE_LONG_LONG)
-      ALIGN_MAP[TYPE_LONG_LONG] = ALIGN_MAP[-TYPE_LONG_LONG] = ALIGN_LONG_LONG
-      PACK_MAP[TYPE_LONG_LONG] = PACK_MAP[-TYPE_LONG_LONG] = "q"
-      SIZE_MAP[TYPE_LONG_LONG] = SIZE_MAP[-TYPE_LONG_LONG] = SIZEOF_LONG_LONG
-      PACK_MAP[TYPE_VOIDP] = "q" if SIZEOF_LONG_LONG == SIZEOF_VOIDP
+      ALIGN_MAP[TYPE_LONG_LONG] = ALIGN_MAP[TYPE_ULONG_LONG] = ALIGN_LONG_LONG
+      PACK_MAP[TYPE_LONG_LONG] = "q"
+      PACK_MAP[TYPE_ULONG_LONG] = "Q"
+      SIZE_MAP[TYPE_LONG_LONG] = SIZE_MAP[TYPE_ULONG_LONG] = SIZEOF_LONG_LONG
+      PACK_MAP[TYPE_VOIDP] = "Q" if SIZEOF_LONG_LONG == SIZEOF_VOIDP
     end
 
     def align(addr, align)