public int DecodeASMToFile(string inputFilename, string outputFilename, bool littleEndian, bool useRegAliases, uint pc)
{
ClearErrorText();
BinaryReader reader = null;
StreamWriter writer = null;
try
{
reader = new BinaryReader(File.Open(inputFilename, FileMode.Open));
writer = new StreamWriter(outputFilename, false, Encoding.ASCII);
}
catch (Exception)
{
return(ASMFileDecoderResult.FileOpenError);
}
long length = reader.BaseStream.Length;
int result = ASMFileDecoderResult.Success;
try
{
int charPos = 0;
while (charPos < length)
{
charPos += 4;
uint line = reader.ReadUInt32();
if (!littleEndian)
{
line = ASMValueHelper.ReverseBytes(line);
}
string displayHex = ASMValueHelper.UnsignedToHex_WithLength(line, 8);
string instruction = DecodeASMSingle(line, pc, useRegAliases);
StringBuilder sb = new StringBuilder();
sb.Append(ASMValueHelper.UnsignedToHex_WithLength(pc, 8).ToLower());
sb.Append(": ");
sb.Append(displayHex);
sb.Append(" ");
sb.Append(instruction);
writer.WriteLine(sb.ToString());
pc += 4;
}
}
catch
{
result = ASMFileDecoderResult.ASMDecodeError;
}
finally
{
reader.Close();
writer.Close();
}
return(result);
}
public string ReplaceLabelsInHex(string hex, bool littleEndian)
{
string result = hex.ToUpper();
foreach (string label in LabelDict.Keys)
{
uint labelValue = LabelToUnsigned(label);
labelValue = littleEndian ? ASMValueHelper.ReverseBytes(labelValue) : labelValue;
string labelHex = ASMValueHelper.UnsignedToHex_WithLength(labelValue, 8).ToUpper();
result = result.Replace(label, labelHex);
}
return(result);
}
public ASMDecoderResult DecodeASM(string hex, uint pc, string spacePadding, bool littleEndian, bool includeAddress, bool useRegAliases, bool clearErrorText)
{
if (clearErrorText)
{
ClearErrorText();
}
//string[] lines = hex.Split('\n');
//lines = ASMStringHelper.RemoveFromLines(lines, "\r");
string[] lines = ASMValueHelper.GetHexLines(hex);
StringBuilder sb = new StringBuilder();
foreach (string line in lines)
{
if (string.IsNullOrEmpty(line))
{
continue;
}
string strAddress = "[0x" + ASMValueHelper.UnsignedToHex_WithLength(pc, 8) + "] ";
string strPrefix = (includeAddress ? strAddress : "") + spacePadding;
string modLine = line.Replace(" ", "").Replace("\t", "");
try
{
uint uLine = Convert.ToUInt32(modLine, 16);
if (littleEndian)
{
uLine = ASMValueHelper.ReverseBytes(uLine);
}
string decodedLine = TryDecodeSingle(uLine, pc, useRegAliases);
sb.Append(strPrefix);
sb.Append(decodedLine);
sb.Append("\r\n");
pc += 4;
}
catch (Exception ex)
{
_errorTextBuilder.AppendLine("FAILED TO DECODE LINE: " + line + " (" + ex.Message + ")");
}
}
return(new ASMDecoderResult(sb.ToString(), _errorTextBuilder.ToString()));
}
public string ReplaceLabelsInHex(string hex, bool littleEndian, bool replaceAll = false)
{
string result = hex.ToUpper();
List <string> labels = new List <string>(LabelDict.Keys);
labels.Sort((a, b) => a.Length.CompareTo(b.Length));
labels.Reverse();
foreach (string label in labels)
{
uint labelValue = LabelToUnsigned(label);
labelValue = littleEndian ? ASMValueHelper.ReverseBytes(labelValue) : labelValue;
string labelHex = ASMValueHelper.UnsignedToHex_WithLength(labelValue, 8).ToUpper();
result = result.Replace(label, labelHex);
}
if (replaceAll)
{
int persistentLabelIndex = result.IndexOf(PersistentLabelPrefix);
HashSet <char> endChars = new HashSet <char>()
{
' ', '\t', '\r', '\n'
};
while (persistentLabelIndex != -1)
{
int endIndex = persistentLabelIndex;
for (; endIndex < result.Length; endIndex++)
{
if (endChars.Contains(result[endIndex]))
{
break;
}
}
string label = (endIndex < result.Length) ? result.Substring(persistentLabelIndex, endIndex - persistentLabelIndex) : result.Substring(persistentLabelIndex);
result = result.Replace(label, "00000000");
persistentLabelIndex = result.IndexOf(PersistentLabelPrefix);
}
}
return(result);
}
public string ReplaceLabelsInHex(string hex, bool littleEndian)
{
string result = hex.ToUpper();
List <string> labels = new List <string>(LabelDict.Keys);
labels.Sort((a, b) => a.Length.CompareTo(b.Length));
labels.Reverse();
foreach (string label in labels)
{
uint labelValue = LabelToUnsigned(label);
labelValue = littleEndian ? ASMValueHelper.ReverseBytes(labelValue) : labelValue;
string labelHex = ASMValueHelper.UnsignedToHex_WithLength(labelValue, 8).ToUpper();
result = result.Replace(label, labelHex);
}
return(result);
}
private ASMSingleEncodeResult EncodeASMSingle(string[] parts, EncodingFormat encoding, uint pc, bool littleEndian)
{
// Initialize variables
//string binary = "";
//string hex = "";
string strArgs = "";
string[] args = null;
/*
* if (!string.IsNullOrEmpty(parts[1]))
* {
* strArgs = ASMStringHelper.RemoveSpaces(parts[1]).Replace('(',',').Replace(")","");
* args = strArgs.Split(',');
* }
*/
// Find encoding format and syntax
string command = parts[0].ToLower();
EncodingFormat encodingFormat = FormatHelper.FindFormatByCommand(command);
string formatBinary = encodingFormat.Binary;
string syntax = encodingFormat.Syntax;
string newFormat = formatBinary;
if (!string.IsNullOrEmpty(parts[1]))
{
List <string> argsList = new List <string>();
strArgs = ASMStringHelper.RemoveSpaces(parts[1]);
bool foundArg = false;
int strArgCharIndex = 0;
foreach (char currentChar in syntax)
{
if (Char.IsLetter(currentChar))
{
foundArg = true;
}
else if (foundArg)
{
foundArg = false;
bool isHiLo = ((strArgs.IndexOf("%hi(", strArgCharIndex) == strArgCharIndex) || (strArgs.IndexOf("%lo(", strArgCharIndex) == strArgCharIndex));
int separatorIndex = strArgs.IndexOf(currentChar, strArgCharIndex + (isHiLo ? 4 : 0));
argsList.Add(strArgs.Substring(strArgCharIndex, separatorIndex - strArgCharIndex));
strArgCharIndex = separatorIndex + 1;
}
}
if (foundArg)
{
argsList.Add(strArgs.Substring(strArgCharIndex, strArgs.Length - strArgCharIndex));
}
args = argsList.ToArray();
}
// Create array for registers and immediates
Nullable <uint>[] regValue = new Nullable <uint> [26];
Nullable <uint>[][] partialRegValue = new Nullable <uint> [26][];
uint[] immedValue = new uint[26];
int argsIndex = 0;
int regIndex = 0;
int immedIndex = 0;
// Fill arrays based on order of arguments (syntax)
foreach (char elementTypeChar in syntax)
{
bool incrementArgsIndex = true;
switch (elementTypeChar)
{
case ASMElementTypeCharacter.GPRegister:
regValue[regIndex++] = EncodeGPRegister(args[argsIndex]);
break;
case ASMElementTypeCharacter.GenericRegister:
regValue[regIndex++] = EncodeGenericRegister(args[argsIndex]);
break;
case ASMElementTypeCharacter.FloatRegister:
regValue[regIndex++] = EncodeFloatRegister(args[argsIndex]);
break;
case ASMElementTypeCharacter.VFPURegister:
regValue[regIndex] = EncodeVFPURegister(args[argsIndex], encodingFormat.VFPURegisterTypes[regIndex]);
regIndex++;
break;
case ASMElementTypeCharacter.PartialVFPURegister:
partialRegValue[regIndex] = EncodePartialVFPURegister(args[argsIndex], encodingFormat.VFPURegisterTypes[regIndex], encodingFormat.PartialRegisterSizes, encodingFormat.PartialRegisterIncludeMasks[regIndex]);
regIndex++;
break;
case ASMElementTypeCharacter.InvertedSingleBitVFPURegister:
regValue[regIndex] = EncodeInvertedSingleBitVFPURegister(args[argsIndex], encodingFormat.VFPURegisterTypes[regIndex]);
regIndex++;
break;
case ASMElementTypeCharacter.Cop0Register:
regValue[regIndex] = EncodeCop0Register(args[argsIndex]);
regIndex++;
break;
case ASMElementTypeCharacter.GTEControlRegister:
regValue[regIndex] = EncodeGTEControlRegister(args[argsIndex]);
regIndex++;
break;
case ASMElementTypeCharacter.GTEDataRegister:
regValue[regIndex] = EncodeGTEDataRegister(args[argsIndex]);
regIndex++;
break;
case ASMElementTypeCharacter.SignedImmediate:
case ASMElementTypeCharacter.UnsignedImmediate:
immedValue[immedIndex] = EncodeImmediate(args[argsIndex], encodingFormat.ImmediateLengths[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
immedIndex++;
break;
case ASMElementTypeCharacter.BranchImmediate:
immedValue[immedIndex] = EncodeBranchImmediate(args[argsIndex], pc, (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
immedIndex++;
break;
case ASMElementTypeCharacter.JumpImmediate:
immedValue[immedIndex] = EncodeJumpImmediate(args[argsIndex], 26, pc);
immedIndex++;
break;
case ASMElementTypeCharacter.DecrementedImmediate:
immedValue[immedIndex] = EncodeDecrementedImmediate(args[argsIndex], encodingFormat.ImmediateLengths[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
immedIndex++;
break;
case ASMElementTypeCharacter.ModifiedImmediate:
immedValue[immedIndex] = EncodeModifiedImmediate(args[argsIndex], args[argsIndex - 1], encodingFormat.ImmediateLengths[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
immedIndex++;
break;
case ASMElementTypeCharacter.ShiftedImmediate:
immedValue[immedIndex] = EncodeShiftedImmediate(args[argsIndex], encodingFormat.ImmediateLengths[immedIndex], encodingFormat.ShiftedImmediateAmounts[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
immedIndex++;
break;
case ASMElementTypeCharacter.VFPUPrefixImmediate:
immedValue[immedIndex] = EncodeVFPUPrefixImmediate(args[argsIndex], encodingFormat.VFPUPrefixType, encodingFormat.ImmediateLengths[immedIndex]);
immedIndex++;
break;
default:
incrementArgsIndex = false;
break;
}
if (incrementArgsIndex)
{
argsIndex++;
}
}
/*
* // Replace bracket blocks in format with appropriate values
* for (int i = 0; i < regIndex; i++)
* {
* newFormat = newFormat.Replace("[" + encodingFormat.RegisterTypes[i] + (i + 1) + "]", regBinary[i]);
*
* if (partialRegBinary[i] != null)
* {
* newFormat = newFormat.Replace("[" + encodingFormat.RegisterTypes[i] + (i + 1) + "-1]", partialRegBinary[i][0]);
* newFormat = newFormat.Replace("[" + encodingFormat.RegisterTypes[i] + (i + 1) + "-2]", partialRegBinary[i][1]);
* }
* }
* for (int i = 0; i < immedIndex; i++)
* {
* newFormat = newFormat.Replace("[" + encodingFormat.ImmediateTypes[i] + (i + 1) + "]", immedBinary[i]);
* }
*
* binary = newFormat;
*/
uint uEncodingValue = encodingFormat.BaseEncoding;
for (int i = 0; i < regIndex; i++)
{
if (regValue[i] != null)
{
uEncodingValue |= (((uint)regValue[i]) << encodingFormat.RegisterPositions[i]);
}
else if (partialRegValue[i] != null)
{
uEncodingValue |= (((uint)partialRegValue[i][0]) << encodingFormat.PartialRegisterPositions[i][0]);
uEncodingValue |= (((uint)partialRegValue[i][1]) << encodingFormat.PartialRegisterPositions[i][1]);
}
}
for (int i = 0; i < immedIndex; i++)
{
uEncodingValue |= (immedValue[i] << encodingFormat.ImmediatePositions[i]);
}
//byte[] bytes = BitConverter.GetBytes(uEncodingValue);
byte[] bytes = ASMValueHelper.ConvertUIntToBytes(uEncodingValue, littleEndian);
if (littleEndian)
{
uEncodingValue = ASMValueHelper.ReverseBytes(uEncodingValue);
}
//else
//{
// Array.Reverse(bytes);
//}
string hex = ASMValueHelper.UnsignedToHex_WithLength(uEncodingValue, 8).ToUpper();
return(new ASMSingleEncodeResult(hex, bytes));
}
