2003-03-20 Michael Koch <konqueror@gmx.de>

	* gnu/java/nio/FileChannelImpl.java
	(address): Removed.
	(map_address): New member variable.
	(length): Make it package private.
	(fd): Make it package private.
	(buf): Make it package private.
	(file_obj): Make it package private.
	(FileChannelImpl): New constructor.
	(nio_mmap_file): Use RawData instead of long.
	(nio_munmap_file): Use RawData instead of long.
	(nio_msync): Use RawData instead of long.
	(implCloseChannel): New implementation using map_address.
	(read): Reformated.
	(map): Implemented.
	(create_direct_mapped_buffer): Implemented, use RawData, throws
	IOException.
	(force): Use map_address instead of address.
	* gnu/java/nio/MappedByteFileBuffer.java
	(address): Removed.
	(map_address): New member variable.
	(MappedByteFileBuffer): Use map_address instead of address, reformated.
	(several methods): Use map_address instead of address, replaced long
	with RawData where appropriate.
	* gnu/java/nio/natFileChannelImpl.cc
	(nio_mmap_file): Replaced long with RawData.
	(nio_munmap_file): Replaced long with RawData.
	(nio_msync): Replaced long with RawData.
	* gnu/java/nio/natMappedByteFileBuffer.cc
	(several methods): Replaced long with RawData where appropriate.

From-SVN: r64612

5 files changed, 170 insertions, 108 deletions

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 3c32c68..acc6347 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,5 +1,37 @@
 2003-03-20  Michael Koch  <konqueror@gmx.de>
 
+	* gnu/java/nio/FileChannelImpl.java
+	(address): Removed.
+	(map_address): New member variable.
+	(length): Make it package private.
+	(fd): Make it package private.
+	(buf): Make it package private.
+	(file_obj): Make it package private.
+	(FileChannelImpl): New constructor.
+	(nio_mmap_file): Use RawData instead of long.
+	(nio_munmap_file): Use RawData instead of long.
+	(nio_msync): Use RawData instead of long.
+	(implCloseChannel): New implementation using map_address.
+	(read): Reformated.
+	(map): Implemented.
+	(create_direct_mapped_buffer): Implemented, use RawData, throws
+	IOException.
+	(force): Use map_address instead of address.
+	* gnu/java/nio/MappedByteFileBuffer.java
+	(address): Removed.
+	(map_address): New member variable.
+	(MappedByteFileBuffer): Use map_address instead of address, reformated.
+	(several methods): Use map_address instead of address, replaced long
+	with RawData where appropriate.
+	* gnu/java/nio/natFileChannelImpl.cc
+	(nio_mmap_file): Replaced long with RawData.
+	(nio_munmap_file): Replaced long with RawData.
+	(nio_msync): Replaced long with RawData.
+	* gnu/java/nio/natMappedByteFileBuffer.cc
+	(several methods): Replaced long with RawData where appropriate.
+
+2003-03-20  Michael Koch  <konqueror@gmx.de>
+
 	* java/net/InetAddress.java,
 	java/net/JarURLConnection.java,
 	java/net/PlainDatagramSocketImpl.java,
diff --git a/libjava/gnu/java/nio/FileChannelImpl.java b/libjava/gnu/java/nio/FileChannelImpl.java
index 2283540..c233d82 100644
--- a/libjava/gnu/java/nio/FileChannelImpl.java
+++ b/libjava/gnu/java/nio/FileChannelImpl.java
@@ -52,6 +52,7 @@ import java.nio.channels.NonReadableChannelException;
 import java.nio.channels.NonWritableChannelException;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.WritableByteChannel;
+import gnu.gcj.RawData;
 
 /**
  * This file is not user visible !
@@ -63,11 +64,14 @@ import java.nio.channels.WritableByteChannel;
 
 public class FileChannelImpl extends FileChannel
 {
-  public long address;
-  public int length;
-  public FileDescriptor fd;
-  public MappedByteBuffer buf;
-  public Object file_obj; // just to keep it live...
+  // GCJ LOCAL: This variable stores a pointer to the memory
+  // where the file is mapped.
+  RawData map_address;
+  
+  int length;
+  FileDescriptor fd;
+  MappedByteBuffer buf;
+  Object file_obj; // just to keep it live...
 
   public FileChannelImpl (FileDescriptor fd, boolean write, Object obj)
   {
@@ -80,24 +84,27 @@ public class FileChannelImpl extends FileChannel
     this.file_obj = obj;
   }
 
+  public FileChannelImpl ()
+  {
+    this (new FileDescriptor (-1), true, null);
+  }
+
   private native long implPosition ();
   private native FileChannel implPosition (long newPosition);
   private native FileChannel implTruncate (long size);
   
-  private native long nio_mmap_file (long pos, long size, int mode);
-  private native void nio_unmmap_file (long address, int size);
-  private native void nio_msync (long address, int length);
+  private native RawData nio_mmap_file (long pos, long size, int mode);
+  private native void nio_unmmap_file (RawData map_address, int size);
+  private native void nio_msync (RawData map_address, int length);
 
   public native long size () throws IOException;
     
   protected void implCloseChannel() throws IOException
   {
-    // FIXME
-    
-    if (address != 0)
+    if (map_address != null)
       {
-        //nio_unmmap_file (fd, address, (int) length);
-        address = 0;
+        nio_unmmap_file (map_address, (int) length);
+        map_address = null;
       }
 
     if (file_obj instanceof RandomAccessFile)
@@ -126,9 +133,9 @@ public class FileChannelImpl extends FileChannel
         throw new EOFException("file not mapped");
       }
 
-    for (int i=0; i<s; i++)
+    for (int i = 0; i < s; i++)
       {
-        dst.put( buf.get() );
+        dst.put (buf.get());
       }
 
     return s;
@@ -154,9 +161,9 @@ public class FileChannelImpl extends FileChannel
     long result = 0;
 
     for (int i = offset; i < offset + length; i++)
-	    {
-        result += write (dsts[i]);
-	    }
+      {
+        result += write (dsts [i]);
+      }
 
     return result;
   }
@@ -218,23 +225,22 @@ public class FileChannelImpl extends FileChannel
         || size > Integer.MAX_VALUE)
       throw new IllegalArgumentException ();
     
-//     int cmode = mode.m;
-//     address = nio_mmap_file (fd, position, size, cmode);
-//     length = size;
-//     buf = new MappedByteFileBuffer (this);
-//     return buf;
-    return null;
+    int cmode = mode.m;
+    map_address = nio_mmap_file (position, size, cmode);
+    length = (int) size;
+    buf = new MappedByteFileBuffer (this);
+    return buf;
   }
 
-  static MappedByteBuffer create_direct_mapped_buffer (long address,
+  static MappedByteBuffer create_direct_mapped_buffer (RawData map_address,
                                                        long length)
+    throws IOException
   {
-//     FileChannelImpl ch = new FileChannelImpl (-1, null);
-//     ch.address = address;
-//     ch.length = (int) length;
-//     ch.buf = new MappedByteFileBuffer (ch);
-//     return ch.buf;			 
-    return null;
+    FileChannelImpl ch = new FileChannelImpl ();
+    ch.map_address = map_address;
+    ch.length = (int) length;
+    ch.buf = new MappedByteFileBuffer (ch);
+    return ch.buf;			 
   }
 
   public long write (ByteBuffer[] srcs)
@@ -253,7 +259,7 @@ public class FileChannelImpl extends FileChannel
 
     // FIXME: What to do with metaData ?
     
-    nio_msync (address, length);
+    nio_msync (map_address, length);
   }
 
   public long transferTo (long position, long count, WritableByteChannel target)
diff --git a/libjava/gnu/java/nio/MappedByteFileBuffer.java b/libjava/gnu/java/nio/MappedByteFileBuffer.java
index acade62..ec6c83c 100644
--- a/libjava/gnu/java/nio/MappedByteFileBuffer.java
+++ b/libjava/gnu/java/nio/MappedByteFileBuffer.java
@@ -46,11 +46,12 @@ import java.nio.LongBuffer;
 import java.nio.ShortBuffer;
 import java.nio.MappedByteBuffer;
 import java.io.IOException;
+import gnu.gcj.RawData;
 
 final public class MappedByteFileBuffer
   extends MappedByteBuffer
 {
-  public long address;
+  RawData map_address;
   boolean readOnly;
   boolean direct;
   public FileChannelImpl ch;
@@ -60,13 +61,17 @@ final public class MappedByteFileBuffer
     super ((int) ch.size (), (int) ch.size (), 0, -1);
     
     this.ch = ch;
-    address = ch.address;
-    try {
-      long si = ch.size() / 1;
-      limit((int)si);
-    } catch (IOException e) {
-      System.err.println("failed to get size of file-channel's file");
-    }
+    map_address = ch.map_address;
+    
+    try
+      {
+        long si = ch.size () / 1;
+        limit ((int) si);
+      }
+    catch (IOException e)
+      {
+        System.err.println ("failed to get size of file-channel's file");
+      }
   }
   
   public MappedByteFileBuffer (MappedByteFileBuffer b)
@@ -76,7 +81,7 @@ final public class MappedByteFileBuffer
     
     this.readOnly = b.isReadOnly ();
     this.ch = b.ch;
-    address = b.address;
+    map_address = b.map_address;
     limit (b.limit ());
   }
 
@@ -87,57 +92,59 @@ final public class MappedByteFileBuffer
   
   public static native byte nio_read_Byte_file_channel (FileChannelImpl ch,
                                                         int index, int limit,
-                                                        long address);
+                                                        RawData map_address);
   public static native void nio_write_Byte_file_channel (FileChannelImpl ch,
                                                          int index, int limit,
                                                          byte value,
-                                                         long address);
+                                                         RawData map_address);
   public static native short nio_read_Short_file_channel (FileChannelImpl ch,
                                                           int index, int limit,
-                                                          long address);
+                                                          RawData map_address);
   public static native void nio_write_Short_file_channel (FileChannelImpl ch,
                                                           int index, int limit,
                                                           short value,
-                                                          long address);
+                                                          RawData map_address);
   public static native char nio_read_Char_file_channel (FileChannelImpl ch,
                                                         int index, int limit,
-                                                        long address);
+                                                        RawData map_address);
   public static native void nio_write_Char_file_channel (FileChannelImpl ch,
                                                          int index, int limit,
                                                          char value,
-                                                         long address);
+                                                         RawData map_address);
   public static native int nio_read_Int_file_channel (FileChannelImpl ch,
                                                       int index, int limit,
-                                                      long address);
+                                                      RawData map_address);
   public static native void nio_write_Int_file_channel (FileChannelImpl ch,
                                                         int index, int limit,
-                                                        int value, long address);
+                                                        int value,
+                                                        RawData map_address);
   public static native long nio_read_Long_file_channel (FileChannelImpl ch,
                                                         int index, int limit,
-                                                        long address);
+                                                        RawData map_address);
   public static native void nio_write_Long_file_channel (FileChannelImpl ch,
                                                          int index, int limit,
                                                          long value,
-                                                         long address);
+                                                         RawData map_address);
   public static native float nio_read_Float_file_channel (FileChannelImpl ch,
                                                           int index, int limit,
-                                                          long address);
+                                                          RawData map_address);
   public static native void nio_write_Float_file_channel (FileChannelImpl ch,
                                                           int index, int limit,
                                                           float value,
-                                                          long address);
-  public static native double nio_read_Double_file_channel (FileChannelImpl ch,
-                                                            int index, int limit,
-                                                            long address);
+                                                          RawData map_address);
+  public static native double
+    nio_read_Double_file_channel (FileChannelImpl ch, int index, int limit,
+                                  RawData map_address);
   public static native void nio_write_Double_file_channel (FileChannelImpl ch,
                                                            int index, int limit,
                                                            double value,
-                                                           long address);
+                                                           RawData map_address);
 
   final public byte get ()
   {
     byte a = MappedByteFileBuffer.nio_read_Byte_file_channel (ch, position (),
-                                                              limit (), address);
+                                                              limit (),
+                                                              map_address);
     position (position () + 1);
     return a;
   }
@@ -145,7 +152,7 @@ final public class MappedByteFileBuffer
   final public ByteBuffer put (byte b)
   {
     MappedByteFileBuffer.nio_write_Byte_file_channel (ch, position (), limit (),
-                                                      b, address);
+                                                      b, map_address);
     position (position () + 1);
     return this;
   }
@@ -154,14 +161,14 @@ final public class MappedByteFileBuffer
   {
     byte a = MappedByteFileBuffer.nio_read_Byte_file_channel (ch, index,
                                                               limit (),
-                                                              address);
+                                                              map_address);
     return a;
   }
 
   final public ByteBuffer put (int index, byte b)
   {
     MappedByteFileBuffer.nio_write_Byte_file_channel (ch, index, limit (), b,
-                                                      address);
+                                                      map_address);
     return this;
   }
 
@@ -203,27 +210,28 @@ final public class MappedByteFileBuffer
   
   final public byte getByte ()
   {
-    byte a = nio_read_Byte_file_channel (ch, position (), limit (), address);
+    byte a = nio_read_Byte_file_channel (ch, position (), limit (),
+                                         map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putByte (byte value)
   {
-    nio_write_Byte_file_channel (ch, position (), limit (), value, address);
+    nio_write_Byte_file_channel (ch, position (), limit (), value, map_address);
     position (position () + 1);
     return this;
   }
   
   final public byte getByte (int index)
   {
-    byte a = nio_read_Byte_file_channel (ch, index, limit(), address);
+    byte a = nio_read_Byte_file_channel (ch, index, limit(), map_address);
     return a;
   }
   
   final public ByteBuffer putByte (int index, byte value)
   {
-    nio_write_Byte_file_channel (ch, index, limit (), value, address);
+    nio_write_Byte_file_channel (ch, index, limit (), value, map_address);
     return this;
   };
   
@@ -237,27 +245,28 @@ final public class MappedByteFileBuffer
 
   final public char getChar ()
   {
-    char a = nio_read_Char_file_channel (ch, position (), limit (), address);
+    char a = nio_read_Char_file_channel (ch, position (), limit (),
+                                         map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putChar (char value)
   {
-    nio_write_Char_file_channel (ch, position (), limit (), value, address);
+    nio_write_Char_file_channel (ch, position (), limit (), value, map_address);
     position (position () + 1);
     return this;
   }
   
   final public char getChar (int index)
   {
-    char a = nio_read_Char_file_channel (ch, index, limit (), address);
+    char a = nio_read_Char_file_channel (ch, index, limit (), map_address);
     return a;
   }
   
   final public ByteBuffer putChar (int index, char value)
   {
-    nio_write_Char_file_channel (ch, index, limit (), value, address);
+    nio_write_Char_file_channel (ch, index, limit (), value, map_address);
     return this;
   };
 
@@ -271,27 +280,29 @@ final public class MappedByteFileBuffer
   
   final public short getShort ()
   {
-    short a = nio_read_Short_file_channel (ch, position (), limit (), address);
+    short a = nio_read_Short_file_channel (ch, position (), limit (),
+                                           map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putShort (short value)
   {
-    nio_write_Short_file_channel (ch, position (), limit (), value, address);
+    nio_write_Short_file_channel (ch, position (), limit (), value,
+                                  map_address);
     position (position () + 1);
     return this;
   }
   
   final public short getShort (int index)
   {
-    short a = nio_read_Short_file_channel (ch, index, limit (), address);
+    short a = nio_read_Short_file_channel (ch, index, limit (), map_address);
     return a;
   }
   
   final public ByteBuffer putShort (int index, short value)
   {
-    nio_write_Short_file_channel (ch, index, limit (), value, address);
+    nio_write_Short_file_channel (ch, index, limit (), value, map_address);
     return this;
   }
 
@@ -305,28 +316,27 @@ final public class MappedByteFileBuffer
   
   final public int getInt ()
   {
-    int a = nio_read_Int_file_channel (ch, position (), limit (), address);
+    int a = nio_read_Int_file_channel (ch, position (), limit (), map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putInt (int value)
   {
-    nio_write_Int_file_channel (ch, position (), limit (), value, address);
+    nio_write_Int_file_channel (ch, position (), limit (), value, map_address);
     position (position () + 1);
     return this;
   }
   
   final public int getInt (int index)
   {
-    int a = nio_read_Int_file_channel (ch, index, limit (),
-                                                            address);
+    int a = nio_read_Int_file_channel (ch, index, limit (), map_address);
     return a;
   }
   
   final public ByteBuffer putInt (int index, int value)
   {
-    nio_write_Int_file_channel (ch, index, limit (), value, address);
+    nio_write_Int_file_channel (ch, index, limit (), value, map_address);
     return this;
   }
 
@@ -340,27 +350,28 @@ final public class MappedByteFileBuffer
   
   final public long getLong ()
   {
-    long a = nio_read_Long_file_channel (ch, position (), limit (), address);
+    long a = nio_read_Long_file_channel (ch, position (), limit (),
+                                         map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putLong (long value)
   {
-    nio_write_Long_file_channel (ch, position (), limit (), value, address);
+    nio_write_Long_file_channel (ch, position (), limit (), value, map_address);
     position (position () + 1);
     return this;
   }
   
   final public long getLong (int index)
   {
-    long a = nio_read_Long_file_channel (ch, index, limit (), address);
+    long a = nio_read_Long_file_channel (ch, index, limit (), map_address);
     return a;
   }
   
   final public ByteBuffer putLong (int index, long value)
   {
-    nio_write_Long_file_channel (ch, index, limit (), value, address);
+    nio_write_Long_file_channel (ch, index, limit (), value, map_address);
     return this;
   }
 
@@ -374,27 +385,29 @@ final public class MappedByteFileBuffer
   
   final public float getFloat ()
   {
-    float a = nio_read_Float_file_channel (ch, position (), limit (), address);
+    float a = nio_read_Float_file_channel (ch, position (), limit (),
+                                           map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putFloat (float value)
   {
-    nio_write_Float_file_channel (ch, position (), limit (), value, address);
+    nio_write_Float_file_channel (ch, position (), limit (), value,
+                                  map_address);
     position (position () + 1);
     return this;
   }
   
   final public float getFloat (int index)
   {
-    float a = nio_read_Float_file_channel (ch, index, limit (), address);
+    float a = nio_read_Float_file_channel (ch, index, limit (), map_address);
     return a;
   }
   
   final public ByteBuffer putFloat (int index, float value)
   {
-    nio_write_Float_file_channel (ch, index, limit (), value, address);
+    nio_write_Float_file_channel (ch, index, limit (), value, map_address);
     return this;
   }
 
@@ -408,27 +421,29 @@ final public class MappedByteFileBuffer
   
   final public double getDouble ()
   {
-    double a = nio_read_Double_file_channel (ch, position (), limit (), address);
+    double a = nio_read_Double_file_channel (ch, position (), limit (),
+                                             map_address);
     position (position () + 1);
     return a;
   }
   
   final public ByteBuffer putDouble (double value)
   {
-    nio_write_Double_file_channel (ch, position (), limit (), value, address);
+    nio_write_Double_file_channel (ch, position (), limit (), value,
+                                   map_address);
     position (position () + 1);
     return this;
   }
   
   final public double getDouble (int index)
   {
-    double a = nio_read_Double_file_channel (ch, index, limit (), address);
+    double a = nio_read_Double_file_channel (ch, index, limit (), map_address);
     return a;
   }
   
   final public ByteBuffer putDouble (int index, double value)
   {
-    nio_write_Double_file_channel (ch, index, limit (), value, address);
+    nio_write_Double_file_channel (ch, index, limit (), value, map_address);
     return this;
   }
 }
diff --git a/libjava/gnu/java/nio/natFileChannelImpl.cc b/libjava/gnu/java/nio/natFileChannelImpl.cc
index 8ba8382..9413a77 100644
--- a/libjava/gnu/java/nio/natFileChannelImpl.cc
+++ b/libjava/gnu/java/nio/natFileChannelImpl.cc
@@ -24,6 +24,7 @@ details.  */
 #include <fcntl.h>
 #endif
 
+#include <gnu/gcj/RawData.h>
 #include <gnu/java/nio/FileChannelImpl.h>
 #include <java/io/FileDescriptor.h>
 #include <java/io/IOException.h>
@@ -55,20 +56,20 @@ gnu::java::nio::FileChannelImpl::implTruncate (jlong size)
   return this;
 }
 
-jlong
-gnu::java::nio::FileChannelImpl::nio_mmap_file (jlong, jlong, jint)
+gnu::gcj::RawData*
+gnu::java::nio::FileChannelImpl::nio_mmap_file (jlong pos, jlong size, jint /*mode*/)
 {
   throw new ::java::io::IOException (JvNewStringUTF ("mmap not implemented"));
 }
 
 void
-gnu::java::nio::FileChannelImpl::nio_unmmap_file (jlong, jint)
+gnu::java::nio::FileChannelImpl::nio_unmmap_file (gnu::gcj::RawData* map_address, jint size)
 {
   throw new ::java::io::IOException (JvNewStringUTF ("munmap not implemented"));
 }
 
 void
-gnu::java::nio::FileChannelImpl::nio_msync (jlong, jint)
+gnu::java::nio::FileChannelImpl::nio_msync (gnu::gcj::RawData* map_address, jint length)
 {
   throw new ::java::io::IOException (JvNewStringUTF ("msync not implemented"));
 }
diff --git a/libjava/gnu/java/nio/natMappedByteFileBuffer.cc b/libjava/gnu/java/nio/natMappedByteFileBuffer.cc
index 6f2eee2..e64e27c 100644
--- a/libjava/gnu/java/nio/natMappedByteFileBuffer.cc
+++ b/libjava/gnu/java/nio/natMappedByteFileBuffer.cc
@@ -24,13 +24,14 @@ details.  */
 #include <fcntl.h>
 #endif
 
+#include <gnu/gcj/RawData.h>
 #include <gnu/java/nio/MappedByteFileBuffer.h>
 #include <java/lang/Error.h>
 
 jbyte
 gnu::java::nio::MappedByteFileBuffer::nio_read_Byte_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -38,7 +39,7 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Byte_file_channel
 jchar
 gnu::java::nio::MappedByteFileBuffer::nio_read_Char_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -46,7 +47,7 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Char_file_channel
 jdouble
 gnu::java::nio::MappedByteFileBuffer::nio_read_Double_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -54,7 +55,7 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Double_file_channel
 jfloat
 gnu::java::nio::MappedByteFileBuffer::nio_read_Float_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -62,7 +63,7 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Float_file_channel
 jint
 gnu::java::nio::MappedByteFileBuffer::nio_read_Int_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -70,7 +71,7 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Int_file_channel
 jlong
 gnu::java::nio::MappedByteFileBuffer::nio_read_Long_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -78,7 +79,7 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Long_file_channel
 jshort
 gnu::java::nio::MappedByteFileBuffer::nio_read_Short_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong)
+                                             jint, jint, gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -86,7 +87,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_read_Short_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Byte_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jbyte, jlong)
+                                             jint, jint, jbyte,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -94,7 +96,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_write_Byte_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Char_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jchar, jlong)
+                                             jint, jint, jchar,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -102,7 +105,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_write_Char_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Double_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jdouble, jlong)
+                                             jint, jint, jdouble,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -110,7 +114,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_write_Double_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Float_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jfloat, jlong)
+                                             jint, jint, jfloat,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -118,7 +123,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_write_Float_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Int_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jint, jlong)
+                                             jint, jint, jint,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -126,7 +132,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_write_Int_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Long_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jlong, jlong)
+                                             jint, jint, jlong,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }
@@ -134,7 +141,8 @@ gnu::java::nio::MappedByteFileBuffer::nio_write_Long_file_channel
 void
 gnu::java::nio::MappedByteFileBuffer::nio_write_Short_file_channel
                                             (gnu::java::nio::FileChannelImpl*,
-                                             jint, jint, jshort, jlong)
+                                             jint, jint, jshort,
+                                             gnu::gcj::RawData*)
 {
   throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented"));
 }