ffi 0.6.0 → 1.0.0

data/History.txt

@@ -0,0 +1,109 @@
+== 1.0.0 / 2010-11-30
+* Major improvements
+  * Better handling of non-ruby thread callbacks
+  * Support for releasing the GIL during C function calls
+* Minor improvements
+  * code cleanups
+
+== 0.5.0 / 2009-10-06
+
+* Major improvements
+  * New Function class
+  * Structs can be passed and returned by value
+  * Implement a custom trampoline for x86_64, resulting in roughly 30% speedup
+  * Improve dispatch of functions which take (0..6) char/short/int/long/pointer arguments by between 50% and 200% on x86_64
+  * Callbacks are now approximately 100% faster on x86_64
+* Minor improvements
+  * Add support for MacOSX Snow Leopard
+  * Improve support for Windows releasing fat binaries on rubyforge
+  * Better introspection in structs:
+    * Add StructLayout::Field#type, size, offset, alignment and name 
+      methods
+    * Add StructLayout#fields which returns an array of 
+      StructLayout::Field objects
+  * Add automagic deducing of library name from module name. 
+    Idea and prototype implementation from Matt Hulse
+  * Callback fields in structs can now be both read and written
+  * Add a bunch of new benchmarks
+  * Lots of refactoring
+* Experimental features
+  * blocking functions (i.e. native code that blocks the thread) support
+* Bug fixes
+  * Fix RUBY-FFI_43 (rake gem dependency)
+
+== 0.4.0 / 2009-08-05
+
+* Major improvements
+  * Add support for boolean types
+  * Add support for methods as callbacks
+  * Add FFI::IO.read as described in JRUBY-3636
+* Minor improvements
+  * Add Pointer::NULL constant
+  * Add AbstractMemory#get_array_of_string()
+  * Implement Pointer.new(address) and Pointer.new(:type, address)
+* Bug fixes
+  * Fix RUBY_FFI-38
+  * Fix issues related to 1.9.1 build
+  * Fix issues related to OSX build
+  * Fix issues related to FreeBSD build
+  * Fix issues related to OpenSolaris build
+
+== 0.3.5 / 2009-05-08
+
+* Bug fixes
+  * Fix RUBY_FFI-17
+  * Fix RUBY_FFI-21
+
+== 0.3.4 / 2009-05-01
+
+* Minor improvements
+  * Add return statements to functions that call rb_raise(), in case
+    rb_raise is not declared noreturn, to avoid gcc warnings.
+
+== 0.3.3 / 2009-04-27
+
+* Minor improvements
+  * Implement RUBY_FFI-16 - Add support for anonymous callbacks
+  * Add support for callback parameters in callbacks
+  * Add support for function pointer return values
+  * Callbacks can now coerce proc objects into function pointers for
+    return values.
+  * Implement FFI::Type and FFI::Type::Builtin
+  * Add support for enumerations
+* Bug fixes
+  * Fix RUBY_FFI-19
+  * Fix RUBY_FFI-15
+
+== 0.3.2 / 2009-05-01
+
+* Bug fixes
+  * Fix JRUBY-3527 by passing RTLD_GLOBAL instead of RTLD_LOCAL
+
+== 0.3.1 / 2009-03-23
+
+* Bug fixes
+  * Correctly save errno/GetLastError after each call.
+
+== 0.3.0 / 2009-03-19
+
+* Switch compilation to rake-compiler
+  * Makes cross-compilation from linux -> win32 super easy
+  * win32 support is available now, but highly experimental
+* Performance improvements
+  * struct field access approx 3x faster than 0.2.0
+  * function invocation approx 20% faster than 0.2.0
+* A bunch of minor improvements
+  * Struct instances can now be passed as :pointer parameters without calling
+    Struct#pointer
+  * Support for array struct members
+  * Structs are now padded correctly to the alignment of the struct's  
+    largest field
+  * Global library variables
+  * Callbacks in global library variables
+  * Strings passed in as :string arguments are scrubbed to avoid 
+    poison-null-byte attacks.
+  * Union support
+  * nil can be passed as a :string argument (passed as NULL)
+  * Structs can now be fields inside another struct
+  * Lots of internal cleanups and refactorings.
+ 

data/LICENSE

@@ -1,25 +1,14 @@
-Copyright (c) 2008, 2009 Ruby FFI contributors
+Copyright (c) 2008-2010 Ruby-FFI 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:
+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.
 
-* 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 JRuby 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 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.
 
-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.
+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/>.

data/README.rdoc

@@ -24,6 +24,7 @@ using Ruby-FFI here[http://wiki.github.com/ffi/ffi/why-use-ffi].
 
   module MyLib
     extend FFI::Library
+    ffi_lib 'c'
     attach_function :puts, [ :string ], :int
   end
 

data/Rakefile

@@ -75,7 +75,7 @@ PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
 PROJ.url = 'http://wiki.github.com/ffi/ffi'
-PROJ.version = '0.6.0'
+PROJ.version = '1.0.0'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 
@@ -88,7 +88,7 @@ PROJ.ann.email[:server] = 'smtp.gmail.com'
 
 # Gem specifications
 PROJ.gem.need_tar = false
-PROJ.gem.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec}/**/*")
+PROJ.gem.files = %w(History.txt LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec,tasks}/**/*")
 PROJ.gem.platform = Gem::Platform::RUBY
 
 # Override Mr. Bones autogenerated extensions and force ours in
@@ -147,6 +147,7 @@ task :distclean => :clobber do
   FileUtils.rm_rf(Dir["lib/**/ffi_c.#{Config::CONFIG['DLEXT']}"])
   FileUtils.rm_rf('lib/1.8')
   FileUtils.rm_rf('lib/1.9')
+  FileUtils.rm_rf('lib/ffi/types.conf')
   FileUtils.rm_rf('conftest.dSYM')
   FileUtils.rm_rf('pkg')
 end

data/ext/ffi_c/AbstractMemory.c

@@ -3,33 +3,26 @@
  *
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * This file is part of ruby-ffi.
  *
- * * 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.
- * * The name of the author or authors may not 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 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.
+ * 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/>.
  */
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -49,17 +42,18 @@ memory_allocate(VALUE klass)
     AbstractMemory* memory;
     VALUE obj;
     obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
-    memory->access = MEM_RD | MEM_WR;
+    memory->flags = MEM_RD | MEM_WR;
 
     return obj;
 }
+#define VAL(x, swap) (unlikely(((memory->flags & MEM_SWAP) != 0)) ? swap((x)) : (x))
 
-#define NUM_OP(name, type, toNative, fromNative) \
+#define NUM_OP(name, type, toNative, fromNative, swap) \
 static void memory_op_put_##name(AbstractMemory* memory, long off, VALUE value); \
 static void \
 memory_op_put_##name(AbstractMemory* memory, long off, VALUE value) \
 { \
-    type tmp = (type) toNative(value); \
+    type tmp = (type) VAL(toNative(value), swap); \
     checkWrite(memory); \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(memory->address + off, &tmp, sizeof(tmp)); \
@@ -81,7 +75,7 @@ memory_op_get_##name(AbstractMemory* memory, long off) \
     checkRead(memory); \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(&tmp, memory->address + off, sizeof(tmp)); \
-    return fromNative(tmp); \
+    return fromNative(VAL(tmp, swap)); \
 } \
 static VALUE memory_get_##name(VALUE self, VALUE offset); \
 static VALUE \
@@ -104,7 +98,7 @@ memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
     checkWrite(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; i++) { \
-        type tmp = (type) toNative(RARRAY_PTR(ary)[i]); \
+        type tmp = (type) VAL(toNative(RARRAY_PTR(ary)[i]), swap); \
         memcpy(memory->address + off + (i * sizeof(type)), &tmp, sizeof(tmp)); \
     } \
     return self; \
@@ -123,23 +117,47 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
     for (i = 0; i < count; ++i) { \
         type tmp; \
         memcpy(&tmp, memory->address + off + (i * sizeof(type)), sizeof(tmp)); \
-        rb_ary_push(retVal, fromNative(tmp)); \
+        rb_ary_push(retVal, fromNative(VAL(tmp, swap))); \
     } \
     return retVal; \
 }
 
-NUM_OP(int8, int8_t, NUM2INT, INT2NUM);
-NUM_OP(uint8, uint8_t, NUM2UINT, UINT2NUM);
-NUM_OP(int16, int16_t, NUM2INT, INT2NUM);
-NUM_OP(uint16, uint16_t, NUM2UINT, UINT2NUM);
-NUM_OP(int32, int32_t, NUM2INT, INT2NUM);
-NUM_OP(uint32, uint32_t, NUM2UINT, UINT2NUM);
-NUM_OP(int64, int64_t, NUM2LL, LL2NUM);
-NUM_OP(uint64, uint64_t, NUM2ULL, ULL2NUM);
-NUM_OP(long, long, NUM2LONG, LONG2NUM);
-NUM_OP(ulong, unsigned long, NUM2ULONG, ULONG2NUM);
-NUM_OP(float32, float, NUM2DBL, rb_float_new);
-NUM_OP(float64, double, NUM2DBL, rb_float_new);
+#define NOSWAP(x) (x)
+#define bswap16(x) (((x) >> 8) & 0xff) | (((x) << 8) & 0xff00);
+static inline int16_t
+SWAPS16(int16_t x)
+{
+    return bswap16(x);
+}
+
+static inline uint16_t
+SWAPU16(uint16_t x)
+{
+    return bswap16(x);
+}
+
+#define SWAP16(x) (x)
+#define SWAP32(x) __builtin_bswap32(x)
+#define SWAP64(x) __builtin_bswap64(x)
+
+#if LONG_MAX > INT_MAX
+# define SWAPLONG SWAP64
+#else
+# define SWAPLONG SWAP32
+#endif
+
+NUM_OP(int8, int8_t, NUM2INT, INT2NUM, NOSWAP);
+NUM_OP(uint8, uint8_t, NUM2UINT, UINT2NUM, NOSWAP);
+NUM_OP(int16, int16_t, NUM2INT, INT2NUM, SWAP16);
+NUM_OP(uint16, uint16_t, NUM2UINT, UINT2NUM, SWAP16);
+NUM_OP(int32, int32_t, NUM2INT, INT2NUM, SWAP32);
+NUM_OP(uint32, uint32_t, NUM2UINT, UINT2NUM, SWAP32);
+NUM_OP(int64, int64_t, NUM2LL, LL2NUM, SWAP64);
+NUM_OP(uint64, uint64_t, NUM2ULL, ULL2NUM, SWAP64);
+NUM_OP(long, long, NUM2LONG, LONG2NUM, SWAPLONG);
+NUM_OP(ulong, unsigned long, NUM2ULONG, ULONG2NUM, SWAPLONG);
+NUM_OP(float32, float, NUM2DBL, rb_float_new, NOSWAP);
+NUM_OP(float64, double, NUM2DBL, rb_float_new, NOSWAP);
 
 static inline void*
 get_pointer_value(VALUE value)
@@ -161,7 +179,7 @@ get_pointer_value(VALUE value)
     }
 }
 
-NUM_OP(pointer, void *, get_pointer_value, rbffi_Pointer_NewInstance);
+NUM_OP(pointer, void *, get_pointer_value, rbffi_Pointer_NewInstance, NOSWAP);
 
 static VALUE
 memory_clear(VALUE self)

data/ext/ffi_c/AbstractMemory.h

@@ -3,27 +3,19 @@
  *
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * This file is part of ruby-ffi.
  *
- * * 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.
- * * The name of the author or authors may not 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 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.
+ * 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/>.
  */
 
 #ifndef RBFFI_ABSTRACTMEMORY_H
@@ -44,6 +36,7 @@ extern "C" {
 #define MEM_RD   0x01
 #define MEM_WR   0x02
 #define MEM_CODE 0x04
+#define MEM_SWAP 0x08
 
 typedef struct AbstractMemory_ AbstractMemory;
 
@@ -72,7 +65,7 @@ typedef struct {
 struct AbstractMemory_ {
     char* address; // Use char* instead of void* to ensure adding to it works correctly
     long size;
-    int access;
+    int flags;
     int typeSize;
 };
 
@@ -98,7 +91,7 @@ checkBounds(AbstractMemory* mem, long off, long len)
 static inline void
 checkRead(AbstractMemory* mem)
 {
-    if (unlikely((mem->access & MEM_RD) == 0)) {
+    if (unlikely((mem->flags & MEM_RD) == 0)) {
         rbffi_AbstractMemory_Error(mem, MEM_RD);
     }
 }
@@ -106,7 +99,7 @@ checkRead(AbstractMemory* mem)
 static inline void
 checkWrite(AbstractMemory* mem)
 {
-    if (unlikely((mem->access & MEM_WR) == 0)) {
+    if (unlikely((mem->flags & MEM_WR) == 0)) {
         rbffi_AbstractMemory_Error(mem, MEM_WR);
     }
 }

data/ext/ffi_c/Buffer.c

@@ -1,28 +1,21 @@
 /*
- * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2008-2010 Wayne Meissner
+ * 
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * This file is part of ruby-ffi.
  *
- * * 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.
- * * The name of the author or authors may not 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 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.
+ * 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/>.
  */
 
 #include <stdbool.h>
@@ -54,7 +47,7 @@ buffer_allocate(VALUE klass)
 
     obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
     buffer->rbParent = Qnil;
-    buffer->memory.access = MEM_RD | MEM_WR;
+    buffer->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
 }
@@ -122,7 +115,7 @@ slice(VALUE self, long offset, long len)
     obj = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, result);
     result->memory.address = ptr->memory.address + offset;
     result->memory.size = len;
-    result->memory.access = ptr->memory.access;
+    result->memory.flags = ptr->memory.flags;
     result->memory.typeSize = ptr->memory.typeSize;
     result->rbParent = self;
 
@@ -159,6 +152,51 @@ buffer_inspect(VALUE self)
     return rb_str_new2(tmp);
 }
 
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+# define SWAPPED_ORDER BIG_ENDIAN
+#else
+# define SWAPPED_ORDER LITTLE_ENDIAN
+#endif
+
+static VALUE
+buffer_order(int argc, VALUE* argv, VALUE self)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, 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"));
+    } else {
+        VALUE rbOrder = Qnil;
+        int order = BYTE_ORDER;
+
+        if (rb_scan_args(argc, argv, "1", &rbOrder) < 1) {
+            rb_raise(rb_eArgError, "need byte order");
+        }
+        if (SYMBOL_P(rbOrder)) {
+            ID id = SYM2ID(rbOrder);
+            if (id == rb_intern("little")) {
+                order = LITTLE_ENDIAN;
+
+            } else if (id == rb_intern("big") || id == rb_intern("network")) {
+                order = BIG_ENDIAN;
+            }
+        }
+        if (order != BYTE_ORDER) {
+            Buffer* p2;
+            VALUE retval = slice(self, 0, ptr->memory.size);
+
+            Data_Get_Struct(retval, Buffer, p2);
+            p2->memory.flags |= MEM_SWAP;
+            return retval;
+        }
+
+        return self;
+    }
+}
+
 /* Only used to free the buffer if the yield in the initializer throws an exception */
 static VALUE
 buffer_free(VALUE self)
@@ -196,6 +234,7 @@ rbffi_Buffer_Init(VALUE moduleFFI)
     rb_define_alias(rb_singleton_class(BufferClass), "new_inout", "alloc_inout");
     
     rb_define_method(BufferClass, "initialize", buffer_initialize, -1);
+    rb_define_method(BufferClass, "order", buffer_order, -1);
     rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
     rb_define_alias(BufferClass, "length", "total");
     rb_define_method(BufferClass, "+", buffer_plus, 1);