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))); }