| /* |
| * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package nsk.share.jdwp; |
| |
| import java.io.*; |
| import nsk.share.*; |
| |
| /** |
| * This class represents a byte buffer of variable size. |
| */ |
| public class ByteBuffer { |
| |
| /** |
| * Empty byte value (zero). |
| */ |
| private static final byte EMPTY_BYTE = (byte)0; |
| |
| /** |
| * Current number of bytes in the buffer. |
| */ |
| private int CurrentSize; |
| |
| /** |
| * Delta to increase buffer size. |
| */ |
| private int Delta; |
| |
| /** |
| * Current offset from the buffer begin during parsing packet. |
| */ |
| int parseOffset; |
| |
| /** |
| * Array of bytes in the buffer. |
| */ |
| protected byte[] bytes; |
| |
| /** |
| * Make an empty <code>ByteBuffer</code> object. |
| */ |
| public ByteBuffer() { |
| this(128, 128); |
| } |
| |
| /** |
| * Make an empty <code>ByteBuffer</code> object with given initial capacity. |
| * When there is no space for a new byte in a buffer it's capacity |
| * grows by Delta. |
| */ |
| public ByteBuffer(int InitialSize, int Delta) { |
| if (Delta <= 0) |
| Delta = 16; |
| this.Delta = Delta; |
| CurrentSize = 0; |
| bytes = new byte[InitialSize]; |
| parseOffset = 0; |
| } |
| |
| /** |
| * Make a copy of specified byte buffer. |
| */ |
| public ByteBuffer(ByteBuffer buffer) { |
| int InitialSize = buffer.bytes.length; |
| Delta = buffer.Delta; |
| CurrentSize = buffer.CurrentSize; |
| bytes = new byte[InitialSize]; |
| for (int i = 0; i < CurrentSize; i++ ) { |
| bytes[i] = buffer.bytes[i]; |
| } |
| parseOffset = 0; |
| } |
| |
| /** |
| * Return number of bytes in this buffer. |
| */ |
| public int length() { |
| return CurrentSize; |
| } |
| |
| /** |
| * Return array of bytes in this buffer. |
| */ |
| public byte[] getBytes() { |
| return bytes; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Replace the byte at the specified offset in this buffer with the |
| * less significant byte from the int value. |
| * |
| * @throws BoundException if specified offset is out of buffer bounds |
| */ |
| public void putByte(int off, byte value) throws BoundException { |
| |
| if ((off < 0) || (off >= CurrentSize)) |
| throw new BoundException("Unable to put one byte at " + offsetString(off)); |
| |
| bytes[off] = value; |
| } |
| |
| /** |
| * Replace len bytes starting at offset off with the bytes from the |
| * given byte array. |
| * |
| * @throws BoundException if offset and length are out of buffer bounds |
| */ |
| public void putBytes(int off, byte[] value, int start, int len) throws BoundException { |
| if (len > (CurrentSize - off)) { |
| throw new BoundException("Unable to put " + len + " bytes at " + offsetString(off) + |
| " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| try { |
| for (int i = 0; i < len; i++) |
| putByte(off++, value[start++]); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + len + |
| "bytes at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace count (1 - 8) bytes starting at offset off with the less |
| * significant bytes from the specified ID value. |
| * |
| * @throws BoundException if offset and count are out of buffer bounds |
| */ |
| public void putID(int off, long value, int count) throws BoundException { |
| |
| if ((count <= 0) || (count > 8)) |
| throw new TestBug("Illegal number of bytes of ID value to put: " + count); |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of ID value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| putValueBytes(off, value, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of ID value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace four bytes starting at offset off with the bytes from the |
| * specified int value. |
| * |
| * @throws BoundException if offset is out of buffer bounds |
| */ |
| public void putInt(int off, int value) throws BoundException { |
| final int count = JDWP.TypeSize.INT; |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of int value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| putValueBytes(off, value, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of int value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace two bytes starting at offset off with the bytes |
| * from the specified short value. |
| * |
| * @throws BoundException if offset is out of buffer bounds |
| */ |
| public void putShort(int off, short value) throws BoundException { |
| final int count = JDWP.TypeSize.SHORT; |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of short value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| putValueBytes(off, value, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of short value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace eight bytes starting at offset off with the bytes |
| * from the specified long value. |
| * |
| * @throws BoundException if offset is out of buffer bounds |
| */ |
| public void putLong(int off, long value) throws BoundException { |
| final int count = JDWP.TypeSize.LONG; |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of long value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| putValueBytes(off, value, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of long value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace four bytes starting at offset off with the bytes |
| * from the specified float value. |
| * |
| * @throws BoundException if offset is out of buffer bounds |
| */ |
| public void putFloat(int off, float value) throws BoundException { |
| final int count = JDWP.TypeSize.FLOAT; |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of float value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| long l = Float.floatToIntBits(value); |
| putValueBytes(off, l, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of float value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace eight bytes starting at offset off with the bytes |
| * from the specified double value. |
| * |
| * @throws BoundException if offset is out of buffer bounds |
| */ |
| public void putDouble(int off, double value) throws BoundException { |
| final int count = JDWP.TypeSize.DOUBLE; |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of double value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| long l = Double.doubleToLongBits(value); |
| putValueBytes(off, l, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of double value at " + offsetString(off) + ": \n\t" + e); |
| } |
| } |
| |
| /** |
| * Replace two bytes starting at offset off with the bytes |
| * from the specified char value. |
| * |
| * @throws BoundException if offset is out of buffer bounds |
| */ |
| public void putChar(int off, char value) throws BoundException { |
| final int count = JDWP.TypeSize.CHAR; |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of char value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| long l = (long)value; |
| putValueBytes(off, l, count); |
| } catch (BoundException e) { |
| throw new Failure("Caught unexpected bound exception while putting " + count + |
| "bytes of char value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Append the specified byte to the end of this buffer. |
| */ |
| public void addByte(byte value) { |
| checkSpace(1); |
| |
| int where = CurrentSize; |
| CurrentSize++; |
| |
| try { |
| putByte(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding one byte:\n\t" |
| + e); |
| }; |
| } |
| |
| /** |
| * Append specified byte value repeated count to the end of this buffer. |
| */ |
| public void addBytes(byte value, int count) { |
| checkSpace(count); |
| for (int i = 0; i < count; i++) { |
| addByte(value); |
| } |
| } |
| |
| /** |
| * Append the bytes from the specified byte array to the end of this buffer. |
| */ |
| public void addBytes(byte[] value, int start, int len) { |
| checkSpace(len); |
| |
| int where = CurrentSize; |
| CurrentSize = CurrentSize + len; |
| |
| try { |
| putBytes(where, value, start, len); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| len + " bytes:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Appends the count (1 - 8) less significant bytes from the |
| * specified ID value to the end of this buffer. |
| */ |
| public void addID(long value, int count) { |
| if ((count <= 0) || (count > 8)) |
| throw new TestBug("Illegal number bytes of ID value to add: " + count); |
| |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| |
| try { |
| putID(where, value, count); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of ID value:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Append four bytes from the specified int value to the |
| * end of this buffer. |
| */ |
| public void addInt(int value) { |
| final int count = JDWP.TypeSize.INT; |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| |
| try { |
| putInt(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of int value:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Append two bytes from the specified int value to the |
| * end of this buffer. |
| */ |
| public void addShort(short value) { |
| final int count = JDWP.TypeSize.SHORT; |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| try { |
| putShort(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of short value:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Appends eight bytes from the specified long |
| * value to the end of this buffer. |
| */ |
| public void addLong(long value) { |
| final int count = JDWP.TypeSize.LONG; |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| try { |
| putLong(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of long value:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Appends four bytes from the specified float |
| * value to the end of this buffer. |
| */ |
| public void addFloat(float value) { |
| final int count = JDWP.TypeSize.FLOAT; |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| try { |
| putFloat(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of float value:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Appends eight bytes from the specified double |
| * value to the end of this buffer. |
| */ |
| public void addDouble(double value) { |
| final int count = JDWP.TypeSize.DOUBLE; |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| try { |
| putDouble(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of double value:\n\t" + e); |
| }; |
| } |
| |
| /** |
| * Appends four bytes from the specified char |
| * value to the end of this buffer. |
| */ |
| public void addChar(char value) { |
| final int count = JDWP.TypeSize.CHAR; |
| final int where = CurrentSize; |
| addBytes(EMPTY_BYTE, count); |
| try { |
| putChar(where, value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while adding " + |
| count + " bytes of float value:\n\t" + e); |
| }; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Read a byte value from this buffer at the specified position. |
| * |
| * @throws BoundException if there are no bytes at this position |
| */ |
| public byte getByte(int off) throws BoundException { |
| if (off < 0 || off >= CurrentSize) { |
| throw new BoundException("Unable to get one byte at " + offsetString(off) + |
| ": no bytes available"); |
| } |
| return bytes[off]; |
| } |
| |
| /** |
| * Read count bytes (1-8) from this buffer at the specified |
| * position and returns a long value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public long getID(int off, int count) throws BoundException { |
| if ((count <= 0) || (count > 8)) |
| throw new TestBug("Illegal number of bytes of ID value to get: " + count); |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of ID value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| return getValueBytes(off, count); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of ID value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Read four bytes from this buffer at the specified |
| * position and returns an integer value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public int getInt(int off) throws BoundException { |
| final int count = JDWP.TypeSize.INT; |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of int value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| return (int)getValueBytes(off, count); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of int value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Read two bytes from this buffer at the specified |
| * position and returns a short value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public short getShort(int off) throws BoundException { |
| final int count = JDWP.TypeSize.SHORT; |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of short value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| return (short)getValueBytes(off, count); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of short value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Read eight bytes from this buffer at the specified |
| * position and returns a long value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public long getLong(int off) throws BoundException { |
| final int count = JDWP.TypeSize.LONG; |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of long value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| return getValueBytes(off, count); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of long value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Read eight bytes from this buffer at the specified |
| * position and returns a double value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public double getDouble(int off) throws BoundException { |
| final int count = JDWP.TypeSize.DOUBLE; |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of double value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| long value = getValueBytes(off, count); |
| return Double.longBitsToDouble(value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of long value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Read four bytes from this buffer at the specified |
| * position and returns a float value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public float getFloat(int off) throws BoundException { |
| final int count = JDWP.TypeSize.FLOAT; |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of float value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| int value = (int)getValueBytes(off, count); |
| return Float.intBitsToFloat(value); |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of float value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| /** |
| * Read two bytes from this buffer at the specified |
| * position and returns a char value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes at this position |
| */ |
| public char getChar(int off) throws BoundException { |
| final int count = JDWP.TypeSize.CHAR; |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to get " + count + " bytes of char value at " + |
| offsetString(off) + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| try { |
| int value = (int)getValueBytes(off, count); |
| return (char)value; |
| } |
| catch (BoundException e) { |
| throw new TestBug("Caught unexpected bound exception while getting " + |
| count + " bytes of char value at " + offsetString(off) + ":\n\t" + e); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Set the current parser position to 0. |
| */ |
| public void resetPosition() { |
| resetPosition(0); |
| } |
| |
| /** |
| * Set the current parser position to the specified value. |
| */ |
| public void resetPosition(int i) { |
| parseOffset = i; |
| } |
| |
| /** |
| * Return current parser position. |
| */ |
| public int currentPosition() { |
| return parseOffset; |
| } |
| |
| /** |
| * Return true if the parser pointer is set to the end of buffer. |
| */ |
| public boolean isParsed() { |
| return (parseOffset == CurrentSize); |
| } |
| |
| /** |
| * Read a byte value from this buffer at the current parser position. |
| * |
| * @throws BoundException if there are no more bytes in the buffer |
| */ |
| public byte getByte() throws BoundException { |
| return getByte(parseOffset++); |
| } |
| |
| /** |
| * Read count bytes (1-8) from this buffer at the current parser |
| * position and returns a long value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public long getID(int count) throws BoundException { |
| long value = getID(parseOffset, count); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Read four bytes from this buffer at the current parser |
| * position and returns an integer value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public int getInt() throws BoundException { |
| final int count = JDWP.TypeSize.INT; |
| int value = getInt(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Read two bytes from this buffer at the current parser |
| * position and returns a short value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public short getShort() throws BoundException { |
| final int count = JDWP.TypeSize.SHORT; |
| short value = getShort(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Read eight bytes from this buffer at the current parser |
| * position and returns a long value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public long getLong() throws BoundException { |
| final int count = JDWP.TypeSize.LONG; |
| long value = getLong(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Read eight bytes from this buffer at the current parser |
| * position and returns a double value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public double getDouble() throws BoundException { |
| final int count = JDWP.TypeSize.DOUBLE; |
| double value = getDouble(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Read four bytes from this buffer at the current parser |
| * position and returns a float value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public float getFloat() throws BoundException { |
| final int count = JDWP.TypeSize.FLOAT; |
| float value = getFloat(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Read two bytes from this buffer at the current parser |
| * position and returns a char value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public char getChar() throws BoundException { |
| final int count = JDWP.TypeSize.CHAR; |
| char value = getChar(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| |
| /** |
| * Remove at least first count bytes from the buffer. |
| */ |
| |
| public void deleteBytes(int count) { |
| int j = 0; |
| while (count < CurrentSize) |
| bytes[j++] = bytes[count++]; |
| |
| CurrentSize = j; |
| } |
| |
| /** |
| * Clear the buffer. |
| */ |
| public void resetBuffer() { |
| CurrentSize = 0; |
| } |
| |
| /** |
| * Return string representation of the buffer starting at given offset. |
| */ |
| public String toString(int start) { |
| |
| String Result = "", HexLine = "", DisplayLine = ""; |
| |
| int j = 0; |
| |
| for (int i = start; i < length(); i++) { |
| |
| HexLine = HexLine + toHexString(bytes[i], 2) + " "; |
| |
| String ch = "."; |
| if (bytes[i] >= 0x20 && bytes[i] < 0x80) { |
| try { |
| ch = new String(bytes, i, 1, "US-ASCII"); |
| } catch (UnsupportedEncodingException ignore) { |
| } |
| } |
| DisplayLine = DisplayLine + ch; |
| |
| if ((i == length() - 1) || (((i - start) & 0x0F) == 0x0F)) { |
| Result = Result + |
| " " + |
| toHexString(j, 4) + ": " + |
| PadR(HexLine, 48) + " " + |
| DisplayLine + "\n"; |
| HexLine = ""; |
| DisplayLine = ""; |
| j = j + 16; |
| } |
| } |
| return Result; |
| } |
| |
| /** |
| * Return string representation of the buffer. |
| */ |
| public String toString() { |
| return toString(0); |
| } |
| |
| /** |
| * Return string with hexadecimal representation of bytes. |
| */ |
| public static String toHexString(long b, int length) { |
| return Right(Long.toHexString(b), length).replace(' ', '0'); |
| } |
| |
| /** |
| * Return string with hexadecimal representation of bytes. |
| */ |
| public static String toHexDecString(long b, int length) { |
| return toHexString(b, length) + " (" + b + ")"; |
| } |
| |
| // ----- |
| |
| /** |
| * Return string with hexadecimal representation of offset. |
| */ |
| public static String offsetString(int off) { |
| return "0x" + toHexString(off, 4); |
| } |
| |
| /** |
| * Return string with hexadecimal representation of the current offset. |
| */ |
| public String offsetString() { |
| return offsetString(currentPosition()); |
| } |
| |
| // ----- |
| |
| /** |
| * Check if there space for new bytes in the buffer. |
| */ |
| protected void checkSpace(int space) { |
| |
| int newSize = CurrentSize + space; |
| |
| if (bytes.length >= newSize) |
| return; |
| |
| byte[] newBytes = new byte[newSize]; |
| |
| for (int i = 0; i < CurrentSize; i++) |
| newBytes[i] = bytes[i]; |
| |
| bytes = newBytes; |
| } |
| |
| /** |
| * Replace count (1 - 8) bytes starting at offset off with the less |
| * significant bytes from the specified long value. |
| * |
| * @throws BoundException if offset and count are out of buffer bounds |
| */ |
| protected void putValueBytes(int off, long value, int count) throws BoundException { |
| if ((count <= 0) || (count > 8)) |
| throw new TestBug("Illegal number of bytes of value to put: " + count); |
| |
| if (count > CurrentSize - off) { |
| throw new BoundException("Unable to put " + count + " bytes of value at " + |
| off + " (available bytes: " + (CurrentSize - off) + ")" ); |
| } |
| |
| int shift = (count - 1) * 8; |
| for (int i = 0; i < count; i++) { |
| putByte(off++, (byte) ((value >>> shift) & 0xFF)); |
| shift = shift - 8; |
| } |
| } |
| /** |
| * Appends the count (1 - 8) less significant bytes from the |
| * specified long value to the end of this buffer. |
| */ |
| protected void addValueBytes(long value, int count) throws BoundException { |
| if ((count <= 0) || (count > 8)) |
| throw new TestBug("Illegal number of bytes of value to add: " + count); |
| |
| checkSpace(count); |
| |
| int where = CurrentSize; |
| CurrentSize += count; |
| |
| putValueBytes(where, value, count); |
| } |
| |
| /** |
| * Read count bytes (1-8) from this buffer at the specified |
| * position and returns a long value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| public long getValueBytes(int off, int count) throws BoundException { |
| if ((count <= 0) || (count > 8)) |
| throw new TestBug("Illegal number of bytes of value to get: " + count); |
| |
| long l = 0; |
| |
| for (int i = 0; i < count; i++) { |
| l = (l * 0x100) + ((long) getByte(off + i) & 0xFF); |
| } |
| |
| return l; |
| } |
| |
| /** |
| * Read count bytes (1-8) from this buffer at the current parser |
| * position and returns a long value composed of these bytes. |
| * |
| * @throws BoundException if there are no so many bytes in the buffer |
| */ |
| /* |
| protected long getValueBytes(int count) throws BoundException { |
| long value = getValueBytes(parseOffset); |
| parseOffset += count; |
| return value; |
| } |
| */ |
| |
| // --- |
| |
| private static String PadL(String source, int length, String what) { |
| |
| if (length <= 0) |
| return ""; |
| |
| if (source.length() > length) |
| return PadL("", length, "*"); |
| |
| while (source.length() < length) |
| source = what + source; |
| |
| return source; |
| } |
| |
| |
| private static String PadL(String source, int length) { |
| return PadL(source, length, " "); |
| } |
| |
| private static String PadR(String source, int length, String what) { |
| |
| if (length <= 0) |
| return ""; |
| |
| if (source.length() > length) |
| return PadR("", length, "*"); |
| |
| while (source.length() < length) |
| source = source + what; |
| |
| return source; |
| } |
| |
| private static String PadR(String source, int length) { |
| return PadR(source, length, " "); |
| } |
| |
| private static String Left(String source, int length) { |
| |
| if (length <= 0) |
| return ""; |
| |
| if (length <= source.length()) |
| return source.substring(0, length); |
| else |
| return PadR(source, length); |
| } |
| |
| private static String Right(String source, int length) { |
| |
| if (length <= 0) |
| return ""; |
| |
| if (length <= source.length()) |
| return source.substring(source.length() - length, source.length()); |
| else |
| return PadL(source, length); |
| } |
| |
| } |
