ffi 0.4.0-x86-mswin32 → 0.5.0-x86-mswin32

data/README.rdoc

@@ -1,6 +1,6 @@
 ruby-ffi
     by Wayne Meissner
-    http://kenai.com/projects/ruby-ffi
+    http://wiki.github.com/ffi/ffi
 
 == DESCRIPTION:
 
@@ -8,7 +8,7 @@ Ruby-FFI is a ruby extension for programmatically loading dynamic
 libraries, binding functions within them, and calling those functions
 from Ruby code. Moreover, a Ruby-FFI extension works without changes
 on Ruby and JRuby. Discover why should you write your next extension
-using Ruby-FFI {here}[http://kenai.com/projects/ruby-ffi/pages/WhyUseFFI].
+using Ruby-FFI here[http://wiki.github.com/ffi/ffi/why-use-ffi].
 
 == FEATURES/PROBLEMS:
 
@@ -32,8 +32,8 @@ using Ruby-FFI {here}[http://kenai.com/projects/ruby-ffi/pages/WhyUseFFI].
 For less minimalistic and more sane examples you may look at:
 
 * the samples/ folder
-* the examples on the Kenai {wiki}[http://kenai.com/projects/ruby-ffi/pages/Home]
-* the projects using FFI listed on this {page}[http://kenai.com/projects/ruby-ffi/pages/ProjectsUsingFFI]
+* the examples on the wiki[http://wiki.github.com/ffi/ffi]
+* the projects using FFI listed on this page[http://wiki.github.com/ffi/ffi/projects-using-ffi]
 
 == REQUIREMENTS:
 
@@ -45,24 +45,24 @@ From rubyforge:
 
   [sudo] gem install ffi
 
-or from the mercurial repository on Kenai:
+or from the git repository on github:
 
-  hg clone https://kenai.com/hg/ruby-ffi~mercurial ruby-ffi
-  cd ruby-ffi
+  git clone git://github.com/ffi/ffi.git
+  cd ffi
   rake gem:install
 
 == CREDITS:
 
 Special thanks to:
 
-Yehuda Katz
-Luc Heinrich
-Andrea Fazzi
-Mike Dalessio
-Hongli Lai
-Evan Phoenix
-Aman Gupta
-Beoran
+* Yehuda Katz
+* Luc Heinrich
+* Andrea Fazzi
+* Mike Dalessio
+* Hongli Lai
+* Evan Phoenix
+* Aman Gupta
+* Beoran
 
 == LICENSE:
 

data/Rakefile

@@ -23,8 +23,52 @@ rescue LoadError
   end
 end
 
-LIBEXT = Config::CONFIG['host_os'].downcase =~ /darwin/ ? "dylib" : "so"
-GMAKE = Config::CONFIG['host_os'].downcase =~ /bsd/ ? "gmake" : "make"
+LIBEXT = case Config::CONFIG['host_os'].downcase
+  when /darwin/
+    "dylib"
+  when /mswin|mingw/
+    "dll"
+  else
+    Config::CONFIG['DLEXT']
+  end
+
+CPU = case Config::CONFIG['host_cpu'].downcase
+  when /i[3456]86/
+    # Darwin always reports i686, even when running in 64bit mode
+    if Config::CONFIG['host_os'] =~ /darwin/ && 0xfee1deadbeef.is_a?(Fixnum)
+      "x86_64"
+    else
+      "i386"
+    end
+  when /amd64|x86_64/
+    "x86_64"
+  when /ppc|powerpc/
+    "powerpc"
+  else
+    Config::CONFIG['host_cpu']
+  end
+
+OS = case Config::CONFIG['host_os'].downcase
+  when /linux/
+    "linux"
+  when /darwin/
+    "darwin"
+  when /freebsd/
+    "freebsd"
+  when /openbsd/
+    "openbsd"
+  when /sunos|solaris/
+    "solaris"
+  when /mswin|mingw/
+    "win32"
+  else
+    Config::CONFIG['host_os'].downcase
+  end
+
+CC=ENV['CC'] || Config::CONFIG['CC'] || "gcc"
+
+GMAKE = Config::CONFIG['host_os'].downcase =~ /bsd|solaris/ ? "gmake" : "make"
+
 LIBTEST = "build/libtest.#{LIBEXT}"
 BUILD_DIR = "build"
 BUILD_EXT_DIR = File.join(BUILD_DIR, "#{Config::CONFIG['arch']}", 'ffi_c', RUBY_VERSION)
@@ -33,8 +77,8 @@ BUILD_EXT_DIR = File.join(BUILD_DIR, "#{Config::CONFIG['arch']}", 'ffi_c', RUBY_
 PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
-PROJ.url = 'http://kenai.com/projects/ruby-ffi'
-PROJ.version = '0.4.0'
+PROJ.url = 'http://wiki.github.com/ffi/ffi'
+PROJ.version = '0.5.0'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 
@@ -42,7 +86,7 @@ PROJ.readme_file = 'README.rdoc'
 PROJ.ann.paragraphs << 'FEATURES' << 'SYNOPSIS' << 'REQUIREMENTS' << 'DOWNLOAD/INSTALL' << 'CREDITS' << 'LICENSE'
 
 PROJ.ann.email[:from] = 'andrea.fazzi@alcacoop.it'
-PROJ.ann.email[:to] << 'dev@ruby-ffi.kenai.com' << 'users@ruby-ffi.kenai.com'
+PROJ.ann.email[:to] << 'ruby-ffi@groups.google.com'
 PROJ.ann.email[:server] = 'smtp.gmail.com'
 
 # Gem specifications
@@ -61,9 +105,14 @@ PROJ.rdoc.opts << '-x' << 'ext'
 PROJ.ruby_opts = []
 PROJ.ruby_opts << '-I' << BUILD_EXT_DIR unless RUBY_PLATFORM == "java"
 
-#RSpec
+# RSpec
+PROJ.spec.files.exclude /rbx/
 PROJ.spec.opts << '--color' << '-fs'
 
+# Dependencies
+
+depend_on 'rake', '>=0.8.7'
+
 TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
   desc "Run all specs"
@@ -98,7 +147,7 @@ task :install => 'gem:install'
 desc "Clean all built files"
 task :distclean => :clobber do
   FileUtils.rm_rf('build')
-  FileUtils.rm_rf(Dir['lib/**/ffi_c.so'])
+  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('conftest.dSYM')
@@ -108,7 +157,7 @@ end
 
 desc "Build the native test lib"
 task "build/libtest.#{LIBEXT}" do
-  sh %{#{GMAKE} -f libtest/GNUmakefile CPU=#{Config::CONFIG['host_cpu']}}
+  sh %{#{GMAKE} -f libtest/GNUmakefile CPU=#{CPU} OS=#{OS} }
 end
 
 

data/ext/ffi_c/AbstractMemory.c

@@ -1,3 +1,31 @@
+/*
+ * Copyright (c) 2008, 2009, 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:
+ *
+ * * 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 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.
+ */
+
 #include <sys/types.h>
 #include <sys/param.h>
 #include <stdint.h>
@@ -7,13 +35,13 @@
 #include "compat.h"
 #include "AbstractMemory.h"
 #include "Pointer.h"
-#include "Callback.h"
+#include "Function.h"
 
 
 static inline char* memory_address(VALUE self);
 VALUE rbffi_AbstractMemoryClass = Qnil;
-static ID id_to_ptr = 0;
-static ID id_call = 0;
+static VALUE NullPointerErrorClass = Qnil;
+static ID id_to_ptr = 0, id_plus = 0, id_call = 0;
 
 static VALUE
 memory_allocate(VALUE klass)
@@ -22,6 +50,7 @@ memory_allocate(VALUE klass)
     VALUE obj;
     obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
     memory->ops = &rbffi_AbstractMemoryOps;
+    memory->access = MEM_RD | MEM_WR;
 
     return obj;
 }
@@ -32,6 +61,7 @@ static void \
 memory_op_put_##name(AbstractMemory* memory, long off, VALUE value) \
 { \
     type tmp = (type) toNative(value); \
+    checkWrite(memory); \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(memory->address + off, &tmp, sizeof(tmp)); \
 } \
@@ -49,6 +79,7 @@ static VALUE \
 memory_op_get_##name(AbstractMemory* memory, long off) \
 { \
     type tmp; \
+    checkRead(memory); \
     checkBounds(memory, off, sizeof(type)); \
     memcpy(&tmp, memory->address + off, sizeof(tmp)); \
     return fromNative(tmp); \
@@ -71,6 +102,7 @@ memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
     long off = NUM2LONG(offset); \
     AbstractMemory* memory = MEMORY(self); \
     long i; \
+    checkWrite(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; i++) { \
         type tmp = (type) toNative(RARRAY_PTR(ary)[i]); \
@@ -86,6 +118,7 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
     long off = NUM2LONG(offset); \
     AbstractMemory* memory = MEMORY(self); \
     long i; \
+    checkRead(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     VALUE retVal = rb_ary_new2(count); \
     for (i = 0; i < count; ++i) { \
@@ -128,24 +161,6 @@ get_pointer_value(VALUE value)
 
 NUM_OP(pointer, void *, get_pointer_value, rbffi_Pointer_NewInstance);
 
-static VALUE
-memory_put_callback(VALUE self, VALUE offset, VALUE proc, VALUE cbInfo)
-{
-    AbstractMemory* memory = MEMORY(self);
-    long off = NUM2LONG(offset);
-    checkBounds(memory, off, sizeof(void *));
-
-    if (rb_obj_is_kind_of(proc, rb_cProc) || rb_respond_to(proc, id_call)) {
-        VALUE callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
-        void* code = ((NativeCallback *) DATA_PTR(callback))->code;
-        memcpy(memory->address + off, &code, sizeof(code));
-    } else {
-        rb_raise(rb_eArgError, "parameter is not a proc");
-    }
-
-    return self;
-}
-
 static VALUE
 memory_clear(VALUE self)
 {
@@ -157,7 +172,11 @@ memory_clear(VALUE self)
 static VALUE
 memory_size(VALUE self) 
 {
-    return LONG2FIX((MEMORY(self))->size);
+    AbstractMemory* ptr;
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+
+    return LONG2NUM(ptr->size);
 }
 
 static VALUE
@@ -171,7 +190,9 @@ memory_get_string(int argc, VALUE* argv, VALUE self)
 
     off = NUM2LONG(offset);
     len = nargs > 1 && length != Qnil ? NUM2LONG(length) : (ptr->size - off);
+    checkRead(ptr);
     checkBounds(ptr, off, len);
+
     end = memchr(ptr->address + off, 0, len);
     return rb_tainted_str_new((char *) ptr->address + off,
             (end != NULL ? end - ptr->address - off : len));
@@ -191,6 +212,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
     retVal = rb_ary_new2(count);
 
     Data_Get_Struct(self, AbstractMemory, ptr);
+    checkRead(ptr);
 
     if (countnum != Qnil) {
         int i;
@@ -226,12 +248,16 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
     off = NUM2LONG(offset);
     len = RSTRING_LEN(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");
     }
+
     memcpy(ptr->address + off, RSTRING_PTR(str), len);
     *((char *) ptr->address + off + len) = '\0';
+
     return self;
 }
 
@@ -243,7 +269,10 @@ memory_get_bytes(VALUE self, VALUE offset, VALUE length)
     
     off = NUM2LONG(offset);
     len = NUM2LONG(length);
+
+    checkRead(ptr);
     checkBounds(ptr, off, len);
+    
     return rb_tainted_str_new((char *) ptr->address + off, len);
 }
 
@@ -266,14 +295,41 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     if ((idx + len) > RSTRING_LEN(str)) {
         rb_raise(rb_eRangeError, "index+length is greater than size of string");
     }
+
+    checkWrite(ptr);
     checkBounds(ptr, off, len);
+
     if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
         rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
     }
     memcpy(ptr->address + off, RSTRING_PTR(str) + idx, len);
+
     return self;
 }
 
+static VALUE
+memory_type_size(VALUE self)
+{
+    AbstractMemory* ptr;
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+
+    return INT2NUM(ptr->typeSize);
+}
+
+static VALUE
+memory_aref(VALUE self, VALUE idx)
+{
+    AbstractMemory* ptr;
+    VALUE rbOffset = Qnil;
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+
+    rbOffset = ULONG2NUM(NUM2ULONG(idx) * ptr->typeSize);
+
+    return rb_funcall2(self, id_plus, 1, &rbOffset);
+}
+
 static inline char*
 memory_address(VALUE obj)
 {
@@ -293,12 +349,26 @@ rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass)
     return NULL;
 }
 
+void
+rbffi_AbstractMemory_Error(AbstractMemory *mem, int op)
+{
+    VALUE rbErrorClass = mem->address == NULL ? NullPointerErrorClass : rb_eRuntimeError;
+    if (op == MEM_RD) {
+        rb_raise(rbErrorClass, "invalid memory read at address=%p", mem->address);
+    } else if (op == MEM_WR) {
+        rb_raise(rbErrorClass, "invalid memory write at address=%p", mem->address);
+    } else {
+        rb_raise(rbErrorClass, "invalid memory access at address=%p", mem->address);
+    }
+}
+
 static VALUE
 memory_op_get_strptr(AbstractMemory* ptr, long offset)
 {
     void* tmp = NULL;
 
     if (ptr != NULL && ptr->address != NULL) {
+        checkRead(ptr);
         checkBounds(ptr, offset, sizeof(tmp));
         memcpy(&tmp, ptr->address + offset, sizeof(tmp));
     }
@@ -337,8 +407,12 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     VALUE classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
     rbffi_AbstractMemoryClass = classMemory;
     rb_global_variable(&rbffi_AbstractMemoryClass);
-
     rb_define_alloc_func(classMemory, memory_allocate);
+
+    NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
+    rb_global_variable(&NullPointerErrorClass);
+
+
 #undef INT
 #define INT(type) \
     rb_define_method(classMemory, "put_" #type, memory_put_##type, 2); \
@@ -396,7 +470,6 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "get_pointer", memory_get_pointer, 1);
     rb_define_method(classMemory, "put_array_of_pointer", memory_put_array_of_pointer, 2);
     rb_define_method(classMemory, "get_array_of_pointer", memory_get_array_of_pointer, 2);
-    rb_define_method(classMemory, "put_callback", memory_put_callback, 3);
     rb_define_method(classMemory, "get_string", memory_get_string, -1);
     rb_define_method(classMemory, "put_string", memory_put_string, 2);
     rb_define_method(classMemory, "get_bytes", memory_get_bytes, 2);
@@ -405,8 +478,12 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
 
     rb_define_method(classMemory, "clear", memory_clear, 0);
     rb_define_method(classMemory, "total", memory_size, 0);
+    rb_define_alias(classMemory, "size", "total");
+    rb_define_method(classMemory, "type_size", memory_type_size, 0);
+    rb_define_method(classMemory, "[]", memory_aref, 1);
 
     id_to_ptr = rb_intern("to_ptr");
     id_call = rb_intern("call");
+    id_plus = rb_intern("+");
 }
 

data/ext/ffi_c/AbstractMemory.h

@@ -1,16 +1,50 @@
-#ifndef _ABSTRACTMEMORY_H
-#define	_ABSTRACTMEMORY_H
+/*
+ * Copyright (c) 2008, 2009, 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:
+ *
+ * * 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 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.
+ */
+
+#ifndef RBFFI_ABSTRACTMEMORY_H
+#define	RBFFI_ABSTRACTMEMORY_H
 
 #include <sys/param.h>
 #include <sys/types.h>
 #include <stdint.h>
 
 #include "compat.h"
+#include "Types.h"
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
+
+#define MEM_RD   0x01
+#define MEM_WR   0x02
+#define MEM_CODE 0x04
+
 typedef struct AbstractMemory_ AbstractMemory;
 
 typedef struct {
@@ -36,33 +70,91 @@ typedef struct {
 struct AbstractMemory_ {
     char* address; // Use char* instead of void* to ensure adding to it works correctly
     long size;
+    int access;
+    int typeSize;
     MemoryOps* ops;
 };
 
+extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
+
+extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
+
+extern void rbffi_AbstractMemory_Error(AbstractMemory *, int op);
 
 static inline void
 checkBounds(AbstractMemory* mem, long off, long len)
 {
-    if ((off | len | (off + len) | (mem->size - (off + len))) < 0) {
+    if (unlikely((off | len | (off + len) | (mem->size - (off + len))) < 0)) {
         rb_raise(rb_eIndexError, "Memory access offset=%ld size=%ld is out of bounds",
                 off, len);
     }
 }
 
+static inline void
+checkRead(AbstractMemory* mem)
+{
+    if (unlikely((mem->access & MEM_RD) == 0)) {
+        rbffi_AbstractMemory_Error(mem, MEM_RD);
+    }
+}
+
+static inline void
+checkWrite(AbstractMemory* mem)
+{
+    if (unlikely((mem->access & MEM_WR) == 0)) {
+        rbffi_AbstractMemory_Error(mem, MEM_WR);
+    }
+}
+
+static inline MemoryOp*
+memory_get_op(AbstractMemory* ptr, Type* type)
+{
+    if (ptr == NULL || ptr->ops == NULL || type == NULL) {
+        return NULL;
+    }
+    switch (type->nativeType) {
+        case NATIVE_INT8:
+            return ptr->ops->int8;
+        case NATIVE_UINT8:
+            return ptr->ops->uint8;
+        case NATIVE_INT16:
+            return ptr->ops->int16;
+        case NATIVE_UINT16:
+            return ptr->ops->uint16;
+        case NATIVE_INT32:
+            return ptr->ops->int32;
+        case NATIVE_UINT32:
+            return ptr->ops->uint32;
+        case NATIVE_INT64:
+            return ptr->ops->int64;
+        case NATIVE_UINT64:
+            return ptr->ops->uint64;
+        case NATIVE_FLOAT32:
+            return ptr->ops->float32;
+        case NATIVE_FLOAT64:
+            return ptr->ops->float64;
+        case NATIVE_POINTER:
+            return ptr->ops->pointer;
+        case NATIVE_STRING:
+            return ptr->ops->strptr;
+        default:
+            return NULL;
+    }
+}
+
 #define MEMORY(obj) rbffi_AbstractMemory_Cast((obj), rbffi_AbstractMemoryClass)
 #define MEMORY_PTR(obj) MEMORY((obj))->address
 #define MEMORY_LEN(obj) MEMORY((obj))->size
 
-extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
 
-extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
 
 extern VALUE rbffi_AbstractMemoryClass;
 extern MemoryOps rbffi_AbstractMemoryOps;
 
+
 #ifdef	__cplusplus
 }
 #endif
 
-#endif	/* _ABSTRACTMEMORY_H */
+#endif	/* RBFFI_ABSTRACTMEMORY_H */