ffi 1.1.5 → 1.15.5

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,6 +46,14 @@ 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 inline char* memory_address(VALUE self);
 VALUE rbffi_AbstractMemoryClass = Qnil;
@@ -118,11 +132,13 @@ 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); \
@@ -145,7 +161,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 +208,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);
@@ -301,7 +317,7 @@ memory_clear(VALUE self)
  * @return [Numeric]
  */
 static VALUE
-memory_size(VALUE self) 
+memory_size(VALUE self)
 {
     AbstractMemory* ptr;
 
@@ -310,6 +326,72 @@ memory_size(VALUE self)
     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 [Numeric] 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;
+
+    nType = rbffi_Type_Lookup(type_name);
+    if(NIL_P(nType)) goto undefined_type;
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+    Data_Get_Struct(nType, Type, type);
+
+    MemoryOp *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 [Numeric] 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;
+
+    nType = rbffi_Type_Lookup(type_name);
+    if(NIL_P(nType)) goto undefined_type;
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+    Data_Get_Struct(nType, Type, type);
+
+    MemoryOp *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.
@@ -334,7 +416,7 @@ 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));
 }
 
@@ -367,10 +449,10 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
         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 +462,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));
         }
     }
 
@@ -394,7 +476,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
  * @param [Numeric] 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);
@@ -431,11 +513,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';
@@ -457,14 +534,14 @@ 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);
 }
 
 /*
@@ -493,7 +570,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 +582,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;
@@ -521,7 +594,7 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
  * 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);
@@ -536,7 +609,7 @@ memory_read_bytes(VALUE self, VALUE length)
  * 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);
@@ -569,7 +642,7 @@ memory_type_size(VALUE self)
  * Document-method: []
  * call-seq: memory[idx]
  * @param [Numeric] idx index to access in memory
- * @return 
+ * @return
  * Memory read accessor.
  */
 static VALUE
@@ -640,7 +713,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
@@ -674,9 +747,9 @@ MemoryOps rbffi_AbstractMemoryOps = {
 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 :
@@ -704,8 +777,8 @@ 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);
@@ -733,13 +806,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); \
@@ -757,12 +830,12 @@ 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)
@@ -1014,6 +1087,9 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     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, "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);
     rb_define_alias(classMemory, "size", "total");

data/ext/ffi_c/AbstractMemory.h

@@ -1,21 +1,30 @@
 /*
  * 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.
  */
 
 #ifndef RBFFI_ABSTRACTMEMORY_H

data/ext/ffi_c/ArrayType.c

@@ -1,21 +1,30 @@
 /*
  * Copyright (c) 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 <ruby.h>
@@ -126,12 +135,16 @@ array_type_element_type(VALUE self)
 void
 rbffi_ArrayType_Init(VALUE moduleFFI)
 {
+    VALUE ffi_Type;
+
+    ffi_Type = rbffi_TypeClass;
+
     /*
      * Document-class: FFI::ArrayType < FFI::Type
      *
      * This is a typed array. The type is a {NativeType native type}.
      */
-    rbffi_ArrayTypeClass = rb_define_class_under(moduleFFI, "ArrayType", rbffi_TypeClass);
+    rbffi_ArrayTypeClass = rb_define_class_under(moduleFFI, "ArrayType", ffi_Type);
     /*
      * Document-variable: FFI::ArrayType
      */
@@ -139,7 +152,7 @@ rbffi_ArrayType_Init(VALUE moduleFFI)
     /*
      * Document-constant: FFI::Type::Array
      */
-    rb_define_const(rbffi_TypeClass, "Array", rbffi_ArrayTypeClass);
+    rb_define_const(ffi_Type, "Array", rbffi_ArrayTypeClass);
 
     rb_define_alloc_func(rbffi_ArrayTypeClass, array_type_s_allocate);
     rb_define_method(rbffi_ArrayTypeClass, "initialize", array_type_initialize, 2);

data/ext/ffi_c/ArrayType.h

@@ -1,21 +1,30 @@
 /*
  * Copyright (c) 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.
  */
 
 #ifndef RBFFI_ARRAYTYPE_H

data/ext/ffi_c/Buffer.c

@@ -1,33 +1,35 @@
 /*
  * Copyright (c) 2008-2010 Wayne Meissner
+ * Copyright (C) 2009 Aman Gupta <aman@tmm1.net>
  * 
+ * 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.
  */
 
-#ifndef _MSC_VER
-#include <stdbool.h>
-#else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
-#ifndef _MSC_VER
 #include <stdint.h>
-#endif
+#include <stdbool.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -107,7 +109,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
         }
 
         /* ensure the memory is aligned on at least a 8 byte boundary */
-        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7ULL);
     
         if (p->memory.size > 0 && (nargs < 3 || RTEST(rbClear))) {
             memset(p->memory.address, 0, p->memory.size);
@@ -147,7 +149,7 @@ buffer_initialize_copy(VALUE self, VALUE other)
         return Qnil;
     }
     
-    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     
@@ -246,7 +248,7 @@ buffer_inspect(VALUE self)
  * @overload order(order)
  *  @param [:big, :little, :network] order
  *  @return [self]
- *  Set endinaness of Buffer (+:network+ is an alias for +:big+).
+ *  Set endianness of Buffer (+:network+ is an alias for +:big+).
  */
 static VALUE
 buffer_order(int argc, VALUE* argv, VALUE self)
@@ -310,12 +312,14 @@ buffer_mark(Buffer* ptr)
 void
 rbffi_Buffer_Init(VALUE moduleFFI)
 {
+    VALUE ffi_AbstractMemory =  rbffi_AbstractMemoryClass;
+
     /*
      * Document-class: FFI::Buffer < FFI::AbstractMemory
      *
      * A Buffer is a function argument type. It should be use with functions playing with C arrays.
      */
-    BufferClass = rb_define_class_under(moduleFFI, "Buffer", rbffi_AbstractMemoryClass);
+    BufferClass = rb_define_class_under(moduleFFI, "Buffer", ffi_AbstractMemory);
 
     /*
      * Document-variable: FFI::Buffer