diff options
Diffstat (limited to 'libjava')
22 files changed, 3899 insertions, 0 deletions
diff --git a/libjava/ChangeLog b/libjava/ChangeLog index f14e39e..85215d5 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,5 +1,29 @@ 2002-11-18 Michael Koch <konqueror@gmx.de> + * gnu/java/nio/ByteBufferImpl.java, + gnu/java/nio/CharBufferImpl.java, + gnu/java/nio/DatagramChannelImpl.java, + gnu/java/nio/DoubleBufferImpl.java, + gnu/java/nio/FileChannelImpl.java, + gnu/java/nio/FloatBufferImpl.java, + gnu/java/nio/IntBufferImpl.java, + gnu/java/nio/LongBufferImpl.java, + gnu/java/nio/PipeImpl.java, + gnu/java/nio/SelectionKeyImpl.java, + gnu/java/nio/SelectorImpl.java, + gnu/java/nio/SelectorProviderImpl.java, + gnu/java/nio/ServerSocketChannelImpl.java, + gnu/java/nio/ShortBufferImpl.java, + gnu/java/nio/SocketChannelImpl.java, + java/nio/DoubleBuffer.java, + java/nio/FloatBuffer.java, + java/nio/IntBuffer.java, + java/nio/LongBuffer.java, + java/nio/ShortBuffer.java, + java/nio/channels/FileChannel.java: New files. + +2002-11-18 Michael Koch <konqueror@gmx.de> + * Makefile.am (ordinary_java_source_files): Added java/nio/ReadOnlyBufferException.java and java/nio/channels/ClosedSelectorException.java. diff --git a/libjava/gnu/java/nio/ByteBufferImpl.java b/libjava/gnu/java/nio/ByteBufferImpl.java new file mode 100644 index 0000000..e27207e --- /dev/null +++ b/libjava/gnu/java/nio/ByteBufferImpl.java @@ -0,0 +1,214 @@ +/* ByteBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class ByteBufferImpl extends ByteBuffer +{ + private byte[] backing_buffer; + private int array_offset; + private boolean ro; + + public ByteBufferImpl (int cap, int off, int lim) + { + this.cap = cap; + position (off); + limit (lim); + this.backing_buffer = new byte[cap]; + } + + public ByteBufferImpl (byte[] array, int off, int lim) + { + this.cap = array.length; + position (off); + limit (lim); + this.backing_buffer = array; + } + + public ByteBufferImpl (ByteBufferImpl copy) + { + this.cap = copy.capacity (); + position (copy.position ()); + limit (copy.limit ()); + ro = copy.ro; + backing_buffer = copy.backing_buffer; + } + + void inc_pos (int toAdd) + { + position (position () + toAdd); + } + +// private static native byte[] nio_cast(byte[]copy); +// private static native byte[] nio_cast(char[]copy); +// private static native byte[] nio_cast(short[]copy); +// private static native byte[] nio_cast(long[]copy); +// private static native byte[] nio_cast(int[]copy); +// private static native byte[] nio_cast(float[]copy); +// private static native byte[] nio_cast(double[]copy); + + private static byte[] nio_cast(byte[]copy) { return null; }; + private static byte[] nio_cast(char[]copy) { return null; }; + private static byte[] nio_cast(short[]copy) { return null; }; + private static byte[] nio_cast(long[]copy) { return null; }; + private static byte[] nio_cast(int[]copy) { return null; }; + private static byte[] nio_cast(float[]copy) { return null; }; + private static byte[] nio_cast(double[]copy) { return null; }; + + ByteBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(ByteBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(ByteBufferImpl b, int index, int limit, byte value) { }; + public ByteBuffer asByteBuffer() { ByteBufferImpl res = new ByteBufferImpl(backing_buffer); res.limit((limit()*1)/1); return res; } + + ByteBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Char(ByteBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(ByteBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(ByteBufferImpl b, int index, int limit, char value) { }; + public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/1); return res; } + + ByteBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Short(ByteBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(ByteBufferImpl b, int index, int limit, short value) { }; + public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/1); return res; } + + ByteBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Int(ByteBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(ByteBufferImpl b, int index, int limit, int value) { }; + public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/1); return res; } + + ByteBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Long(ByteBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(ByteBufferImpl b, int index, int limit, long value) { }; + public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/1); return res; } + + ByteBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Float(ByteBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(ByteBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(ByteBufferImpl b, int index, int limit, float value) { }; + public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/1); return res; } + + ByteBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Double(ByteBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(ByteBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(ByteBufferImpl b, int index, int limit, double value) { }; + public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/1); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public ByteBuffer slice() + { + ByteBufferImpl A = new ByteBufferImpl(this); + A.array_offset = position(); + return A; + } + + public ByteBuffer duplicate() + { + return new ByteBufferImpl(this); + } + + public ByteBuffer asReadOnlyBuffer() + { + ByteBufferImpl a = new ByteBufferImpl(this); + a.ro = true; + return a; + } + + public ByteBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public byte get() + { + byte e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public ByteBuffer put(byte b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public byte get(int index) + { + return backing_buffer[index]; + } + + final public ByteBuffer put(int index, byte b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public ByteBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public ByteBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public ByteBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public ByteBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public ByteBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public ByteBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public ByteBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public ByteBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public ByteBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public ByteBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public ByteBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public ByteBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; +} diff --git a/libjava/gnu/java/nio/CharBufferImpl.java b/libjava/gnu/java/nio/CharBufferImpl.java new file mode 100644 index 0000000..5253646 --- /dev/null +++ b/libjava/gnu/java/nio/CharBufferImpl.java @@ -0,0 +1,223 @@ +/* CharBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class CharBufferImpl extends CharBuffer +{ + private int array_offset; + private boolean ro; + + public CharBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new char[cap]; + this.cap = cap; + this.position(off); + this.limit(lim); + } + + public CharBufferImpl(char[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public CharBufferImpl (CharBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position (copy.position ()); + limit (copy.limit()); + } + + void inc_pos (int a) + { + position (position () + a); + } + +// private static native char[] nio_cast(byte[]copy); +// private static native char[] nio_cast(char[]copy); +// private static native char[] nio_cast(short[]copy); +// private static native char[] nio_cast(long[]copy); +// private static native char[] nio_cast(int[]copy); +// private static native char[] nio_cast(float[]copy); +// private static native char[] nio_cast(double[]copy); + + private static char[] nio_cast(byte[]copy) { return null; }; + private static char[] nio_cast(char[]copy) { return null; }; + private static char[] nio_cast(short[]copy) { return null; }; + private static char[] nio_cast(long[]copy) { return null; }; + private static char[] nio_cast(int[]copy) { return null; }; + private static char[] nio_cast(float[]copy) { return null; }; + private static char[] nio_cast(double[]copy) { return null; }; + + CharBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(CharBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(CharBufferImpl b, int index, int limit, byte value) { }; + public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/2); return res; } + + CharBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Char(CharBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(CharBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(CharBufferImpl b, int index, int limit, char value) { }; + public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; } + + CharBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Short(CharBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(CharBufferImpl b, int index, int limit, short value) { }; + public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; } + + CharBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Int(CharBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(CharBufferImpl b, int index, int limit, int value) { }; + public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; } + + CharBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Long(CharBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(CharBufferImpl b, int index, int limit, long value) { }; + public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; } + + CharBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Float(CharBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(CharBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(CharBufferImpl b, int index, int limit, float value) { }; + public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; } + + CharBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Double(CharBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(CharBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(CharBufferImpl b, int index, int limit, double value) { }; + public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; } + + public boolean isReadOnly() + { + return ro; + } + public CharBuffer slice() + { + CharBufferImpl A = new CharBufferImpl(this); + A.array_offset = position(); + return A; + } + public CharBuffer duplicate() + { + return new CharBufferImpl(this); + } + public CharBuffer asReadOnlyBuffer() + { + CharBufferImpl a = new CharBufferImpl(this); + a.ro = true; + return a; + } + public CharBuffer compact() + { + return this; + } + public boolean isDirect() + { + return backing_buffer != null; + } + final public char get() + { + char e = backing_buffer[position()]; + position(position()+1); + return e; + } + final public CharBuffer put(char b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + final public char get(int index) + { + return backing_buffer[index]; + } + final public java.nio. CharBuffer put(int index, char b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { return get(); } final public java.nio. CharBuffer putChar(char value) { return put(value); } final public char getChar(int index) { return get(index); } final public java.nio. CharBuffer putChar(int index, char value) { return put(index, value); }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. CharBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. CharBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. CharBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. CharBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. CharBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. CharBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. CharBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. CharBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. CharBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. CharBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; + + public String toString() + { + if (backing_buffer != null) + { + return new String(backing_buffer, position(), limit()); + } + return super.toString(); + } + + public final ByteOrder order() + { + return endian; + } + + public CharSequence subSequence(int a, int b) + { + return null; + } +} diff --git a/libjava/gnu/java/nio/DatagramChannelImpl.java b/libjava/gnu/java/nio/DatagramChannelImpl.java new file mode 100644 index 0000000..b192ef2 --- /dev/null +++ b/libjava/gnu/java/nio/DatagramChannelImpl.java @@ -0,0 +1,110 @@ +/* DatagramChannelImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.net.DatagramSocket; +import java.net.SocketAddress; +import java.nio.ByteBuffer; +import java.nio.channels.DatagramChannel; +import java.nio.channels.spi.SelectorProvider; + +public class DatagramChannelImpl extends DatagramChannel +{ + protected DatagramChannelImpl (SelectorProvider provider) + { + super (provider); + } + + protected void implCloseSelectableChannel () + { + } + + protected void implConfigureBlocking (boolean block) + { + } + + public int write (ByteBuffer src) + { + return 0; + } + + public long write (ByteBuffer[] srcs, int offset, int length) + { + return 0; + } + + public int read (ByteBuffer dst) + { + return 0; + } + + public DatagramChannel connect (SocketAddress remote) + { + return null; + } + + public DatagramChannel disconnect () + { + return null; + } + + public boolean isConnected () + { + return false; + } + + public long read (ByteBuffer[] dsts, int offset, int length) + { + return 0; + } + + public SocketAddress receive (ByteBuffer dst) + { + return null; + } + + public int send (ByteBuffer src, SocketAddress target) + { + return 0; + } + + public DatagramSocket socket () + { + return null; + } +} diff --git a/libjava/gnu/java/nio/DoubleBufferImpl.java b/libjava/gnu/java/nio/DoubleBufferImpl.java new file mode 100644 index 0000000..40628679 --- /dev/null +++ b/libjava/gnu/java/nio/DoubleBufferImpl.java @@ -0,0 +1,212 @@ +/* DoubleBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class DoubleBufferImpl extends DoubleBuffer +{ + private int array_offset; + private boolean ro; + + public DoubleBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new double[cap]; + this.cap = cap; + this.position(off); + this.limit(lim); + } + + public DoubleBufferImpl(double[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public DoubleBufferImpl(DoubleBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position(copy.position()); + limit(copy.limit()); + } + + void inc_pos(int a) + { + position(position() + a); + } + +// private static native double[] nio_cast(byte[]copy); +// private static native double[] nio_cast(char[]copy); +// private static native double[] nio_cast(short[]copy); +// private static native double[] nio_cast(long[]copy); +// private static native double[] nio_cast(int[]copy); +// private static native double[] nio_cast(float[]copy); +// private static native double[] nio_cast(double[]copy); + + private static double[] nio_cast(byte[]copy) { return null; }; + private static double[] nio_cast(char[]copy) { return null; }; + private static double[] nio_cast(short[]copy) { return null; }; + private static double[] nio_cast(long[]copy) { return null; }; + private static double[] nio_cast(int[]copy) { return null; }; + private static double[] nio_cast(float[]copy) { return null; }; + private static double[] nio_cast(double[]copy) { return null; }; + + DoubleBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(DoubleBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(DoubleBufferImpl b, int index, int limit, byte value) { }; + public ByteBuffer asByteBuffer() { ByteBufferImpl res = new ByteBufferImpl(backing_buffer); res.limit((limit()*1)/8); return res; } + + DoubleBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Char(DoubleBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(DoubleBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(DoubleBufferImpl b, int index, int limit, char value) { }; + public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; } + + DoubleBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Short(DoubleBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(DoubleBufferImpl b, int index, int limit, short value) { }; + public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; } + + DoubleBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Int(DoubleBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(DoubleBufferImpl b, int index, int limit, int value) { }; + public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; } + + DoubleBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Long(DoubleBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(DoubleBufferImpl b, int index, int limit, long value) { }; + public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; } + + DoubleBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Float(DoubleBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(DoubleBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(DoubleBufferImpl b, int index, int limit, float value) { }; + public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; } + + DoubleBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Double(DoubleBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(DoubleBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(DoubleBufferImpl b, int index, int limit, double value) { }; + public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public DoubleBuffer slice() + { + DoubleBufferImpl A = new DoubleBufferImpl(this); + A.array_offset = position(); + return A; + } + + public DoubleBuffer duplicate() + { + return new DoubleBufferImpl(this); + } + + public DoubleBuffer asReadOnlyBuffer() + { + DoubleBufferImpl a = new DoubleBufferImpl(this); + a.ro = true; + return a; + } + + public DoubleBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public double get() + { + double e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public DoubleBuffer put(double b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public double get(int index) + { + return backing_buffer[index]; + } + + final public DoubleBuffer put(int index, double b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public DoubleBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public DoubleBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public DoubleBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public DoubleBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public DoubleBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public DoubleBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public DoubleBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public DoubleBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public DoubleBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public DoubleBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { return get(); } final public DoubleBuffer putDouble(double value) { return put(value); } final public double getDouble(int index) { return get(index); } final public DoubleBuffer putDouble(int index, double value) { return put(index, value); }; +} diff --git a/libjava/gnu/java/nio/FileChannelImpl.java b/libjava/gnu/java/nio/FileChannelImpl.java new file mode 100644 index 0000000..26b48e5 --- /dev/null +++ b/libjava/gnu/java/nio/FileChannelImpl.java @@ -0,0 +1,234 @@ +/* FileChannelImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.io.EOFException; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.nio.ByteBuffer; +import java.nio.MappedByteBuffer; +import java.nio.channels.FileChannel; + +/** + * This file is not user visible ! + * But alas, Java does not have a concept of friendly packages + * so this class is public. + * Instances of this class are created by invoking getChannel + * Upon a Input/Output/RandomAccessFile object. + */ + +public class FileChannelImpl extends FileChannel +{ + public long address; + public int length; + public int fd; + public MappedByteBuffer buf; + public Object file_obj; // just to keep it live... + + /** + * This method came from java.io.RandomAccessFile + * It is private there so we will repeat it here. + */ +// private native long lengthInternal (int native_fd) throws IOException; + private long lengthInternal (int native_fd) throws IOException + { + return 0; + }; + + public FileChannelImpl (int fd, Object obj) + { + this.fd = fd; + this.file_obj = obj; + } + + public long size () throws IOException + { + return lengthInternal (fd); + } + + protected void implCloseChannel() throws IOException + { + if (address != 0) + { + nio_unmmap_file (fd, address, (int) length); + } + + // FIXME + fd = 0; + + if (file_obj instanceof RandomAccessFile) + { + RandomAccessFile o = (RandomAccessFile) file_obj; + o.close(); + } + else if (file_obj instanceof FileInputStream) + { + FileInputStream o = (FileInputStream) file_obj; + o.close(); + } + else if (file_obj instanceof FileOutputStream) + { + FileOutputStream o = (FileOutputStream) file_obj; + o.close(); + } + } + + public int read (ByteBuffer dst) throws IOException + { + int w = 0; + int s = (int)size(); + + if (buf == null) + { + throw new EOFException("file not mapped"); + } + + for (int i=0; i<s; i++) + { + dst.put( buf.get() ); + } + + return s; + } + + public long read (ByteBuffer[] dsts) throws IOException + { + return read (dsts, 0, dsts.length); + } + + public long read (ByteBuffer[] dsts, int offset, int length) + throws IOException + { + long result = 0; + + for (int i = offset; i < offset + length; i++) + { + result += write (dsts[i]); + } + + return result; + } + + public int write (ByteBuffer src) throws IOException + { + int w = 0; + + if (buf == null) + { + throw new EOFException ("file not mapped"); + } + + while (src.hasRemaining ()) + { + buf.put (src.get ()); + w++; + } + + return w; + } + + public long write(ByteBuffer[] srcs, int offset, int length) + throws IOException + { + long res = 0; + + for (int i = offset;i < offset + length;i++) + { + res += write (srcs[i]); + } + return res; + } + + public MappedByteBuffer map (FileChannel.MapMode mode, long position, + long size) + throws IOException + { +// int cmode = mode.m; +// address = nio_mmap_file (fd, position, size, cmode); +// length = size; +// buf = new MappedByteFileBuffer (this); +// return buf; + return null; + } + + static MappedByteBuffer create_direct_mapped_buffer (long address, + long length) + { +// FileChannelImpl ch = new FileChannelImpl (-1, null); +// ch.address = address; +// ch.length = (int) length; +// ch.buf = new MappedByteFileBuffer (ch); +// return ch.buf; + return null; + } + + public long write (ByteBuffer[] srcs) + throws IOException + { + return write (srcs, 0, srcs.length); + } + + /** + * msync with the disk + */ + public void force (boolean metaData) + { + nio_msync (fd, address, length); + } + +// static native long nio_mmap_file (int fd, long pos, int size, int mode); + +// static native void nio_unmmap_file (int fd, long address, int size); + +// static native void nio_msync (int fd, long address, int length); + + static long nio_mmap_file (int fd, long pos, int size, int mode) + { + return 0; + } + + static void nio_unmmap_file (int fd, long address, int size) + { + }; + + static void nio_msync (int fd, long address, int length) + { + }; +} diff --git a/libjava/gnu/java/nio/FloatBufferImpl.java b/libjava/gnu/java/nio/FloatBufferImpl.java new file mode 100644 index 0000000..0df0f72 --- /dev/null +++ b/libjava/gnu/java/nio/FloatBufferImpl.java @@ -0,0 +1,218 @@ +/* FloatBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class FloatBufferImpl extends FloatBuffer +{ + private int array_offset; + private boolean ro; + + public FloatBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new float[cap]; + this.cap = cap; + this.position(off); + this.limit(lim); + } + + public FloatBufferImpl(float[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public FloatBufferImpl(FloatBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position(copy.position()); + limit(copy.limit()); + } + + void inc_pos(int a) + { + position(position() + a); + } + +// private static native float[] nio_cast(byte[]copy); +// private static native float[] nio_cast(char[]copy); +// private static native float[] nio_cast(short[]copy); +// private static native float[] nio_cast(long[]copy); +// private static native float[] nio_cast(int[]copy); +// private static native float[] nio_cast(float[]copy); +// private static native float[] nio_cast(double[]copy); + + private static float[] nio_cast(byte[]copy) { return null; }; + private static float[] nio_cast(char[]copy) { return null; }; + private static float[] nio_cast(short[]copy) { return null; }; + private static float[] nio_cast(long[]copy) { return null; }; + private static float[] nio_cast(int[]copy) { return null; }; + private static float[] nio_cast(float[]copy) { return null; }; + private static float[] nio_cast(double[]copy) { return null; }; + + FloatBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast (copy) : null; } +// private static native byte nio_get_Byte (FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Byte (FloatBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte (FloatBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte (FloatBufferImpl b, int index, int limit, byte value) { }; + + public ByteBuffer asByteBuffer() + { + ByteBufferImpl res = new ByteBufferImpl (backing_buffer); + res.limit ((limit () * 1) / 4); + return res; + } + + FloatBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Char(FloatBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(FloatBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(FloatBufferImpl b, int index, int limit, char value) { }; + public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; } + + FloatBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Short(FloatBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(FloatBufferImpl b, int index, int limit) { return 0;}; + private static void nio_put_Short(FloatBufferImpl b, int index, int limit, short value) { }; + public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; } + + FloatBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Int(FloatBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(FloatBufferImpl b, int index, int limit) { return 0;}; + private static void nio_put_Int(FloatBufferImpl b, int index, int limit, int value) { }; + public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; } + + FloatBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Long(FloatBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(FloatBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(FloatBufferImpl b, int index, int limit, long value) { }; + public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; } + + FloatBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Float(FloatBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(FloatBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(FloatBufferImpl b, int index, int limit, float value) { }; + public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; } + + FloatBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(FloatBufferImpl b, int index, int limit); +// private static native void nio_put_Double(FloatBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(FloatBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(FloatBufferImpl b, int index, int limit, double value) { }; + public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public java.nio. FloatBuffer slice() + { + FloatBufferImpl A = new FloatBufferImpl(this); + A.array_offset = position(); + return A; + } + + public java.nio. FloatBuffer duplicate() + { + return new FloatBufferImpl(this); + } + + public java.nio. FloatBuffer asReadOnlyBuffer() + { + FloatBufferImpl a = new FloatBufferImpl(this); + a.ro = true; + return a; + } + + public java.nio. FloatBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public float get() + { + float e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public java.nio. FloatBuffer put(float b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public float get(int index) + { + return backing_buffer[index]; + } + + final public java.nio. FloatBuffer put(int index, float b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. FloatBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. FloatBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. FloatBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. FloatBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. FloatBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. FloatBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. FloatBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. FloatBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { return get(); } final public java.nio. FloatBuffer putFloat(float value) { return put(value); } final public float getFloat(int index) { return get(index); } final public java.nio. FloatBuffer putFloat(int index, float value) { return put(index, value); }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. FloatBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. FloatBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; +} diff --git a/libjava/gnu/java/nio/IntBufferImpl.java b/libjava/gnu/java/nio/IntBufferImpl.java new file mode 100644 index 0000000..db1754d --- /dev/null +++ b/libjava/gnu/java/nio/IntBufferImpl.java @@ -0,0 +1,206 @@ +/* IntBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.IntBuffer; + +public final class IntBufferImpl extends IntBuffer +{ + private int array_offset; + private boolean ro; + + public IntBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new int[cap]; + this.cap = cap; + this.position(off); + this.limit(lim); + } + + public IntBufferImpl(int[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public IntBufferImpl(IntBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position(copy.position()); + limit(copy.limit()); + } + + void inc_pos(int a) + { + position(position() + a); + } + +// private static native int[] nio_cast(byte[]copy); +// private static native int[] nio_cast(char[]copy); +// private static native int[] nio_cast(short[]copy); +// private static native int[] nio_cast(long[]copy); +// private static native int[] nio_cast(int[]copy); +// private static native int[] nio_cast(float[]copy); +// private static native int[] nio_cast(double[]copy); + + private static int[] nio_cast(byte[]copy) { return null; }; + private static int[] nio_cast(char[]copy) { return null; }; + private static int[] nio_cast(short[]copy) { return null; }; + private static int[] nio_cast(long[]copy) { return null; }; + private static int[] nio_cast(int[]copy) { return null; }; + private static int[] nio_cast(float[]copy) { return null; }; + private static int[] nio_cast(double[]copy) { return null; }; + + IntBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(IntBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(IntBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(IntBufferImpl b, int index, int limit, byte value) { }; + public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/4); return res; } + + IntBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Char(IntBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(IntBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(IntBufferImpl b, int index, int limit, char value) { }; + public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; } + + IntBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Short(IntBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(IntBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(IntBufferImpl b, int index, int limit, short value) { }; + public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; } + + IntBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Int(IntBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(IntBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(IntBufferImpl b, int index, int limit, int value) { }; + public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; } + + IntBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Long(IntBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(IntBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(IntBufferImpl b, int index, int limit, long value) { }; + public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; } + + IntBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Float(IntBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(IntBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(IntBufferImpl b, int index, int limit, float value) { }; + public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; } + + IntBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(IntBufferImpl b, int index, int limit); +// private static native void nio_put_Double(IntBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(IntBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(IntBufferImpl b, int index, int limit, double value) { }; + public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public java.nio. IntBuffer slice() + { + IntBufferImpl A = new IntBufferImpl(this); + A.array_offset = position(); + return A; + } + + public java.nio. IntBuffer duplicate() + { + return new IntBufferImpl(this); + } + + public java.nio. IntBuffer asReadOnlyBuffer() + { + IntBufferImpl a = new IntBufferImpl(this); + a.ro = true; + return a; + } + + public java.nio. IntBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public int get() + { + int e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public java.nio. IntBuffer put(int b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public int get(int index) + { + return backing_buffer[index]; + } + + final public java.nio. IntBuffer put(int index, int b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. IntBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. IntBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. IntBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. IntBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { return get(); } final public java.nio. IntBuffer putInt(int value) { return put(value); } final public int getInt(int index) { return get(index); } final public java.nio. IntBuffer putInt(int index, int value) { return put(index, value); }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. IntBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. IntBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. IntBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. IntBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. IntBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. IntBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; +} diff --git a/libjava/gnu/java/nio/LongBufferImpl.java b/libjava/gnu/java/nio/LongBufferImpl.java new file mode 100644 index 0000000..096481f --- /dev/null +++ b/libjava/gnu/java/nio/LongBufferImpl.java @@ -0,0 +1,212 @@ +/* LongBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class LongBufferImpl extends LongBuffer +{ + private int array_offset; + private boolean ro; + + public LongBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new long[cap]; + this.cap = cap ; + this.position(off); + this.limit(lim); + } + + public LongBufferImpl(long[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public LongBufferImpl(LongBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position(copy.position()); + limit(copy.limit()); + } + + void inc_pos(int a) + { + position(position() + a); + } + +// private static native long[] nio_cast(byte[]copy); +// private static native long[] nio_cast(char[]copy); +// private static native long[] nio_cast(short[]copy); +// private static native long[] nio_cast(long[]copy); +// private static native long[] nio_cast(int[]copy); +// private static native long[] nio_cast(float[]copy); +// private static native long[] nio_cast(double[]copy); + + private static long[] nio_cast(byte[]copy) { return null; }; + private static long[] nio_cast(char[]copy) { return null; }; + private static long[] nio_cast(short[]copy) { return null; }; + private static long[] nio_cast(long[]copy) { return null; }; + private static long[] nio_cast(int[]copy) { return null; }; + private static long[] nio_cast(float[]copy) { return null; }; + private static long[] nio_cast(double[]copy) { return null; }; + + LongBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(LongBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(LongBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(LongBufferImpl b, int index, int limit, byte value) { }; + public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/8); return res; } + + LongBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Char(LongBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(LongBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(LongBufferImpl b, int index, int limit, char value) { }; + public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; } + + LongBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Short(LongBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(LongBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(LongBufferImpl b, int index, int limit, short value) { }; + public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; } + + LongBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Int(LongBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(LongBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(LongBufferImpl b, int index, int limit, int value) { }; + public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; } + + LongBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Long(LongBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(LongBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(LongBufferImpl b, int index, int limit, long value) { }; + public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; } + + LongBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Float(LongBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(LongBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(LongBufferImpl b, int index, int limit, float value) { }; + public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; } + + LongBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(LongBufferImpl b, int index, int limit); +// private static native void nio_put_Double(LongBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(LongBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(LongBufferImpl b, int index, int limit, double value) { }; + public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public java.nio. LongBuffer slice() + { + LongBufferImpl A = new LongBufferImpl(this); + A.array_offset = position(); + return A; + } + + public java.nio. LongBuffer duplicate() + { + return new LongBufferImpl(this); + } + + public java.nio. LongBuffer asReadOnlyBuffer() + { + LongBufferImpl a = new LongBufferImpl(this); + a.ro = true; + return a; + } + + public java.nio. LongBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public long get() + { + long e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public java.nio. LongBuffer put(long b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public long get(int index) + { + return backing_buffer[index]; + } + + final public java.nio. LongBuffer put(int index, long b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. LongBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. LongBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. LongBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. LongBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. LongBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. LongBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { return get(); } final public java.nio. LongBuffer putLong(long value) { return put(value); } final public long getLong(int index) { return get(index); } final public java.nio. LongBuffer putLong(int index, long value) { return put(index, value); }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. LongBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. LongBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. LongBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. LongBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; +} diff --git a/libjava/gnu/java/nio/PipeImpl.java b/libjava/gnu/java/nio/PipeImpl.java new file mode 100644 index 0000000..77341e7 --- /dev/null +++ b/libjava/gnu/java/nio/PipeImpl.java @@ -0,0 +1,57 @@ +/* PipeImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.channels.Pipe; + +class PipeImpl extends Pipe +{ + public PipeImpl() + { + } + + public Pipe.SinkChannel sink() + { + return null; + } + + public Pipe.SourceChannel source() + { + return null; + } +} diff --git a/libjava/gnu/java/nio/SelectionKeyImpl.java b/libjava/gnu/java/nio/SelectionKeyImpl.java new file mode 100644 index 0000000..8ef6f7f --- /dev/null +++ b/libjava/gnu/java/nio/SelectionKeyImpl.java @@ -0,0 +1,83 @@ +/* SelectionKeyImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.channels.SelectableChannel; +import java.nio.channels.SelectionKey; +import java.nio.channels.Selector; +import java.nio.channels.spi.AbstractSelectionKey; + +public class SelectionKeyImpl extends AbstractSelectionKey +{ + int fd, ops; + SelectorImpl impl; + SelectableChannel ch; + + public SelectionKeyImpl(SelectableChannel ch, SelectorImpl impl, int fd) + { + this.ch = ch; + this.impl = impl; + this.fd = fd; + } + + public SelectableChannel channel () + { + return ch; + } + + public int readyOps () + { + return 0; + } + + public int interestOps () + { + return ops; + } + + public SelectionKey interestOps (int ops) + { + this.ops = ops; + return this; + } + + public Selector selector () + { + return impl; + } +} diff --git a/libjava/gnu/java/nio/SelectorImpl.java b/libjava/gnu/java/nio/SelectorImpl.java new file mode 100644 index 0000000..7d3d88c --- /dev/null +++ b/libjava/gnu/java/nio/SelectorImpl.java @@ -0,0 +1,204 @@ +/* SelectorImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.channels.ClosedSelectorException; +import java.nio.channels.SelectableChannel; +import java.nio.channels.SelectionKey; +import java.nio.channels.Selector; +import java.nio.channels.spi.AbstractSelectableChannel; +import java.nio.channels.spi.AbstractSelector; +import java.nio.channels.spi.SelectorProvider; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +public class SelectorImpl extends AbstractSelector +{ + boolean closed = false; + Set keys, selected, canceled; + + public SelectorImpl (SelectorProvider provider) + { + super (provider); + } + + public Set keys () + { + return keys; + } + + public int selectNow () + { + return select (1); + } + + public int select () + { + return select (Long.MAX_VALUE); + } + +// private static native int java_do_select(int[] read, int[] write, +// int[] except, long timeout); + + private static int java_do_select(int[] read, int[] write, + int[] except, long timeout) + { + return 0; + } + + public int select (long timeout) + { + if (closed) + { + throw new ClosedSelectorException (); + } + + if (keys == null) + { + return 0; + } + + int[] read = new int[keys.size ()]; + int[] write = new int[keys.size ()]; + int[] except = new int[keys.size ()]; + int i = 0; + Iterator it = keys.iterator (); + + while (it.hasNext ()) + { + SelectionKeyImpl k = (SelectionKeyImpl) it.next (); + read[i] = k.fd; + write[i] = k.fd; + except[i] = k.fd; + i++; + } + + int ret = java_do_select (read, write, except, timeout); + + i = 0; + it = keys.iterator (); + + while (it.hasNext ()) + { + SelectionKeyImpl k = (SelectionKeyImpl) it.next (); + + if (read[i] != -1 || + write[i] != -1 || + except[i] != -1) + { + add_selected (k); + } + + i++; + } + + return ret; + } + + public Set selectedKeys () + { + return selected; + } + + public Selector wakeup () + { + return null; + } + + public void add (SelectionKeyImpl k) + { + if (keys == null) + keys = new HashSet (); + + keys.add (k); + } + + void add_selected (SelectionKeyImpl k) + { + if (selected == null) + selected = new HashSet (); + + selected.add(k); + } + + protected void implCloseSelector () + { + closed = true; + } + + protected SelectionKey register (SelectableChannel ch, int ops, Object att) + { + return register ((AbstractSelectableChannel) ch, ops, att); + } + + protected SelectionKey register (AbstractSelectableChannel ch, int ops, + Object att) + { +// // filechannel is not selectable ? +// if (ch instanceof FileChannelImpl) +// { +// FileChannelImpl fc = (FileChannelImpl) ch; +// SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, fc.fd); +// keys.add (impl); +// return impl; +// } +// else + + if (ch instanceof SocketChannelImpl) + { + SocketChannelImpl sc = (SocketChannelImpl) ch; + SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, sc.fd); + add (impl); + return impl; + } + else if (ch instanceof ServerSocketChannelImpl) + { + ServerSocketChannelImpl ssc = (ServerSocketChannelImpl) ch; + SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, ssc.fd); + add (impl); + return impl; + } + else + { + System.err.println ("INTERNAL ERROR, no known channel type"); + } + + return null; + } +} diff --git a/libjava/gnu/java/nio/SelectorProviderImpl.java b/libjava/gnu/java/nio/SelectorProviderImpl.java new file mode 100644 index 0000000..3fedfc73 --- /dev/null +++ b/libjava/gnu/java/nio/SelectorProviderImpl.java @@ -0,0 +1,77 @@ +/* SelectorProviderImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.channels.DatagramChannel; +import java.nio.channels.Pipe; +import java.nio.channels.ServerSocketChannel; +import java.nio.channels.SocketChannel; +import java.nio.channels.spi.SelectorProvider; +import java.nio.channels.spi.AbstractSelector; + +public class SelectorProviderImpl extends SelectorProvider +{ + public SelectorProviderImpl () + { + } + + public DatagramChannel openDatagramChannel () + { + return new DatagramChannelImpl (this); + } + + public Pipe openPipe () + { + return new PipeImpl (); + } + + public AbstractSelector openSelector () + { + return new SelectorImpl (this); + } + + public ServerSocketChannel openServerSocketChannel () + { + return new ServerSocketChannelImpl (this); + } + + public SocketChannel openSocketChannel () + { + return new SocketChannelImpl (this); + } +} diff --git a/libjava/gnu/java/nio/ServerSocketChannelImpl.java b/libjava/gnu/java/nio/ServerSocketChannelImpl.java new file mode 100644 index 0000000..e75c68d --- /dev/null +++ b/libjava/gnu/java/nio/ServerSocketChannelImpl.java @@ -0,0 +1,118 @@ +/* ServerSocketChannelImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.ServerSocket; +import java.net.SocketAddress; +import java.nio.channels.ServerSocketChannel; +import java.nio.channels.SocketChannel; +import java.nio.channels.spi.SelectorProvider; + +class ServerSocketChannelImpl extends ServerSocketChannel +{ + ServerSocket sock_object; + int fd; +// int local_port; + boolean blocking = true; + boolean connected = false; +// InetSocketAddress sa; + +// private static native int NioSocketAccept (ServerSocketChannelImpl server, +// SocketChannelImpl s); + + private static int NioSocketAccept (ServerSocketChannelImpl server, + SocketChannelImpl s) + { + return 0; + } + + protected ServerSocketChannelImpl (SelectorProvider provider) + { + super (provider); + fd = SocketChannelImpl.SocketCreate (); + + try + { + sock_object = new ServerSocket (); + } + catch (IOException e) + { + System.err.println ("ServerSocket could not be created."); + } + } + + public void finalizer() + { + if (connected) + { + try + { + close(); + } + catch (Exception e) + { + } + } + } + + protected void implCloseSelectableChannel () + { + connected = false; + SocketChannelImpl.SocketClose (fd); + fd = SocketChannelImpl.SocketCreate (); + } + + protected void implConfigureBlocking (boolean block) + { + } + + public SocketChannel accept () + { + SocketChannelImpl result = new SocketChannelImpl (provider ()); + result.sa = new InetSocketAddress (0); + int res = NioSocketAccept (this, result); + return result; + } + + public ServerSocket socket () + { + return sock_object; + } +} diff --git a/libjava/gnu/java/nio/ShortBufferImpl.java b/libjava/gnu/java/nio/ShortBufferImpl.java new file mode 100644 index 0000000..15a0cd6 --- /dev/null +++ b/libjava/gnu/java/nio/ShortBufferImpl.java @@ -0,0 +1,212 @@ +/* ShortBufferImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class ShortBufferImpl extends ShortBuffer +{ + private int array_offset; + private boolean ro; + + public ShortBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new short[cap]; + this.cap = cap ; + this.position(off); + this.limit(lim); + } + + public ShortBufferImpl(short[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public ShortBufferImpl(ShortBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position(copy.position()); + limit(copy.limit()); + } + + void inc_pos(int a) + { + position(position() + a); + } + +// private static native short[] nio_cast(byte[]copy); +// private static native short[] nio_cast(char[]copy); +// private static native short[] nio_cast(short[]copy); +// private static native short[] nio_cast(long[]copy); +// private static native short[] nio_cast(int[]copy); +// private static native short[] nio_cast(float[]copy); +// private static native short[] nio_cast(double[]copy); + + private static short[] nio_cast(byte[]copy) { return null; }; + private static short[] nio_cast(char[]copy) { return null; }; + private static short[] nio_cast(short[]copy) { return null; }; + private static short[] nio_cast(long[]copy) { return null; }; + private static short[] nio_cast(int[]copy) { return null; }; + private static short[] nio_cast(float[]copy) { return null; }; + private static short[] nio_cast(double[]copy) { return null; }; + + ShortBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(ShortBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(ShortBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(ShortBufferImpl b, int index, int limit, byte value) { }; + public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/2); return res; } + + ShortBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Char(ShortBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(ShortBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(ShortBufferImpl b, int index, int limit, char value) { }; + public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; } + + ShortBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Short(ShortBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(ShortBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(ShortBufferImpl b, int index, int limit, short value) { }; + public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; } + + ShortBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Int(ShortBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(ShortBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(ShortBufferImpl b, int index, int limit, int value) { }; + public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; } + + ShortBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Long(ShortBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(ShortBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(ShortBufferImpl b, int index, int limit, long value) { }; + public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; } + + ShortBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Float(ShortBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(ShortBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(ShortBufferImpl b, int index, int limit, float value) { }; + public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; } + + ShortBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(ShortBufferImpl b, int index, int limit); +// private static native void nio_put_Double(ShortBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(ShortBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(ShortBufferImpl b, int index, int limit, double value) { }; + public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public ShortBuffer slice() + { + ShortBufferImpl a = new ShortBufferImpl(this); + a.array_offset = position(); + return a; + } + + public ShortBuffer duplicate() + { + return new ShortBufferImpl(this); + } + + public ShortBuffer asReadOnlyBuffer() + { + ShortBufferImpl a = new ShortBufferImpl(this); + a.ro = true; + return a; + } + + public ShortBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public short get() + { + short e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public ShortBuffer put(short b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public short get(int index) + { + return backing_buffer[index]; + } + + final public ShortBuffer put(int index, short b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. ShortBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. ShortBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { return get(); } final public java.nio. ShortBuffer putShort(short value) { return put(value); } final public short getShort(int index) { return get(index); } final public java.nio. ShortBuffer putShort(int index, short value) { return put(index, value); }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. ShortBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. ShortBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. ShortBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. ShortBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. ShortBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. ShortBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. ShortBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. ShortBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; +} diff --git a/libjava/gnu/java/nio/SocketChannelImpl.java b/libjava/gnu/java/nio/SocketChannelImpl.java new file mode 100644 index 0000000..b43108b --- /dev/null +++ b/libjava/gnu/java/nio/SocketChannelImpl.java @@ -0,0 +1,234 @@ +/* SocketChannelImpl.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.java.nio; + +import java.io.IOException; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.net.SocketAddress; +import java.nio.ByteBuffer; +import java.nio.channels.AlreadyConnectedException; +import java.nio.channels.SocketChannel; +import java.nio.channels.spi.SelectorProvider; +import gnu.classpath.Configuration; + +public class SocketChannelImpl extends SocketChannel +{ + Socket sock_object; + int fd; + int local_port; + boolean blocking = true; + boolean connected = false; + InetSocketAddress sa; + +/* + static native int SocketCreate(); + static native int SocketConnect(int fd, InetAddress a, int port); + static native int SocketBind(int fd, InetAddress host, int port); + static native int SocketListen(int fd, int backlog); + static native int SocketAvailable(int fd); + static native int SocketClose(int fd); + static native int SocketRead(int fd, byte b[], int off, int len); + static native int SocketWrite(int fd, byte b[], int off, int len); +*/ + + static int SocketCreate() { return 0; }; + static int SocketConnect(int fd, InetAddress a, int port) { return 0; }; + static int SocketBind(int fd, InetAddress host, int port) { return 0; }; + static int SocketListen(int fd, int backlog) { return 0; }; + static int SocketAvailable(int fd) { return 0; }; + static int SocketClose(int fd) { return 0; }; + static int SocketRead(int fd, byte b[], int off, int len) { return 0; }; + static int SocketWrite(int fd, byte b[], int off, int len) { return 0; }; + + public SocketChannelImpl(SelectorProvider provider) + { + super(provider); + fd = SocketCreate(); + + if (fd == -1) + { + System.err.println("failed to create socket:"+fd); + } + } + + public void finalizer() + { + if (connected) + { + try + { + close(); + } + catch (Exception e) + { + } + } + } + + protected void implCloseSelectableChannel() + { + connected = false; + SocketClose(fd); + fd = SocketCreate(); + } + + protected void implConfigureBlocking(boolean block) + { + if (blocking == block) + return; + } + + public boolean connect(SocketAddress remote) + throws IOException + { + if (connected) + { + throw new AlreadyConnectedException(); + } + + // ok, lets connect ! + + sa = (InetSocketAddress) remote; + + InetAddress addr = sa.getAddress(); + int port = sa.getPort(); + int err = SocketConnect(fd, addr, port); + + if (err < 0) + { + throw new IOException("Connection refused:"+err + ", connect="+err); + } + + local_port = err; + connected = true; + return blocking; + } + + public boolean finishConnect() + { + return false; + } + + public boolean isConnected() + { + return connected; + } + + public boolean isConnectionPending() + { + if (blocking) + return true; + + return false; + } + + public Socket socket() + { + if (sock_object != null) + { + //sock_object.ch = this; + } + + return sock_object; + } + + public int read(ByteBuffer dst) + { + int bytes = 0; + int len = 1024; + byte[]b = new byte[len]; + + bytes = SocketRead(fd, b, 0, len); + dst.put(b, 0, bytes); + + if (bytes == 0) + { + // we've hit eof ? + return -1; + } + + return bytes; + } + + public long read(ByteBuffer[] dsts, int offset, int length) + { + long bytes = 0; + + for (int i=offset; i<length; i++) + { + bytes += read(dsts[i]); + } + + return bytes; + } + + public int write(ByteBuffer src) + { + int bytes = 0; + int len = src.position(); + + if (src instanceof ByteBufferImpl) + { + ByteBufferImpl bi = (ByteBufferImpl) src; + byte[]b = bi.array(); + bytes = SocketWrite(fd, b, 0, len); + } + else + { + byte[]b = new byte[len]; + src.get(b, 0, len); + bytes = SocketWrite(fd, b, 0, len); + } + + return bytes; + } + + public long write (ByteBuffer[] srcs, int offset, int length) + { + long bytes = 0; + + for (int i=offset; i<length; i++) + { + bytes += write(srcs[i]); + } + + return bytes; + } +} diff --git a/libjava/java/nio/DoubleBuffer.java b/libjava/java/nio/DoubleBuffer.java new file mode 100644 index 0000000..7059b6e --- /dev/null +++ b/libjava/java/nio/DoubleBuffer.java @@ -0,0 +1,225 @@ +/* DoubleBuffer.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.nio; + +import gnu.java.nio.DoubleBufferImpl; + +public abstract class DoubleBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected double [] backing_buffer; + + public static DoubleBuffer allocateDirect(int capacity) + { + return new DoubleBufferImpl(capacity, 0, capacity); + } + + public static DoubleBuffer allocate(int capacity) + { + return new DoubleBufferImpl(capacity, 0, capacity); + } + + final public static DoubleBuffer wrap (double[] array, int offset, int length) + { + return new DoubleBufferImpl(array, offset, length); + } + + final public static DoubleBuffer wrap(String a) + { + int len = a.length(); + double[] buffer = new double[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (double) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static DoubleBuffer wrap(double[] array) + { + return wrap(array, 0, array.length); + } + + final public DoubleBuffer get (double[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public DoubleBuffer get(double[] dst) + { + return get(dst, 0, dst.length); + } + + final public DoubleBuffer put(DoubleBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public DoubleBuffer put (double[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final DoubleBuffer put(double[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final double[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof DoubleBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + DoubleBuffer a = (DoubleBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final DoubleBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract double get(); + public abstract DoubleBuffer put (double b); + public abstract double get(int index); + public abstract DoubleBuffer put(int index, double b); + public abstract DoubleBuffer compact(); + public abstract boolean isDirect(); + public abstract DoubleBuffer slice(); + public abstract DoubleBuffer duplicate(); + public abstract DoubleBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract DoubleBuffer putChar(char value); + public abstract char getChar(int index); + public abstract DoubleBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract DoubleBuffer putShort(short value); + public abstract short getShort(int index); + public abstract DoubleBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract DoubleBuffer putInt(int value); + public abstract int getInt(int index); + public abstract DoubleBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract DoubleBuffer putLong(long value); + public abstract long getLong(int index); + public abstract DoubleBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract DoubleBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract DoubleBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract DoubleBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract DoubleBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/FloatBuffer.java b/libjava/java/nio/FloatBuffer.java new file mode 100644 index 0000000..f06ef18 --- /dev/null +++ b/libjava/java/nio/FloatBuffer.java @@ -0,0 +1,224 @@ +/* FloatBuffer.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.nio; + +import gnu.java.nio.FloatBufferImpl; + +public abstract class FloatBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected float [] backing_buffer; + + public static FloatBuffer allocateDirect(int capacity) + { + return new FloatBufferImpl (capacity, 0, capacity); + } + + public static FloatBuffer allocate(int capacity) + { + return new FloatBufferImpl (capacity, 0, capacity); + } + + final public static FloatBuffer wrap(float[] array, int offset, int length) + { + return new FloatBufferImpl(array, offset, length); + } + + final public static FloatBuffer wrap(String a) + { + int len = a.length(); + float[] buffer = new float[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (float) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static FloatBuffer wrap(float[] array) + { + return wrap(array, 0, array.length); + } + + final public FloatBuffer get(float[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public FloatBuffer get(float[] dst) + { + return get(dst, 0, dst.length); + } + + final public FloatBuffer put(FloatBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public FloatBuffer put(float[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final FloatBuffer put(float[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final float[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof FloatBuffer) + { + return compareTo(obj) == 0; + } + return false; + } + + public int compareTo(Object ob) + { + FloatBuffer a = (FloatBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final FloatBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract float get(); + public abstract java.nio. FloatBuffer put(float b); + public abstract float get(int index); + public abstract java.nio. FloatBuffer put(int index, float b); + public abstract FloatBuffer compact(); + public abstract boolean isDirect(); + public abstract FloatBuffer slice(); + public abstract FloatBuffer duplicate(); + public abstract FloatBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract FloatBuffer putChar(char value); + public abstract char getChar(int index); + public abstract FloatBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract FloatBuffer putShort(short value); + public abstract short getShort(int index); + public abstract FloatBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract FloatBuffer putInt(int value); + public abstract int getInt(int index); + public abstract FloatBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract FloatBuffer putLong(long value); + public abstract long getLong(int index); + public abstract FloatBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract FloatBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract FloatBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract FloatBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract FloatBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/IntBuffer.java b/libjava/java/nio/IntBuffer.java new file mode 100644 index 0000000..d2d28d3 --- /dev/null +++ b/libjava/java/nio/IntBuffer.java @@ -0,0 +1,225 @@ +/* IntBuffer.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.nio; + +import gnu.java.nio.IntBufferImpl; + +public abstract class IntBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected int [] backing_buffer; + + public static IntBuffer allocateDirect(int capacity) + { + return new IntBufferImpl (capacity, 0, capacity); + } + + public static IntBuffer allocate(int capacity) + { + return new IntBufferImpl (capacity, 0, capacity); + } + + final public static IntBuffer wrap(int[] array, int offset, int length) + { + return new IntBufferImpl(array, offset, length); + } + + final public static IntBuffer wrap(String a) + { + int len = a.length(); + int[] buffer = new int[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (int) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static IntBuffer wrap(int[] array) + { + return wrap(array, 0, array.length); + } + + final public IntBuffer get(int[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public IntBuffer get(int[] dst) + { + return get(dst, 0, dst.length); + } + + final public IntBuffer put(IntBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public IntBuffer put(int[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final IntBuffer put(int[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final int[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof IntBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + IntBuffer a = (IntBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final IntBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract int get(); + public abstract IntBuffer put(int b); + public abstract int get(int index); + public abstract IntBuffer put(int index, int b); + public abstract IntBuffer compact(); + public abstract boolean isDirect(); + public abstract IntBuffer slice(); + public abstract IntBuffer duplicate(); + public abstract IntBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract IntBuffer putChar(char value); + public abstract char getChar(int index); + public abstract IntBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract IntBuffer putShort(short value); + public abstract short getShort(int index); + public abstract IntBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract IntBuffer putInt(int value); + public abstract int getInt(int index); + public abstract IntBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract IntBuffer putLong(long value); + public abstract long getLong(int index); + public abstract IntBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract IntBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract IntBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract IntBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract IntBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/LongBuffer.java b/libjava/java/nio/LongBuffer.java new file mode 100644 index 0000000..5bca6d5 --- /dev/null +++ b/libjava/java/nio/LongBuffer.java @@ -0,0 +1,226 @@ +/* LongBuffer.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.nio; + +import gnu.java.nio.LongBufferImpl; + +public abstract class LongBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected long [] backing_buffer; + + public static LongBuffer allocateDirect(int capacity) + { + return new LongBufferImpl(capacity, 0, capacity); + } + + public static LongBuffer allocate(int capacity) + { + return new LongBufferImpl(capacity, 0, capacity); + } + + final public static LongBuffer wrap(long[] array, int offset, int length) + { + return new LongBufferImpl (array, offset, length); + } + + final public static LongBuffer wrap(String a) + { + int len = a.length(); + long[] buffer = new long[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (long) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static LongBuffer wrap(long[] array) + { + return wrap(array, 0, array.length); + } + + final public LongBuffer get(long[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public LongBuffer get(long[] dst) + { + return get(dst, 0, dst.length); + } + + final public LongBuffer put(LongBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public LongBuffer put(long[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final LongBuffer put(long[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final long[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof LongBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + LongBuffer a = (LongBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final LongBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract long get(); + public abstract java.nio. LongBuffer put(long b); + public abstract long get(int index); + public abstract java.nio. LongBuffer put(int index, long b); + public abstract LongBuffer compact(); + public abstract boolean isDirect(); + public abstract LongBuffer slice(); + public abstract LongBuffer duplicate(); + public abstract LongBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract LongBuffer putChar(char value); + public abstract char getChar(int index); + public abstract LongBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract LongBuffer putShort(short value); + public abstract short getShort(int index); + public abstract LongBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract LongBuffer putInt(int value); + public abstract int getInt(int index); + public abstract LongBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract LongBuffer putLong(long value); + public abstract long getLong(int index); + public abstract LongBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract LongBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract LongBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract LongBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract LongBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/ShortBuffer.java b/libjava/java/nio/ShortBuffer.java new file mode 100644 index 0000000..5301366 --- /dev/null +++ b/libjava/java/nio/ShortBuffer.java @@ -0,0 +1,226 @@ +/* ShortBuffer.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.nio; + +import gnu.java.nio.ShortBufferImpl; + +public abstract class ShortBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected short [] backing_buffer; + + public static ShortBuffer allocateDirect(int capacity) + { + return new ShortBufferImpl(capacity, 0, capacity); + } + + public static ShortBuffer allocate(int capacity) + { + return new ShortBufferImpl(capacity, 0, capacity); + } + + final public static ShortBuffer wrap(short[] array, int offset, int length) + { + return new ShortBufferImpl(array, offset, length); + } + + final public static ShortBuffer wrap(String a) + { + int len = a.length(); + short[] buffer = new short[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (short) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static ShortBuffer wrap(short[] array) + { + return wrap(array, 0, array.length); + } + + final public ShortBuffer get(short[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public ShortBuffer get(short[] dst) + { + return get(dst, 0, dst.length); + } + + final public ShortBuffer put(ShortBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public ShortBuffer put(short[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final ShortBuffer put(short[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final short[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof ShortBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + ShortBuffer a = (ShortBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final ShortBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract short get(); + public abstract java.nio. ShortBuffer put(short b); + public abstract short get(int index); + public abstract java.nio. ShortBuffer put(int index, short b); + public abstract ShortBuffer compact(); + public abstract boolean isDirect(); + public abstract ShortBuffer slice(); + public abstract ShortBuffer duplicate(); + public abstract ShortBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract ShortBuffer putChar(char value); + public abstract char getChar(int index); + public abstract ShortBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract ShortBuffer putShort(short value); + public abstract short getShort(int index); + public abstract ShortBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract ShortBuffer putInt(int value); + public abstract int getInt(int index); + public abstract ShortBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract ShortBuffer putLong(long value); + public abstract long getLong(int index); + public abstract ShortBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract ShortBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract ShortBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract ShortBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract ShortBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/channels/FileChannel.java b/libjava/java/nio/channels/FileChannel.java new file mode 100644 index 0000000..8970b98 --- /dev/null +++ b/libjava/java/nio/channels/FileChannel.java @@ -0,0 +1,135 @@ +/* FileChannel.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.nio.channels; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.MappedByteBuffer; +import java.nio.channels.spi.AbstractInterruptibleChannel; + +/** + * @author Michael Koch + * @since 1.4 + */ +public abstract class FileChannel extends AbstractInterruptibleChannel + implements ByteChannel, GatheringByteChannel, ScatteringByteChannel +{ + public static class MapMode + { + public int m; + + public static MapMode READ_ONLY = new MapMode(0); + public static MapMode READ_WRITE = new MapMode(1); + public static MapMode PRIVATE = new MapMode(2); + + /** + * Initializes the MapMode. + */ + MapMode(int a) + { + m = a; + } + + public String toString() + { + return "" + m; + } + } + + /** + * Initializes the channel. + */ + protected FileChannel () + { + } + + /** + * Maps the file into the memory. + * + * @exception IOException If an error occurs. + */ + public abstract MappedByteBuffer map(MapMode mode, long position, long size) + throws IOException; + + /** + * Return the size of the file thus far + */ + public abstract long size() throws IOException; + + /** + * Writes data to the channel. + * + * @exception IOException If an error occurs. + */ + public long write (ByteBuffer[] srcs) throws IOException + { + long result = 0; + + for (int i = 0; i < srcs.length; i++) + { + result += write (srcs[i]); + } + + return result; + } + + /** + * Writes data to the channel. + */ + public abstract long write(ByteBuffer[] srcs, int offset, int length) + throws IOException; + + /** + * Reads data from the channel. + */ + public abstract int read(ByteBuffer dst) throws IOException; + + /** + * Closes the channel. + * + * This is called from @see close. + * + * @exception IOException If an error occurs. + */ + protected abstract void implCloseChannel() throws IOException; + + /** + * msync with the disk + */ + public abstract void force(boolean metaData); +} |