1
0
mirror of https://github.com/fadden/6502bench.git synced 2024-12-11 13:50:13 +00:00
6502bench/SourceGen/WpfGui/FormatAddressTable.xaml.cs

566 lines
23 KiB
C#
Raw Normal View History

/*
* Copyright 2019 faddenSoft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using Asm65;
using CommonUtil;
namespace SourceGen.WpfGui {
/// <summary>
/// Split-address table generator.
/// </summary>
public partial class FormatAddressTable : Window, INotifyPropertyChanged {
/// Format descriptors to apply.
/// </summary>
public SortedList<int, FormatDescriptor> NewFormatDescriptors { get; private set; }
/// <summary>
/// User labels to apply.
/// </summary>
public Dictionary<int, Symbol> NewUserLabels { get; private set; }
/// <summary>
/// All target offsets found. The list may contain redundant entries.
/// </summary>
public List<int> AllTargetOffsets { get; private set; }
/// <summary>
/// If set, targets are offset by one for RTS/RTL.
/// </summary>
public bool IsAdjustedForReturn {
get { return mIsAdjustedForReturn; }
set { mIsAdjustedForReturn = value; OnPropertyChanged(); UpdateControls(); }
}
private bool mIsAdjustedForReturn;
/// <summary>
/// If set, this is a split-address table, e.g. all of the low bytes are followed
/// by all of the high bytes.
/// </summary>
public bool IsSplitTable {
get { return mIsSplitTable; }
set { mIsSplitTable = value; OnPropertyChanged(); UpdateControls(); }
}
private bool mIsSplitTable;
/// <summary>
/// If set, caller will add code start points to targets.
/// </summary>
public bool WantCodeStartPoints {
get { return mWantCodeStartPoints; }
set {
mWantCodeStartPoints = value;
OnPropertyChanged();
}
}
private bool mWantCodeStartPoints;
/// <summary>
/// Set to true to make the "incompatible with selection" message visible.
/// </summary>
public bool IncompatibleSelectionVisibility {
get { return mIncompatibleSelectionVisibility; }
set {
mIncompatibleSelectionVisibility = value;
OnPropertyChanged();
}
}
private bool mIncompatibleSelectionVisibility;
/// <summary>
/// Set to true to make the "invalid constant" message visible.
/// </summary>
public bool InvalidConstantVisibility {
get { return mInvalidConstantVisibility; }
set {
mInvalidConstantVisibility = value;
OnPropertyChanged();
}
}
private bool mInvalidConstantVisibility;
/// <summary>
/// Set to true when valid output is available.
/// </summary>
private bool mOutputReady;
/// <summary>
/// Set to true when input is valid. Controls whether the OK button is enabled.
/// </summary>
public bool IsValid {
get { return mIsValid; }
set { mIsValid = value; OnPropertyChanged(); }
}
private bool mIsValid;
public class OutputPreviewItem {
public string Addr { get; private set; }
public string Offset { get; private set; }
public string Symbol { get; private set; }
public OutputPreviewItem(string addr, string offset, string symbol) {
Addr = addr;
Offset = offset;
Symbol = symbol;
}
}
public ObservableCollection<OutputPreviewItem> OutputPreviewList { get; private set; }
/// <summary>
/// Selected offsets. An otherwise contiguous range of offsets can be broken up
/// by user-specified labels and address discontinuities, so this needs to be
/// processed by range.
/// </summary>
private TypedRangeSet mSelection;
/// <summary>
/// Project reference.
/// </summary>
private DisasmProject mProject;
/// <summary>
/// Formatter to use when displaying addresses and hex values.
/// </summary>
private Formatter mFormatter;
/// <summary>
/// Reentrancy block for UpdateControls().
/// </summary>
private bool mUpdating;
// INotifyPropertyChanged implementation
public event PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged([CallerMemberName] string propertyName = "") {
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
public FormatAddressTable(Window owner, DisasmProject project, TypedRangeSet selection,
Formatter formatter) {
InitializeComponent();
Owner = owner;
DataContext = this;
mProject = project;
mFormatter = formatter;
mSelection = selection;
IsValid = false;
OutputPreviewList = new ObservableCollection<OutputPreviewItem>();
}
private void Window_Loaded(object sender, RoutedEventArgs e) {
mUpdating = true;
string fmt, infoStr;
if (mSelection.RangeCount == 1 && mSelection.Count == 1) {
infoStr = (string)FindResource("str_SingleByte");
} else if (mSelection.RangeCount == 1) {
fmt = (string)FindResource("str_SingleGroup");
infoStr = string.Format(fmt, mSelection.Count);
} else {
fmt = (string)FindResource("str_MultiGroup");
infoStr = string.Format(fmt, mSelection.Count, mSelection.RangeCount);
}
selectionInfoLabel.Text = infoStr;
width16Radio.IsChecked = true;
lowFirstPartRadio.IsChecked = true;
highSecondPartRadio.IsChecked = true;
bankNthPartRadio.IsChecked = true;
IncompatibleSelectionVisibility = InvalidConstantVisibility = false;
if (mProject.CpuDef.HasAddr16) {
// Disable the 24-bit option. Having 16-bit selected will disable the rest.
width24Radio.IsEnabled = false;
}
mUpdating = false;
UpdateControls();
}
private void OkButton_Click(object sender, RoutedEventArgs e) {
DialogResult = true;
}
private void UpdateControls() {
if (mUpdating) {
return;
}
mUpdating = true; // no re-entry
// handled with XAML bindings
//lowThirdPartRadio.Enabled = width24Radio.Checked;
//highThirdPartRadio.Enabled = width24Radio.Checked;
//bankByteGroupBox.Enabled = width24Radio.Checked;
lowSecondPartRadio.IsEnabled = true;
// If the user selects "constant" for high byte or bank byte, then there is no
// 3rd part available for low/high, so we need to turn those back off.
if (width24Radio.IsChecked == true) {
bool haveThree = !(highConstantRadio.IsChecked == true ||
bankConstantRadio.IsChecked == true);
lowThirdPartRadio.IsEnabled = haveThree;
highThirdPartRadio.IsEnabled = haveThree;
// If "constant" is selected for high byte *and* bank byte, then there's no
// 2nd part available for low.
if (highConstantRadio.IsChecked == true && bankConstantRadio.IsChecked == true) {
lowSecondPartRadio.IsEnabled = false;
}
} else {
// For 16-bit address, if high byte is constant, then there's no second
// part for the low byte.
if (highConstantRadio.IsChecked == true) {
lowSecondPartRadio.IsEnabled = false;
}
}
// Was a now-invalidated radio button selected before?
if (!lowThirdPartRadio.IsEnabled && lowThirdPartRadio.IsChecked == true) {
// low now invalid, switch to whatever high isn't using
if (highFirstPartRadio.IsChecked == true) {
lowSecondPartRadio.IsChecked = true;
} else {
lowFirstPartRadio.IsChecked = true;
}
}
if (width16Radio.IsChecked == true && highThirdPartRadio.IsChecked == true) {
// high now invalid, switch to whatever low isn't using
if (lowFirstPartRadio.IsChecked == true) {
highSecondPartRadio.IsChecked = true;
} else {
highFirstPartRadio.IsChecked = true;
}
}
if (!lowSecondPartRadio.IsEnabled && lowSecondPartRadio.IsChecked == true) {
// Should only happen when high part is constant.
Debug.Assert(highFirstPartRadio.IsChecked == false);
lowFirstPartRadio.IsChecked = true;
}
mUpdating = false;
UpdatePreview();
IsValid = mOutputReady;
}
private void WidthRadio_CheckedChanged(object sender, RoutedEventArgs e) {
UpdateControls();
}
private void LowByte_CheckedChanged(object sender, RoutedEventArgs e) {
// If we conflict with the high byte, change the high byte.
if (lowFirstPartRadio.IsChecked == true && highFirstPartRadio.IsChecked == true) {
highSecondPartRadio.IsChecked = true;
} else if (lowSecondPartRadio.IsChecked == true && highSecondPartRadio.IsChecked == true) {
highFirstPartRadio.IsChecked = true;
} else if (lowThirdPartRadio.IsChecked == true && highThirdPartRadio.IsChecked == true) {
highFirstPartRadio.IsChecked = true;
}
UpdateControls();
}
private void HighByte_CheckedChanged(object sender, RoutedEventArgs e) {
// If we conflict with the low byte, change the low byte.
if (lowFirstPartRadio.IsChecked == true && highFirstPartRadio.IsChecked == true) {
lowSecondPartRadio.IsChecked = true;
} else if (lowSecondPartRadio.IsChecked == true && highSecondPartRadio.IsChecked == true) {
lowFirstPartRadio.IsChecked = true;
} else if (lowThirdPartRadio.IsChecked == true && highThirdPartRadio.IsChecked == true) {
lowFirstPartRadio.IsChecked = true;
}
UpdateControls();
}
private void BankByte_CheckedChanged(object sender, EventArgs e) {
UpdateControls();
}
private void HighConstantTextBox_TextChanged(object sender, TextChangedEventArgs e) {
highConstantRadio.IsChecked = true;
UpdateControls();
}
private void BankConstantTextBox_TextChanged(object sender, TextChangedEventArgs e) {
bankConstantRadio.IsChecked = true;
UpdateControls();
}
private void UpdatePreview() {
mOutputReady = false;
int minDiv;
if (width16Radio.IsChecked == true) {
if (highConstantRadio.IsChecked == true) {
minDiv = 1;
} else {
minDiv = 2;
}
} else {
if (highConstantRadio.IsChecked == true) {
if (bankConstantRadio.IsChecked == true) {
minDiv = 1;
} else {
minDiv = 2;
}
} else {
if (bankConstantRadio.IsChecked == true) {
minDiv = 2;
} else {
minDiv = 3;
}
}
}
IncompatibleSelectionVisibility = InvalidConstantVisibility = false;
// Start by clearing the previous contents of the list. If something goes
// wrong, we want to show the error messages on an empty list.
OutputPreviewList.Clear();
if ((mSelection.Count % minDiv) != 0) {
IncompatibleSelectionVisibility = true;
return;
}
int highConstant = -1;
if (highConstantRadio.IsChecked == true) {
if (!Number.TryParseInt(highConstantTextBox.Text, out highConstant,
out int unused) || (highConstant != (byte) highConstant)) {
InvalidConstantVisibility = true;
return;
}
}
int bankConstant = -1;
if (bankConstantRadio.IsEnabled && bankConstantRadio.IsChecked == true) {
if (!Number.TryParseInt(bankConstantTextBox.Text, out bankConstant,
out int unused) || (bankConstant != (byte) bankConstant)) {
InvalidConstantVisibility = true;
return;
}
}
// Looks valid, generate format list.
GenerateFormats(minDiv, highConstant, bankConstant);
}
private void GenerateFormats(int div, int highConst, int bankConst) {
SortedList<int, FormatDescriptor> newDfds = new SortedList<int, FormatDescriptor>();
Dictionary<int, Symbol> newLabels = new Dictionary<int, Symbol>();
List<int> targetOffsets = new List<int>();
bool isBigEndian;
// Identify the offset where each set of data starts.
int span = mSelection.Count / div;
int lowOff, highOff, bankOff;
int stride;
if (lowFirstPartRadio.IsChecked == true) {
lowOff = 0;
isBigEndian = false;
} else if (lowSecondPartRadio.IsChecked == true) {
lowOff = 1;
isBigEndian = true;
} else if (lowThirdPartRadio.IsChecked == true) {
lowOff = 2;
isBigEndian = true;
} else {
Debug.Assert(false);
lowOff = -1;
isBigEndian = false;
}
if (highFirstPartRadio.IsChecked == true) {
highOff = 0;
} else if (highSecondPartRadio.IsChecked == true) {
highOff = 1;
} else if (highThirdPartRadio.IsChecked == true) {
highOff = 2;
} else {
highOff = -1; // use constant
}
if (width24Radio.IsChecked == true) {
if (bankNthPartRadio.IsChecked == true) {
// Use whichever part isn't being used by the other two.
if (lowOff != 0 && highOff != 0) {
bankOff = 0;
} else if (lowOff != 1 && highOff != 1) {
bankOff = 1;
} else {
Debug.Assert(lowOff != 2 && highOff != 2);
bankOff = 2;
}
} else {
bankOff = -1; // use constant
}
} else {
bankOff = -1; // use constant
// Set the constant bank value equal to whichever bank the table lives in.
// This is correct for "JMP (addr,X)". We use the offset of the first item
// in the range set, which is a little awkward to get to.
int offset = 0;
foreach (TypedRangeSet.Tuple tup in mSelection) {
offset = tup.Value;
break;
}
int addr = mProject.AddrMap.OffsetToAddress(offset);
bankConst = (byte)(addr >> 16);
}
if (IsSplitTable) {
// Split table, so stride is 1 and each section start is determined by the span.
stride = 1;
lowOff *= span;
highOff *= span;
bankOff *= span;
} else {
// For non-split table, the stride is the width of each entry.
stride = 1;
if (highOff >= 0) {
stride++;
}
if (bankOff >= 0) {
stride++;
}
}
Debug.WriteLine("FormatAddressTable: stride=" + stride + " span=" + span +
" count=" + mSelection.Count);
Debug.WriteLine(" low=" + lowOff + " high=" + highOff + " bank=" + bankOff);
// The TypedRangeSet doesn't have an index operation, so copy the values into
// an array.
int[] offsets = new int[mSelection.Count];
int index = 0;
foreach (TypedRangeSet.Tuple tup in mSelection) {
offsets[index++] = tup.Value;
}
int adj = 0;
if (IsAdjustedForReturn) {
adj = 1;
}
// Walk through the file data, generating addresses as we go.
byte[] fileData = mProject.FileData;
for (int i = 0; i < span; i++) {
byte low, high, bank;
low = fileData[offsets[lowOff + i * stride]];
if (highOff >= 0) {
high = fileData[offsets[highOff + i * stride]];
} else {
high = (byte) highConst;
}
if (bankOff >= 0) {
bank = fileData[offsets[bankOff + i * stride]];
} else {
bank = (byte) bankConst;
}
int addr = ((bank << 16) | (high << 8) | low) + adj;
int targetOffset = mProject.AddrMap.AddressToOffset(offsets[0], addr);
if (targetOffset < 0) {
// Address not within file bounds.
// TODO(maybe): look for matching platform/project symbols
AddPreviewItem(addr, -1, Res.Strings.INVALID_ADDRESS);
} else {
// Note the same target offset may appear more than once.
targetOffsets.Add(targetOffset);
// If there's a user-defined label there already, use it. Otherwise, we'll
// need to generate one.
string targetLabel;
if (mProject.UserLabels.TryGetValue(targetOffset, out Symbol sym)) {
targetLabel = sym.Label;
AddPreviewItem(addr, targetOffset, targetLabel);
} else {
// Generate a symbol that's unique vs. the symbol table. We don't need
// it to be unique vs. the labels we're generating here, because we
// won't generate identical labels for different addresses, and we do
// want to generate a single label if more than one table entry refers
// to the same target.
Symbol tmpSym = AutoLabel.GenerateUniqueForAddress(addr,
mProject.SymbolTable, "T");
// tmpSym was returned as an auto-label, make it a user label instead
// (with global scope)
tmpSym = new Symbol(tmpSym.Label, tmpSym.Value, Symbol.Source.User,
Symbol.Type.GlobalAddr, Symbol.LabelAnnotation.Generated);
newLabels[targetOffset] = tmpSym; // overwrites previous
targetLabel = tmpSym.Label;
AddPreviewItem(addr, targetOffset, "(+) " + targetLabel);
}
if (IsSplitTable) {
// Now we need to create format descriptors for the addresses where we
// extracted the low, high, and bank values.
newDfds.Add(offsets[lowOff + i * stride], FormatDescriptor.Create(1,
new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.Low), false));
if (highOff >= 0) {
newDfds.Add(offsets[highOff + i * stride], FormatDescriptor.Create(1,
new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.High), false));
}
if (bankOff >= 0) {
newDfds.Add(offsets[bankOff + i * stride], FormatDescriptor.Create(1,
new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.Bank), false));
}
} else {
// Create a single format descriptor that spans all bytes. Note we
// don't want to use lowOff here -- we want to put the format on
// whichever byte came first.
// TODO(maybe): we don't correctly deal with a "scrambled" non-split
// 24-bit table, i.e. low then bank then high. This is not really
// a thing, but we should either prevent it or punt to single-byte
// like we do for split tables.
Debug.Assert(stride >= 1 && stride <= 3);
newDfds.Add(offsets[0 + i * stride], FormatDescriptor.Create(stride,
new WeakSymbolRef(targetLabel, WeakSymbolRef.Part.Low), isBigEndian));
}
}
}
NewFormatDescriptors = newDfds;
NewUserLabels = newLabels;
AllTargetOffsets = targetOffsets;
// Don't show ready if all addresses are invalid. It's okay if some work and
// some don't.
mOutputReady = (AllTargetOffsets.Count > 0);
}
private void AddPreviewItem(int addr, int offset, string label) {
OutputPreviewItem newItem = new OutputPreviewItem(
mFormatter.FormatAddress(addr, !mProject.CpuDef.HasAddr16),
(offset >= 0 ? mFormatter.FormatOffset24(offset) : "---"),
label);
OutputPreviewList.Add(newItem);
}
}
}