mirror of
https://github.com/dmolony/DiskBrowser.git
synced 2024-09-25 10:55:45 +00:00
354 lines
12 KiB
Java
Executable File
354 lines
12 KiB
Java
Executable File
package com.bytezone.diskbrowser.utilities;
|
|
|
|
// -----------------------------------------------------------------------------------//
|
|
public class HexFormatter
|
|
// -----------------------------------------------------------------------------------//
|
|
{
|
|
private static String[] hex =
|
|
{ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format (byte[] buffer)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return format (buffer, 0, buffer.length);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String formatNoHeader (byte[] buffer)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return formatNoHeader (buffer, 0, buffer.length);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format (byte[] buffer, int offset, int length)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return format (buffer, offset, length, true, 0);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format (byte[] buffer, int offset, int length, int startingAddress)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return format (buffer, offset, length, true, startingAddress);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String formatNoHeader (byte[] buffer, int offset, int length)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return format (buffer, offset, length, false, 0);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String formatNoHeader (byte[] buffer, int offset, int length,
|
|
int startingAddress)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return format (buffer, offset, length, false, startingAddress);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format (byte[] buffer, int offset, int length, boolean header,
|
|
int startingAddress)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder line = new StringBuilder ();
|
|
int[] freq = new int[256];
|
|
boolean startedOnBoundary = offset % 0x100 == 0;
|
|
|
|
if (header)
|
|
{
|
|
line.append (" ");
|
|
for (int i = 0; i < 16; i++)
|
|
line.append (" " + hex[i]);
|
|
if (offset == 0)
|
|
line.append ("\n");
|
|
}
|
|
|
|
for (int i = offset; i < offset + length; i += 16)
|
|
{
|
|
if (line.length () > 0 && i > 0)
|
|
line.append ("\n");
|
|
if (i > offset && startedOnBoundary && (i % 0x200) == 0)
|
|
line.append ("\n");
|
|
|
|
// print offset
|
|
line.append (String.format ("%05X : ", (startingAddress + i - offset)));
|
|
|
|
// print hex values
|
|
StringBuffer trans = new StringBuffer ();
|
|
StringBuffer hexLine = new StringBuffer ();
|
|
|
|
int max = Math.min (i + 16, offset + length);
|
|
max = Math.min (max, buffer.length);
|
|
for (int j = i; j < max; j++)
|
|
{
|
|
int c = buffer[j] & 0xFF;
|
|
freq[c]++;
|
|
hexLine.append (String.format ("%02X ", c));
|
|
|
|
if (c > 127)
|
|
{
|
|
if (c < 160)
|
|
c -= 64;
|
|
else
|
|
c -= 128;
|
|
}
|
|
if (c < 32 || c == 127) // non-printable
|
|
trans.append (".");
|
|
else // standard ascii
|
|
trans.append ((char) c);
|
|
}
|
|
while (hexLine.length () < 48)
|
|
hexLine.append (" ");
|
|
|
|
line.append (hexLine.toString () + ": " + trans.toString ());
|
|
}
|
|
|
|
if (false)
|
|
{
|
|
line.append ("\n\n");
|
|
int totalBits = 0;
|
|
for (int i = 0; i < freq.length; i++)
|
|
if (freq[i] > 0)
|
|
{
|
|
totalBits += (Integer.bitCount (i) * freq[i]);
|
|
line.append (
|
|
String.format ("%02X %3d %d%n", i, freq[i], Integer.bitCount (i)));
|
|
}
|
|
line.append (String.format ("%nTotal bits : %d%n", totalBits));
|
|
}
|
|
return line.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String sanitiseString (byte[] buffer, int offset, int length)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder trans = new StringBuilder ();
|
|
for (int j = offset; j < offset + length; j++)
|
|
{
|
|
int c = buffer[j] & 0xFF;
|
|
|
|
if (c > 127)
|
|
{
|
|
if (c < 160)
|
|
c -= 64;
|
|
else
|
|
c -= 128;
|
|
}
|
|
|
|
if (c < 32 || c == 127) // non-printable
|
|
trans.append (".");
|
|
else
|
|
trans.append ((char) c); // standard ascii
|
|
}
|
|
return trans.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getString (byte[] buffer)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return getString (buffer, 0, buffer.length);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getString (byte[] buffer, int offset, int length)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder text = new StringBuilder ();
|
|
|
|
for (int i = offset; i < offset + length; i++)
|
|
{
|
|
int c = buffer[i] & 0xFF;
|
|
if (c > 127)
|
|
{
|
|
if (c < 160)
|
|
c -= 64;
|
|
else
|
|
c -= 128;
|
|
}
|
|
if (c == 13)
|
|
text.append ("\n");
|
|
else if (c < 32) // non-printable
|
|
text.append (".");
|
|
else // standard ascii
|
|
text.append ((char) c);
|
|
}
|
|
return text.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getString2 (byte[] buffer, int offset, int length)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder text = new StringBuilder ();
|
|
|
|
for (int i = offset; i < offset + length; i++)
|
|
{
|
|
int c = buffer[i] & 0xFF;
|
|
if (c == 136)
|
|
{
|
|
if (text.length () > 0)
|
|
text.deleteCharAt (text.length () - 1);
|
|
continue;
|
|
}
|
|
if (c > 127)
|
|
{
|
|
if (c < 160)
|
|
c -= 64;
|
|
else
|
|
c -= 128;
|
|
}
|
|
if (c < 32) // non-printable
|
|
text.append ((char) (c + 64));
|
|
else // standard ascii
|
|
text.append ((char) c);
|
|
}
|
|
return text.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getHexString (byte[] buffer, int offset, int length)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return getHexString (buffer, offset, length, true);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getHexString (byte[] buffer)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return getHexString (buffer, 0, buffer.length);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getHexString (byte[] buffer, int offset, int length, boolean space)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder hex = new StringBuilder ();
|
|
|
|
int max = Math.min (offset + length, buffer.length);
|
|
for (int i = offset; i < max; i++)
|
|
{
|
|
hex.append (String.format ("%02X", buffer[i]));
|
|
if (space)
|
|
hex.append (' ');
|
|
}
|
|
|
|
if (length > 0 && space)
|
|
hex.deleteCharAt (hex.length () - 1);
|
|
|
|
return hex.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getHexStringReversed (byte[] buffer, int offset, int length,
|
|
boolean space)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder hex = new StringBuilder ();
|
|
for (int i = length - 1; i >= 0; i--)
|
|
{
|
|
hex.append (String.format ("%02X", buffer[offset + i]));
|
|
if (space)
|
|
hex.append (' ');
|
|
}
|
|
if (length > 0 && space)
|
|
hex.deleteCharAt (hex.length () - 1);
|
|
return hex.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getBitString (byte b)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
String s = "0000000" + Integer.toBinaryString (b & 0xFF);
|
|
s = s.replaceAll ("0", ".");
|
|
return s.substring (s.length () - 8);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static char byteValue (byte b)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int c = b & 0xFF;
|
|
if (c > 127)
|
|
c -= 128;
|
|
if (c > 95)
|
|
c -= 64;
|
|
if (c < 32) // non-printable
|
|
return '.';
|
|
return (char) c; // standard ascii
|
|
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format4 (int value)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
if (value < 0)
|
|
return "***err**";
|
|
|
|
StringBuilder text = new StringBuilder ();
|
|
for (int i = 0, weight = 4096; i < 4; i++)
|
|
{
|
|
int digit = value / weight;
|
|
if (digit < 0 || digit > 15)
|
|
return "***err**";
|
|
text.append (hex[digit]);
|
|
value %= weight;
|
|
weight /= 16;
|
|
}
|
|
|
|
return text.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format3 (int value)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return format4 (value).substring (1);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format2 (int value)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
if (value < 0)
|
|
value += 256;
|
|
|
|
return hex[value / 16] + hex[value % 16];
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String format1 (int value)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return hex[value];
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getPascalString (byte[] buffer, int offset)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int length = buffer[offset] & 0xFF;
|
|
return HexFormatter.getString (buffer, offset + 1, length);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static String getCString (byte[] buffer, int offset)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int end = offset;
|
|
while (buffer[end] != 0)
|
|
end++;
|
|
|
|
return HexFormatter.getString (buffer, offset, end - offset);
|
|
}
|
|
}
|