ffi 1.9.24 → 1.16.3

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/nested_struct5.c

@@ -31,6 +31,15 @@ static B B_fn(struct A b2, struct B b3)
 	 (int)b3.x.a, b3.x.b, b3.y,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/nested_struct6.c

@@ -36,6 +36,17 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 (int)b3.x.a, b3.x.b, b3.y, (int)b4.d, b4.e,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)b4.d == 2);
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 15);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/nested_struct7.c

@@ -31,6 +31,15 @@ static B B_fn(struct A b2, struct B b3)
 	 (int)b3.x.a, b3.x.b, b3.y,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)result.x.a == 13);
+  CHECK(result.x.b == 233);
+  CHECK(result.y == 134);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/nested_struct8.c

@@ -36,6 +36,17 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 (int)b3.x.a, b3.x.b, b3.y, (int)b4.d, b4.e,
 	 (int)result.x.a, result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)b4.d == 2);
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 15);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/nested_struct9.c

@@ -36,6 +36,17 @@ static B B_fn(struct A b2, struct B b3, struct C b4)
 	 b3.x.a, (int)b3.x.b, b3.y, (int)b4.d, b4.e,
 	 result.x.a, (int)result.x.b, result.y);
 
+  CHECK((int)b2.a == 1);
+  CHECK(b2.b == 7);
+  CHECK((int)b3.x.a == 12);
+  CHECK(b3.x.b == 127);
+  CHECK(b3.y == 99);
+  CHECK((int)b4.d == 2); 
+  CHECK(b4.e == 9);
+  CHECK((int)result.x.a == 15);
+  CHECK(result.x.b == 242);
+  CHECK(result.y == 143);
+  
   return result;
 }
 

data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs1.c

@@ -0,0 +1,86 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Single argument structs have a different ABI in emscripten.
+   Limitations:        none.
+   PR:         none.
+   Originator: <hood@mit.edu>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  int a;
+} A;
+
+static struct A A_fn(int b0, struct A b1)
+{
+  b1.a += b0;
+  return b1;
+}
+
+static void
+A_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  int b0;
+  struct A b1;
+
+  b0 = *(int*)(args[0]);
+  b1 = *(struct A*)(args[1]);
+
+  *(A*)resp = A_fn(b0, b1);
+}
+
+int main (void)
+{
+  printf("123\n");
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[2];
+  ffi_type cls_struct_type;
+  ffi_type* dbl_arg_types[3];
+
+  int e_dbl = 12125;
+  struct A f_dbl = { 31625 };
+
+  struct A res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_fields[0] = &ffi_type_sint;
+  cls_struct_fields[1] = NULL;
+
+  dbl_arg_types[0] = &ffi_type_sint;
+  dbl_arg_types[1] = &cls_struct_type;
+  dbl_arg_types[2] = NULL;
+
+  res_dbl = A_fn(e_dbl, f_dbl);
+  printf("0 res: %d\n", res_dbl.a);
+  /* { dg-output "0 res: 43750" } */
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+
+  ffi_call(&cif, FFI_FN(A_fn), &res_dbl, args_dbl);
+  printf("1 res: %d\n", res_dbl.a);
+  /* { dg-output "\n1 res: 43750" } */
+  CHECK( res_dbl.a == (e_dbl + f_dbl.a));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, A_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((A(*)(int, A))(code))(e_dbl, f_dbl);
+  printf("2 res: %d\n", res_dbl.a);
+  /* { dg-output "\n2 res: 43750" } */
+  CHECK( res_dbl.a == (e_dbl + f_dbl.a));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs2.c

@@ -0,0 +1,102 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Single argument structs have a different ABI in emscripten.
+   Limitations:        none.
+   PR:         none.
+   Originator: <hood@mit.edu>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  int a, b;
+} A;
+
+typedef struct B {
+  struct A y;
+} B;
+
+static struct B B_fn(int b0, struct B b1)
+{
+  b1.y.a += b0;
+  b1.y.b -= b0;
+  return b1;
+}
+
+static void
+B_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  int b0;
+  struct B b1;
+
+  b0 = *(int*)(args[0]);
+  b1 = *(struct B*)(args[1]);
+
+  *(B*)resp = B_fn(b0, b1);
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[3];
+  ffi_type* cls_struct_fields1[2];
+  ffi_type cls_struct_type, cls_struct_type1;
+  ffi_type* dbl_arg_types[3];
+
+  int e_dbl = 12125;
+  struct B f_dbl = { { 31625, 16723 } };
+
+  struct B res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_type1.size = 0;
+  cls_struct_type1.alignment = 0;
+  cls_struct_type1.type = FFI_TYPE_STRUCT;
+  cls_struct_type1.elements = cls_struct_fields1;
+
+  cls_struct_fields[0] = &ffi_type_sint;
+  cls_struct_fields[1] = &ffi_type_sint;
+  cls_struct_fields[2] = NULL;
+
+  cls_struct_fields1[0] = &cls_struct_type;
+  cls_struct_fields1[1] = NULL;
+
+
+  dbl_arg_types[0] = &ffi_type_sint;
+  dbl_arg_types[1] = &cls_struct_type1;
+  dbl_arg_types[2] = NULL;
+
+  res_dbl = B_fn(e_dbl, f_dbl);
+  printf("0 res: %d %d\n", res_dbl.y.a, res_dbl.y.b);
+  /* { dg-output "0 res: 43750 4598" } */
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type1,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+  ffi_call(&cif, FFI_FN(B_fn), &res_dbl, args_dbl);
+  printf("1 res: %d %d\n", res_dbl.y.a, res_dbl.y.b);
+  /* { dg-output "\n1 res: 43750 4598" } */
+  CHECK( res_dbl.y.a == (f_dbl.y.a + e_dbl));
+  CHECK( res_dbl.y.b == (f_dbl.y.b - e_dbl));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, B_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((B(*)(int, B))(code))(e_dbl, f_dbl);
+  printf("2 res: %d %d\n", res_dbl.y.a, res_dbl.y.b);
+  /* { dg-output "\n2 res: 43750 4598" } */
+  CHECK( res_dbl.y.a == (f_dbl.y.a + e_dbl));
+  CHECK( res_dbl.y.b == (f_dbl.y.b - e_dbl));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs3.c

@@ -0,0 +1,101 @@
+/* Area:       ffi_call, closure_call
+   Purpose:    Single argument structs have a different ABI in emscripten.
+   Limitations:        none.
+   PR:         none.
+   Originator: <hood@mit.edu>  */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct A {
+  int a;
+} A;
+
+typedef struct B {
+  struct A y;
+} B;
+
+static struct B B_fn(int b0, struct B b1)
+{
+  b1.y.a += b0;
+  return b1;
+}
+
+static void
+B_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+     void* userdata __UNUSED__)
+{
+  int b0;
+  struct B b1;
+
+  b0 = *(int*)(args[0]);
+  b1 = *(struct B*)(args[1]);
+
+  *(B*)resp = B_fn(b0, b1);
+}
+
+int main (void)
+{
+  printf("123\n");
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[2];
+  ffi_type* cls_struct_fields1[2];
+  ffi_type cls_struct_type, cls_struct_type1;
+  ffi_type* dbl_arg_types[3];
+
+  int e_dbl = 12125;
+  struct B f_dbl = { { 31625 } };
+
+  struct B res_dbl;
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  cls_struct_type1.size = 0;
+  cls_struct_type1.alignment = 0;
+  cls_struct_type1.type = FFI_TYPE_STRUCT;
+  cls_struct_type1.elements = cls_struct_fields1;
+
+  cls_struct_fields[0] = &ffi_type_sint;
+  cls_struct_fields[1] = NULL;
+
+  cls_struct_fields1[0] = &cls_struct_type;
+  cls_struct_fields1[1] = NULL;
+
+
+  dbl_arg_types[0] = &ffi_type_sint;
+  dbl_arg_types[1] = &cls_struct_type1;
+  dbl_arg_types[2] = NULL;
+
+  res_dbl = B_fn(e_dbl, f_dbl);
+  printf("0 res: %d\n", res_dbl.y.a);
+  /* { dg-output "0 res: 43750" } */
+
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type1,
+                    dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &e_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+
+  ffi_call(&cif, FFI_FN(B_fn), &res_dbl, args_dbl);
+  printf("1 res: %d\n", res_dbl.y.a);
+  /* { dg-output "\n1 res: 43750" } */
+  CHECK( res_dbl.y.a == (e_dbl + f_dbl.y.a));
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, B_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((B(*)(int, B))(code))(e_dbl, f_dbl);
+  printf("2 res: %d\n", res_dbl.y.a);
+  /* { dg-output "\n2 res: 43750" } */
+  CHECK( res_dbl.y.a == (e_dbl + f_dbl.y.a));
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/stret_medium.c

@@ -21,7 +21,7 @@ typedef struct struct_72byte {
 	double i;
 } struct_72byte;
 
-struct_72byte cls_struct_72byte_fn(
+static struct_72byte cls_struct_72byte_fn(
 	struct_72byte b0,
 	struct_72byte b1,
 	struct_72byte b2,

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/stret_medium2.c

@@ -22,7 +22,7 @@ typedef struct struct_72byte {
 	long long i;
 } struct_72byte;
 
-struct_72byte cls_struct_72byte_fn(
+static struct_72byte cls_struct_72byte_fn(
 	struct_72byte b0,
 	struct_72byte b1,
 	struct_72byte b2,

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/testclosure.c

@@ -14,12 +14,17 @@ typedef struct cls_struct_combined {
   float d;
 } cls_struct_combined;
 
-void cls_struct_combined_fn(struct cls_struct_combined arg)
+static void cls_struct_combined_fn(struct cls_struct_combined arg)
 {
   printf("%g %g %g %g\n",
 	 arg.a, arg.b,
 	 arg.c, arg.d);
   fflush(stdout);
+
+  CHECK_FLOAT_EQ(arg.a, 4);
+  CHECK_FLOAT_EQ(arg.b, 5);
+  CHECK_FLOAT_EQ(arg.c, 1);
+  CHECK_FLOAT_EQ(arg.d, 8);
 }
 
 static void

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/unwindtest.cc

@@ -4,7 +4,7 @@
    PR:		none.
    Originator:	Jeff Sturm <jsturm@one-point.com>  */
 
-/* { dg-do run { xfail x86_64-apple-darwin* moxie*-*-* } } */
+/* { dg-do run { xfail moxie*-*-* } } */
 
 #include "ffitest.h"
 
@@ -48,6 +48,7 @@ typedef int (*closure_test_type1)(float, float, float, float, signed short,
 				  float, float, int, double, int, int, float,
 				  int, int, int, int);
 
+extern "C"
 int main (void)
 {
   ffi_cif cif;

data/ext/ffi_c/libffi/testsuite/{libffi.call → libffi.closures}/unwindtest_ffi_call.cc

@@ -14,6 +14,7 @@ static int checking(int a __UNUSED__, short b __UNUSED__,
   throw 9;
 }
 
+extern "C"
 int main (void)
 {
   ffi_cif cif;

data/ext/ffi_c/libffi.bsd.mk

@@ -18,8 +18,8 @@ INCFLAGS := -I${LIBFFI_BUILD_DIR}/include -I${INCFLAGS}
 
 LIBFFI = ${LIBFFI_BUILD_DIR}/.libs/libffi_convenience.a
 LIBFFI_AUTOGEN = ${LIBFFI_SRC_DIR}/autogen.sh
-LIBFFI_CONFIGURE = ${LIBFFI_SRC_DIR}/configure --disable-static \
-	--with-pic=yes --disable-dependency-tracking --disable-docs
+LIBFFI_CONFIGURE = ${LIBFFI_SRC_DIR}/configure --disable-shared --enable-static \
+	--with-pic=yes --disable-dependency-tracking --disable-docs $(LIBFFI_DEBUG)
 
 $(OBJS):	${LIBFFI}
 

data/ext/ffi_c/libffi.darwin.mk

@@ -58,7 +58,7 @@ build_ffi = \
 	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(LIBFFI_CFLAGS)" LDFLAGS="-arch $(1)" \
 		$(LIBFFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
 	fi); \
-	env MACOSX_DEPLOYMENT_TARGET=10.4 $(MAKE) -C "$(BUILD_DIR)"/libffi-$(1)
+	$(MAKE) -C "$(BUILD_DIR)"/libffi-$(1)
 
 target_ffi = "$(BUILD_DIR)"/libffi-$(1)/.libs/libffi_convenience.a:; $(call build_ffi,$(1))
 

data/ext/ffi_c/libffi.gnu.mk

@@ -21,8 +21,8 @@ endif
 
 LIBFFI = "$(LIBFFI_BUILD_DIR)"/.libs/libffi_convenience.a
 LIBFFI_AUTOGEN = ${LIBFFI_SRC_DIR}/autogen.sh
-LIBFFI_CONFIGURE = "$(LIBFFI_SRC_DIR)"/configure --disable-static \
-	--with-pic=yes --disable-dependency-tracking --disable-docs
+LIBFFI_CONFIGURE = "$(LIBFFI_SRC_DIR)"/configure --disable-shared --enable-static \
+	--with-pic=yes --disable-dependency-tracking --disable-docs $(LIBFFI_DEBUG)
 
 $(OBJS):	$(LIBFFI)
 

data/ext/ffi_c/rbffi.h

@@ -39,12 +39,11 @@ extern "C" {
 #define MAX_PARAMETERS (32)
 
 extern VALUE rbffi_FFIModule;
-    
+
 extern void rbffi_Type_Init(VALUE ffiModule);
 extern void rbffi_Buffer_Init(VALUE ffiModule);
 extern void rbffi_Invoker_Init(VALUE ffiModule);
 extern void rbffi_Variadic_Init(VALUE ffiModule);
-extern void rbffi_DataConverter_Init(VALUE ffiModule);
 extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
 extern int rbffi_type_size(VALUE type);
 extern void rbffi_Thread_Init(VALUE moduleFFI);
@@ -54,4 +53,3 @@ extern void rbffi_Thread_Init(VALUE moduleFFI);
 #endif
 
 #endif	/* RBFFI_RBFFI_H */
-

data/ffi.gemspec

@@ -5,17 +5,25 @@ Gem::Specification.new do |s|
   s.version = FFI::VERSION
   s.author = 'Wayne Meissner'
   s.email = 'wmeissner@gmail.com'
-  s.homepage = 'http://wiki.github.com/ffi/ffi'
+  s.homepage = 'https://github.com/ffi/ffi/wiki'
   s.summary = 'Ruby FFI'
   s.description = 'Ruby FFI library'
+  if s.respond_to?(:metadata)
+    s.metadata['bug_tracker_uri'] = 'https://github.com/ffi/ffi/issues'
+    s.metadata['changelog_uri'] = 'https://github.com/ffi/ffi/blob/master/CHANGELOG.md'
+    s.metadata['documentation_uri'] = 'https://github.com/ffi/ffi/wiki'
+    s.metadata['wiki_uri'] = 'https://github.com/ffi/ffi/wiki'
+    s.metadata['source_code_uri'] = 'https://github.com/ffi/ffi/'
+    s.metadata['mailing_list_uri'] = 'http://groups.google.com/group/ruby-ffi'
+  end
   s.files = `git ls-files -z`.split("\x0").reject do |f|
-    f =~ /^(bench|gen|libtest|nbproject|spec)/
+    f =~ /^(\.|bench|gen|libtest|nbproject|spec)/
   end
 
   # Add libffi git files
   lfs = `git --git-dir ext/ffi_c/libffi/.git ls-files -z`.split("\x0")
   # Add autoconf generated files of libffi
-  lfs += %w[ configure config.guess config.sub install-sh ltmain.sh missing fficonfig.h.in ]
+  lfs += %w[ compile configure config.guess config.sub install-sh ltmain.sh missing fficonfig.h.in ]
   # Add automake generated files of libffi
   lfs += `git --git-dir ext/ffi_c/libffi/.git ls-files -z *.am */*.am`.gsub(".am\0", ".in\0").split("\x0")
   s.files += lfs.map do |f|
@@ -23,14 +31,12 @@ Gem::Specification.new do |s|
   end
 
   s.extensions << 'ext/ffi_c/extconf.rb'
-  s.has_rdoc = false
   s.rdoc_options = %w[--exclude=ext/ffi_c/.*\.o$ --exclude=ffi_c\.(bundle|so)$]
   s.license = 'BSD-3-Clause'
   s.require_paths << 'ext/ffi_c'
-  s.required_ruby_version = '>= 1.9'
-  s.add_development_dependency 'rake', '~> 10.1'
-  s.add_development_dependency 'rake-compiler', '~> 1.0'
-  s.add_development_dependency 'rake-compiler-dock', '~> 0.6.2'
+  s.required_ruby_version = '>= 2.5'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'rake-compiler', '~> 1.1'
+  s.add_development_dependency 'rake-compiler-dock', '~> 1.0'
   s.add_development_dependency 'rspec', '~> 2.14.1'
-  s.add_development_dependency 'rubygems-tasks', "~> 0.2.4"
 end

data/lib/ffi/abstract_memory.rb

@@ -0,0 +1,44 @@
+#
+# Copyright (C) 2020 Lars Kanis
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
+
+
+module FFI
+  class AbstractMemory
+    LONG_MAX = FFI::Pointer.new(1).size
+    private_constant :LONG_MAX
+
+    # Return +true+ if +self+ has a size limit.
+    #
+    # @return [Boolean]
+    def size_limit?
+      size != LONG_MAX
+    end
+  end
+end

data/lib/ffi/autopointer.rb

@@ -76,21 +76,21 @@ module FFI
     #  going to be useful if you subclass {AutoPointer}, and override
     #  #release, which by default does nothing.
     def initialize(ptr, proc=nil, &block)
+      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) ||
+          ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
       super(ptr.type_size, ptr)
-      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
-        || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
 
       @releaser = if proc
                     if not proc.respond_to?(:call)
                       raise RuntimeError.new("proc must be callable")
                     end
-                    CallableReleaser.new(ptr, proc)
+                    Releaser.new(ptr, proc)
 
                   else
-                    if not self.class.respond_to?(:release)
+                    if not self.class.respond_to?(:release, true)
                       raise RuntimeError.new("no release method defined")
                     end
-                    DefaultReleaser.new(ptr, self.class)
+                    Releaser.new(ptr, self.class.method(:release))
                   end
 
       ObjectSpace.define_finalizer(self, @releaser)
@@ -107,6 +107,7 @@ module FFI
     # @return [Boolean] +autorelease+
     # Set +autorelease+ property. See {Pointer Autorelease section at Pointer}.
     def autorelease=(autorelease)
+      raise FrozenError.new("can't modify frozen #{self.class}") if frozen?
       @releaser.autorelease=(autorelease)
     end
 
@@ -117,7 +118,7 @@ module FFI
     end
 
     # @abstract Base class for {AutoPointer}'s releasers.
-    #  
+    #
     #  All subclasses of Releaser should define a +#release(ptr)+ method.
     # A releaser is an object in charge of release an {AutoPointer}.
     class Releaser
@@ -149,23 +150,7 @@ module FFI
       def call(*args)
         release(@ptr) if @autorelease && @ptr
       end
-    end
-
-    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined
-    # without Proc or Method. In this case, the pointer to release must be of
-    # a class derived from AutoPointer with a {release} class method.
-    class DefaultReleaser < Releaser
-      # @param [Pointer] ptr
-      # @return [nil]
-      # Release +ptr+ using the {release} class method of its class.
-      def release(ptr)
-        @proc.release(ptr)
-      end
-    end
 
-    # CallableReleaser is a {Releaser} used when an {AutoPointer} is defined with a
-    # Proc or a Method.
-    class CallableReleaser < Releaser
       # Release +ptr+ by using Proc or Method defined at +ptr+
       # {AutoPointer#initialize initialization}.
       #
@@ -182,7 +167,7 @@ module FFI
     # @return [Type::POINTER]
     # @raise {RuntimeError} if class does not implement a +#release+ method
     def self.native_type
-      if not self.respond_to?(:release)
+      if not self.respond_to?(:release, true)
         raise RuntimeError.new("no release method defined for #{self.inspect}")
       end
       Type::POINTER