diff options
Diffstat (limited to 'libjava/java')
| -rw-r--r-- | libjava/java/nio/ByteBufferHelper.java | 589 | ||||
| -rw-r--r-- | libjava/java/nio/ByteBufferImpl.java | 242 | ||||
| -rw-r--r-- | libjava/java/nio/DirectByteBufferImpl.java | 102 | ||||
| -rw-r--r-- | libjava/java/nio/MappedByteBufferImpl.java | 161 |
4 files changed, 699 insertions, 395 deletions
diff --git a/libjava/java/nio/ByteBufferHelper.java b/libjava/java/nio/ByteBufferHelper.java new file mode 100644 index 0000000..609c38f --- /dev/null +++ b/libjava/java/nio/ByteBufferHelper.java @@ -0,0 +1,589 @@ +/* ByteBufferImpl.java -- + Copyright (C) 2003 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; + +/** + * @author Michael Koch <konqueror@gmx.de> + */ +final class ByteBufferHelper +{ + private static final void checkRemainingForRead (ByteBuffer buffer, int bytes) + { + if (buffer.remaining() < bytes) + throw new BufferUnderflowException(); + } + + private static final void checkRemainingForWrite (ByteBuffer buffer, int bytes) + { + if (buffer.remaining() < bytes) + throw new BufferOverflowException(); + } + + private static final void checkAvailableForRead (ByteBuffer buffer, + int index, int bytes) + { + if (buffer.limit() < (index + bytes)) + throw new BufferUnderflowException(); + } + + private static final void checkAvailableForWrite (ByteBuffer buffer, + int index, int bytes) + { + if (buffer.limit() < (index + bytes)) + throw new BufferOverflowException(); + } + + public static final char getChar (ByteBuffer buffer) + { + checkRemainingForRead (buffer, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (char) ((buffer.get() & 0xff) + + ((buffer.get() & 0xff) << 8)); + } + + return (char) (((buffer.get() & 0xff) << 8) + + (buffer.get() & 0xff)); + } + + public static final ByteBuffer putChar (ByteBuffer buffer, char value) + { + checkRemainingForWrite (buffer, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put ((byte) (((int) value) & 0x00ff)); + buffer.put ((byte) ((((int) value) & 0xff00) >> 8)); + } + else + { + buffer.put ((byte) ((((int) value) & 0xff00) >> 8)); + buffer.put ((byte) (((int) value) & 0x00ff)); + } + + return buffer; + } + + public static final char getChar (ByteBuffer buffer, int index) + { + checkAvailableForRead (buffer, index, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (char) (((buffer.get (index + 1) & 0xff) << 8) + + (buffer.get (index) & 0xff)); + } + + return (char) (((buffer.get (index) & 0xff) << 8) + + (buffer.get (index + 1) & 0xff)); + } + + public static final ByteBuffer putChar (ByteBuffer buffer, int index, + char value) + { + checkAvailableForWrite (buffer, index, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put (index + 1, (byte) ((((int) value) & 0x00ff) >> 8)); + buffer.put (index, (byte) (((int) value) & 0xff00)); + } + else + { + buffer.put (index, (byte) ((((int) value) & 0xff00) >> 8)); + buffer.put (index + 1, (byte) (((int) value) & 0x00ff)); + } + + return buffer; + } + + public static final short getShort (ByteBuffer buffer) + { + checkRemainingForRead (buffer, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (short) ((buffer.get() & 0xff) + + ((buffer.get() & 0xff) << 8)); + } + + return (short) (((buffer.get() & 0xff) << 8) + + (buffer.get() & 0xff)); + } + + public static final ByteBuffer putShort (ByteBuffer buffer, short value) + { + checkRemainingForWrite (buffer, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put ((byte) (((int) value) & 0x00ff)); + buffer.put ((byte) ((((int) value) & 0xff00) >> 8)); + } + else + { + buffer.put ((byte) ((((int) value) & 0xff00) >> 8)); + buffer.put ((byte) (((int) value) & 0x00ff)); + } + + return buffer; + } + + public static final short getShort (ByteBuffer buffer, int index) + { + checkAvailableForRead (buffer, index, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (short) ((buffer.get (index) & 0xff) + + ((buffer.get (index + 1) & 0xff) << 8)); + } + + return (short) (((buffer.get (index) & 0xff) << 8) + + (buffer.get (index + 1) & 0xff)); + } + + public static final ByteBuffer putShort (ByteBuffer buffer, int index, + short value) + { + checkAvailableForWrite (buffer, index, 2); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put (index + 1, (byte) ((((int) value) & 0xff00) >> 8)); + buffer.put (index, (byte) (((int) value) & 0x00ff)); + } + else + { + buffer.put (index, (byte) ((((int) value) & 0xff00) >> 8)); + buffer.put (index + 1, (byte) (((int) value) & 0x00ff)); + } + + return buffer; + } + + public static final int getInt (ByteBuffer buffer) + { + checkRemainingForRead (buffer, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (int) ((buffer.get() & 0xff) + + ((buffer.get() & 0xff) << 8) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 24)); + } + + return (int) (((buffer.get() & 0xff) << 24) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 8) + + (buffer.get() & 0xff)); + } + + public static final ByteBuffer putInt (ByteBuffer buffer, int value) + { + checkRemainingForWrite (buffer, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put ((byte) (value & 0x000000ff)); + buffer.put ((byte) ((value & 0x0000ff00) >> 8)); + buffer.put ((byte) ((value & 0x00ff0000) >> 16)); + buffer.put ((byte) ((value & 0xff000000) >> 24)); + } + else + { + buffer.put ((byte) ((value & 0xff000000) >> 24)); + buffer.put ((byte) ((value & 0x00ff0000) >> 16)); + buffer.put ((byte) ((value & 0x0000ff00) >> 8)); + buffer.put ((byte) (value & 0x000000ff)); + } + + return buffer; + } + + public static final int getInt (ByteBuffer buffer, int index) + { + checkAvailableForRead (buffer, index, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (int) ((buffer.get (index) & 0xff)) + + ((buffer.get (index + 1) & 0xff) << 8) + + ((buffer.get (index + 2) & 0xff) << 16) + + ((buffer.get (index + 3) & 0xff) << 24); + } + + return (int) (((buffer.get (index) & 0xff) << 24) + + ((buffer.get (index + 1) & 0xff) << 16) + + ((buffer.get (index + 2) & 0xff) << 8) + + (buffer.get (index + 3) & 0xff)); + } + + public static final ByteBuffer putInt (ByteBuffer buffer, int index, + int value) + { + checkAvailableForWrite (buffer, index, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put (index + 3, (byte) ((value & 0xff000000) >> 24)); + buffer.put (index + 2, (byte) ((value & 0x00ff0000) >> 16)); + buffer.put (index + 1, (byte) ((value & 0x0000ff00) >> 8)); + buffer.put (index, (byte) (value & 0x000000ff)); + } + else + { + buffer.put (index, (byte) ((value & 0xff000000) >> 24)); + buffer.put (index + 1, (byte) ((value & 0x00ff0000) >> 16)); + buffer.put (index + 2, (byte) ((value & 0x0000ff00) >> 8)); + buffer.put (index + 3, (byte) (value & 0x000000ff)); + } + + return buffer; + } + + public static final long getLong (ByteBuffer buffer) + { + checkRemainingForRead (buffer, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (long) (((buffer.get() & 0xff)) + + ((buffer.get() & 0xff) << 8) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 24) + + ((buffer.get() & 0xff) << 32) + + ((buffer.get() & 0xff) << 40) + + ((buffer.get() & 0xff) << 48) + + ((buffer.get() & 0xff) << 56)); + } + + return (long) (((buffer.get() & 0xff) << 56) + + ((buffer.get() & 0xff) << 48) + + ((buffer.get() & 0xff) << 40) + + ((buffer.get() & 0xff) << 32) + + ((buffer.get() & 0xff) << 24) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 8) + + (buffer.get() & 0xff)); + } + + public static final ByteBuffer putLong (ByteBuffer buffer, long value) + { + checkRemainingForWrite (buffer, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put ((byte) (value & 0xff00000000000000L)); + buffer.put ((byte) ((value & 0x00ff000000000000L) >> 8)); + buffer.put ((byte) ((value & 0x0000ff0000000000L) >> 16)); + buffer.put ((byte) ((value & 0x000000ff00000000L) >> 24)); + buffer.put ((byte) ((value & 0x00000000ff000000L) >> 32)); + buffer.put ((byte) ((value & 0x0000000000ff0000L) >> 40)); + buffer.put ((byte) ((value & 0x000000000000ff00L) >> 48)); + buffer.put ((byte) ((value & 0x00000000000000ffL) >> 56)); + } + else + { + buffer.put ((byte) ((value & 0xff00000000000000L) >> 56)); + buffer.put ((byte) ((value & 0x00ff000000000000L) >> 48)); + buffer.put ((byte) ((value & 0x0000ff0000000000L) >> 40)); + buffer.put ((byte) ((value & 0x000000ff00000000L) >> 32)); + buffer.put ((byte) ((value & 0x00000000ff000000L) >> 24)); + buffer.put ((byte) ((value & 0x0000000000ff0000L) >> 16)); + buffer.put ((byte) ((value & 0x000000000000ff00L) >> 8)); + buffer.put ((byte) (value & 0x00000000000000ffL)); + } + + return buffer; + } + + public static final long getLong (ByteBuffer buffer, int index) + { + checkAvailableForRead (buffer, index, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (long) ((buffer.get (index) & 0xff) + + ((buffer.get (index + 1) & 0xff) << 8) + + ((buffer.get (index + 2) & 0xff) << 16) + + ((buffer.get (index + 3) & 0xff) << 24) + + ((buffer.get (index + 4) & 0xff) << 32) + + ((buffer.get (index + 5) & 0xff) << 40) + + ((buffer.get (index + 6) & 0xff) << 48) + + ((buffer.get (index + 7) & 0xff) << 56)); + } + + return (long) (((buffer.get (index) & 0xff) << 56) + + ((buffer.get (index + 1) & 0xff) << 48) + + ((buffer.get (index + 2) & 0xff) << 40) + + ((buffer.get (index + 3) & 0xff) << 32) + + ((buffer.get (index + 4) & 0xff) << 24) + + ((buffer.get (index + 5) & 0xff) << 16) + + ((buffer.get (index + 6) & 0xff) << 8) + + (buffer.get (index + 7) & 0xff)); + } + + public static final ByteBuffer putLong (ByteBuffer buffer, int index, + long value) + { + checkAvailableForWrite (buffer, index, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put (index + 7, (byte) ((value & 0xff00000000000000L) >> 56)); + buffer.put (index + 6, (byte) ((value & 0x00ff000000000000L) >> 48)); + buffer.put (index + 5, (byte) ((value & 0x0000ff0000000000L) >> 40)); + buffer.put (index + 4, (byte) ((value & 0x000000ff00000000L) >> 32)); + buffer.put (index + 3, (byte) ((value & 0x00000000ff000000L) >> 24)); + buffer.put (index + 2, (byte) ((value & 0x0000000000ff0000L) >> 16)); + buffer.put (index + 1, (byte) ((value & 0x000000000000ff00L) >> 8)); + buffer.put (index, (byte) (value & 0x00000000000000ffL)); + } + else + { + buffer.put (index, (byte) ((value & 0xff00000000000000L) >> 56)); + buffer.put (index + 1, (byte) ((value & 0x00ff000000000000L) >> 48)); + buffer.put (index + 2, (byte) ((value & 0x0000ff0000000000L) >> 40)); + buffer.put (index + 3, (byte) ((value & 0x000000ff00000000L) >> 32)); + buffer.put (index + 4, (byte) ((value & 0x00000000ff000000L) >> 24)); + buffer.put (index + 5, (byte) ((value & 0x0000000000ff0000L) >> 16)); + buffer.put (index + 6, (byte) ((value & 0x000000000000ff00L) >> 8)); + buffer.put (index + 7, (byte) (value & 0x00000000000000ffL)); + } + + return buffer; + } + + public static final float getFloat (ByteBuffer buffer) + { + checkRemainingForRead (buffer, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (float) ((buffer.get() & 0xff) + + ((buffer.get() & 0xff) << 8) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 24)); + } + + return (float) (((buffer.get() & 0xff) << 24) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 8) + + (buffer.get() & 0xff)); + } + + public static final ByteBuffer putFloat (ByteBuffer buffer, float value) + { + checkRemainingForWrite (buffer, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put ((byte) (((int) value) & 0xff000000)); + buffer.put ((byte) ((((int) value) & 0x00ff0000) >> 8)); + buffer.put ((byte) ((((int) value) & 0x0000ff00) >> 16)); + buffer.put ((byte) ((((int) value) & 0x000000ff) >> 24)); + } + else + { + buffer.put ((byte) ((((int) value) & 0xff000000) >> 24)); + buffer.put ((byte) ((((int) value) & 0x00ff0000) >> 16)); + buffer.put ((byte) ((((int) value) & 0x0000ff00) >> 8)); + buffer.put ((byte) (((int) value) & 0x000000ff)); + } + + return buffer; + } + + public static final float getFloat (ByteBuffer buffer, int index) + { + checkAvailableForRead (buffer, index, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (float) ((buffer.get (index) & 0xff) + + ((buffer.get (index + 1) & 0xff) << 8) + + ((buffer.get (index + 2) & 0xff) << 16) + + ((buffer.get (index + 3) & 0xff) << 24)); + } + + return (float) (((buffer.get (index) & 0xff) << 24) + + ((buffer.get (index + 1) & 0xff) << 16) + + ((buffer.get (index + 2) & 0xff) << 8) + + (buffer.get (index + 3) & 0xff)); + } + + public static final ByteBuffer putFloat (ByteBuffer buffer, int index, + float value) + { + checkAvailableForWrite (buffer, index, 4); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put (index + 3, (byte) ((((int) value) & 0xff000000) >> 24)); + buffer.put (index + 2, (byte) ((((int) value) & 0x00ff0000) >> 16)); + buffer.put (index + 1, (byte) ((((int) value) & 0x0000ff00) >> 8)); + buffer.put (index, (byte) (((int) value) & 0x000000ff)); + } + else + { + buffer.put (index, (byte) ((((int) value) & 0xff000000) >> 24)); + buffer.put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); + buffer.put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); + buffer.put (index + 3, (byte) (((int) value) & 0x000000ff)); + } + + return buffer; + } + + public static final double getDouble (ByteBuffer buffer) + { + checkRemainingForRead (buffer, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (double) ((buffer.get() & 0xff) + + ((buffer.get() & 0xff) << 8) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 24) + + ((buffer.get() & 0xff) << 32) + + ((buffer.get() & 0xff) << 40) + + ((buffer.get() & 0xff) << 48) + + ((buffer.get() & 0xff) << 56)); + } + + return (double) (((buffer.get() & 0xff) << 56) + + ((buffer.get() & 0xff) << 48) + + ((buffer.get() & 0xff) << 40) + + ((buffer.get() & 0xff) << 32) + + ((buffer.get() & 0xff) << 24) + + ((buffer.get() & 0xff) << 16) + + ((buffer.get() & 0xff) << 8) + + (buffer.get() & 0xff)); + } + + public static final ByteBuffer putDouble (ByteBuffer buffer, double value) + { + checkRemainingForWrite (buffer, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put ((byte) (((long) value) & 0xff00000000000000L)); + buffer.put ((byte) ((((long) value) & 0x00ff000000000000L) >> 8)); + buffer.put ((byte) ((((long) value) & 0x0000ff0000000000L) >> 16)); + buffer.put ((byte) ((((long) value) & 0x000000ff00000000L) >> 24)); + buffer.put ((byte) ((((long) value) & 0x00000000ff000000L) >> 32)); + buffer.put ((byte) ((((long) value) & 0x0000000000ff0000L) >> 40)); + buffer.put ((byte) ((((long) value) & 0x000000000000ff00L) >> 48)); + buffer.put ((byte) ((((long) value) & 0x00000000000000ffL) >> 56)); + } + else + { + buffer.put ((byte) ((((long) value) & 0xff00000000000000L) >> 56)); + buffer.put ((byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + buffer.put ((byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + buffer.put ((byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + buffer.put ((byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + buffer.put ((byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + buffer.put ((byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + buffer.put ((byte) (((long) value) & 0x00000000000000ffL)); + } + + return buffer; + } + + public static final double getDouble (ByteBuffer buffer, int index) + { + checkAvailableForRead (buffer, index, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + return (double) ((buffer.get (index) & 0xff) + + ((buffer.get (index + 1) & 0xff) << 8) + + ((buffer.get (index + 2) & 0xff) << 16) + + ((buffer.get (index + 3) & 0xff) << 24) + + ((buffer.get (index + 4) & 0xff) << 32) + + ((buffer.get (index + 5) & 0xff) << 40) + + ((buffer.get (index + 6) & 0xff) << 48) + + ((buffer.get (index + 7) & 0xff) << 56)); + } + + return (double) (((buffer.get (index) & 0xff) << 56) + + ((buffer.get (index + 1) & 0xff) << 48) + + ((buffer.get (index + 2) & 0xff) << 40) + + ((buffer.get (index + 3) & 0xff) << 32) + + ((buffer.get (index + 4) & 0xff) << 24) + + ((buffer.get (index + 5) & 0xff) << 16) + + ((buffer.get (index + 6) & 0xff) << 8) + + (buffer.get (index + 7) & 0xff)); + } + + public static final ByteBuffer putDouble (ByteBuffer buffer, int index, + double value) + { + checkAvailableForWrite (buffer, index, 8); + + if (buffer.order() == ByteOrder.LITTLE_ENDIAN) + { + buffer.put (index + 7, (byte) ((((long) value) & 0xff00000000000000L) >> 56)); + buffer.put (index + 6, (byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + buffer.put (index + 5, (byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + buffer.put (index + 4, (byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + buffer.put (index + 3, (byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + buffer.put (index + 2, (byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + buffer.put (index + 1, (byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + buffer.put (index, (byte) (((long) value) & 0x00000000000000ffL)); + } + else + { + buffer.put (index, (byte) ((((long) value) & 0xff00000000000000L) >> 56)); + buffer.put (index + 1, (byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + buffer.put (index + 2, (byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + buffer.put (index + 3, (byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + buffer.put (index + 4, (byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + buffer.put (index + 5, (byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + buffer.put (index + 6, (byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + buffer.put (index + 7, (byte) (((long) value) & 0x00000000000000ffL)); + } + + return buffer; + } + +} // ByteBufferHelper diff --git a/libjava/java/nio/ByteBufferImpl.java b/libjava/java/nio/ByteBufferImpl.java index 7ea3a3a..76c965d 100644 --- a/libjava/java/nio/ByteBufferImpl.java +++ b/libjava/java/nio/ByteBufferImpl.java @@ -182,313 +182,121 @@ final class ByteBufferImpl extends ByteBuffer final public char getChar () { - if (remaining() < 2) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (char) (((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getChar (this); } final public ByteBuffer putChar (char value) { - if (remaining() < 2) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put ((byte) ((((int) value) & 0xff00) >> 8)); - put ((byte) (((int) value) & 0x00ff)); - return this; + return ByteBufferHelper.putChar (this, value); } final public char getChar (int index) { - if (remaining() < 2) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (char) (((get (index) & 0xff) << 8) + (get (index + 1) & 0xff)); + return ByteBufferHelper.getChar (this, index); } final public ByteBuffer putChar (int index, char value) { - if (remaining() < 2) - throw new BufferOverflowException(); - // FIXME: this handles little endian only - put (index, (byte) ((((int) value) & 0xff00) >> 8)); - put (index + 1, (byte) (((int) value) & 0x00ff)); - return this; + return ByteBufferHelper.putChar (this, index, value); } final public short getShort () { - if (remaining() < 2) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (short) (((get () & 0xff) << 8) + (get () & 0xff)); + return ByteBufferHelper.getShort (this); } final public ByteBuffer putShort (short value) { - if (remaining() < 2) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put ((byte) ((((int) value) & 0xff00) >> 8)); - put ((byte) (((int) value) & 0x00ff)); - return this; + return ByteBufferHelper.putShort (this, value); } final public short getShort (int index) { - if (remaining() < 2) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (short) (((get (index) & 0xff) << 8) + (get (index + 1) & 0xff)); + return ByteBufferHelper.getShort (this, index); } final public ByteBuffer putShort (int index, short value) { - if (remaining() < 2) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put (index, (byte) ((((int) value) & 0xff00) >> 8)); - put (index + 1, (byte) (((int) value) & 0x00ff)); - return this; + return ByteBufferHelper.putShort (this, index, value); } final public int getInt () { - if (remaining() < 4) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (int) (((get () & 0xff) << 24) - + ((get () & 0xff) << 16) - + ((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getInt (this); } final public ByteBuffer putInt (int value) { - if (remaining() < 4) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put ((byte) ((value & 0xff000000) >> 24)); - put ((byte) ((value & 0x00ff0000) >> 16)); - put ((byte) ((value & 0x0000ff00) >> 8)); - put ((byte) (value & 0x000000ff)); - return this; + return ByteBufferHelper.putInt (this, value); } final public int getInt (int index) { - if (remaining() < 4) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (int) (((get (index) & 0xff) << 24) - + ((get (index + 1) & 0xff) << 16) - + ((get (index + 2) & 0xff) << 8) - + (get (index + 3) & 0xff)); + return ByteBufferHelper.getInt (this, index); } final public ByteBuffer putInt (int index, int value) { - if (remaining() < 4) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put (index, (byte) ((value & 0xff000000) >> 24)); - put (index + 1, (byte) ((value & 0x00ff0000) >> 16)); - put (index + 2, (byte) ((value & 0x0000ff00) >> 8)); - put (index + 3, (byte) (value & 0x000000ff)); - return this; + return ByteBufferHelper.putInt (this, index, value); } final public long getLong () { - if (remaining() < 8) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (long) (((get () & 0xff) << 56) - + ((get () & 0xff) << 48) - + ((get () & 0xff) << 40) - + ((get () & 0xff) << 32) - + ((get () & 0xff) << 24) - + ((get () & 0xff) << 16) - + ((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getLong (this); } final public ByteBuffer putLong (long value) { - if (remaining() < 8) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put ((byte) ((value & 0xff00000000000000L) >> 56)); - put ((byte) ((value & 0x00ff000000000000L) >> 48)); - put ((byte) ((value & 0x0000ff0000000000L) >> 40)); - put ((byte) ((value & 0x000000ff00000000L) >> 32)); - put ((byte) ((value & 0x00000000ff000000L) >> 24)); - put ((byte) ((value & 0x0000000000ff0000L) >> 16)); - put ((byte) ((value & 0x000000000000ff00L) >> 8)); - put ((byte) (value & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putLong (this, value); } final public long getLong (int index) { - if (remaining() < 8) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (long) (((get (index) & 0xff) << 56) - + ((get (index + 1) & 0xff) << 48) - + ((get (index + 2) & 0xff) << 40) - + ((get (index + 3) & 0xff) << 32) - + ((get (index + 4) & 0xff) << 24) - + ((get (index + 5) & 0xff) << 16) - + ((get (index + 6) & 0xff) << 8) - + (get (index + 7) & 0xff)); + return ByteBufferHelper.getLong (this, index); } final public ByteBuffer putLong (int index, long value) { - if (remaining() < 8) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put (index, (byte) ((value & 0xff00000000000000L) >> 56)); - put (index + 1, (byte) ((value & 0x00ff000000000000L) >> 48)); - put (index + 2, (byte) ((value & 0x0000ff0000000000L) >> 40)); - put (index + 3, (byte) ((value & 0x000000ff00000000L) >> 32)); - put (index + 4, (byte) ((value & 0x00000000ff000000L) >> 24)); - put (index + 5, (byte) ((value & 0x0000000000ff0000L) >> 16)); - put (index + 6, (byte) ((value & 0x000000000000ff00L) >> 8)); - put (index + 7, (byte) (value & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putLong (this, index, value); } final public float getFloat () { - if (remaining() < 4) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (float) (((get () & 0xff) << 24) - + ((get () & 0xff) << 16) - + ((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getFloat (this); } final public ByteBuffer putFloat (float value) { - if (remaining() < 4) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put ((byte) ((((int) value) & 0xff000000) >> 24)); - put ((byte) ((((int) value) & 0x00ff0000) >> 16)); - put ((byte) ((((int) value) & 0x0000ff00) >> 8)); - put ((byte) (((int) value) & 0x000000ff)); - return this; + return ByteBufferHelper.putFloat (this, value); } final public float getFloat (int index) { - if (remaining() < 4) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (float) (((get (index) & 0xff) << 24) - + ((get (index + 1) & 0xff) << 16) - + ((get (index + 2) & 0xff) << 8) - + (get (index + 3) & 0xff)); + return ByteBufferHelper.getFloat (this, index); } - final public ByteBuffer putFloat (int index, float value) + public final ByteBuffer putFloat (int index, float value) { - if (remaining() < 4) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put (index, (byte) ((((int) value) & 0xff000000) >> 24)); - put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); - put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); - put (index + 3, (byte) (((int) value) & 0x000000ff)); - return this; + return ByteBufferHelper.putFloat (this, index, value); } final public double getDouble () { - if (remaining() < 8) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (double) (((get () & 0xff) << 56) - + ((get () & 0xff) << 48) - + ((get () & 0xff) << 40) - + ((get () & 0xff) << 32) - + ((get () & 0xff) << 24) - + ((get () & 0xff) << 16) - + ((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getDouble (this); } final public ByteBuffer putDouble (double value) { - if (remaining() < 8) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put ((byte) ((((long) value) & 0xff00000000000000L) >> 56)); - put ((byte) ((((long) value) & 0x00ff000000000000L) >> 48)); - put ((byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); - put ((byte) ((((long) value) & 0x000000ff00000000L) >> 32)); - put ((byte) ((((long) value) & 0x00000000ff000000L) >> 24)); - put ((byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); - put ((byte) ((((long) value) & 0x000000000000ff00L) >> 8)); - put ((byte) (((long) value) & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putDouble (this, value); } final public double getDouble (int index) { - if (remaining() < 8) - throw new BufferUnderflowException(); - - // FIXME: this handles little endian only - return (double) (((get (index) & 0xff) << 56) - + ((get (index + 1) & 0xff) << 48) - + ((get (index + 2) & 0xff) << 40) - + ((get (index + 3) & 0xff) << 32) - + ((get (index + 4) & 0xff) << 24) - + ((get (index + 5) & 0xff) << 16) - + ((get (index + 6) & 0xff) << 8) - + (get (index + 7) & 0xff)); + return ByteBufferHelper.getDouble (this, index); } final public ByteBuffer putDouble (int index, double value) { - if (remaining() < 8) - throw new BufferOverflowException(); - - // FIXME: this handles little endian only - put (index, (byte) ((((long) value) & 0xff00000000000000L) >> 56)); - put (index + 1, (byte) ((((long) value) & 0x00ff000000000000L) >> 48)); - put (index + 2, (byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); - put (index + 3, (byte) ((((long) value) & 0x000000ff00000000L) >> 32)); - put (index + 4, (byte) ((((long) value) & 0x00000000ff000000L) >> 24)); - put (index + 5, (byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); - put (index + 6, (byte) ((((long) value) & 0x000000000000ff00L) >> 8)); - put (index + 7, (byte) (((long) value) & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putDouble (this, index, value); } } diff --git a/libjava/java/nio/DirectByteBufferImpl.java b/libjava/java/nio/DirectByteBufferImpl.java index cdeafef..4028b54 100644 --- a/libjava/java/nio/DirectByteBufferImpl.java +++ b/libjava/java/nio/DirectByteBufferImpl.java @@ -292,134 +292,56 @@ class DirectByteBufferImpl extends ByteBuffer final public ByteBuffer putLong (long value) { - // FIXME: this handles little endian only - put ((byte) ((value & 0xff00000000000000L) >> 56)); - put ((byte) ((value & 0x00ff000000000000L) >> 48)); - put ((byte) ((value & 0x0000ff0000000000L) >> 40)); - put ((byte) ((value & 0x000000ff00000000L) >> 32)); - put ((byte) ((value & 0x00000000ff000000L) >> 24)); - put ((byte) ((value & 0x0000000000ff0000L) >> 16)); - put ((byte) ((value & 0x000000000000ff00L) >> 8)); - put ((byte) (value & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putLong (this, value); } final public long getLong (int index) { - // FIXME: this handles little endian only - return (long) (((get (index) & 0xff) << 56) - + ((get (index + 1) & 0xff) << 48) - + ((get (index + 2) & 0xff) << 40) - + ((get (index + 3) & 0xff) << 32) - + ((get (index + 4) & 0xff) << 24) - + ((get (index + 5) & 0xff) << 16) - + ((get (index + 6) & 0xff) << 8) - + (get (index + 7) & 0xff)); + return ByteBufferHelper.getLong (this, index); } final public ByteBuffer putLong (int index, long value) { - // FIXME: this handles little endian only - put (index, (byte) ((value & 0xff00000000000000L) >> 56)); - put (index + 1, (byte) ((value & 0x00ff000000000000L) >> 48)); - put (index + 2, (byte) ((value & 0x0000ff0000000000L) >> 40)); - put (index + 3, (byte) ((value & 0x000000ff00000000L) >> 32)); - put (index + 4, (byte) ((value & 0x00000000ff000000L) >> 24)); - put (index + 5, (byte) ((value & 0x0000000000ff0000L) >> 16)); - put (index + 6, (byte) ((value & 0x000000000000ff00L) >> 8)); - put (index + 7, (byte) (value & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putLong (this, index, value); } final public float getFloat () { - // FIXME: this handles little endian only - return (float) (((get () & 0xff) << 24) - + ((get () & 0xff) << 16) - + ((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getFloat (this); } final public ByteBuffer putFloat (float value) { - // FIXME: this handles little endian only - put ((byte) ((((int) value) & 0xff000000) >> 24)); - put ((byte) ((((int) value) & 0x00ff0000) >> 16)); - put ((byte) ((((int) value) & 0x0000ff00) >> 8)); - put ((byte) (((int) value) & 0x000000ff)); - return this; + return ByteBufferHelper.putFloat (this, value); } - final public float getFloat (int index) + public final float getFloat (int index) { - // FIXME: this handles little endian only - return (float) (((get (index) & 0xff) << 24) - + ((get (index + 1) & 0xff) << 16) - + ((get (index + 2) & 0xff) << 8) - + (get (index + 3) & 0xff)); + return ByteBufferHelper.getFloat (this, index); } final public ByteBuffer putFloat (int index, float value) { - // FIXME: this handles little endian only - put (index, (byte) ((((int) value) & 0xff000000) >> 24)); - put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); - put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); - put (index + 3, (byte) (((int) value) & 0x000000ff)); - return this; + return ByteBufferHelper.putFloat (this, index, value); } final public double getDouble () { - // FIXME: this handles little endian only - return (double) (((get () & 0xff) << 56) - + ((get () & 0xff) << 48) - + ((get () & 0xff) << 40) - + ((get () & 0xff) << 32) - + ((get () & 0xff) << 24) - + ((get () & 0xff) << 16) - + ((get () & 0xff) << 8) - + (get () & 0xff)); + return ByteBufferHelper.getDouble (this); } final public ByteBuffer putDouble (double value) { - // FIXME: this handles little endian only - put ((byte) ((((long) value) & 0xff00000000000000L) >> 56)); - put ((byte) ((((long) value) & 0x00ff000000000000L) >> 48)); - put ((byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); - put ((byte) ((((long) value) & 0x000000ff00000000L) >> 32)); - put ((byte) ((((long) value) & 0x00000000ff000000L) >> 24)); - put ((byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); - put ((byte) ((((long) value) & 0x000000000000ff00L) >> 8)); - put ((byte) (((long) value) & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putDouble (this, value); } final public double getDouble (int index) { - // FIXME: this handles little endian only - return (double) (((get (index) & 0xff) << 56) - + ((get (index + 1) & 0xff) << 48) - + ((get (index + 2) & 0xff) << 40) - + ((get (index + 3) & 0xff) << 32) - + ((get (index + 4) & 0xff) << 24) - + ((get (index + 5) & 0xff) << 16) - + ((get (index + 6) & 0xff) << 8) - + (get (index + 7) & 0xff)); + return ByteBufferHelper.getDouble (this, index); } final public ByteBuffer putDouble (int index, double value) { - // FIXME: this handles little endian only - put (index, (byte) ((((long) value) & 0xff00000000000000L) >> 56)); - put (index + 1, (byte) ((((long) value) & 0x00ff000000000000L) >> 48)); - put (index + 2, (byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); - put (index + 3, (byte) ((((long) value) & 0x000000ff00000000L) >> 32)); - put (index + 4, (byte) ((((long) value) & 0x00000000ff000000L) >> 24)); - put (index + 5, (byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); - put (index + 6, (byte) ((((long) value) & 0x000000000000ff00L) >> 8)); - put (index + 7, (byte) (((long) value) & 0x00000000000000ffL)); - return this; + return ByteBufferHelper.putDouble (this, index, value); } } diff --git a/libjava/java/nio/MappedByteBufferImpl.java b/libjava/java/nio/MappedByteBufferImpl.java index c5b460e..47673c6 100644 --- a/libjava/java/nio/MappedByteBufferImpl.java +++ b/libjava/java/nio/MappedByteBufferImpl.java @@ -58,6 +58,15 @@ public class MappedByteBufferImpl extends MappedByteBuffer limit ((int) si); } + public MappedByteBufferImpl (FileChannelImpl ch, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (capacity, limit, position, mark); + + this.ch = ch; + this.array_offset = offset; + this.readOnly = readOnly; + } + public boolean isReadOnly () { return readOnly; @@ -164,147 +173,123 @@ public class MappedByteBufferImpl extends MappedByteBuffer return new DoubleViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); } - public char getChar () + public final char getChar() { - char value = getChar (position()); - position (position() + 2); - return value; + return ByteBufferHelper.getChar (this); } - - public char getChar (int index) + + public final ByteBuffer putChar (char value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putChar (this, value); } - - public ByteBuffer putChar (char value) + + public final char getChar (int index) { - putChar (position(), value); - position (position() + 2); - return this; + return ByteBufferHelper.getChar (this, index); } - - public ByteBuffer putChar (int index, char value) + + public final ByteBuffer putChar (int index, char value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putChar (this, index, value); } - public double getDouble () + public final short getShort() { - double value = getDouble (position()); - position (position() + 8); - return value; + return ByteBufferHelper.getShort (this); } - - public double getDouble (int index) + + public final ByteBuffer putShort (short value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putShort (this, value); } - - public ByteBuffer putDouble (double value) + + public final short getShort (int index) { - putDouble (position(), value); - position (position() + 8); - return this; + return ByteBufferHelper.getShort (this, index); } - - public ByteBuffer putDouble (int index, double value) + + public final ByteBuffer putShort (int index, short value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putShort (this, index, value); } - public float getFloat () + public final int getInt() { - float value = getFloat (position ()); - position (position() + 4); - return value; + return ByteBufferHelper.getInt (this); } - - public float getFloat (int index) + + public final ByteBuffer putInt (int value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putInt (this, value); } - - public ByteBuffer putFloat (float value) + + public final int getInt (int index) { - putFloat (position(), value); - position (position() + 4); - return this; + return ByteBufferHelper.getInt (this, index); } - - public ByteBuffer putFloat (int index, float value) + + public final ByteBuffer putInt (int index, int value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putInt (this, index, value); } - public int getInt () + public final long getLong() { - int value = getInt (position()); - position (position() + 8); - return value; + return ByteBufferHelper.getLong (this); } - - public int getInt (int index) + + public final ByteBuffer putLong (long value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putLong (this, value); } - - public ByteBuffer putInt (int value) + + public final long getLong (int index) { - putInt (position(), value); - position (position() + 4); - return this; + return ByteBufferHelper.getLong (this, index); } - - public ByteBuffer putInt (int index, int value) + + public final ByteBuffer putLong (int index, long value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putLong (this, index, value); } - public long getLong () + public final float getFloat() { - long value = getLong (position()); - position (position() + 8); - return value; + return ByteBufferHelper.getFloat (this); } - - public long getLong (int index) + + public final ByteBuffer putFloat (float value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putFloat (this, value); } - - public ByteBuffer putLong (long value) + + public final float getFloat (int index) { - putLong (position(), value); - position (position() + 8); - return this; + return ByteBufferHelper.getFloat (this, index); } - public ByteBuffer putLong (int index, long value) + public final ByteBuffer putFloat (int index, float value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putFloat (this, index, value); } - public short getShort () + public final double getDouble() { - short value = getShort (position()); - position (position() + 2); - return value; + return ByteBufferHelper.getDouble (this); } - public short getShort (int index) + public final ByteBuffer putDouble (double value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putDouble (this, value); } - - public ByteBuffer putShort (short value) + + public final double getDouble (int index) { - putShort (position(), value); - position (position() + 2); - return this; + return ByteBufferHelper.getDouble (this, index); } - - public ByteBuffer putShort (int index, short value) + + public final ByteBuffer putDouble (int index, double value) { - throw new Error ("Not implemented"); + return ByteBufferHelper.putDouble (this, index, value); } } |