public KeymapEntry GetKeymapEntry(System.Windows.Forms.Keys keyData) { if (!Keymap.ContainsKey(keyData)) { return(null); } return(Keymap[keyData]); }
public ProjectConfig Configuration(string ConfigName) { if (Configs.ContainsKey(ConfigName)) { return(Configs[ConfigName]); } return(null); }
public bool FetchValue(int Address, out byte Content) { Content = 0; if (State != DebuggerState.PAUSED) { return(false); } if (!m_RequestedMemoryValues[Address]) { m_RequestedMemoryValues[Address] = true; m_MemoryValues.Remove(Address); RequestData requData = new RequestData(DebugRequestType.MEM_DUMP); requData.Parameter1 = Address; requData.Parameter2 = Address + 1 - 1; requData.Info = ""; QueueRequest(requData); } else if (m_MemoryValues.ContainsKey(Address)) { Content = m_MemoryValues[Address]; return(true); } return(false); }
public void AddVirtualBreakpoints(Types.ASM.FileInfo ASMFileInfo) { if (ASMFileInfo == null) { return; } foreach (var virtualBP in ASMFileInfo.VirtualBreakpoints.Values) { virtualBP.IsVirtual = true; int globalLineIndex = -1; if (!ASMFileInfo.FindGlobalLineIndex(virtualBP.LineIndex, virtualBP.DocumentFilename, out globalLineIndex)) { Core.AddToOutput("Cannot assign breakpoint for line " + virtualBP.LineIndex + ", no address found" + System.Environment.NewLine); continue; } int address = ASMFileInfo.FindLineAddress(globalLineIndex); if (address != -1) { var existingBP = BreakpointAtAddress(address); if (existingBP == null) { C64Studio.Types.Breakpoint bp = new C64Studio.Types.Breakpoint(); bp.LineIndex = virtualBP.LineIndex; bp.Address = address; bp.TriggerOnExec = true; bp.IsVirtual = true; bp.DocumentFilename = virtualBP.DocumentFilename; bp.Virtual.Add(virtualBP); virtualBP.Address = address; // we just need any key (as null is not allowed) if (!BreakPoints.ContainsKey("C64Studio.DebugBreakpoints")) { BreakPoints.Add("C64Studio.DebugBreakpoints", new List <C64Studio.Types.Breakpoint>()); } BreakPoints["C64Studio.DebugBreakpoints"].Add(bp); //AddBreakpoint( bp ); Debug.Log("Add virtual bp for $" + address.ToString("X4")); } else { // merge with existing existingBP.TriggerOnExec = true; existingBP.Virtual.Add(virtualBP); } } else { Core.AddToOutput("Cannot assign breakpoint for line " + virtualBP.LineIndex + ", no address found" + System.Environment.NewLine); } } }
public KeymapEntry GetDefaultKeymapEntry(uint curNeutralLangID, System.Windows.Forms.Keys keyData) { if (!DefaultKeymaps.ContainsKey(curNeutralLangID)) { // fallback to english if (curNeutralLangID == 9) { return(null); } if (curNeutralLangID != 9) { curNeutralLangID = 9; } } if ((!DefaultKeymaps.ContainsKey(curNeutralLangID)) && (!DefaultKeymaps[curNeutralLangID].ContainsKey(keyData))) { return(null); } return(DefaultKeymaps[curNeutralLangID][keyData]); }
public SymbolInfo TokenInfoFromName(string Token, string Zone, string CheapLabelParent) { if (AssemblerSettings != null) { if (!AssemblerSettings.CaseSensitive) { Token = Token.ToUpper(); } } if (!Labels.ContainsKey(Token)) { if (Token.StartsWith("@")) { if (Labels.ContainsKey(CheapLabelParent + Token)) { return(Labels[CheapLabelParent + Token]); } } if (Labels.ContainsKey(Zone + Token)) { return(Labels[Zone + Token]); } var tempLabel = TempLabelInfo.FirstOrDefault(tl => tl.Name == Token); if (tempLabel != null) { return(tempLabel.Symbol); } if (Macros.ContainsKey(Token)) { return(Macros[Token].Symbol); } return(null); } return(Labels[Token]); }
public MacroFunctionInfo MacroFromName(string MacroName) { if (AssemblerSettings != null) { if (!AssemblerSettings.CaseSensitive) { MacroName = MacroName.ToUpper(); } } if (!Macros.ContainsKey(MacroName)) { return(null); } return(Macros[MacroName]); }
public int Handle(string[] args) { if (args.Length == 0) { System.Console.WriteLine("MediaManager V" + System.Windows.Forms.Application.ProductVersion); System.Console.WriteLine(""); System.Console.WriteLine("Call with mediamanager"); System.Console.WriteLine(" [-d64 <disk image>]"); System.Console.WriteLine(" [-t64 <tape file>]"); System.Console.WriteLine(" [-import <file name>[,load address]]"); System.Console.WriteLine(" [-export <file name>]"); System.Console.WriteLine(" [-rename <file name>]"); System.Console.WriteLine(" [-renameto <file name>]"); System.Console.WriteLine(" [-delete <file name>]"); System.Console.WriteLine(" [-listfiles]"); System.Console.WriteLine(""); System.Console.WriteLine("load address can be given as decimal, hexadecimal (prefix $ or 0x). If load address is given it is prepended to the import file data."); System.Console.WriteLine("The filename given to -renameto is used for the actually written file when exporting"); System.Console.WriteLine("The filename given to -renameto is used for the file info entry when importing"); return(1); } bool expectingParameter = false; string expectingParameterName = ""; string methodToUse = ""; GR.Collections.Map <string, string> paramMap = new GR.Collections.Map <string, string>(); for (int i = 0; i < args.Length; ++i) { if (expectingParameter) { paramMap[expectingParameterName] = args[i]; expectingParameter = false; } else if ((args[i].ToUpper() == "-D64") || (args[i].ToUpper() == "-T64") || (args[i].ToUpper() == "-IMPORT") || (args[i].ToUpper() == "-DELETE") || (args[i].ToUpper() == "-RENAME") || (args[i].ToUpper() == "-RENAMETO") || (args[i].ToUpper() == "-EXPORT")) { expectingParameter = true; expectingParameterName = args[i].ToUpper(); if ((expectingParameterName == "-IMPORT") || (expectingParameterName == "-EXPORT") || (expectingParameterName == "-DELETE") || (expectingParameterName == "-RENAME")) { methodToUse = expectingParameterName; } } else if (args[i].ToUpper() == "-LISTFILES") { paramMap[args[i].ToUpper()] = ""; methodToUse = args[i].ToUpper(); } else { System.Console.Error.WriteLine("Unsupported option " + args[i]); return(1); } } if (expectingParameter) { System.Console.Error.WriteLine("Missing value for " + expectingParameterName); return(1); } // do we have a container? if ((!paramMap.ContainsKey("-D64")) && (!paramMap.ContainsKey("-T64"))) { System.Console.Error.WriteLine("Missing medium"); return(1); } // load C64Studio.Formats.MediaFormat medium = null; string mediumFilename = ""; if (paramMap.ContainsKey("-D64")) { medium = new C64Studio.Formats.D64(); mediumFilename = paramMap["-D64"]; } else if (paramMap.ContainsKey("-T64")) { medium = new C64Studio.Formats.T64(); mediumFilename = paramMap["-T64"]; } if (!medium.Load(mediumFilename)) { System.Console.WriteLine("No image found, start empty"); medium.CreateEmptyMedia(); } // handle command if (methodToUse == "-LISTFILES") { List <C64Studio.Types.FileInfo> files = medium.Files(); foreach (C64Studio.Types.FileInfo file in files) { string filename = C64Studio.Util.FilenameToReadableUnicode(file.Filename); filename = filename.PadRight(16); System.Console.WriteLine("\"" + filename + "\" " + file.Blocks + " blocks " + file.Type.ToString() + " " + file.Filename); } System.Console.WriteLine(files.Count + " files"); } else if (methodToUse == "-EXPORT") { C64Studio.Types.FileInfo fileInfo = medium.LoadFile(C64Studio.Util.ToFilename(paramMap["-EXPORT"])); if (fileInfo != null) { string outputFilename = paramMap["-EXPORT"]; if (paramMap.ContainsKey("-RENAMETO")) { outputFilename = paramMap["-RENAMETO"]; } GR.IO.File.WriteAllBytes(outputFilename, fileInfo.Data); System.Console.WriteLine("File " + paramMap["-EXPORT"] + " exported"); } else { System.Console.Error.WriteLine("File " + paramMap["-EXPORT"] + " not found in medium"); } } else if (methodToUse == "-DELETE") { C64Studio.Types.FileInfo fileInfo = medium.LoadFile(C64Studio.Util.ToFilename(paramMap["-DELETE"])); if (fileInfo != null) { if (!medium.DeleteFile(C64Studio.Util.ToFilename(paramMap["-DELETE"]))) { System.Console.Error.WriteLine("File could not be deleted: " + medium.LastError); } else { System.Console.WriteLine("File deleted"); medium.Save(mediumFilename); } } else { System.Console.Error.WriteLine("File " + paramMap["-DELETE"] + " not found in medium"); } } else if (methodToUse == "-IMPORT") { bool addAddress = false; ushort startAddress = 0x0801; string filenameImport = paramMap["-IMPORT"]; string[] paramList = filenameImport.Split(','); if ((paramList.Length == 0) || (paramList.Length > 2)) { System.Console.Error.WriteLine("Invalid parameter value for -IMPORT"); return(1); } filenameImport = paramList[0]; if (paramList.Length >= 2) { addAddress = true; string loadAdressPart = paramList[1]; if (loadAdressPart.StartsWith("0x")) { ushort.TryParse(loadAdressPart.Substring(2), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out startAddress); } else if (loadAdressPart.StartsWith("$")) { ushort.TryParse(loadAdressPart.Substring(1), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out startAddress); } else { ushort.TryParse(loadAdressPart, out startAddress); } } GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(filenameImport); if (data == null) { System.Console.Error.WriteLine("Could not read file " + paramMap["-IMPORT"]); return(1); } // insert load address if (addAddress) { GR.Memory.ByteBuffer newData = new GR.Memory.ByteBuffer(2 + data.Length); newData.SetU16At(0, startAddress); data.CopyTo(newData, 0, (int)data.Length, 2); data = newData; } if (paramMap.ContainsKey("-RENAMETO")) { filenameImport = paramMap["-RENAMETO"]; } if (!medium.WriteFile(C64Studio.Util.ToFilename(filenameImport), data, C64Studio.Types.FileType.PRG)) { System.Console.Error.WriteLine("Could not write file to medium: " + medium.LastError); return(1); } System.Console.WriteLine("File imported"); medium.Save(mediumFilename); } else if (methodToUse == "-RENAME") { if (!paramMap.ContainsKey("-RENAMETO")) { System.Console.Error.WriteLine("Missing -renameto directive"); return(1); } string origFilename = paramMap["-RENAME"]; GR.Memory.ByteBuffer origFilenameBuffer = C64Studio.Util.ToFilename(origFilename); string targetFilename = paramMap["-RENAMETO"]; GR.Memory.ByteBuffer targetFilenameBuffer = C64Studio.Util.ToFilename(targetFilename); if (!medium.RenameFile(origFilenameBuffer, targetFilenameBuffer)) { System.Console.Error.WriteLine("Failed to rename file"); return(1); } System.Console.WriteLine("File renamed"); medium.Save(mediumFilename); } else { System.Console.Error.WriteLine("Unsupported method " + methodToUse); } return(0); }
private void RefreshNodes() { treeProject.BeginUpdate(); NodeRoot.Nodes.Clear(); IList <Types.SymbolInfo> sortedTokens = null; // sort by line number if (Core.Settings.OutlineSortByIndex) { GR.Collections.MultiMap <int, Types.SymbolInfo> sortedTokensInner = new GR.Collections.MultiMap <int, C64Studio.Types.SymbolInfo>(); foreach (KeyValuePair <string, Types.SymbolInfo> token in OutlineTokens) { if (!string.IsNullOrEmpty(Core.Settings.OutlineFilter)) { if (token.Key.ToUpper().Contains(Core.Settings.OutlineFilter.ToUpper())) { sortedTokensInner.Add(token.Value.LineIndex, token.Value); } } else { sortedTokensInner.Add(token.Value.LineIndex, token.Value); } } sortedTokens = sortedTokensInner.Values; } else { GR.Collections.MultiMap <string, Types.SymbolInfo> sortedTokensInner = new GR.Collections.MultiMap <string, C64Studio.Types.SymbolInfo>(); foreach (KeyValuePair <string, Types.SymbolInfo> token in OutlineTokens) { if (!string.IsNullOrEmpty(Core.Settings.OutlineFilter)) { if (token.Key.ToUpper().Contains(Core.Settings.OutlineFilter.ToUpper())) { sortedTokensInner.Add(token.Key.ToUpper(), token.Value); } } else { sortedTokensInner.Add(token.Key.ToUpper(), token.Value); } } sortedTokens = sortedTokensInner.Values; } string curZone = ""; System.Windows.Forms.TreeNode parentNode = new System.Windows.Forms.TreeNode(); parentNode = new System.Windows.Forms.TreeNode(); parentNode.Text = "Global Zone"; parentNode.ImageIndex = parentNode.SelectedImageIndex = 0; NodeRoot.Nodes.Add(parentNode); System.Windows.Forms.TreeNode globalZone = parentNode; Dictionary <string, TreeNode> zoneNodes = new Dictionary <string, TreeNode>(); zoneNodes.Add(parentNode.Text, globalZone); // add zone nodes first foreach (var token in sortedTokens) { if (token.Type == C64Studio.Types.SymbolInfo.Types.ZONE) { System.Windows.Forms.TreeNode node = new System.Windows.Forms.TreeNode(); node.Text = token.Name; node.Tag = token; parentNode = new System.Windows.Forms.TreeNode(); parentNode.Text = token.Zone; parentNode.ImageIndex = parentNode.SelectedImageIndex = 0; NodeRoot.Nodes.Add(parentNode); parentNode.Tag = token; zoneNodes.Add(parentNode.Text, parentNode); } } // now add child nodes parentNode = globalZone; foreach (var token in sortedTokens) { if (token.Type == C64Studio.Types.SymbolInfo.Types.ZONE) { curZone = token.Zone; parentNode = zoneNodes[token.Zone]; continue; } System.Windows.Forms.TreeNode node = new System.Windows.Forms.TreeNode(); bool addNode = true; node.Text = token.Name; node.Tag = token; switch (token.Type) { case C64Studio.Types.SymbolInfo.Types.CONSTANT_1: case C64Studio.Types.SymbolInfo.Types.CONSTANT_2: node.ImageIndex = node.SelectedImageIndex = 2; node.Text += " = $" + token.AddressOrValue.ToString("X4"); break; case C64Studio.Types.SymbolInfo.Types.LABEL: if ((token.Name.Contains(".")) && (!Core.Settings.OutlineShowLocalLabels)) { addNode = false; } if ((token.Name.StartsWith(C64Studio.Parser.ASMFileParser.InternalLabelPrefix)) && (!Core.Settings.OutlineShowShortCutLabels)) { addNode = false; } node.ImageIndex = node.SelectedImageIndex = 1; node.Text += " = $" + token.AddressOrValue.ToString("X4"); break; case C64Studio.Types.SymbolInfo.Types.PREPROCESSOR_LABEL: case C64Studio.Types.SymbolInfo.Types.PREPROCESSOR_CONSTANT_1: case C64Studio.Types.SymbolInfo.Types.PREPROCESSOR_CONSTANT_2: node.ImageIndex = node.SelectedImageIndex = 3; node.Text += " = $" + token.AddressOrValue.ToString("X4"); break; case C64Studio.Types.SymbolInfo.Types.UNKNOWN: break; } if (!addNode) { continue; } // cut off zone try { // find parent node if ((string.IsNullOrEmpty(token.Zone)) || (!zoneNodes.ContainsKey(token.Zone))) { globalZone.Nodes.Add(node); } else //if ( curZone.Length > 0 ) { var parentZoneNode = zoneNodes[token.Zone]; int dotPos = node.Text.IndexOf('.'); string nodeParentText = parentZoneNode.Text; if (dotPos != -1) { node.Text = node.Text.Substring(dotPos); } parentZoneNode.Nodes.Add(node); if ((_ExpandedNodes.ContainsKey(nodeParentText)) && (_ExpandedNodes[nodeParentText])) { parentZoneNode.Expand(); } } } catch (Exception ex) { Debug.Log(ex.Message); } } NodeRoot.Expand(); treeProject.EndUpdate(); }
private string MnemonicToString(Tiny64.Opcode opcode, GR.Memory.ByteBuffer Data, int DataStartAddress, int CodePos, GR.Collections.Set <ushort> AccessedAddresses, GR.Collections.Map <int, string> NamedLabels) { string output = opcode.Mnemonic.ToLower(); ushort targetAddress = 0; bool twoBytes = true; switch (opcode.Addressing) { case Tiny64.Opcode.AddressingType.IMPLICIT: break; case Tiny64.Opcode.AddressingType.ABSOLUTE: targetAddress = Data.UInt16At(CodePos + 1 - DataStartAddress); break; case Tiny64.Opcode.AddressingType.ABSOLUTE_X: targetAddress = Data.UInt16At(CodePos + 1 - DataStartAddress); break; case Tiny64.Opcode.AddressingType.ABSOLUTE_Y: targetAddress = Data.UInt16At(CodePos + 1 - DataStartAddress); break; case Tiny64.Opcode.AddressingType.IMMEDIATE: targetAddress = Data.ByteAt(CodePos + 1 - DataStartAddress); twoBytes = false; break; case Tiny64.Opcode.AddressingType.INDIRECT: targetAddress = Data.UInt16At(CodePos + 1 - DataStartAddress); break; case Tiny64.Opcode.AddressingType.ZEROPAGE_INDIRECT_X: targetAddress = Data.ByteAt(CodePos + 1 - DataStartAddress); twoBytes = false; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_INDIRECT_Y: targetAddress = Data.ByteAt(CodePos + 1 - DataStartAddress); twoBytes = false; break; case Tiny64.Opcode.AddressingType.RELATIVE: { // int delta = value - lineInfo.AddressStart - 2; sbyte relValue = (sbyte)Data.ByteAt(CodePos + 1 - DataStartAddress); targetAddress = (ushort)(relValue + 2 + CodePos); } break; case Tiny64.Opcode.AddressingType.ZEROPAGE: targetAddress = Data.ByteAt(CodePos + 1 - DataStartAddress); twoBytes = false; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_X: targetAddress = Data.ByteAt(CodePos + 1 - DataStartAddress); twoBytes = false; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_Y: targetAddress = Data.ByteAt(CodePos + 1 - DataStartAddress); twoBytes = false; break; } string addressPlacement; if (twoBytes) { addressPlacement = "$" + targetAddress.ToString("x4"); } else { addressPlacement = "$" + targetAddress.ToString("x2"); } if (AccessedAddresses.ContainsValue(targetAddress)) { addressPlacement = "label_" + targetAddress.ToString("x4"); } if (NamedLabels.ContainsKey(targetAddress)) { addressPlacement = NamedLabels[targetAddress]; } switch (opcode.Addressing) { case Tiny64.Opcode.AddressingType.IMPLICIT: break; case Tiny64.Opcode.AddressingType.ABSOLUTE: output += " " + addressPlacement; break; case Tiny64.Opcode.AddressingType.ABSOLUTE_X: output += " " + addressPlacement + ", x"; break; case Tiny64.Opcode.AddressingType.ABSOLUTE_Y: output += " " + addressPlacement + ", y"; break; case Tiny64.Opcode.AddressingType.IMMEDIATE: output += " #" + addressPlacement; break; case Tiny64.Opcode.AddressingType.INDIRECT: output += " ( " + addressPlacement + " )"; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_INDIRECT_X: output += " ( " + addressPlacement + ", x)"; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_INDIRECT_Y: output += " ( " + addressPlacement + " ), y"; break; case Tiny64.Opcode.AddressingType.RELATIVE: { // int delta = value - lineInfo.AddressStart - 2; output += " " + addressPlacement; //output += " (" + delta.ToString( "X2" ) + ")"; } break; case Tiny64.Opcode.AddressingType.ZEROPAGE: output += " " + addressPlacement; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_X: output += " " + addressPlacement + ", x"; break; case Tiny64.Opcode.AddressingType.ZEROPAGE_Y: output += " " + addressPlacement + ", y"; break; } return(output); }
public bool Disassemble(int DataStartAddress, GR.Collections.Set <int> JumpedAtAddresses, GR.Collections.Map <int, string> NamedLabels, DisassemblerSettings Settings, out string Disassembly, out int FirstLineWithOpcode) { StringBuilder sb = new StringBuilder(); Disassembly = ""; FirstLineWithOpcode = 1; if (JumpedAtAddresses.Count == 0) { return(false); } int progStepPos = JumpedAtAddresses.First; GR.Collections.Set <ushort> accessedAddresses = new GR.Collections.Set <ushort>(); GR.Collections.Set <int> addressesToCheck = new GR.Collections.Set <int>(JumpedAtAddresses); GR.Collections.Set <int> addressesChecked = new GR.Collections.Set <int>(); GR.Collections.Set <ushort> probableLabel = new GR.Collections.Set <ushort>(); // check for basic header int sysAddress = -1; if (HasBASICJumpAddress(DataStartAddress, out sysAddress)) { progStepPos = sysAddress; addressesToCheck.Add(progStepPos); } /* * else * { * // automatically check at data start address * addressesToCheck.Add( DataStartAddress ); * }*/ int codeStartPos = progStepPos; GR.Collections.Map <ushort, GR.Generic.Tupel <Tiny64.Opcode, ushort> > disassembly = new GR.Collections.Map <ushort, GR.Generic.Tupel <Tiny64.Opcode, ushort> >(); while (addressesToCheck.Count > 0) { progStepPos = addressesToCheck.First; //Debug.Log( "check address:" + progStepPos ); addressesToCheck.Remove(progStepPos); if (addressesChecked.ContainsValue(progStepPos)) { continue; } while (true) { if (progStepPos < DataStartAddress) { break; } /* * sb.Append( "Jumped to address before data\r\n" ); * Disassembly = sb.ToString(); * return false; * }*/ if (progStepPos >= DataStartAddress + m_SourceData.Length) { // reached the end break; } Tiny64.Opcode opcode = null; bool outsideData = false; if (!DisassembleInstruction(m_SourceData, DataStartAddress, progStepPos, out opcode, out outsideData)) { if (!outsideData) { sb.Append("Failed to disassemble data $" + m_SourceData.ByteAt(progStepPos - DataStartAddress).ToString("X2") + " at location " + progStepPos + "($" + progStepPos.ToString("X4") + ")\r\n"); Disassembly = sb.ToString(); return(false); } } if (outsideData) { break; } addressesChecked.Add(progStepPos); //Debug.Log( "Mnemonic: " + OpcodeToString( opcode, Data, progStepPos + 1 - DataStartAddress ) ); //Debug.Log( progStepPos.ToString( "X4" ) + ": " + MnemonicToString( opcode, Data, DataStartAddress, progStepPos ) ); if ((opcode.ByteValue == 0x4c) || // jmp (opcode.ByteValue == 0x20)) // jsr { // absolute jump accessedAddresses.Add(m_SourceData.UInt16At(progStepPos + 1 - DataStartAddress)); addressesToCheck.Add(m_SourceData.UInt16At(progStepPos + 1 - DataStartAddress)); //Debug.Log( "access address " + Data.UInt16At( progStepPos + 1 ).ToString( "X4" ) ); } else if (opcode.ByteValue == 0x6c) // jmp indirect { probableLabel.Add(m_SourceData.UInt16At(progStepPos + 1 - DataStartAddress)); } else if (opcode.Addressing == Tiny64.Opcode.AddressingType.RELATIVE) { int targetAddress = (sbyte)m_SourceData.ByteAt(progStepPos + 1 - DataStartAddress) + 2 + progStepPos; probableLabel.Add((ushort)targetAddress); addressesToCheck.Add(targetAddress); accessedAddresses.Add((ushort)targetAddress); } disassembly[(ushort)progStepPos] = new GR.Generic.Tupel <Tiny64.Opcode, ushort>(opcode, m_SourceData.UInt16At(progStepPos + 1)); if ((opcode.ByteValue == 0x40) || // rts (opcode.ByteValue == 0x60) || // rti (opcode.ByteValue == 0x4c)) // jmp { // end of code here break; } //string output = MnemonicToString( opcode, Data, DataStartAddress, progStepPos ); //Debug.Log( output ); progStepPos += opcode.NumOperands + 1; } } progStepPos = codeStartPos; //foreach ( KeyValuePair<ushort,GR.Generic.Tupel<Opcode, ushort>> instruction in disassembly ) // remove potential labels that are not in our code GR.Collections.Set <ushort> addressesToRemove = new GR.Collections.Set <ushort>(); foreach (var accessedAddress in accessedAddresses) { if (!disassembly.ContainsKey(accessedAddress)) { addressesToRemove.Add(accessedAddress); } } foreach (var addressToRemove in addressesToRemove) { accessedAddresses.Remove(addressToRemove); } sb.Append("* = $"); sb.AppendLine(DataStartAddress.ToString("x4")); if (!Settings.AddLineAddresses) { foreach (var namedLabel in NamedLabels) { sb.Append(namedLabel.Value); sb.Append(" = $"); sb.AppendLine(namedLabel.Key.ToString("X4")); } if (NamedLabels.Count > 0) { sb.AppendLine(); } } int trueAddress = DataStartAddress; bool hadBytes = false; int hadBytesStart = 0; int localLineIndex = 1; while (trueAddress < DataStartAddress + m_SourceData.Length) { if (disassembly.ContainsKey((ushort)trueAddress)) { if (hadBytes) { sb.Append(DisassembleBinary(m_SourceData, DataStartAddress, hadBytesStart, trueAddress - hadBytesStart, Settings)); hadBytes = false; } GR.Generic.Tupel <Tiny64.Opcode, ushort> instruction = disassembly[(ushort)trueAddress]; if (Settings.AddLineAddresses) { sb.Append("$"); sb.Append(trueAddress.ToString("X4") + ": "); } if (DataStartAddress == trueAddress) { FirstLineWithOpcode = localLineIndex; } ++localLineIndex; if (accessedAddresses.ContainsValue((ushort)trueAddress)) { // line break in front of named label sb.AppendLine(); if (Settings.AddLineAddresses) { sb.Append("$"); sb.Append(trueAddress.ToString("X4") + ": "); } if (NamedLabels.ContainsKey(trueAddress)) { sb.AppendLine(NamedLabels[trueAddress]); } else { sb.Append("label_" + trueAddress.ToString("x4") + "\r\n"); } if (Settings.AddLineAddresses) { sb.Append("$"); sb.Append(trueAddress.ToString("X4") + ": "); } } else if (NamedLabels.ContainsKey(trueAddress)) { // line break in front of named label sb.AppendLine(); if (Settings.AddLineAddresses) { sb.Append("$"); sb.Append(trueAddress.ToString("X4") + ": "); } sb.AppendLine(NamedLabels[trueAddress]); if (Settings.AddLineAddresses) { sb.Append("$"); sb.Append(trueAddress.ToString("X4") + ": "); } } if (Settings.AddAssembledBytes) { sb.Append(" "); sb.Append(instruction.first.ByteValue.ToString("X2")); switch (instruction.first.NumOperands) { case 0: sb.Append(" "); break; case 1: sb.Append(" "); sb.Append(m_SourceData.ByteAt(trueAddress + 1 - DataStartAddress).ToString("X2")); sb.Append(" "); break; case 2: sb.Append(" "); sb.Append(m_SourceData.ByteAt(trueAddress + 1 - DataStartAddress).ToString("X2")); sb.Append(" "); sb.Append(m_SourceData.ByteAt(trueAddress + 1 - DataStartAddress + 1).ToString("X2")); break; } } sb.Append(" " + MnemonicToString(instruction.first, m_SourceData, DataStartAddress, trueAddress, accessedAddresses, NamedLabels)); sb.Append("\r\n"); trueAddress += instruction.first.NumOperands + 1; } else { if (!hadBytes) { hadBytes = true; hadBytesStart = trueAddress; } ++trueAddress; } } if (hadBytes) { sb.Append(DisassembleBinary(m_SourceData, DataStartAddress, hadBytesStart, trueAddress - hadBytesStart, Settings)); hadBytes = false; } Disassembly = sb.ToString(); return(true); }
bool CheckColors() { // can all colors be matched to the palette? GR.Collections.Map <uint, byte> matchedColors = new GR.Collections.Map <uint, byte>(); for (int i = 0; i < m_OrigSize.Width; ++i) { for (int j = 0; j < m_OrigSize.Height; ++j) { uint pixelValue = picOriginal.DisplayPage.GetPixel(i, j); byte matchedColor = 0; if (matchedColors.ContainsKey(pixelValue)) { matchedColor = matchedColors[pixelValue]; m_ImportImage.SetPixel(i, j, matchedColor); } else { // TODO - match byte red = (byte)((pixelValue & 0xff0000) >> 16); byte green = (byte)((pixelValue & 0x00ff00) >> 8); byte blue = (byte)(pixelValue & 0xff); if ((picOriginal.DisplayPage.PixelFormat == System.Drawing.Imaging.PixelFormat.Format4bppIndexed) || (picOriginal.DisplayPage.PixelFormat == System.Drawing.Imaging.PixelFormat.Format1bppIndexed) || (picOriginal.DisplayPage.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)) { red = picOriginal.DisplayPage.PaletteRed((int)pixelValue); green = picOriginal.DisplayPage.PaletteGreen((int)pixelValue); blue = picOriginal.DisplayPage.PaletteBlue((int)pixelValue); } //ColorSystem.RGB rgb = new ColorSystem.RGB( red, green, blue ); // HSV-system (painter!) int bestMatch = MatchColor(red, green, blue, m_CurPalette); /* * int bestMatchDistance = 50000000; * int bestMatch = -1; * for ( int k = 0; k < 16; ++k ) * { * int distR = red - (int)( ( m_CurPalette.ColorValues[k] & 0xff0000 ) >> 16 ); * int distG = green - (int)( ( m_CurPalette.ColorValues[k] & 0x00ff00 ) >> 8 ); * int distB = blue - (int)( m_CurPalette.ColorValues[k] & 0xff ); * //int distance = (int)( distR * distR * 0.3f + distG * distG * 0.6f + distB * distB * 0.1f ); * int distance = (int)( distR * distR + distG * distG + distB * distB ); * * if ( distance < bestMatchDistance ) * { * bestMatchDistance = distance; * bestMatch = k; * } * }*/ if (bestMatch == -1) { m_ImportImage.SetPixel(i, j, 16); } else { matchedColor = (byte)bestMatch; matchedColors[pixelValue] = matchedColor; m_ImportImage.SetPixel(i, j, matchedColor); } } } } picPreview.DisplayPage.DrawFromMemoryImage(m_ImportImage, 0, 0); picPreview.Invalidate(); return(true); }