2002-01-30 21:22:28 -05:00
|
|
|
|
|
|
|
/* ====================================================================
|
2004-04-09 09:05:39 -04:00
|
|
|
Copyright 2002-2004 Apache Software Foundation
|
|
|
|
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
you may not use this file except in compliance with the License.
|
|
|
|
You may obtain a copy of the License at
|
|
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
See the License for the specific language governing permissions and
|
|
|
|
limitations under the License.
|
|
|
|
==================================================================== */
|
|
|
|
|
2002-01-30 21:22:28 -05:00
|
|
|
|
|
|
|
package org.apache.poi.util;
|
|
|
|
|
|
|
|
import java.io.*;
|
2003-08-30 05:05:19 -04:00
|
|
|
import java.text.DecimalFormat;
|
2002-01-30 21:22:28 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dump data in hexadecimal format; derived from a HexDump utility I
|
2002-02-09 23:32:07 -05:00
|
|
|
* wrote in June 2001.
|
2002-01-30 21:22:28 -05:00
|
|
|
*
|
|
|
|
* @author Marc Johnson
|
2002-02-09 23:32:07 -05:00
|
|
|
* @author Glen Stampoultzis (glens at apache.org)
|
2002-01-30 21:22:28 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
public class HexDump
|
|
|
|
{
|
2003-06-30 08:20:55 -04:00
|
|
|
public static final String EOL =
|
|
|
|
System.getProperty("line.separator");
|
|
|
|
// private static final StringBuffer _lbuffer = new StringBuffer(8);
|
|
|
|
// private static final StringBuffer _cbuffer = new StringBuffer(2);
|
|
|
|
private static final char _hexcodes[] =
|
|
|
|
{
|
|
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
|
|
|
|
'E', 'F'
|
|
|
|
};
|
|
|
|
private static final int _shifts[] =
|
|
|
|
{
|
2003-08-30 05:05:19 -04:00
|
|
|
60, 56, 52, 48, 44, 40, 36, 32, 28, 24, 20, 16, 12, 8, 4, 0
|
2003-06-30 08:20:55 -04:00
|
|
|
};
|
|
|
|
|
2002-01-30 21:22:28 -05:00
|
|
|
|
|
|
|
// all static methods, so no need for a public constructor
|
|
|
|
private HexDump()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dump an array of bytes to an OutputStream
|
|
|
|
*
|
|
|
|
* @param data the byte array to be dumped
|
|
|
|
* @param offset its offset, whatever that might mean
|
|
|
|
* @param stream the OutputStream to which the data is to be
|
|
|
|
* written
|
|
|
|
* @param index initial index into the byte array
|
2002-06-09 08:48:34 -04:00
|
|
|
* @param length number of characters to output
|
2002-01-30 21:22:28 -05:00
|
|
|
*
|
|
|
|
* @exception IOException is thrown if anything goes wrong writing
|
|
|
|
* the data to stream
|
|
|
|
* @exception ArrayIndexOutOfBoundsException if the index is
|
|
|
|
* outside the data array's bounds
|
|
|
|
* @exception IllegalArgumentException if the output stream is
|
|
|
|
* null
|
|
|
|
*/
|
2002-02-09 23:32:07 -05:00
|
|
|
public synchronized static void dump(final byte [] data, final long offset,
|
2002-06-09 08:48:34 -04:00
|
|
|
final OutputStream stream, final int index, final int length)
|
|
|
|
throws IOException, ArrayIndexOutOfBoundsException,
|
|
|
|
IllegalArgumentException
|
2002-01-30 21:22:28 -05:00
|
|
|
{
|
2004-08-09 22:59:52 -04:00
|
|
|
if (data.length == 0)
|
|
|
|
{
|
|
|
|
stream.write( "No Data".getBytes() );
|
|
|
|
stream.flush();
|
|
|
|
return;
|
|
|
|
}
|
2002-01-30 21:22:28 -05:00
|
|
|
if ((index < 0) || (index >= data.length))
|
|
|
|
{
|
|
|
|
throw new ArrayIndexOutOfBoundsException(
|
|
|
|
"illegal index: " + index + " into array of length "
|
|
|
|
+ data.length);
|
|
|
|
}
|
|
|
|
if (stream == null)
|
|
|
|
{
|
|
|
|
throw new IllegalArgumentException("cannot write to nullstream");
|
|
|
|
}
|
2004-08-09 22:59:52 -04:00
|
|
|
|
2002-01-30 21:22:28 -05:00
|
|
|
long display_offset = offset + index;
|
|
|
|
StringBuffer buffer = new StringBuffer(74);
|
|
|
|
|
2002-06-09 08:48:34 -04:00
|
|
|
|
|
|
|
int data_length = Math.min(data.length,index+length);
|
|
|
|
for (int j = index; j < data_length; j += 16)
|
2002-01-30 21:22:28 -05:00
|
|
|
{
|
2002-06-09 08:48:34 -04:00
|
|
|
int chars_read = data_length - j;
|
2002-01-30 21:22:28 -05:00
|
|
|
|
|
|
|
if (chars_read > 16)
|
|
|
|
{
|
|
|
|
chars_read = 16;
|
|
|
|
}
|
2002-09-01 22:08:31 -04:00
|
|
|
buffer.append(
|
|
|
|
dump(display_offset)
|
|
|
|
).append(' ');
|
2002-01-30 21:22:28 -05:00
|
|
|
for (int k = 0; k < 16; k++)
|
|
|
|
{
|
|
|
|
if (k < chars_read)
|
|
|
|
{
|
|
|
|
buffer.append(dump(data[ k + j ]));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buffer.append(" ");
|
|
|
|
}
|
|
|
|
buffer.append(' ');
|
|
|
|
}
|
|
|
|
for (int k = 0; k < chars_read; k++)
|
|
|
|
{
|
|
|
|
if ((data[ k + j ] >= ' ') && (data[ k + j ] < 127))
|
|
|
|
{
|
|
|
|
buffer.append(( char ) data[ k + j ]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buffer.append('.');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
buffer.append(EOL);
|
|
|
|
stream.write(buffer.toString().getBytes());
|
|
|
|
stream.flush();
|
|
|
|
buffer.setLength(0);
|
|
|
|
display_offset += chars_read;
|
|
|
|
}
|
2002-06-09 08:48:34 -04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dump an array of bytes to an OutputStream
|
|
|
|
*
|
|
|
|
* @param data the byte array to be dumped
|
|
|
|
* @param offset its offset, whatever that might mean
|
|
|
|
* @param stream the OutputStream to which the data is to be
|
|
|
|
* written
|
|
|
|
* @param index initial index into the byte array
|
|
|
|
*
|
|
|
|
* @exception IOException is thrown if anything goes wrong writing
|
|
|
|
* the data to stream
|
|
|
|
* @exception ArrayIndexOutOfBoundsException if the index is
|
|
|
|
* outside the data array's bounds
|
|
|
|
* @exception IllegalArgumentException if the output stream is
|
|
|
|
* null
|
|
|
|
*/
|
|
|
|
|
|
|
|
public synchronized static void dump(final byte [] data, final long offset,
|
|
|
|
final OutputStream stream, final int index)
|
|
|
|
throws IOException, ArrayIndexOutOfBoundsException,
|
|
|
|
IllegalArgumentException
|
|
|
|
{
|
|
|
|
dump(data, offset, stream, index, data.length-index);
|
2002-01-30 21:22:28 -05:00
|
|
|
}
|
|
|
|
|
2002-04-29 21:05:49 -04:00
|
|
|
/**
|
|
|
|
* dump an array of bytes to a String
|
|
|
|
*
|
|
|
|
* @param data the byte array to be dumped
|
|
|
|
* @param offset its offset, whatever that might mean
|
|
|
|
* @param index initial index into the byte array
|
|
|
|
*
|
|
|
|
* @exception ArrayIndexOutOfBoundsException if the index is
|
|
|
|
* outside the data array's bounds
|
|
|
|
* @return output string
|
|
|
|
*/
|
|
|
|
|
|
|
|
public static String dump(final byte [] data, final long offset,
|
|
|
|
final int index) {
|
|
|
|
StringBuffer buffer;
|
|
|
|
if ((index < 0) || (index >= data.length))
|
|
|
|
{
|
|
|
|
throw new ArrayIndexOutOfBoundsException(
|
|
|
|
"illegal index: " + index + " into array of length "
|
|
|
|
+ data.length);
|
|
|
|
}
|
|
|
|
long display_offset = offset + index;
|
|
|
|
buffer = new StringBuffer(74);
|
|
|
|
|
|
|
|
for (int j = index; j < data.length; j += 16)
|
|
|
|
{
|
|
|
|
int chars_read = data.length - j;
|
|
|
|
|
|
|
|
if (chars_read > 16)
|
|
|
|
{
|
|
|
|
chars_read = 16;
|
|
|
|
}
|
|
|
|
buffer.append(dump(display_offset)).append(' ');
|
|
|
|
for (int k = 0; k < 16; k++)
|
|
|
|
{
|
|
|
|
if (k < chars_read)
|
|
|
|
{
|
|
|
|
buffer.append(dump(data[ k + j ]));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buffer.append(" ");
|
|
|
|
}
|
|
|
|
buffer.append(' ');
|
|
|
|
}
|
|
|
|
for (int k = 0; k < chars_read; k++)
|
|
|
|
{
|
|
|
|
if ((data[ k + j ] >= ' ') && (data[ k + j ] < 127))
|
|
|
|
{
|
|
|
|
buffer.append(( char ) data[ k + j ]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buffer.append('.');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
buffer.append(EOL);
|
|
|
|
display_offset += chars_read;
|
|
|
|
}
|
|
|
|
return buffer.toString();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-09-01 22:08:31 -04:00
|
|
|
private static String dump(final long value)
|
2002-01-30 21:22:28 -05:00
|
|
|
{
|
2003-06-30 08:20:55 -04:00
|
|
|
StringBuffer buf = new StringBuffer();
|
|
|
|
buf.setLength(0);
|
2002-01-30 21:22:28 -05:00
|
|
|
for (int j = 0; j < 8; j++)
|
|
|
|
{
|
2004-04-11 22:25:15 -04:00
|
|
|
buf.append( _hexcodes[ (( int ) (value >> _shifts[ j + _shifts.length - 8 ])) & 15 ]);
|
2002-01-30 21:22:28 -05:00
|
|
|
}
|
2003-06-30 08:20:55 -04:00
|
|
|
return buf.toString();
|
2002-01-30 21:22:28 -05:00
|
|
|
}
|
|
|
|
|
2002-09-01 22:08:31 -04:00
|
|
|
private static String dump(final byte value)
|
2002-01-30 21:22:28 -05:00
|
|
|
{
|
2003-06-30 08:20:55 -04:00
|
|
|
StringBuffer buf = new StringBuffer();
|
|
|
|
buf.setLength(0);
|
2002-01-30 21:22:28 -05:00
|
|
|
for (int j = 0; j < 2; j++)
|
|
|
|
{
|
2003-06-30 08:20:55 -04:00
|
|
|
buf.append(_hexcodes[ (value >> _shifts[ j + 6 ]) & 15 ]);
|
2002-01-30 21:22:28 -05:00
|
|
|
}
|
2003-06-30 08:20:55 -04:00
|
|
|
return buf.toString();
|
2002-01-30 21:22:28 -05:00
|
|
|
}
|
2002-02-09 23:32:07 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts the parameter to a hex value.
|
|
|
|
*
|
|
|
|
* @param value The value to convert
|
2002-04-19 18:30:50 -04:00
|
|
|
* @return A String representing the array of bytes
|
|
|
|
*/
|
|
|
|
public static String toHex(final byte[] value)
|
|
|
|
{
|
|
|
|
StringBuffer retVal = new StringBuffer();
|
|
|
|
retVal.append('[');
|
|
|
|
for(int x = 0; x < value.length; x++)
|
|
|
|
{
|
|
|
|
retVal.append(toHex(value[x]));
|
|
|
|
retVal.append(", ");
|
|
|
|
}
|
|
|
|
retVal.append(']');
|
|
|
|
return retVal.toString();
|
|
|
|
}
|
2003-06-30 08:20:55 -04:00
|
|
|
|
2003-08-23 10:49:35 -04:00
|
|
|
/**
|
|
|
|
* <p>Converts the parameter to a hex value breaking the results into
|
|
|
|
* lines.</p>
|
|
|
|
*
|
|
|
|
* @param value The value to convert
|
|
|
|
* @param bytesPerLine The maximum number of bytes per line. The next byte
|
|
|
|
* will be written to a new line
|
|
|
|
* @return A String representing the array of bytes
|
|
|
|
*/
|
|
|
|
public static String toHex(final byte[] value, final int bytesPerLine)
|
|
|
|
{
|
2003-08-30 05:05:19 -04:00
|
|
|
final int digits =
|
|
|
|
(int) Math.round(Math.log(value.length) / Math.log(10) + 0.5);
|
|
|
|
final StringBuffer formatString = new StringBuffer();
|
|
|
|
for (int i = 0; i < digits; i++)
|
|
|
|
formatString.append('0');
|
|
|
|
formatString.append(": ");
|
|
|
|
final DecimalFormat format = new DecimalFormat(formatString.toString());
|
2003-08-23 10:49:35 -04:00
|
|
|
StringBuffer retVal = new StringBuffer();
|
2003-08-30 05:05:19 -04:00
|
|
|
retVal.append(format.format(0));
|
2003-08-23 10:49:35 -04:00
|
|
|
int i = -1;
|
|
|
|
for(int x = 0; x < value.length; x++)
|
|
|
|
{
|
|
|
|
if (++i == bytesPerLine)
|
|
|
|
{
|
2003-08-30 05:05:19 -04:00
|
|
|
retVal.append('\n');
|
|
|
|
retVal.append(format.format(x));
|
2003-08-23 10:49:35 -04:00
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
retVal.append(toHex(value[x]));
|
|
|
|
retVal.append(", ");
|
|
|
|
}
|
|
|
|
return retVal.toString();
|
|
|
|
}
|
|
|
|
|
2002-04-19 18:30:50 -04:00
|
|
|
/**
|
|
|
|
* Converts the parameter to a hex value.
|
|
|
|
*
|
|
|
|
* @param value The value to convert
|
2002-02-09 23:32:07 -05:00
|
|
|
* @return The result right padded with 0
|
|
|
|
*/
|
|
|
|
public static String toHex(final short value)
|
|
|
|
{
|
|
|
|
return toHex(value, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts the parameter to a hex value.
|
|
|
|
*
|
|
|
|
* @param value The value to convert
|
|
|
|
* @return The result right padded with 0
|
|
|
|
*/
|
|
|
|
public static String toHex(final byte value)
|
|
|
|
{
|
|
|
|
return toHex(value, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts the parameter to a hex value.
|
|
|
|
*
|
|
|
|
* @param value The value to convert
|
|
|
|
* @return The result right padded with 0
|
|
|
|
*/
|
|
|
|
public static String toHex(final int value)
|
|
|
|
{
|
|
|
|
return toHex(value, 8);
|
|
|
|
}
|
|
|
|
|
2003-08-30 05:05:19 -04:00
|
|
|
/**
|
|
|
|
* Converts the parameter to a hex value.
|
|
|
|
*
|
|
|
|
* @param value The value to convert
|
|
|
|
* @return The result right padded with 0
|
|
|
|
*/
|
|
|
|
public static String toHex(final long value)
|
|
|
|
{
|
|
|
|
return toHex(value, 16);
|
|
|
|
}
|
|
|
|
|
2002-02-09 23:32:07 -05:00
|
|
|
|
|
|
|
private static String toHex(final long value, final int digits)
|
|
|
|
{
|
|
|
|
StringBuffer result = new StringBuffer(digits);
|
|
|
|
for (int j = 0; j < digits; j++)
|
|
|
|
{
|
2003-08-30 05:05:19 -04:00
|
|
|
result.append( _hexcodes[ (int) ((value >> _shifts[ j + (16 - digits) ]) & 15)]);
|
2002-02-09 23:32:07 -05:00
|
|
|
}
|
|
|
|
return result.toString();
|
|
|
|
}
|
2003-06-30 08:20:55 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Dumps <code>bytesToDump</code> bytes to an output stream.
|
|
|
|
*
|
|
|
|
* @param in The stream to read from
|
|
|
|
* @param out The output stream
|
|
|
|
* @param start The index to use as the starting position for the left hand side label
|
|
|
|
* @param bytesToDump The number of bytes to output. Use -1 to read until the end of file.
|
|
|
|
*/
|
|
|
|
public static void dump( InputStream in, PrintStream out, int start, int bytesToDump ) throws IOException
|
|
|
|
{
|
|
|
|
ByteArrayOutputStream buf = new ByteArrayOutputStream();
|
|
|
|
if (bytesToDump == -1)
|
|
|
|
{
|
|
|
|
int c = in.read();
|
|
|
|
while (c != -1)
|
|
|
|
{
|
|
|
|
buf.write(c);
|
|
|
|
c = in.read();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int bytesRemaining = bytesToDump;
|
|
|
|
while (bytesRemaining-- > 0)
|
|
|
|
{
|
|
|
|
int c = in.read();
|
|
|
|
if (c == -1)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
buf.write(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
byte[] data = buf.toByteArray();
|
|
|
|
dump(data, 0, out, start, data.length);
|
|
|
|
}
|
2002-01-30 21:22:28 -05:00
|
|
|
}
|