// A little endian byte is the same as a big endian byte. But since we
// can't write a method with the identifier byte() [byte is a type], we
// use littleEndianByte()
public static String littleEndianByte(String immediateOperand) {
String littleEndianResult = littleEndianDword(immediateOperand);
if (!(littleEndianResult.endsWith("000000") || littleEndianResult.endsWith("ffffff"))) {
return "ERROR";
}
return StrTools2.slice(littleEndianResult, 0, 2);
}
public static String convertBinStringToHexPairs(String binaryString) {
int maxLength = binaryString.length();
Map<String, Character> binToHexMapping = new HashMap<String, Character>();
binToHexMapping.put("0000", '0');
binToHexMapping.put("0001", '1');
binToHexMapping.put("0010", '2');
binToHexMapping.put("0011", '3');
binToHexMapping.put("0100", '4');
binToHexMapping.put("0101", '5');
binToHexMapping.put("0110", '6');
binToHexMapping.put("0111", '7');
binToHexMapping.put("1000", '8');
binToHexMapping.put("1001", '9');
binToHexMapping.put("1010", 'a');
binToHexMapping.put("1011", 'b');
binToHexMapping.put("1100", 'c');
binToHexMapping.put("1101", 'd');
binToHexMapping.put("1110", 'e');
binToHexMapping.put("1111", 'f');
String hexOutput = "";
for (int i = 0; i < maxLength; i += 4) {
String binaryChunk = StrTools2.slice(binaryString, i, i + 4);
hexOutput += binToHexMapping.get(binaryChunk);
}
return hexOutput;
}
public static String littleEndianDword(int integer) {
boolean isNegative = false;
if (integer < 0) isNegative = true;
String unsignedHexString;
// .toHexString() automatically unsigns the integer. It will never
// return a negative hexadecimal number.
unsignedHexString = Integer.toHexString(integer);
// We can't return numbers wider than a DWORD
if (unsignedHexString.length() > 8) return "ERROR";
// We do not need to append 'f' to the beginning of the unsigned
// hex string. Java does that for us.
if (!isNegative) {
while (unsignedHexString.length() < 8) {
unsignedHexString = '0' + unsignedHexString;
}
}
String littleEndianResult =
StrTools2.slice(unsignedHexString, 6, 8)
+ StrTools2.slice(unsignedHexString, 4, 6)
+ StrTools2.slice(unsignedHexString, 2, 4)
+ StrTools2.slice(unsignedHexString, 0, 2);
return littleEndianResult;
}
public static byte[] hexToBytes(String hexString) throws MintException {
if (!isEven(hexString.length())) {
throw new MintException(
"While trying to convert a hex string to bytes,\n"
+ "the number of hex digits is not divisible by 2."
+ "\n\n(Hex pairs are needed)");
}
int elements = hexString.length() / 2;
byte[] byteArray = new byte[elements];
int y = 0;
for (int x = 0; x < elements; x++) {
String hexPair = StrTools2.slice(hexString, y, y + 2);
byte currentByte = (byte) Integer.parseInt(hexPair, 16);
byteArray[x] = currentByte;
y += 2;
}
return byteArray;
}
public static String littleEndianDword(String immediateOperand) {
if (immediateOperand.equals("-0")) return "00000000";
boolean isNegative = false;
if (immediateOperand.startsWith("-")) {
isNegative = true;
} else if (immediateOperand.startsWith("+")) {
// If the user idiotically put an unnecessary plus sign in front of
// the number, accept it anyways.
immediateOperand = StrTools2.slice(immediateOperand, 1);
}
String unsignedHexString;
if (isNegative) {
int signedNumber = 0;
try {
signedNumber = Integer.parseInt(immediateOperand, 16);
} catch (NumberFormatException exceptionInfo) {
return "ERROR";
}
// .toHexString() automatically unsigns the integer. It will never
// return a negative hexadecimal number.
unsignedHexString = Integer.toHexString(signedNumber);
// We can't return numbers wider than a DWORD
if (unsignedHexString.length() > 8) return "ERROR";
// We do not need to append 'f' to the beginning of the unsigned
// hex string. Java does that for us.
} else {
// The number we got must be positive.
if (immediateOperand.length() > 8) {
// This number is too long. Slice off the leading zeroes.
while (immediateOperand.startsWith("0") && immediateOperand.length() > 8) {
immediateOperand = StrTools2.slice(immediateOperand, 1);
}
// Even after all that work, we see that the number is not
// full of leading zeroes but instead just doesn't fit into a
// dword.
if (immediateOperand.length() > 8) return "ERROR";
}
while (immediateOperand.length() < 8) {
// Zero extend the positive number.
immediateOperand = "0" + immediateOperand;
}
unsignedHexString = immediateOperand;
}
String littleEndianResult =
StrTools2.slice(unsignedHexString, 6, 8)
+ StrTools2.slice(unsignedHexString, 4, 6)
+ StrTools2.slice(unsignedHexString, 2, 4)
+ StrTools2.slice(unsignedHexString, 0, 2);
return littleEndianResult;
}
