private static string GetIncSrc(int offset, int length)
{
int bank = Util.ConvertPCtoSNES(offset) >> 16;
string s = string.Format("incsrc \"bank_{0}.asm\"", Util.NumberToBaseString(bank, Util.NumberBase.Hexadecimal, 2));
return(string.Format("{0," + (length * -1) + "}", s));
}
private void UpdateText(TextBox selected)
{
var noBase = radioDec.Checked ? Util.NumberBase.Decimal : Util.NumberBase.Hexadecimal;
var digits = noBase == Util.NumberBase.Hexadecimal && radioSNES.Checked ? 6 : 0;
if (StartRomOffset < 0)
{
StartRomOffset = 0;
}
if (EndRomOffset >= data.GetRomSize())
{
EndRomOffset = data.GetRomSize() - 1;
}
Count = EndRomOffset - StartRomOffset;
if (Count < 0)
{
Count = 0;
}
updatingText = true;
if (selected != textStart)
{
textStart.Text = Util.NumberToBaseString(radioSNES.Checked ? data.ConvertPCtoSnes(StartRomOffset) : StartRomOffset, noBase, digits);
}
if (selected != textEnd)
{
textEnd.Text = Util.NumberToBaseString(radioSNES.Checked ? data.ConvertPCtoSnes(EndRomOffset) : EndRomOffset, noBase, digits);
}
if (selected != textCount)
{
textCount.Text = Util.NumberToBaseString(Count, noBase, 0);
}
updatingText = false;
}
public static string GetInstruction(int offset)
{
AddressMode mode = GetAddressMode(offset);
string format = GetInstructionFormatString(offset);
string mnemonic = GetMnemonic(offset);
string op1 = "", op2 = "";
if (mode == AddressMode.BLOCK_MOVE)
{
op1 = Util.NumberToBaseString(Data.GetROMByte(offset + 1), Util.NumberBase.Hexadecimal, 2, true);
op2 = Util.NumberToBaseString(Data.GetROMByte(offset + 2), Util.NumberBase.Hexadecimal, 2, true);
}
else if (mode == AddressMode.CONSTANT_8 || mode == AddressMode.IMMEDIATE_8)
{
op1 = Util.NumberToBaseString(Data.GetROMByte(offset + 1), Util.NumberBase.Hexadecimal, 2, true);
}
else if (mode == AddressMode.IMMEDIATE_16)
{
op1 = Util.NumberToBaseString(Util.GetROMWord(offset + 1), Util.NumberBase.Hexadecimal, 4, true);
}
else
{
op1 = FormatOperandAddress(offset, mode);
}
return(string.Format(format, mnemonic, op1, op2));
}
private void UpdateText(TextBox selected)
{
Util.NumberBase noBase = radioDec.Checked ? Util.NumberBase.Decimal : Util.NumberBase.Hexadecimal;
int digits = noBase == Util.NumberBase.Hexadecimal && radioROM.Checked ? 6 : 0;
int size = Data.GetROMSize();
if (start < 0)
{
start = 0;
}
if (end >= size)
{
end = size - 1;
}
count = end - start;
if (count < 0)
{
count = 0;
}
updatingText = true;
if (selected != textStart)
{
textStart.Text = Util.NumberToBaseString(radioROM.Checked ? Util.ConvertPCtoSNES(start) : start, noBase, digits);
}
if (selected != textEnd)
{
textEnd.Text = Util.NumberToBaseString(radioROM.Checked ? Util.ConvertPCtoSNES(end) : end, noBase, digits);
}
if (selected != textCount)
{
textCount.Text = Util.NumberToBaseString(count, noBase, 0);
}
updatingText = false;
}
private void table_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e)
{
int row = e.RowIndex + viewOffset;
if (row >= Data.GetROMSize())
{
return;
}
switch (e.ColumnIndex)
{
case 0: e.Value = Data.GetLabel(Util.ConvertPCtoSNES(row)); break;
case 1: e.Value = Util.NumberToBaseString(Util.ConvertPCtoSNES(row), Util.NumberBase.Hexadecimal, 6); break;
case 2: e.Value = (char)Data.GetROMByte(row); break;
case 3: e.Value = Util.NumberToBaseString(Data.GetROMByte(row), DisplayBase); break;
case 4: e.Value = Util.PointToString(Data.GetInOutPoint(row)); break;
case 5:
int len = Manager.GetInstructionLength(row);
if (row + len <= Data.GetROMSize())
{
e.Value = Util.GetInstruction(row);
}
else
{
e.Value = "";
}
break;
case 6:
int ia = Util.GetIntermediateAddressOrPointer(row);
if (ia >= 0)
{
e.Value = Util.NumberToBaseString(ia, Util.NumberBase.Hexadecimal, 6);
}
else
{
e.Value = "";
}
break;
case 7: e.Value = Util.TypeToString(Data.GetFlag(row)); break;
case 8: e.Value = Util.NumberToBaseString(Data.GetDataBank(row), Util.NumberBase.Hexadecimal, 2); break;
case 9: e.Value = Util.NumberToBaseString(Data.GetDirectPage(row), Util.NumberBase.Hexadecimal, 4); break;
case 10: e.Value = Util.BoolToSize(Data.GetMFlag(row)); break;
case 11: e.Value = Util.BoolToSize(Data.GetXFlag(row)); break;
case 12: e.Value = Data.GetComment(Util.ConvertPCtoSNES(row)); break;
}
}
private void UpdateTextboxes()
{
if (speed == Data.ROMSpeed.Unknown)
{
romspeed.Text = "????";
romtitle.Text = "?????????????????????";
for (int i = 0; i < vectors.GetLength(0); i++)
{
for (int j = 0; j < vectors.GetLength(1); j++)
{
vectors[i, j].Text = "????";
}
}
}
else
{
if (speed == Data.ROMSpeed.SlowROM)
{
romspeed.Text = "SlowROM";
}
else
{
romspeed.Text = "FastROM";
}
title = "";
for (int i = 0; i < 0x15; i++)
{
title += (char)data[offset - 0x15 + i];
}
romtitle.Text = title;
for (int i = 0; i < vectors.GetLength(0); i++)
{
for (int j = 0; j < vectors.GetLength(1); j++)
{
int index = offset + 15 + 0x10 * i + 2 * j;
int val = data[index] + (data[index + 1] << 8);
vectors[i, j].Text = Util.NumberToBaseString(val, Util.NumberBase.Hexadecimal, 4);
if (val < 0x8000)
{
checkboxes[i, j].Checked = false;
checkboxes[i, j].Enabled = false;
}
else
{
checkboxes[i, j].Enabled = true;
}
}
}
}
}
// length forced to 8
private static string GetRawBytes(int offset, int length)
{
string bytes = "";
if (Data.GetFlag(offset) == Data.FlagType.Opcode)
{
for (int i = 0; i < Manager.GetInstructionLength(offset); i++)
{
bytes += Util.NumberToBaseString(Data.GetROMByte(offset + i), Util.NumberBase.Hexadecimal);
}
}
return(string.Format("{0,-8}", bytes));
}
private void radioHex_CheckedChanged(object sender, EventArgs e)
{
if (radioHex.Checked)
{
if (int.TryParse(textPC.Text, out int result))
{
textPC.Text = Util.NumberToBaseString(result, Util.NumberBase.Hexadecimal, 0);
}
}
else
{
if (int.TryParse(textPC.Text, NumberStyles.HexNumber, null, out int result))
{
textPC.Text = result.ToString();
}
}
}
private void textROM_TextChanged(object sender, EventArgs e)
{
if (!updatingText)
{
updatingText = true;
NumberStyles style = radioDec.Checked ? NumberStyles.Number : NumberStyles.HexNumber;
Util.NumberBase noBase = radioDec.Checked ? Util.NumberBase.Decimal : Util.NumberBase.Hexadecimal;
if (int.TryParse(textROM.Text, style, null, out int address))
{
int pc = Util.ConvertSNEStoPC(address);
if (pc >= 0 && pc < Data.GetROMSize())
{
textPC.Text = Util.NumberToBaseString(pc, noBase, 0);
}
}
updatingText = false;
}
}
private void textPC_TextChanged(object sender, EventArgs e)
{
if (!updatingText)
{
updatingText = true;
NumberStyles style = radioDec.Checked ? NumberStyles.Number : NumberStyles.HexNumber;
Util.NumberBase noBase = radioDec.Checked ? Util.NumberBase.Decimal : Util.NumberBase.Hexadecimal;
if (int.TryParse(textPC.Text, style, null, out int offset))
{
int addr = Util.ConvertPCtoSNES(offset);
if (addr >= 0)
{
textROM.Text = Util.NumberToBaseString(addr, noBase, 6);
}
}
updatingText = false;
}
}
private void buttonScan_Click(object sender, EventArgs e)
{
textLog.Text = "";
int found = 0, offset = 0;
while (found < 500 && offset < Data.GetROMSize())
{
Data.FlagType flag = Data.GetFlag(offset), check = flag == Data.FlagType.Opcode ? Data.FlagType.Operand : flag;
int step = flag == Data.FlagType.Opcode ? Manager.GetInstructionLength(offset) : Util.TypeStepSize(flag);
if (flag == Data.FlagType.Operand)
{
found++;
textLog.Text += string.Format("{0} (0x{1}): Operand without Opcode\r\n",
Util.NumberToBaseString(Util.ConvertPCtoSNES(offset), Util.NumberBase.Hexadecimal, 6, true),
Util.NumberToBaseString(offset, Util.NumberBase.Hexadecimal, 0));
}
else if (step > 1)
{
for (int i = 1; i < step; i++)
{
if (Data.GetFlag(offset + i) != check)
{
found++;
textLog.Text += string.Format("{0} (0x{1}): {2} is not {3}\r\n",
Util.NumberToBaseString(Util.ConvertPCtoSNES(offset + i), Util.NumberBase.Hexadecimal, 6, true),
Util.NumberToBaseString(offset + i, Util.NumberBase.Hexadecimal, 0),
Util.TypeToString(Data.GetFlag(offset + i)),
Util.TypeToString(check));
}
}
}
offset += step;
}
if (found == 0)
{
textLog.Text = "No misaligned flags found!";
}
}
private static string FormatOperandAddress(int offset, AddressMode mode)
{
int address = Util.GetIntermediateAddress(offset);
if (address < 0)
{
return("");
}
if (Data.GetLabel(address) != "")
{
return(Data.GetLabel(address));
}
int count = BytesToShow(mode);
if (mode == AddressMode.RELATIVE_8 || mode == AddressMode.RELATIVE_16)
{
address = Util.GetROMWord(offset + 1);
}
address &= ~(-1 << (8 * count));
return(Util.NumberToBaseString(address, Util.NumberBase.Hexadecimal, 2 * count, true));
}
private void buttonScan_Click(object sender, EventArgs e)
{
textLog.Text = "";
int found = 0, offset = 0;
while (found < 500 && offset < Data.GetRomSize())
{
FlagType flag = Data.GetSnesApi().GetFlag(offset), check = flag == FlagType.Opcode ? FlagType.Operand : flag;
var step = flag == FlagType.Opcode ? Data.GetSnesApi().GetInstructionLength(offset) : RomUtil.GetByteLengthForFlag(flag);
if (flag == FlagType.Operand)
{
found++;
textLog.Text +=
$"{Util.NumberToBaseString(Data.ConvertPCtoSnes(offset), Util.NumberBase.Hexadecimal, 6, true)} (0x{Util.NumberToBaseString(offset, Util.NumberBase.Hexadecimal, 0)}): Operand without Opcode\r\n";
}
else if (step > 1)
{
for (var i = 1; i < step; i++)
{
if (Data.GetSnesApi().GetFlag(offset + i) == check)
{
continue;
}
found++;
textLog.Text +=
$"{Util.NumberToBaseString(Data.ConvertPCtoSnes(offset + i), Util.NumberBase.Hexadecimal, 6, true)} (0x{Util.NumberToBaseString(offset + i, Util.NumberBase.Hexadecimal, 0)}): {Util.GetEnumDescription(Data.GetSnesApi().GetFlag(offset + i))} is not {Util.GetEnumDescription(check)}\r\n";
}
}
offset += step;
}
if (found == 0)
{
textLog.Text = "No misaligned flags found!";
}
}
private static string FormatOperandAddress(int offset, AddressMode mode)
{
int address = Util.GetEffectiveAddress(offset);
if (address < 0)
{
return("");
}
int pc = Util.ConvertSNEStoPC(address);
if (pc >= 0 && !string.IsNullOrEmpty(Data.GetLabel(pc)))
{
return(Data.GetLabel(pc));
}
int count = BytesToShow(mode);
if (mode == AddressMode.RELATIVE_8 || mode == AddressMode.RELATIVE_16)
{
address = Util.GetROMWord(offset + 1);
}
address &= ~(-1 << (8 * count));
return(Util.NumberToBaseString(address, Util.NumberBase.Hexadecimal, 2 * count, true));
}
public static int CreateLog(StreamWriter sw, StreamWriter er)
{
Dictionary <int, string> tempAlias = Data.GetAllLabels();
Data.Restore(a: new Dictionary <int, string>(tempAlias));
AliasList.me.locked = true;
bankSize = Data.GetROMMapMode() == Data.ROMMapMode.LoROM ? 0x8000 : 0x10000; // todo
AddTemporaryLabels();
string[] split = format.Split('%');
err = er;
errorCount = 0;
usedLabels = new List <int>();
list = new List <Tuple <string, int> >();
for (int i = 0; i < split.Length; i++)
{
if (i % 2 == 0)
{
list.Add(Tuple.Create(split[i], int.MaxValue));
}
else
{
int colon = split[i].IndexOf(':');
if (colon < 0)
{
list.Add(Tuple.Create(split[i], parameters[split[i]].Item2));
}
else
{
list.Add(Tuple.Create(split[i].Substring(0, colon), int.Parse(split[i].Substring(colon + 1))));
}
}
}
int pointer = 0, size = (Data.GetTable() == ExportDisassembly.sampleTable) ? 0x7B : Data.GetROMSize(), bank = -1;
if (structure == FormatStructure.OneBankPerFile)
{
folder = Path.GetDirectoryName(((FileStream)sw.BaseStream).Name);
sw.WriteLine(GetLine(pointer, "map"));
sw.WriteLine(GetLine(pointer, "empty"));
for (int i = 0; i < size; i += bankSize)
{
sw.WriteLine(GetLine(i, "incsrc"));
}
sw.WriteLine(GetLine(-1, "incsrc"));
}
else
{
sw.WriteLine(GetLine(pointer, "map"));
sw.WriteLine(GetLine(pointer, "empty"));
}
while (pointer < size)
{
int snes = Util.ConvertPCtoSNES(pointer);
if ((snes >> 16) != bank)
{
if (structure == FormatStructure.OneBankPerFile)
{
sw.Close();
sw = new StreamWriter(string.Format("{0}/bank_{1}.asm", folder, Util.NumberToBaseString((snes >> 16), Util.NumberBase.Hexadecimal, 2)));
}
sw.WriteLine(GetLine(pointer, "empty"));
sw.WriteLine(GetLine(pointer, "org"));
sw.WriteLine(GetLine(pointer, "empty"));
if ((snes % bankSize) != 0)
{
err.WriteLine("({0}) Offset 0x{1:X}: An instruction crossed a bank boundary.", ++errorCount, pointer);
}
bank = snes >> 16;
}
string label;
if ((Data.GetInOutPoint(pointer) & (Data.InOutPoint.ReadPoint)) != 0 || (tempAlias.TryGetValue(pointer, out label) && label.Length > 0))
{
sw.WriteLine(GetLine(pointer, "empty"));
}
sw.WriteLine(GetLine(pointer, null));
if ((Data.GetInOutPoint(pointer) & (Data.InOutPoint.EndPoint)) != 0)
{
sw.WriteLine(GetLine(pointer, "empty"));
}
pointer += GetLineByteLength(pointer);
}
if (structure == FormatStructure.OneBankPerFile)
{
sw.Close();
sw = new StreamWriter(string.Format("{0}/labels.asm", folder));
}
else
{
sw.WriteLine(GetLine(pointer, "empty"));
}
foreach (KeyValuePair <int, string> pair in Data.GetAllLabels())
{
if (!usedLabels.Contains(pair.Key))
{
sw.WriteLine(GetLine(pair.Key, "labelassign"));
}
}
if (structure == FormatStructure.OneBankPerFile)
{
sw.Close();
}
Data.Restore(a: tempAlias);
AliasList.me.locked = false;
return(errorCount);
}
// output label at snes offset, and its value
private static string GetLabelAssign(int offset, int length)
{
string s = string.Format("{0} = {1}", Data.GetLabel(offset), Util.NumberToBaseString(offset, Util.NumberBase.Hexadecimal, 6, true));
return(string.Format("{0," + (length * -1) + "}", s));
}
// length forced to 4
private static string GetDirectPage(int offset, int length)
{
return(Util.NumberToBaseString(Data.GetDirectPage(offset), Util.NumberBase.Hexadecimal, 4));
}
// length forced to 2
private static string GetDataBank(int offset, int length)
{
return(Util.NumberToBaseString(Data.GetDataBank(offset), Util.NumberBase.Hexadecimal, 2));
}
// trim to length
private static string GetOffset(int offset, int length)
{
return(string.Format("{0," + (length * -1) + "}", Util.NumberToBaseString(offset, Util.NumberBase.Hexadecimal, 0)));
}
// length forced to 6
private static string GetProgramCounter(int offset, int length)
{
return(Util.NumberToBaseString(Util.ConvertPCtoSNES(offset), Util.NumberBase.Hexadecimal, 6));
}
private static string GetORG(int offset, int length)
{
string org = "ORG " + Util.NumberToBaseString(Util.ConvertPCtoSNES(offset), Util.NumberBase.Hexadecimal, 6, true);
return(string.Format("{0," + (length * -1) + "}", org));
}
// length forced to 6
private static string GetIntermediateAddress(int offset, int length)
{
int ia = Util.GetIntermediateAddressOrPointer(offset);
return(ia >= 0 ? Util.NumberToBaseString(ia, Util.NumberBase.Hexadecimal, 6) : " ");
}
public GotoDialog(int offset)
{
InitializeComponent();
textROM.Text = Util.NumberToBaseString(Util.ConvertPCtoSNES(offset), Util.NumberBase.Hexadecimal, 6);
textPC.Text = Util.NumberToBaseString(offset, Util.NumberBase.Hexadecimal, 0);
}
// length forced to 6
private static string GetEffectiveAddress(int offset, int length)
{
int ea = Util.GetEffectiveAddressOrPointer(offset);
return(ea >= 0 ? Util.NumberToBaseString(ea, Util.NumberBase.Hexadecimal, 6) : " ");
}