ffi 1.1.2 → 1.17.0

data/ext/ffi_c/AbstractMemory.c

@@ -1,38 +1,44 @@
 /*
  * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (C) 2009 Jake Douglas <jake@shiftedlabs.com>
+ * Copyright (C) 2008 Luc Heinrich <luc@honk-honk.com>
  *
+ * 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 <sys/types.h>
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
+#endif
 #include <stdint.h>
 #include <stdbool.h>
-#else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
+
 #include <limits.h>
 #include <ruby.h>
-#if defined(_MSC_VER) && !defined(INT8_MIN)
-#  include "win32/stdint.h"
-#endif
+
 #include "rbffi.h"
 #include "compat.h"
 #include "AbstractMemory.h"
@@ -40,22 +46,39 @@ typedef int bool;
 #include "Function.h"
 #include "LongDouble.h"
 
+#ifdef PRIsVALUE
+# define RB_OBJ_CLASSNAME(obj) rb_obj_class(obj)
+# define RB_OBJ_STRING(obj) (obj)
+#else
+# define PRIsVALUE "s"
+# define RB_OBJ_CLASSNAME(obj) rb_obj_classname(obj)
+# define RB_OBJ_STRING(obj) StringValueCStr(obj)
+#endif
 
+static size_t memsize(const void *data);
 static inline char* memory_address(VALUE self);
 VALUE rbffi_AbstractMemoryClass = Qnil;
 static VALUE NullPointerErrorClass = Qnil;
 static ID id_to_ptr = 0, id_plus = 0, id_call = 0;
 
-static VALUE
-memory_allocate(VALUE klass)
-{
-    AbstractMemory* memory;
-    VALUE obj;
-    obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
-    memory->flags = MEM_RD | MEM_WR;
+const rb_data_type_t rbffi_abstract_memory_data_type = { /* extern */
+    .wrap_struct_name = "FFI::AbstractMemory",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = memsize,
+    },
+    // 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
+};
 
-    return obj;
+static size_t
+memsize(const void *data)
+{
+    return sizeof(AbstractMemory);
 }
+
 #define VAL(x, swap) (unlikely(((memory->flags & MEM_SWAP) != 0)) ? swap((x)) : (x))
 
 #define NUM_OP(name, type, toNative, fromNative, swap) \
@@ -73,7 +96,7 @@ static VALUE \
 memory_put_##name(VALUE self, VALUE offset, VALUE value) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     memory_op_put_##name(memory, NUM2LONG(offset), value); \
     return self; \
 } \
@@ -82,7 +105,7 @@ static VALUE \
 memory_write_##name(VALUE self, VALUE value) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     memory_op_put_##name(memory, 0, value); \
     return self; \
 } \
@@ -101,7 +124,7 @@ static VALUE \
 memory_get_##name(VALUE self, VALUE offset) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     return memory_op_get_##name(memory, NUM2LONG(offset)); \
 } \
 static VALUE memory_read_##name(VALUE self); \
@@ -109,7 +132,7 @@ static VALUE \
 memory_read_##name(VALUE self) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     return memory_op_get_##name(memory, 0); \
 } \
 static MemoryOp memory_op_##name = { memory_op_get_##name, memory_op_put_##name }; \
@@ -118,14 +141,16 @@ static VALUE memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary); \
 static VALUE \
 memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
 { \
-    long count = RARRAY_LEN(ary); \
+    long count; \
     long off = NUM2LONG(offset); \
     AbstractMemory* memory = MEMORY(self); \
     long i; \
-    checkWrite(memory); \
+    Check_Type(ary, T_ARRAY); \
+    count = RARRAY_LEN(ary); \
+    if (likely(count > 0)) checkWrite(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; i++) { \
-        type tmp = (type) VAL(toNative(RARRAY_PTR(ary)[i]), swap); \
+        type tmp = (type) VAL(toNative(RARRAY_AREF(ary, i)), swap); \
         memcpy(memory->address + off + (i * sizeof(type)), &tmp, sizeof(tmp)); \
     } \
     return self; \
@@ -145,7 +170,7 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
     AbstractMemory* memory = MEMORY(self); \
     VALUE retVal = rb_ary_new2(count); \
     long i; \
-    checkRead(memory); \
+    if (likely(count > 0)) checkRead(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; ++i) { \
         type tmp; \
@@ -192,13 +217,13 @@ SWAPU16(uint16_t x)
         ((x >> 40) & 0x000000000000ff00ULL) | \
         ((x >> 56) & 0x00000000000000ffULL))
 
-static inline int32_t 
+static inline int32_t
 SWAPS32(int32_t x)
 {
     return bswap32(x);
 }
 
-static inline uint32_t 
+static inline uint32_t
 SWAPU32(uint32_t x)
 {
     return bswap32(x);
@@ -291,6 +316,7 @@ static VALUE
 memory_clear(VALUE self)
 {
     AbstractMemory* ptr = MEMORY(self);
+    checkWrite(ptr);
     memset(ptr->address, 0, ptr->size);
     return self;
 }
@@ -298,23 +324,91 @@ memory_clear(VALUE self)
 /*
  * call-seq: memory.size
  * Return memory size in bytes (alias: #total)
- * @return [Numeric]
+ * @return [Integer]
  */
 static VALUE
-memory_size(VALUE self) 
+memory_size(VALUE self)
 {
     AbstractMemory* ptr;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     return LONG2NUM(ptr->size);
 }
 
+/*
+ * call-seq: memory.get(type, offset)
+ * Return data of given type contained in memory.
+ * @param [Symbol, Type] type_name type of data to get
+ * @param [Integer] offset point in buffer to start from
+ * @return [Object]
+ * @raise {ArgumentError} if type is not supported
+ */
+static VALUE
+memory_get(VALUE self, VALUE type_name, VALUE offset)
+{
+    AbstractMemory* ptr;
+    VALUE nType;
+    Type *type;
+    MemoryOp *op;
+
+    nType = rbffi_Type_Lookup(type_name);
+    if(NIL_P(nType)) goto undefined_type;
+
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
+    TypedData_Get_Struct(nType, Type, &rbffi_type_data_type, type);
+
+    op = get_memory_op(type);
+    if(op == NULL) goto undefined_type;
+
+    return op->get(ptr, NUM2LONG(offset));
+
+undefined_type: {
+    VALUE msg = rb_sprintf("undefined type '%" PRIsVALUE "'", type_name);
+    rb_exc_raise(rb_exc_new3(rb_eArgError, msg));
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq: memory.put(type, offset, value)
+ * @param [Symbol, Type] type_name type of data to put
+ * @param [Integer] offset point in buffer to start from
+ * @return [nil]
+ * @raise {ArgumentError} if type is not supported
+ */
+static VALUE
+memory_put(VALUE self, VALUE type_name, VALUE offset, VALUE value)
+{
+    AbstractMemory* ptr;
+    VALUE nType;
+    Type *type;
+    MemoryOp *op;
+
+    nType = rbffi_Type_Lookup(type_name);
+    if(NIL_P(nType)) goto undefined_type;
+
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
+    TypedData_Get_Struct(nType, Type, &rbffi_type_data_type, type);
+
+    op = get_memory_op(type);
+    if(op == NULL) goto undefined_type;
+
+    op->put(ptr, NUM2LONG(offset), value);
+    return Qnil;
+
+undefined_type: {
+    VALUE msg = rb_sprintf("unsupported type '%" PRIsVALUE "'", type_name);
+    rb_exc_raise(rb_exc_new3(rb_eArgError, msg));
+    return Qnil;
+  }
+}
+
 /*
  * call-seq: memory.get_string(offset, length=nil)
  * Return string contained in memory.
- * @param [Numeric] offset point in buffer to start from
- * @param [Numeric] length string's length in bytes. If nil, a (memory size - offset) length string is returned).
+ * @param [Integer] offset point in buffer to start from
+ * @param [Integer] length string's length in bytes. If nil, a (memory size - offset) length string is returned).
  * @return [String]
  * @raise {IndexError} if +length+ is too great
  * @raise {NullPointerError} if memory not initialized
@@ -334,15 +428,15 @@ memory_get_string(int argc, VALUE* argv, VALUE self)
     checkBounds(ptr, off, len);
 
     end = memchr(ptr->address + off, 0, len);
-    return rb_tainted_str_new((char *) ptr->address + off,
+    return rb_str_new((char *) ptr->address + off,
             (end != NULL ? end - ptr->address - off : len));
 }
 
 /*
  * call-seq: memory.get_array_of_string(offset, count=nil)
  * Return an array of strings contained in memory.
- * @param [Numeric] offset point in memory to start from
- * @param [Numeric] count number of strings to get. If nil, return all strings
+ * @param [Integer] offset point in memory to start from
+ * @param [Integer] count number of strings to get. If nil, return all strings
  * @return [Array<String>]
  * @raise {IndexError} if +offset+ is too great
  * @raise {NullPointerError} if memory not initialized
@@ -360,17 +454,17 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
     count = (countnum == Qnil ? 0 : NUM2INT(countnum));
     retVal = rb_ary_new2(count);
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
     checkRead(ptr);
 
     if (countnum != Qnil) {
         int i;
 
         checkBounds(ptr, off, count * sizeof (char*));
-        
+
         for (i = 0; i < count; ++i) {
             const char* strptr = *((const char**) (ptr->address + off) + i);
-            rb_ary_push(retVal, (strptr == NULL ? Qnil : rb_tainted_str_new2(strptr)));
+            rb_ary_push(retVal, (strptr == NULL ? Qnil : rb_str_new2(strptr)));
         }
 
     } else {
@@ -380,7 +474,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
             if (strptr == NULL) {
                 break;
             }
-            rb_ary_push(retVal, rb_tainted_str_new2(strptr));
+            rb_ary_push(retVal, rb_str_new2(strptr));
         }
     }
 
@@ -391,10 +485,10 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
  * call-seq: memory.read_array_of_string(count=nil)
  * Return an array of strings contained in memory. Same as:
  *  memory.get_array_of_string(0, count)
- * @param [Numeric] count number of strings to get. If nil, return all strings
+ * @param [Integer] count number of strings to get. If nil, return all strings
  * @return [Array<String>]
  */
-static VALUE 
+static VALUE
 memory_read_array_of_string(int argc, VALUE* argv, VALUE self)
 {
     VALUE* rargv = ALLOCA_N(VALUE, argc + 1);
@@ -411,7 +505,7 @@ memory_read_array_of_string(int argc, VALUE* argv, VALUE self)
 
 /*
  * call-seq: memory.put_string(offset, str)
- * @param [Numeric] offset
+ * @param [Integer] offset
  * @param [String] str
  * @return [self]
  * @raise {SecurityError} when writing unsafe string to memory
@@ -431,11 +525,6 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
 
     checkWrite(ptr);
     checkBounds(ptr, off, len + 1);
-    
-    if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
-        rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
-        return Qnil;
-    }
 
     memcpy(ptr->address + off, RSTRING_PTR(str), len);
     *((char *) ptr->address + off + len) = '\0';
@@ -446,8 +535,8 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
 /*
  * call-seq: memory.get_bytes(offset, length)
  * Return string contained in memory.
- * @param [Numeric] offset point in buffer to start from
- * @param [Numeric] length string's length in bytes.
+ * @param [Integer] offset point in buffer to start from
+ * @param [Integer] length string's length in bytes.
  * @return [String]
  * @raise {IndexError} if +length+ is too great
  * @raise {NullPointerError} if memory not initialized
@@ -457,23 +546,23 @@ memory_get_bytes(VALUE self, VALUE offset, VALUE length)
 {
     AbstractMemory* ptr = MEMORY(self);
     long off, len;
-    
+
     off = NUM2LONG(offset);
     len = NUM2LONG(length);
 
     checkRead(ptr);
     checkBounds(ptr, off, len);
-    
-    return rb_tainted_str_new((char *) ptr->address + off, len);
+
+    return rb_str_new((char *) ptr->address + off, len);
 }
 
 /*
  * call-seq: memory.put_bytes(offset, str, index=0, length=nil)
  * Put a string in memory.
- * @param [Numeric] offset point in buffer to start from
+ * @param [Integer] offset point in buffer to start from
  * @param [String] str string to put to memory
- * @param [Numeric] index
- * @param [Numeric] length string's length in bytes. If nil, a (memory size - offset) length string is returned).
+ * @param [Integer] index
+ * @param [Integer] length string's length in bytes. If nil, a (memory size - offset) length string is returned).
  * @return [self]
  * @raise {IndexError} if +length+ is too great
  * @raise {NullPointerError} if memory not initialized
@@ -493,7 +582,7 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     off = NUM2LONG(offset);
     idx = nargs > 2 ? NUM2LONG(rbIndex) : 0;
     if (idx < 0) {
-        rb_raise(rb_eRangeError, "index canot be less than zero");
+        rb_raise(rb_eRangeError, "index cannot be less than zero");
         return Qnil;
     }
     len = nargs > 3 ? NUM2LONG(rbLength) : (RSTRING_LEN(str) - idx);
@@ -505,10 +594,6 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     checkWrite(ptr);
     checkBounds(ptr, off, len);
 
-    if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
-        rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
-        return Qnil;
-    }
     memcpy(ptr->address + off, RSTRING_PTR(str) + idx, len);
 
     return self;
@@ -516,12 +601,12 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
 
 /*
  * call-seq: memory.read_bytes(length)
- * @param [Numeric] length of string to return
+ * @param [Integer] length of string to return
  * @return [String]
  * equivalent to :
  *  memory.get_bytes(0, length)
  */
-static VALUE 
+static VALUE
 memory_read_bytes(VALUE self, VALUE length)
 {
     return memory_get_bytes(self, INT2FIX(0), length);
@@ -530,13 +615,13 @@ memory_read_bytes(VALUE self, VALUE length)
 /*
  * call-seq: memory.write_bytes(str, index=0, length=nil)
  * @param [String] str string to put to memory
- * @param [Numeric] index
- * @param [Numeric] length string's length in bytes. If nil, a (memory size - offset) length string is returned).
+ * @param [Integer] index
+ * @param [Integer] length string's length in bytes. If nil, a (memory size - offset) length string is returned).
  * @return [self]
  * equivalent to :
  *  memory.put_bytes(0, str, index, length)
  */
-static VALUE 
+static VALUE
 memory_write_bytes(int argc, VALUE* argv, VALUE self)
 {
     VALUE* wargv = ALLOCA_N(VALUE, argc + 1);
@@ -552,7 +637,7 @@ memory_write_bytes(int argc, VALUE* argv, VALUE self)
 
 /*
  * call-seq: memory.type_size
- * @return [Numeric] type size in bytes
+ * @return [Integer] type size in bytes
  * Get the memory's type size.
  */
 static VALUE
@@ -560,7 +645,7 @@ memory_type_size(VALUE self)
 {
     AbstractMemory* ptr;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     return INT2NUM(ptr->typeSize);
 }
@@ -568,8 +653,8 @@ memory_type_size(VALUE self)
 /*
  * Document-method: []
  * call-seq: memory[idx]
- * @param [Numeric] idx index to access in memory
- * @return 
+ * @param [Integer] idx index to access in memory
+ * @return
  * Memory read accessor.
  */
 static VALUE
@@ -578,7 +663,7 @@ memory_aref(VALUE self, VALUE idx)
     AbstractMemory* ptr;
     VALUE rbOffset = Qnil;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     rbOffset = ULONG2NUM(NUM2ULONG(idx) * ptr->typeSize);
 
@@ -588,7 +673,9 @@ memory_aref(VALUE self, VALUE idx)
 static inline char*
 memory_address(VALUE obj)
 {
-    return ((AbstractMemory *) DATA_PTR(obj))->address;
+    AbstractMemory *mem;
+    TypedData_Get_Struct(obj, AbstractMemory, &rbffi_abstract_memory_data_type, mem);
+    return mem->address;
 }
 
 static VALUE
@@ -596,24 +683,33 @@ memory_copy_from(VALUE self, VALUE rbsrc, VALUE rblen)
 {
     AbstractMemory* dst;
 
-    Data_Get_Struct(self, AbstractMemory, dst);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, dst);
 
-    memcpy(dst->address, rbffi_AbstractMemory_Cast(rbsrc, rbffi_AbstractMemoryClass)->address, NUM2INT(rblen));
+    memcpy(dst->address, rbffi_AbstractMemory_Cast(rbsrc, &rbffi_abstract_memory_data_type)->address, NUM2INT(rblen));
 
     return self;
 }
 
-AbstractMemory*
-rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass)
+/*
+ * call-seq:
+ *    res.freeze
+ *
+ * Freeze the AbstractMemory object and unset the writable flag.
+ */
+static VALUE
+memory_freeze(VALUE self)
 {
-    if (rb_obj_is_kind_of(obj, klass)) {
-        AbstractMemory* memory;
-        Data_Get_Struct(obj, AbstractMemory, memory);
-        return memory;
-    }
+    AbstractMemory* ptr = MEMORY(self);
+    ptr->flags &= ~MEM_WR;
+    return rb_call_super(0, NULL);
+}
 
-    rb_raise(rb_eArgError, "Invalid Memory object");
-    return NULL;
+AbstractMemory*
+rbffi_AbstractMemory_Cast(VALUE obj, const rb_data_type_t *data_type)
+{
+    AbstractMemory* memory;
+    TypedData_Get_Struct(obj, AbstractMemory, data_type, memory);
+    return memory;
 }
 
 void
@@ -640,7 +736,7 @@ memory_op_get_strptr(AbstractMemory* ptr, long offset)
         memcpy(&tmp, ptr->address + offset, sizeof(tmp));
     }
 
-    return tmp != NULL ? rb_tainted_str_new2(tmp) : Qnil;
+    return tmp != NULL ? rb_str_new2(tmp) : Qnil;
 }
 
 static void
@@ -651,33 +747,32 @@ memory_op_put_strptr(AbstractMemory* ptr, long offset, VALUE value)
 
 static MemoryOp memory_op_strptr = { memory_op_get_strptr, memory_op_put_strptr };
 
-//static MemoryOp memory_op_pointer = { memory_op_get_pointer, memory_op_put_pointer };
 
 MemoryOps rbffi_AbstractMemoryOps = {
-    &memory_op_int8, //.int8
-    &memory_op_uint8, //.uint8
-    &memory_op_int16, //.int16
-    &memory_op_uint16, //.uint16
-    &memory_op_int32, //.int32
-    &memory_op_uint32, //.uint32
-    &memory_op_int64, //.int64
-    &memory_op_uint64, //.uint64
-    &memory_op_long, //.slong
-    &memory_op_ulong, //.uslong
-    &memory_op_float32, //.float32
-    &memory_op_float64, //.float64
-    &memory_op_longdouble, //.longdouble
-    &memory_op_pointer, //.pointer
-    &memory_op_strptr, //.strptr
-    &memory_op_bool //.boolOp
+    &memory_op_int8, /*.int8 */
+    &memory_op_uint8, /* .uint8 */
+    &memory_op_int16, /* .int16 */
+    &memory_op_uint16, /* .uint16 */
+    &memory_op_int32, /* .int32 */
+    &memory_op_uint32, /* .uint32 */
+    &memory_op_int64, /* .int64 */
+    &memory_op_uint64, /* .uint64 */
+    &memory_op_long, /* .slong */
+    &memory_op_ulong, /* .uslong */
+    &memory_op_float32, /* .float32 */
+    &memory_op_float64, /* .float64 */
+    &memory_op_longdouble, /* .longdouble */
+    &memory_op_pointer, /* .pointer */
+    &memory_op_strptr, /* .strptr */
+    &memory_op_bool /* .boolOp */
 };
 
 void
 rbffi_AbstractMemory_Init(VALUE moduleFFI)
 {
-    /* 
+    /*
      * Document-class: FFI::AbstractMemory
-     * 
+     *
      * {AbstractMemory} is the base class for many memory management classes such as {Buffer}.
      *
      * This class has a lot of methods to work with integers :
@@ -705,11 +800,11 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
      */
     VALUE classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
     rbffi_AbstractMemoryClass = classMemory;
-    /* 
-     * Document-variable: FFI::AbstractMemory 
+    /*
+     * Document-variable: FFI::AbstractMemory
      */
     rb_global_variable(&rbffi_AbstractMemoryClass);
-    rb_define_alloc_func(classMemory, memory_allocate);
+    rb_undef_alloc_func(classMemory);
 
     NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
     /* Document-variable: NullPointerError */
@@ -734,13 +829,13 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "read_array_of_" #type, memory_read_array_of_##type, 1); \
     rb_define_method(classMemory, "write_array_of_u" #type, memory_write_array_of_u##type, 1); \
     rb_define_method(classMemory, "read_array_of_u" #type, memory_read_array_of_u##type, 1);
-    
+
     INT(int8);
     INT(int16);
     INT(int32);
     INT(int64);
     INT(long);
-    
+
 #define ALIAS(name, old) \
     rb_define_alias(classMemory, "put_" #name, "put_" #old); \
     rb_define_alias(classMemory, "get_" #name, "get_" #old); \
@@ -758,16 +853,16 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_alias(classMemory, "read_array_of_" #name, "read_array_of_" #old); \
     rb_define_alias(classMemory, "write_array_of_u" #name, "write_array_of_u" #old); \
     rb_define_alias(classMemory, "read_array_of_u" #name, "read_array_of_u" #old);
-    
+
     ALIAS(char, int8);
     ALIAS(short, int16);
     ALIAS(int, int32);
     ALIAS(long_long, int64);
-    
+
     /*
      * Document-method: put_float32
-     * call-seq: memory.put_float32offset, value)
-     * @param [Numeric] offset
+     * call-seq: memory.put_float32(offset, value)
+     * @param [Integer] offset
      * @param [Numeric] value
      * @return [self]
      * Put +value+ as a 32-bit float in memory at offset +offset+ (alias: #put_float).
@@ -776,7 +871,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: get_float32
      * call-seq: memory.get_float32(offset)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @return [Float]
      * Get a 32-bit float from memory at offset +offset+ (alias: #get_float).
      */
@@ -807,7 +902,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: put_array_of_float32
      * call-seq: memory.put_array_of_float32(offset, ary)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @param [Array<Numeric>] ary
      * @return [self]
      * Put values from +ary+ as 32-bit floats in memory from offset +offset+ (alias: #put_array_of_float).
@@ -816,8 +911,8 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: get_array_of_float32
      * call-seq: memory.get_array_of_float32(offset, length)
-     * @param [Numeric] offset
-     * @param [Numeric] length number of Float to get
+     * @param [Integer] offset
+     * @param [Integer] length number of Float to get
      * @return [Array<Float>]
      * Get 32-bit floats in memory from offset +offset+ (alias: #get_array_of_float).
      */
@@ -836,7 +931,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: read_array_of_float
      * call-seq: memory.read_array_of_float(length)
-     * @param [Numeric] length number of Float to read
+     * @param [Integer] length number of Float to read
      * @return [Array<Float>]
      * Read 32-bit floats from memory.
      *
@@ -849,7 +944,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: put_float64
      * call-seq: memory.put_float64(offset, value)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @param [Numeric] value
      * @return [self]
      * Put +value+ as a 64-bit float (double) in memory at offset +offset+ (alias: #put_double).
@@ -858,7 +953,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: get_float64
      * call-seq: memory.get_float64(offset)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @return [Float]
      * Get a 64-bit float (double) from memory at offset +offset+ (alias: #get_double).
      */
@@ -889,7 +984,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: put_array_of_float64
      * call-seq: memory.put_array_of_float64(offset, ary)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @param [Array<Numeric>] ary
      * @return [self]
      * Put values from +ary+ as 64-bit floats (doubles) in memory from offset +offset+ (alias: #put_array_of_double).
@@ -898,8 +993,8 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: get_array_of_float64
      * call-seq: memory.get_array_of_float64(offset, length)
-     * @param [Numeric] offset
-     * @param [Numeric] length number of Float to get
+     * @param [Integer] offset
+     * @param [Integer] length number of Float to get
      * @return [Array<Float>]
      * Get 64-bit floats (doubles) in memory from offset +offset+ (alias: #get_array_of_double).
      */
@@ -918,7 +1013,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: read_array_of_double
      * call-seq: memory.read_array_of_double(length)
-     * @param [Numeric] length number of Float to read
+     * @param [Integer] length number of Float to read
      * @return [Array<Float>]
      * Read 64-bit floats (doubles) from memory.
      *
@@ -931,7 +1026,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: put_pointer
      * call-seq: memory.put_pointer(offset, value)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @param [nil,Pointer, Integer, #to_ptr] value
      * @return [self]
      * Put +value+ in memory from +offset+..
@@ -940,7 +1035,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: get_pointer
      * call-seq: memory.get_pointer(offset)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @return [Pointer]
      * Get a {Pointer} to the memory from +offset+.
      */
@@ -969,7 +1064,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: put_array_of_pointer
      * call-seq: memory.put_array_of_pointer(offset, ary)
-     * @param [Numeric] offset
+     * @param [Integer] offset
      * @param [Array<#to_ptr>] ary
      * @return [self]
      * Put an array of {Pointer} into memory from +offset+.
@@ -978,8 +1073,8 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: get_array_of_pointer
      * call-seq: memory.get_array_of_pointer(offset, length)
-     * @param [Numeric] offset
-     * @param [Numeric] length
+     * @param [Integer] offset
+     * @param [Integer] length
      * @return [Array<Pointer>]
      * Get an array of {Pointer} of length +length+ from +offset+.
      */
@@ -998,7 +1093,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     /*
      * Document-method: read_array_of_pointer
      * call-seq: memory.read_array_of_pointer(length)
-     * @param [Numeric] length
+     * @param [Integer] length
      * @return [Array<Pointer>]
      * Read an array of {Pointer} of length +length+.
      *
@@ -1014,6 +1109,10 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "read_bytes", memory_read_bytes, 1);
     rb_define_method(classMemory, "write_bytes", memory_write_bytes, -1);
     rb_define_method(classMemory, "get_array_of_string", memory_get_array_of_string, -1);
+    rb_define_method(classMemory, "read_array_of_string", memory_read_array_of_string, -1);
+
+    rb_define_method(classMemory, "get", memory_get, 2);
+    rb_define_method(classMemory, "put", memory_put, 3);
 
     rb_define_method(classMemory, "clear", memory_clear, 0);
     rb_define_method(classMemory, "total", memory_size, 0);
@@ -1021,6 +1120,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "type_size", memory_type_size, 0);
     rb_define_method(classMemory, "[]", memory_aref, 1);
     rb_define_method(classMemory, "__copy_from__", memory_copy_from, 2);
+    rb_define_method(classMemory, "freeze", memory_freeze, 0 );
 
     id_to_ptr = rb_intern("to_ptr");
     id_call = rb_intern("call");