ffi 1.0.0 → 1.17.1

data/ext/ffi_c/Platform.c

@@ -1,35 +1,49 @@
-#include <sys/param.h>
-#include <sys/types.h>
+/*
+ * Copyright (c) 2008-2010 Wayne Meissner
+ *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
+ * 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 <COPYRIGHT HOLDER> 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.
+ */
+
+#ifndef _MSC_VER
+# include <sys/param.h>
+#endif
+# include <sys/types.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
-#include "endian.h"
+#include "rbffi_endian.h"
 #include "Platform.h"
 
-static VALUE PlatformModule = Qnil;
-
-/*
- * Determine the cpu type at compile time - useful for MacOSX where the the
- * system installed ruby incorrectly reports 'host_cpu' as 'powerpc' when running
- * on intel.
- */
-#ifdef __i386__
-#define CPU "i386"
-#elif defined(__ppc__) || defined(__powerpc__)
-#define CPU "powerpc"
-#elif defined(__x86_64__)
-#define CPU "x86_64"
-#elif defined(__sparc__)
-#define CPU "sparc"
-#elif defined(__sparcv9__)
-#define CPU "sparcv9"
-#elif defined(__arm__)
-#define CPU "arm"
-#else
-#error "Unknown cpu type"
+#if defined(__GNU__) || (defined(__GLIBC__) && !defined(__UCLIBC__))
+# include <gnu/lib-names.h>
 #endif
 
+static VALUE PlatformModule = Qnil;
+
 static void
 export_primitive_types(VALUE module)
 {
@@ -45,6 +59,7 @@ export_primitive_types(VALUE module)
     S(LONG, long);
     S(FLOAT, float);
     S(DOUBLE, double);
+    S(LONG_DOUBLE, long double);
     S(ADDRESS, void*);
 #undef S
 }
@@ -56,6 +71,8 @@ rbffi_Platform_Init(VALUE moduleFFI)
     rb_define_const(PlatformModule, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
     rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
     rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
-    rb_define_const(PlatformModule, "CPU", rb_str_new2(CPU));
+#if defined(__GNU__) || (defined(__GLIBC__) && !defined(__UCLIBC__))
+    rb_define_const(PlatformModule, "GNU_LIBC", rb_str_new2(LIBC_SO));
+#endif
     export_primitive_types(PlatformModule);
 }

data/ext/ffi_c/Platform.h

@@ -1,5 +1,34 @@
-#ifndef _PLATFORM_H
-#define	_PLATFORM_H
+/*
+ * Copyright (c) 2008-2010 Wayne Meissner
+ *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
+ * 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 <COPYRIGHT HOLDER> 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.
+ */
+
+#ifndef RBFFI_PLATFORM_H
+#define	RBFFI_PLATFORM_H
 
 #ifdef	__cplusplus
 extern "C" {
@@ -12,5 +41,5 @@ extern "C" {
 }
 #endif
 
-#endif	/* _PLATFORM_H */
+#endif	/* RBFFI_PLATFORM_H */
 

data/ext/ffi_c/Pointer.c

@@ -1,42 +1,65 @@
 /*
  * Copyright (c) 2008, 2009, Wayne Meissner
  *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * 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 code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * 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 <COPYRIGHT HOLDER> 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.
  */
 
-#include <stdbool.h>
 #include <stdint.h>
+#include <stdbool.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
+#include "rbffi_endian.h"
+#include "compat.h"
 #include "AbstractMemory.h"
 #include "Pointer.h"
 
-typedef struct Pointer {
-    AbstractMemory memory;
-    VALUE parent;
-} Pointer;
-
-#define POINTER(obj) rbffi_AbstractMemory_Cast((obj), rbffi_PointerClass)
+#define POINTER(obj) rbffi_AbstractMemory_Cast((obj), &rbffi_pointer_data_type)
 
 VALUE rbffi_PointerClass = Qnil;
 VALUE rbffi_NullPointerSingleton = Qnil;
 
-static void ptr_mark(Pointer* ptr);
+static void ptr_release(void *data);
+static void ptr_mark(void *data);
+static void ptr_compact(void *data);
+static size_t ptr_memsize(const void *data);
+
+const rb_data_type_t rbffi_pointer_data_type = { /* extern */
+    .wrap_struct_name = "FFI::Pointer",
+    .function = {
+        .dmark = ptr_mark,
+        .dfree = ptr_release,
+        .dsize = ptr_memsize,
+        ffi_compact_callback( ptr_compact )
+    },
+    .parent = &rbffi_abstract_memory_data_type,
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
 
 VALUE
 rbffi_Pointer_NewInstance(void* addr)
@@ -48,12 +71,12 @@ rbffi_Pointer_NewInstance(void* addr)
         return rbffi_NullPointerSingleton;
     }
 
-    obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
+    obj = TypedData_Make_Struct(rbffi_PointerClass, Pointer, &rbffi_pointer_data_type, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
     p->memory.flags = (addr == NULL) ? 0 : (MEM_RD | MEM_WR);
     p->memory.typeSize = 1;
-    p->parent = Qnil;
+    RB_OBJ_WRITE(obj, &p->rbParent, Qnil);
 
     return obj;
 }
@@ -64,13 +87,22 @@ ptr_allocate(VALUE klass)
     Pointer* p;
     VALUE obj;
 
-    obj = Data_Make_Struct(klass, Pointer, ptr_mark, -1, p);
-    p->parent = Qnil;
+    obj = TypedData_Make_Struct(klass, Pointer, &rbffi_pointer_data_type, p);
+    RB_OBJ_WRITE(obj, &p->rbParent, Qnil);
     p->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
 }
 
+/*
+ * @overload initialize(address)
+ * @overload initialize(type, address)
+ *  @param [Type] type Optional type for pointer (defaults to byte)
+ *  @param [Pointer, Integer] address base address for pointer
+ *  Create a new pointer from a {Type} and a base address
+ * @return [self]
+ * A new instance of Pointer.
+ */
 static VALUE
 ptr_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -78,7 +110,7 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
     VALUE rbType = Qnil, rbAddress = Qnil;
     int typeSize = 1;
 
-    Data_Get_Struct(self, Pointer, p);
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, p);
 
     switch (rb_scan_args(argc, argv, "11", &rbType, &rbAddress)) {
         case 1:
@@ -95,7 +127,7 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
     switch (TYPE(rbAddress)) {
         case T_FIXNUM:
         case T_BIGNUM:
-            p->memory.address = (void*) (uintptr_t) NUM2LL(rbAddress);
+            p->memory.address = (void*) (uintptr_t) NUM2ULL(rbAddress);
             p->memory.size = LONG_MAX;
             if (p->memory.address == NULL) {
                 p->memory.flags = 0;
@@ -106,8 +138,8 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
             if (rb_obj_is_kind_of(rbAddress, rbffi_PointerClass)) {
                 Pointer* orig;
 
-                p->parent = rbAddress;
-                Data_Get_Struct(rbAddress, Pointer, orig);
+                RB_OBJ_WRITE(self, &p->rbParent, rbAddress);
+                TypedData_Get_Struct(rbAddress, Pointer, &rbffi_pointer_data_type, orig);
                 p->memory = orig->memory;
             } else {
                 rb_raise(rb_eTypeError, "wrong argument type, expected Integer or FFI::Pointer");
@@ -120,6 +152,56 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq: ptr.initialize_copy(other)
+ * @param [Pointer] other source for cloning or dupping
+ * @return [self]
+ * @raise {RuntimeError} if +other+ is an unbounded memory area, or is unreadable/unwritable
+ * @raise {NoMemError} if failed to allocate memory for new object
+ * DO NOT CALL THIS METHOD.
+ *
+ * This method is internally used by #dup and #clone. Memory content is copied from +other+.
+ */
+static VALUE
+ptr_initialize_copy(VALUE self, VALUE other)
+{
+    AbstractMemory* src;
+    Pointer* dst;
+
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, dst);
+    src = POINTER(other);
+    if (src->size == LONG_MAX) {
+        rb_raise(rb_eRuntimeError, "cannot duplicate unbounded memory area");
+        return Qnil;
+    }
+
+    if ((dst->memory.flags & (MEM_RD | MEM_WR)) != (MEM_RD | MEM_WR)) {
+        rb_raise(rb_eRuntimeError, "cannot duplicate unreadable/unwritable memory area");
+        return Qnil;
+    }
+
+    if (dst->storage != NULL) {
+        xfree(dst->storage);
+        dst->storage = NULL;
+    }
+
+    dst->storage = xmalloc(src->size + 7);
+    if (dst->storage == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate memory size=%lu bytes", src->size);
+        return Qnil;
+    }
+
+    dst->allocated = true;
+    dst->autorelease = true;
+    dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7ULL);
+    dst->memory.size = src->size;
+    dst->memory.typeSize = src->typeSize;
+
+    /* finally, copy the actual memory contents */
+    memcpy(dst->memory.address, src->address, src->size);
+
+    return self;
+}
 
 static VALUE
 slice(VALUE self, long offset, long size)
@@ -127,76 +209,128 @@ slice(VALUE self, long offset, long size)
     AbstractMemory* ptr;
     Pointer* p;
     VALUE retval;
-    
-    Data_Get_Struct(self, AbstractMemory, ptr);
-    checkBounds(ptr, offset, 1);
 
-    retval = Data_Make_Struct(rbffi_PointerClass, Pointer, ptr_mark, -1, p);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
+    checkBounds(ptr, offset, size == LONG_MAX ? 1 : size);
+
+    retval = TypedData_Make_Struct(rbffi_PointerClass, Pointer, &rbffi_pointer_data_type, p);
 
     p->memory.address = ptr->address + offset;
     p->memory.size = size;
     p->memory.flags = ptr->flags;
     p->memory.typeSize = ptr->typeSize;
-    p->parent = self;
+    RB_OBJ_WRITE(retval, &p->rbParent, self);
 
     return retval;
 }
 
+/*
+ * Document-method: +
+ * call-seq: ptr + offset
+ * @param [Integer] offset
+ * @return [Pointer]
+ * Return a new {Pointer} from an existing pointer and an +offset+.
+ */
 static VALUE
 ptr_plus(VALUE self, VALUE offset)
 {
     AbstractMemory* ptr;
     long off = NUM2LONG(offset);
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     return slice(self, off, ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off);
 }
 
+/*
+ * call-seq: ptr.slice(offset, length)
+ * @param [Integer] offset
+ * @param [Integer] length
+ * @return [Pointer]
+ * Return a new {Pointer} from an existing one. This pointer points on same contents
+ * from +offset+ for a length +length+.
+ */
 static VALUE
 ptr_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
 {
     return slice(self, NUM2LONG(rbOffset), NUM2LONG(rbLength));
 }
 
+/*
+ * call-seq: ptr.inspect
+ * @return [String]
+ * Inspect pointer object.
+ */
 static VALUE
 ptr_inspect(VALUE self)
 {
+    char buf[100];
     Pointer* ptr;
-    
-    Data_Get_Struct(self, Pointer, ptr);
 
-    return ptr->memory.size != LONG_MAX
-        ? rb_sprintf("#<%s address=%p size=%lu>", rb_obj_classname(self), ptr->memory.address, ptr->memory.size)
-        : rb_sprintf("#<%s address=%p>", rb_obj_classname(self), ptr->memory.address);
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
+
+    if (ptr->memory.size != LONG_MAX) {
+        snprintf(buf, sizeof(buf), "#<%s address=%p size=%lu>",
+                rb_obj_classname(self), ptr->memory.address, ptr->memory.size);
+    } else {
+        snprintf(buf, sizeof(buf), "#<%s address=%p>", rb_obj_classname(self), ptr->memory.address);
+    }
+
+    return rb_str_new2(buf);
 }
 
+/*
+ * Document-method: null?
+ * call-seq: ptr.null?
+ * @return [Boolean]
+ * Return +true+ if +self+ is a {NULL} pointer.
+ */
 static VALUE
 ptr_null_p(VALUE self)
 {
     Pointer* ptr;
 
-    Data_Get_Struct(self, Pointer, ptr);
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
 
     return ptr->memory.address == NULL ? Qtrue : Qfalse;
 }
 
+/*
+ * Document-method: ==
+ * call-seq: ptr == other
+ * @param [Pointer] other
+ * Check equality between +self+ and +other+. Equality is tested on {#address}.
+ */
 static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
     Pointer* ptr;
-    
-    Data_Get_Struct(self, Pointer, ptr);
 
-    return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
+
+    if (NIL_P(other)) {
+        return ptr->memory.address == NULL ? Qtrue : Qfalse;
+    }
+
+    if (!rb_obj_is_kind_of(other, rbffi_PointerClass)) {
+        return Qfalse;
+    }
+    else {
+        return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
+    }
 }
 
+/*
+ * call-seq: ptr.address
+ * @return [Integer] pointer's base address
+ * Return +self+'s base address (alias: #to_i).
+ */
 static VALUE
 ptr_address(VALUE self)
 {
     Pointer* ptr;
-    
-    Data_Get_Struct(self, Pointer, ptr);
+
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
 
     return ULL2NUM((uintptr_t) ptr->memory.address);
 }
@@ -207,12 +341,21 @@ ptr_address(VALUE self)
 # define SWAPPED_ORDER LITTLE_ENDIAN
 #endif
 
+/*
+ * Get or set +self+'s endianness
+ * @overload order
+ *  @return [:big, :little] endianness of +self+
+ * @overload order(order)
+ *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+
+ *   are synonymous.
+ *  @return a new pointer with the new order
+ */
 static VALUE
 ptr_order(int argc, VALUE* argv, VALUE self)
 {
     Pointer* ptr;
 
-    Data_Get_Struct(self, Pointer, ptr);
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
     if (argc == 0) {
         int order = (ptr->memory.flags & MEM_SWAP) == 0 ? BYTE_ORDER : SWAPPED_ORDER;
         return order == BIG_ENDIAN ? ID2SYM(rb_intern("big")) : ID2SYM(rb_intern("little"));
@@ -230,13 +373,15 @@ ptr_order(int argc, VALUE* argv, VALUE self)
 
             } else if (id == rb_intern("big") || id == rb_intern("network")) {
                 order = BIG_ENDIAN;
+            } else {
+                rb_raise(rb_eArgError, "unknown byte order");
             }
         }
         if (order != BYTE_ORDER) {
             Pointer* p2;
             VALUE retval = slice(self, 0, ptr->memory.size);
 
-            Data_Get_Struct(retval, Pointer, p2);
+            TypedData_Get_Struct(retval, Pointer, &rbffi_pointer_data_type, p2);
             p2->memory.flags |= MEM_SWAP;
             return retval;
         }
@@ -245,22 +390,142 @@ ptr_order(int argc, VALUE* argv, VALUE self)
     }
 }
 
+
+/*
+ * call-seq: ptr.free
+ * @return [self]
+ * Free memory pointed by +self+.
+ */
+static VALUE
+ptr_free(VALUE self)
+{
+    Pointer* ptr;
+
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
+
+    if (ptr->allocated) {
+        if (ptr->storage != NULL) {
+            xfree(ptr->storage);
+            ptr->storage = NULL;
+        }
+        ptr->allocated = false;
+
+    } else {
+        VALUE caller = rb_funcall(rb_funcall(Qnil, rb_intern("caller"), 0), rb_intern("first"), 0);
+
+        rb_warn("calling free on non allocated pointer %s from %s", RSTRING_PTR(ptr_inspect(self)), RSTRING_PTR(rb_str_to_str(caller)));
+    }
+
+    return self;
+}
+
+static VALUE
+ptr_type_size(VALUE self)
+{
+    Pointer* ptr;
+
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
+
+    return INT2NUM(ptr->memory.typeSize);
+}
+
+/*
+ * call-seq: ptr.autorelease = autorelease
+ * @param [Boolean] autorelease
+ * @return [Boolean] +autorelease+
+ * Set +autorelease+ attribute. See also Autorelease section.
+ */
+static VALUE
+ptr_autorelease(VALUE self, VALUE autorelease)
+{
+    Pointer* ptr;
+
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
+    ptr->autorelease = RB_TEST(autorelease);
+
+    return autorelease;
+}
+
+/*
+ * call-seq: ptr.autorelease?
+ * @return [Boolean]
+ * Get +autorelease+ attribute. See also Autorelease section.
+ */
+static VALUE
+ptr_autorelease_p(VALUE self)
+{
+    Pointer* ptr;
+
+    TypedData_Get_Struct(self, Pointer, &rbffi_pointer_data_type, ptr);
+
+    return ptr->autorelease ? Qtrue : Qfalse;
+}
+
+
+static void
+ptr_release(void *data)
+{
+    Pointer *ptr = (Pointer *)data;
+    if (ptr->autorelease && ptr->allocated && ptr->storage != NULL) {
+        xfree(ptr->storage);
+        ptr->storage = NULL;
+    }
+    xfree(ptr);
+}
+
+static void
+ptr_mark(void *data)
+{
+    Pointer *ptr = (Pointer *)data;
+    rb_gc_mark_movable(ptr->rbParent);
+}
+
 static void
-ptr_mark(Pointer* ptr)
+ptr_compact(void *data)
 {
-    rb_gc_mark(ptr->parent);
+    Pointer *ptr = (Pointer *)data;
+    ffi_gc_location(ptr->rbParent);
+}
+
+static size_t
+ptr_memsize(const void *data)
+{
+    const Pointer *ptr = (const Pointer *)data;
+    size_t memsize = sizeof(Pointer);
+    if (ptr->allocated) {
+        memsize += ptr->memory.size;
+    }
+    return memsize;
 }
 
 void
 rbffi_Pointer_Init(VALUE moduleFFI)
 {
     VALUE rbNullAddress = ULL2NUM(0);
-
-    rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
+    VALUE ffi_AbstractMemory =  rbffi_AbstractMemoryClass;
+
+    /*
+     * Document-class: FFI::Pointer < FFI::AbstractMemory
+     * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
+     * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
+     *
+     * == Autorelease
+     * By default a pointer object frees its content when it's garbage collected.
+     * Therefore it's usually not necessary to call {#free} explicit.
+     * This behaviour may be changed with {#autorelease=} method.
+     * If it's set to +false+, the memory isn't freed by the garbage collector, but stays valid until +free()+ is called on C level or when the process terminates.
+     */
+    rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", ffi_AbstractMemory);
+    /*
+     * Document-variable: Pointer
+     */
     rb_global_variable(&rbffi_PointerClass);
 
     rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
     rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
+    rb_define_method(rbffi_PointerClass, "initialize_copy", ptr_initialize_copy, 1);
     rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
     rb_define_method(rbffi_PointerClass, "to_s", ptr_inspect, 0);
     rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
@@ -270,7 +535,15 @@ rbffi_Pointer_Init(VALUE moduleFFI)
     rb_define_alias(rbffi_PointerClass, "to_i", "address");
     rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1);
     rb_define_method(rbffi_PointerClass, "order", ptr_order, -1);
+    rb_define_method(rbffi_PointerClass, "autorelease=", ptr_autorelease, 1);
+    rb_define_method(rbffi_PointerClass, "autorelease?", ptr_autorelease_p, 0);
+    rb_define_method(rbffi_PointerClass, "free", ptr_free, 0);
+    rb_define_method(rbffi_PointerClass, "type_size", ptr_type_size, 0);
 
     rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass);
+    /*
+     * NULL pointer
+     */
     rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
 }
+