private static void AddTemporaryLabels()
{
List <int> addMe = new List <int>();
int pointer = 0;
while (pointer < Data.GetROMSize())
{
int length = GetLineByteLength(pointer);
Data.FlagType flag = Data.GetFlag(pointer);
if (unlabeled == FormatUnlabeled.ShowAll)
{
addMe.Add(Util.ConvertPCtoSNES(pointer));
}
else if (unlabeled != FormatUnlabeled.ShowNone &&
(flag == Data.FlagType.Opcode || flag == Data.FlagType.Pointer16Bit || flag == Data.FlagType.Pointer24Bit || flag == Data.FlagType.Pointer32Bit))
{
int ia = Util.GetIntermediateAddressOrPointer(pointer);
if (ia >= 0 && Util.ConvertSNEStoPC(ia) >= 0)
{
addMe.Add(ia);
}
}
pointer += length;
}
// TODO +/- labels
for (int i = 0; i < addMe.Count; i++)
{
Data.AddLabel(addMe[i], Util.GetDefaultLabel(addMe[i]), false);
}
}
public static int ImportUsageMap(byte[] usageMap)
{
int size = Data.GetROMSize();
bool unsaved = false;
int modified = 0;
int prevFlags = 0;
for (int map = 0; map <= 0xFFFFFF; map++)
{
var i = Util.ConvertSNEStoPC(map);
if (i == -1 || i >= size)
{
// branch predictor may optimize this
continue;
}
var flags = (Data.BsnesPlusUsage)usageMap[map];
if (flags == 0)
{
// no information available
continue;
}
if (Data.GetFlag(i) != Data.FlagType.Unreached)
{
// skip if there is something already set..
continue;
}
// opcode: 0x30, operand: 0x20
if (flags.HasFlag(Data.BsnesPlusUsage.UsageExec))
{
Data.SetFlag(i, Data.FlagType.Operand);
if (flags.HasFlag(Data.BsnesPlusUsage.UsageOpcode))
{
prevFlags = ((int)flags & 3) << 4;
Data.SetFlag(i, Data.FlagType.Opcode);
}
Data.SetMXFlags(i, prevFlags);
unsaved = true;
modified++;
}
else if (flags.HasFlag(Data.BsnesPlusUsage.UsageRead))
{
Data.SetFlag(i, Data.FlagType.Data8Bit);
unsaved = true;
modified++;
}
}
Project.unsavedChanges |= unsaved;
return(modified);
}
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 static string GetLine(int offset, string special)
{
string line = "";
for (int i = 0; i < list.Count; i++)
{
if (list[i].Item2 == int.MaxValue) // string literal
{
line += list[i].Item1;
}
else if (special != null) // special parameter (replaces code & everything else = empty)
{
line += GetParameter(offset, "%" + (list[i].Item1 == "code" ? special : "empty"), list[i].Item2);
}
else // normal parameter
{
line += GetParameter(offset, list[i].Item1, list[i].Item2);
}
}
if (special == null)
{
// throw out some errors if stuff looks fishy
Data.FlagType flag = Data.GetFlag(offset), check = flag == Data.FlagType.Opcode ? Data.FlagType.Operand : flag;
int step = flag == Data.FlagType.Opcode ? GetLineByteLength(offset) : Util.TypeStepSize(flag), size = Data.GetROMSize();
if (flag == Data.FlagType.Operand)
{
err.WriteLine("({0}) Offset 0x{1:X}: Bytes marked as operands formatted as data.", ++errorCount, offset);
}
else if (step > 1)
{
for (int i = 1; i < step; i++)
{
if (offset + i >= size)
{
err.WriteLine("({0}) Offset 0x{1:X}: {2} extends past the end of the ROM.", ++errorCount, offset, Util.TypeToString(check));
break;
}
else if (Data.GetFlag(offset + i) != check)
{
err.WriteLine("({0}) Offset 0x{1:X}: Expected {2}, but got {3} instead.", ++errorCount, offset + i, Util.TypeToString(check), Util.TypeToString(Data.GetFlag(offset + i)));
break;
}
}
}
int ia = Util.GetIntermediateAddress(offset, true);
if (ia >= 0 && flag == Data.FlagType.Opcode && Data.GetInOutPoint(offset) == Data.InOutPoint.OutPoint && Data.GetFlag(Util.ConvertSNEStoPC(ia)) != Data.FlagType.Opcode)
{
err.WriteLine("({0}) Offset 0x{1:X}: Branch or jump instruction to a non-instruction.", ++errorCount, offset);
}
}
return(line);
}
// 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));
}
// trim to length
private static string GetCode(int offset, int length)
{
int bytes = GetLineByteLength(offset);
string code = "";
switch (Data.GetFlag(offset))
{
case Data.FlagType.Opcode:
code = Util.GetInstruction(offset);
break;
case Data.FlagType.Unreached:
case Data.FlagType.Operand:
case Data.FlagType.Data8Bit:
case Data.FlagType.Graphics:
case Data.FlagType.Music:
case Data.FlagType.Empty:
code = Util.GetFormattedBytes(offset, 1, bytes);
break;
case Data.FlagType.Data16Bit:
code = Util.GetFormattedBytes(offset, 2, bytes);
break;
case Data.FlagType.Data24Bit:
code = Util.GetFormattedBytes(offset, 3, bytes);
break;
case Data.FlagType.Data32Bit:
code = Util.GetFormattedBytes(offset, 4, bytes);
break;
case Data.FlagType.Pointer16Bit:
code = Util.GetPointer(offset, 2);
break;
case Data.FlagType.Pointer24Bit:
code = Util.GetPointer(offset, 3);
break;
case Data.FlagType.Pointer32Bit:
code = Util.GetPointer(offset, 4);
break;
case Data.FlagType.Text:
code = Util.GetFormattedText(offset, bytes);
break;
}
return(string.Format("{0," + (length * -1) + "}", code));
}
public static int FixMisalignedFlags()
{
int count = 0, size = Data.GetROMSize();
for (int i = 0; i < size; i++)
{
Data.FlagType flag = Data.GetFlag(i);
if (flag == Data.FlagType.Opcode)
{
int len = GetInstructionLength(i);
for (int j = 1; j < len && i + j < size; j++)
{
if (Data.GetFlag(i + j) != Data.FlagType.Operand)
{
Data.SetFlag(i + j, Data.FlagType.Operand);
count++;
}
}
i += len - 1;
}
else if (flag == Data.FlagType.Operand)
{
Data.SetFlag(i, Data.FlagType.Opcode);
count++;
i--;
}
else if (Util.TypeStepSize(flag) > 1)
{
int step = Util.TypeStepSize(flag);
for (int j = 1; j < step; j++)
{
if (Data.GetFlag(i + j) != flag)
{
Data.SetFlag(i + j, flag);
count++;
}
}
i += step - 1;
}
}
if (count > 0)
{
Project.unsavedChanges = true;
}
return(count);
}
public void UpdatePercent()
{
int totalUnreached = 0, size = Data.GetROMSize();
for (int i = 0; i < size; i++)
{
if (Data.GetFlag(i) == Data.FlagType.Unreached)
{
totalUnreached++;
}
}
int reached = size - totalUnreached;
percentComplete.Text = string.Format("{0:N3}% ({1:D}/{2:D})", reached * 100.0 / size, reached, size);
}
public static int ImportTraceLog(string[] lines)
{
// Must follow this format.
// 028cde rep #$30 A:0004 X:0000 Y:0004 S:1fdd D:0000 DB:02 nvmxdiZC V:133 H: 654 F:36
bool unsaved = false;
int modified = 0;
int size = Data.GetROMSize();
foreach (var line in lines)
{
if (line.Length < 80)
{
continue;
}
// TODO: error treatment
// TODO: parse MX flags
int directPageIndex = line.IndexOf("D:") + 2;
int dataBankIndex = line.IndexOf("DB:") + 3;
int snesAddress = Convert.ToInt32(line.Substring(0, 6), 16);
int directPage = Convert.ToInt32(line.Substring(directPageIndex, 4), 16);
int dataBank = Convert.ToInt32(line.Substring(dataBankIndex, 2), 16);
int pc = Util.ConvertSNEStoPC(snesAddress);
if (pc == -1)
{
continue;
}
Data.SetFlag(pc, Data.FlagType.Opcode);
do
{
Data.SetDataBank(pc, dataBank);
Data.SetDirectPage(pc, directPage);
pc++;
unsaved = true;
modified++;
} while (pc < size && Data.GetFlag(pc) == Data.FlagType.Operand);
}
Project.unsavedChanges |= unsaved;
return(modified);
}
public static int GetEffectiveAddressOrPointer(int offset)
{
switch (Data.GetFlag(offset))
{
case Data.FlagType.Opcode:
return(GetEffectiveAddress(offset));
case Data.FlagType.Pointer16Bit:
int bank = Data.GetDataBank(offset);
return((bank << 16) | GetROMWord(offset));
case Data.FlagType.Pointer24Bit:
case Data.FlagType.Pointer32Bit:
return(GetROMLong(offset));
}
return(-1);
}
private void GoToUnreached(bool end, bool direction)
{
int offset = table.CurrentCell.RowIndex + viewOffset;
int size = Data.GetROMSize();
int unreached = end ? (direction ? 0 : size - 1) : offset;
if (direction)
{
if (!end)
{
while (unreached < size - 1 && Data.GetFlag(unreached) == Data.FlagType.Unreached)
{
unreached++;
}
}
while (unreached < size - 1 && Data.GetFlag(unreached) != Data.FlagType.Unreached)
{
unreached++;
}
}
else
{
if (unreached > 0)
{
unreached--;
}
while (unreached > 0 && Data.GetFlag(unreached) != Data.FlagType.Unreached)
{
unreached--;
}
}
while (unreached > 0 && Data.GetFlag(unreached - 1) == Data.FlagType.Unreached)
{
unreached--;
}
if (Data.GetFlag(unreached) == Data.FlagType.Unreached)
{
SelectOffset(unreached, 1);
}
}
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!";
}
}
public static void RescanInOutPoints()
{
for (int i = 0; i < Data.GetROMSize(); i++)
{
Data.ClearInOutPoint(i);
}
for (int i = 0; i < Data.GetROMSize(); i++)
{
if (Data.GetFlag(i) == Data.FlagType.Opcode)
{
switch (Data.GetArchitechture(i))
{
case Data.Architechture.CPU65C816: CPU65C816.MarkInOutPoints(i); break;
case Data.Architechture.APUSPC700: break;
case Data.Architechture.GPUSuperFX: break;
}
}
}
Project.unsavedChanges = true;
}
private static byte[] SaveVersion1()
{
int size = Data.GetROMSize();
byte[] romSettings = new byte[31];
romSettings[0] = (byte)Data.GetROMMapMode();
romSettings[1] = (byte)Data.GetROMSpeed();
Util.IntegerIntoByteArray(size, romSettings, 2);
for (int i = 0; i < 0x15; i++)
{
romSettings[6 + i] = (byte)Data.GetROMByte(Util.ConvertSNEStoPC(0xFFC0 + i));
}
for (int i = 0; i < 4; i++)
{
romSettings[27 + i] = (byte)Data.GetROMByte(Util.ConvertSNEStoPC(0xFFDC + i));
}
// TODO put selected offset in save file
List <byte> label = new List <byte>(), comment = new List <byte>();
Dictionary <int, string> all_labels = Data.GetAllLabels(), all_comments = Data.GetAllComments();
Util.IntegerIntoByteList(all_labels.Count, label);
foreach (KeyValuePair <int, string> pair in all_labels)
{
Util.IntegerIntoByteList(pair.Key, label);
for (int i = 0; i < pair.Value.Length; i++)
{
label.Add((byte)pair.Value[i]);
}
label.Add(0);
}
Util.IntegerIntoByteList(all_comments.Count, comment);
foreach (KeyValuePair <int, string> pair in all_comments)
{
Util.IntegerIntoByteList(pair.Key, comment);
for (int i = 0; i < pair.Value.Length; i++)
{
comment.Add((byte)pair.Value[i]);
}
comment.Add(0);
}
byte[] romLocation = Util.StringToByteArray(currentROMFile);
byte[] data = new byte[romSettings.Length + romLocation.Length + 8 * size + label.Count + comment.Count];
romSettings.CopyTo(data, 0);
for (int i = 0; i < romLocation.Length; i++)
{
data[romSettings.Length + i] = romLocation[i];
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + i] = (byte)Data.GetDataBank(i);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + size + i] = (byte)Data.GetDirectPage(i);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + 2 * size + i] = (byte)(Data.GetDirectPage(i) >> 8);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + 3 * size + i] = (byte)(Data.GetXFlag(i) ? 1 : 0);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + 4 * size + i] = (byte)(Data.GetMFlag(i) ? 1 : 0);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + 5 * size + i] = (byte)Data.GetFlag(i);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + 6 * size + i] = (byte)Data.GetArchitechture(i);
}
for (int i = 0; i < size; i++)
{
data[romSettings.Length + romLocation.Length + 7 * size + i] = (byte)Data.GetInOutPoint(i);
}
// ???
label.CopyTo(data, romSettings.Length + romLocation.Length + 8 * size);
comment.CopyTo(data, romSettings.Length + romLocation.Length + 8 * size + label.Count);
// ???
return(data);
}
public static int AutoStep(int offset, bool harsh, int amount)
{
Project.unsavedChanges = true;
int newOffset = offset, prevOffset = offset - 1, nextOffset = offset;
if (harsh)
{
while (newOffset < offset + amount)
{
nextOffset = Step(newOffset, false, true, prevOffset);
prevOffset = newOffset;
newOffset = nextOffset;
}
}
else
{
Stack <int> stack = new Stack <int>();
List <int> seenBranches = new List <int>();
bool keepGoing = true;
while (keepGoing)
{
switch (Data.GetArchitechture(newOffset))
{
case Data.Architechture.CPU65C816:
if (seenBranches.Contains(newOffset))
{
keepGoing = false;
break;
}
int opcode = Data.GetROMByte(newOffset);
nextOffset = Step(newOffset, false, false, prevOffset);
int jumpOffset = Step(newOffset, true, false, prevOffset);
if (opcode == 0x40 || opcode == 0xCB || opcode == 0xDB || opcode == 0xF8 || // RTI WAI STP SED
opcode == 0xFB || opcode == 0x00 || opcode == 0x02 || opcode == 0x42 || // XCE BRK COP WDM
opcode == 0x6C || opcode == 0x7C || opcode == 0xDC || opcode == 0xFC // JMP JMP JML JSR
)
{
keepGoing = false;
}
if (opcode == 0x4C || opcode == 0x5C || opcode == 0x80 || opcode == 0x82 || // JMP JML BRA BRL
opcode == 0x10 || opcode == 0x30 || opcode == 0x50 || opcode == 0x70 || // BPL BMI BVC BVS
opcode == 0x90 || opcode == 0xB0 || opcode == 0xD0 || opcode == 0xF0 // BCC BCS BNE BEQ
)
{
seenBranches.Add(newOffset);
}
if (opcode == 0x08) // PHP
{
stack.Push(Data.GetMXFlags(newOffset));
}
else if (opcode == 0x28) // PLP
{
if (stack.Count == 0)
{
keepGoing = false; break;
}
else
{
Data.SetMXFlags(newOffset, stack.Pop());
}
}
if (opcode == 0x60 || opcode == 0x6B) // RTS RTL
{
if (stack.Count == 0)
{
keepGoing = false;
break;
}
else
{
prevOffset = newOffset;
newOffset = stack.Pop();
}
}
else if (opcode == 0x20 || opcode == 0x22) // JSR JSL
{
stack.Push(nextOffset);
prevOffset = newOffset;
newOffset = jumpOffset;
}
else
{
prevOffset = newOffset;
newOffset = nextOffset;
}
break;
case Data.Architechture.APUSPC700:
case Data.Architechture.GPUSuperFX:
nextOffset = Step(newOffset, false, true, prevOffset);
prevOffset = newOffset;
newOffset = nextOffset;
break;
}
Data.FlagType flag = Data.GetFlag(newOffset);
if (!(flag == Data.FlagType.Unreached || flag == Data.FlagType.Opcode || flag == Data.FlagType.Operand))
{
keepGoing = false;
}
}
}
return(newOffset);
}
public static string GetDefaultLabel(int offset)
{
int snes = ConvertPCtoSNES(offset);
return(string.Format("{0}_{1}", TypeToLabel(Data.GetFlag(offset)), NumberToBaseString(snes, NumberBase.Hexadecimal, 6)));
}
public static int Step(int offset, bool branch, bool force, int prevOffset)
{
int opcode = Data.GetROMByte(offset);
int prevDirectPage = Data.GetDirectPage(offset);
int prevDataBank = Data.GetDataBank(offset);
bool prevX = Data.GetXFlag(offset), prevM = Data.GetMFlag(offset);
while (prevOffset >= 0 && Data.GetFlag(prevOffset) == Data.FlagType.Operand)
{
prevOffset--;
}
if (prevOffset >= 0 && Data.GetFlag(prevOffset) == Data.FlagType.Opcode)
{
prevDirectPage = Data.GetDirectPage(prevOffset);
prevDataBank = Data.GetDataBank(prevOffset);
prevX = Data.GetXFlag(prevOffset);
prevM = Data.GetMFlag(prevOffset);
}
if (opcode == 0xC2 || opcode == 0xE2) // REP SEP
{
prevX = (Data.GetROMByte(offset + 1) & 0x10) != 0 ? opcode == 0xE2 : prevX;
prevM = (Data.GetROMByte(offset + 1) & 0x20) != 0 ? opcode == 0xE2 : prevM;
}
// set first byte first, so the instruction length is correct
Data.SetFlag(offset, Data.FlagType.Opcode);
Data.SetDataBank(offset, prevDataBank);
Data.SetDirectPage(offset, prevDirectPage);
Data.SetXFlag(offset, prevX);
Data.SetMFlag(offset, prevM);
int length = GetInstructionLength(offset);
for (int i = 1; i < length; i++)
{
Data.SetFlag(offset + i, Data.FlagType.Operand);
Data.SetDataBank(offset + i, prevDataBank);
Data.SetDirectPage(offset + i, prevDirectPage);
Data.SetXFlag(offset + i, prevX);
Data.SetMFlag(offset + i, prevM);
}
MarkInOutPoints(offset);
int nextOffset = offset + length;
if (!force && (opcode == 0x4C || opcode == 0x5C || opcode == 0x80 || opcode == 0x82 || // JMP JML BRA BRL
(branch && (opcode == 0x10 || opcode == 0x30 || opcode == 0x50 || // BPL BMI BVC
opcode == 0x70 || opcode == 0x90 || opcode == 0xB0 || opcode == 0xD0 || // BVS BCC BCS BNE
opcode == 0xF0 || opcode == 0x20 || opcode == 0x22)))) // BEQ JSR JSL
{
int iaNextOffsetPC = Util.ConvertSNEStoPC(Util.GetIntermediateAddress(offset, true));
if (iaNextOffsetPC >= 0)
{
nextOffset = iaNextOffsetPC;
}
}
return(nextOffset);
}
private static int GetLineByteLength(int offset)
{
int max = 1, step = 1;
int size = Data.GetROMSize();
switch (Data.GetFlag(offset))
{
case Data.FlagType.Opcode:
switch (Data.GetArchitechture(offset))
{
case Data.Architechture.CPU65C816: return(CPU65C816.GetInstructionLength(offset));
case Data.Architechture.APUSPC700: return(1);
case Data.Architechture.GPUSuperFX: return(1);
}
return(1);
case Data.FlagType.Unreached:
case Data.FlagType.Operand:
case Data.FlagType.Data8Bit:
case Data.FlagType.Graphics:
case Data.FlagType.Music:
case Data.FlagType.Empty:
max = dataPerLine;
break;
case Data.FlagType.Text:
max = 21;
break;
case Data.FlagType.Data16Bit:
step = 2;
max = dataPerLine;
break;
case Data.FlagType.Data24Bit:
step = 3;
max = dataPerLine;
break;
case Data.FlagType.Data32Bit:
step = 4;
max = dataPerLine;
break;
case Data.FlagType.Pointer16Bit:
step = 2;
max = 2;
break;
case Data.FlagType.Pointer24Bit:
step = 3;
max = 3;
break;
case Data.FlagType.Pointer32Bit:
step = 4;
max = 4;
break;
}
int min = step, myBank = offset / bankSize;
while (
min < max &&
offset + min < size &&
Data.GetFlag(offset + min) == Data.GetFlag(offset) &&
Data.GetLabel(Util.ConvertPCtoSNES(offset + min)) == "" &&
(offset + min) / bankSize == myBank
)
{
min += step;
}
return(min);
}
public static void PaintCell(int offset, DataGridViewCellStyle style, int column, int selOffset)
{
// editable cells show up green
if (column == 0 || column == 8 || column == 9 || column == 12)
{
style.SelectionBackColor = Color.Chartreuse;
}
switch (Data.GetFlag(offset))
{
case Data.FlagType.Unreached:
style.BackColor = Color.LightGray;
style.ForeColor = Color.DarkSlateGray;
break;
case Data.FlagType.Opcode:
int opcode = Data.GetROMByte(offset);
switch (column)
{
case 4: // <*>
Data.InOutPoint point = Data.GetInOutPoint(offset);
int r = 255, g = 255, b = 255;
if ((point & (Data.InOutPoint.EndPoint | Data.InOutPoint.OutPoint)) != 0)
{
g -= 50;
}
if ((point & (Data.InOutPoint.InPoint)) != 0)
{
r -= 50;
}
if ((point & (Data.InOutPoint.ReadPoint)) != 0)
{
b -= 50;
}
style.BackColor = Color.FromArgb(r, g, b);
break;
case 5: // Instruction
if (opcode == 0x40 || opcode == 0xCB || opcode == 0xDB || opcode == 0xF8 || // RTI WAI STP SED
opcode == 0xFB || opcode == 0x00 || opcode == 0x02 || opcode == 0x42 // XCE BRK COP WDM
)
{
style.BackColor = Color.Yellow;
}
break;
case 8: // Data Bank
if (opcode == 0xAB || opcode == 0x44 || opcode == 0x54) // PLB MVP MVN
{
style.BackColor = Color.OrangeRed;
}
else if (opcode == 0x8B) // PHB
{
style.BackColor = Color.Yellow;
}
break;
case 9: // Direct Page
if (opcode == 0x2B || opcode == 0x5B) // PLD TCD
{
style.BackColor = Color.OrangeRed;
}
if (opcode == 0x0B || opcode == 0x7B) // PHD TDC
{
style.BackColor = Color.Yellow;
}
break;
case 10: // M Flag
case 11: // X Flag
int mask = column == 10 ? 0x20 : 0x10;
if (opcode == 0x28 || ((opcode == 0xC2 || opcode == 0xE2) && // PLP SEP REP
(Data.GetROMByte(offset + 1) & mask) != 0)) // relevant bit set
{
style.BackColor = Color.OrangeRed;
}
if (opcode == 0x08) // PHP
{
style.BackColor = Color.Yellow;
}
break;
}
break;
case Data.FlagType.Operand:
style.ForeColor = Color.LightGray;
break;
case Data.FlagType.Graphics:
style.BackColor = Color.LightPink;
break;
case Data.FlagType.Music:
style.BackColor = Color.PowderBlue;
break;
case Data.FlagType.Data8Bit:
case Data.FlagType.Data16Bit:
case Data.FlagType.Data24Bit:
case Data.FlagType.Data32Bit:
style.BackColor = Color.NavajoWhite;
break;
case Data.FlagType.Pointer16Bit:
case Data.FlagType.Pointer24Bit:
case Data.FlagType.Pointer32Bit:
style.BackColor = Color.Orchid;
break;
case Data.FlagType.Text:
style.BackColor = Color.Aquamarine;
break;
case Data.FlagType.Empty:
style.BackColor = Color.DarkSlateGray;
style.ForeColor = Color.LightGray;
break;
}
if (selOffset >= 0 && selOffset < Data.GetROMSize())
{
if (column == 1
//&& (Data.GetFlag(selOffset) == Data.FlagType.Opcode || Data.GetFlag(selOffset) == Data.FlagType.Unreached)
&& ConvertSNEStoPC(GetIntermediateAddressOrPointer(selOffset)) == offset
)
{
style.BackColor = Color.DeepPink;
}
if (column == 6
//&& (Data.GetFlag(offset) == Data.FlagType.Opcode || Data.GetFlag(offset) == Data.FlagType.Unreached)
&& ConvertSNEStoPC(GetIntermediateAddressOrPointer(offset)) == selOffset
)
{
style.BackColor = Color.DeepPink;
}
}
}
public static string GetDefaultLabel(int address)
{
int pc = ConvertSNEStoPC(address);
return(string.Format("{0}_{1}", TypeToLabel(Data.GetFlag(pc)), NumberToBaseString(address, NumberBase.Hexadecimal, 6)));
}
