2019-07-05 21:53:45 +00:00
|
|
|
|
/*
|
|
|
|
|
* 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.ComponentModel;
|
|
|
|
|
using System.Diagnostics;
|
|
|
|
|
using System.Runtime.CompilerServices;
|
|
|
|
|
using System.Windows;
|
|
|
|
|
using System.Windows.Controls;
|
|
|
|
|
using System.Windows.Media;
|
|
|
|
|
|
|
|
|
|
using Asm65;
|
|
|
|
|
|
2019-07-20 20:28:10 +00:00
|
|
|
|
namespace SourceGen.WpfGui {
|
2019-07-05 21:53:45 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Symbol edit dialog.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public partial class EditDefSymbol : Window, INotifyPropertyChanged {
|
2021-07-20 20:08:19 +00:00
|
|
|
|
// 256-byte zero page, +1 for 16-bit access at $ff.
|
|
|
|
|
private const int MAX_VAR_WIDTH = 257;
|
|
|
|
|
|
2019-07-05 21:53:45 +00:00
|
|
|
|
/// <summary>
|
2019-08-26 00:25:15 +00:00
|
|
|
|
/// Result; will be set non-null on OK.
|
2019-07-05 21:53:45 +00:00
|
|
|
|
/// </summary>
|
2019-08-26 00:25:15 +00:00
|
|
|
|
public DefSymbol NewSym { get; private set; }
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
2020-04-23 17:42:54 +00:00
|
|
|
|
public enum InputField {
|
|
|
|
|
Unknown = 0, Label, Value, Comment
|
|
|
|
|
}
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Determines which field gets focus initially.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public InputField InitialFocusField { get; set; }
|
|
|
|
|
|
2019-07-05 21:53:45 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Set to true when all fields are valid. Controls whether the OK button is enabled.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public bool IsValid {
|
|
|
|
|
get { return mIsValid; }
|
2019-08-26 00:25:15 +00:00
|
|
|
|
set { mIsValid = value; OnPropertyChanged(); }
|
2019-07-05 21:53:45 +00:00
|
|
|
|
}
|
|
|
|
|
private bool mIsValid;
|
|
|
|
|
|
2019-08-26 00:25:15 +00:00
|
|
|
|
public string Label {
|
|
|
|
|
get { return mLabel; }
|
|
|
|
|
set { mLabel = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private string mLabel;
|
|
|
|
|
|
|
|
|
|
public string Value {
|
|
|
|
|
get { return mValue; }
|
|
|
|
|
set { mValue = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private string mValue;
|
|
|
|
|
|
|
|
|
|
public string VarWidth {
|
|
|
|
|
get { return mWidth; }
|
|
|
|
|
set { mWidth = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private string mWidth;
|
|
|
|
|
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
public string WidthLimitLabel {
|
|
|
|
|
get { return mWidthLimitLabel; }
|
|
|
|
|
set { mWidthLimitLabel = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mWidthLimitLabel;
|
|
|
|
|
|
2019-08-26 00:25:15 +00:00
|
|
|
|
public string Comment {
|
|
|
|
|
get { return mComment; }
|
|
|
|
|
set { mComment = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mComment;
|
|
|
|
|
|
2019-08-29 00:34:29 +00:00
|
|
|
|
public bool IsAddress {
|
|
|
|
|
get { return mIsAddress; }
|
|
|
|
|
set { mIsAddress = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsAddress;
|
|
|
|
|
|
|
|
|
|
public bool IsConstant {
|
|
|
|
|
get { return mIsConstant; }
|
|
|
|
|
set { mIsConstant = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsConstant;
|
|
|
|
|
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
public string ConstantLabel {
|
|
|
|
|
get { return mConstantLabel; }
|
|
|
|
|
set { mConstantLabel = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mConstantLabel;
|
|
|
|
|
|
2019-10-15 23:37:14 +00:00
|
|
|
|
public bool IsReadChecked {
|
|
|
|
|
get { return mIsReadChecked; }
|
|
|
|
|
set { mIsReadChecked = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsReadChecked;
|
|
|
|
|
|
|
|
|
|
public bool IsWriteChecked {
|
|
|
|
|
get { return mIsWriteChecked; }
|
|
|
|
|
set { mIsWriteChecked = value; OnPropertyChanged(); UpdateControls(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsWriteChecked;
|
|
|
|
|
|
Instruction operand editor rework, part 2
Implemented local variable editing. Operands that have a local
variable reference, or are eligible to have one, can now be edited
directly from the instruction operand edit dialog.
Also, updated the code list double-click handler so that, if you
double-click on the opcode of an instruction that uses a local
variable reference, the selection and view will jump to the place
where that variable was defined.
Also, tweaked the way the References window refers to references
to an address that didn't use a symbol at that address. Updated
the explanation in the manual, which was a bit confusing.
Also, fixed some odds and ends in the manual.
Also, fixed a nasty infinite recursion bug (issue #47).
2019-09-08 01:57:22 +00:00
|
|
|
|
public bool ReadOnlyValueAndType {
|
|
|
|
|
get { return mReadOnlyValueAndType; }
|
|
|
|
|
set { mReadOnlyValueAndType = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
public bool NotReadOnlyValueAndType {
|
|
|
|
|
get { return !mReadOnlyValueAndType; }
|
|
|
|
|
}
|
|
|
|
|
private bool mReadOnlyValueAndType;
|
|
|
|
|
|
2019-10-15 23:37:14 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Set to true if we should create a Variable rather than a project symbol.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public bool IsVariable {
|
|
|
|
|
get { return mIsVariable; }
|
|
|
|
|
set { mIsVariable = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
public bool IsNotVariable {
|
|
|
|
|
get { return !mIsVariable; }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsVariable;
|
|
|
|
|
|
2019-07-05 21:53:45 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Format object to use when formatting addresses and constants.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private Formatter mNumFormatter;
|
|
|
|
|
|
2019-08-26 00:25:15 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Old symbol value. May be null.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private DefSymbol mOldSym;
|
|
|
|
|
|
2019-07-05 21:53:45 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// List of existing symbols, for uniqueness check. The list will not be modified.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private SortedList<string, DefSymbol> mDefSymbolList;
|
|
|
|
|
|
2019-08-26 00:25:15 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Full symbol table, for extended uniqueness check.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private SymbolTable mSymbolTable;
|
|
|
|
|
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Set to true if the width value is optional.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private bool mIsWidthOptional;
|
|
|
|
|
|
2019-12-30 01:59:35 +00:00
|
|
|
|
private Brush mDefaultLabelColor = SystemColors.WindowTextBrush;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
|
|
|
|
// INotifyPropertyChanged implementation
|
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
|
private void OnPropertyChanged([CallerMemberName] string propertyName = "") {
|
|
|
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2019-08-26 00:25:15 +00:00
|
|
|
|
/// <summary>
|
Instruction operand editor rework, part 2
Implemented local variable editing. Operands that have a local
variable reference, or are eligible to have one, can now be edited
directly from the instruction operand edit dialog.
Also, updated the code list double-click handler so that, if you
double-click on the opcode of an instruction that uses a local
variable reference, the selection and view will jump to the place
where that variable was defined.
Also, tweaked the way the References window refers to references
to an address that didn't use a symbol at that address. Updated
the explanation in the manual, which was a bit confusing.
Also, fixed some odds and ends in the manual.
Also, fixed a nasty infinite recursion bug (issue #47).
2019-09-08 01:57:22 +00:00
|
|
|
|
/// Constructor, for editing a project or platform symbol.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public EditDefSymbol(Window owner, Formatter formatter,
|
|
|
|
|
SortedList<string, DefSymbol> defList, DefSymbol defSym,
|
|
|
|
|
SymbolTable symbolTable)
|
|
|
|
|
: this(owner, formatter, defList, defSym, symbolTable, false, false) { }
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2019-09-08 23:41:54 +00:00
|
|
|
|
/// Constructor, for editing a local variable, or editing a project symbol with
|
|
|
|
|
/// the value field locked.
|
2019-08-26 00:25:15 +00:00
|
|
|
|
/// </summary>
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
/// <remarks>
|
|
|
|
|
/// TODO(someday): disable the "constant" radio button unless CPU=65816.
|
|
|
|
|
/// </remarks>
|
2019-07-05 21:53:45 +00:00
|
|
|
|
public EditDefSymbol(Window owner, Formatter formatter,
|
2019-08-26 23:58:53 +00:00
|
|
|
|
SortedList<string, DefSymbol> defList, DefSymbol defSym,
|
Instruction operand editor rework, part 2
Implemented local variable editing. Operands that have a local
variable reference, or are eligible to have one, can now be edited
directly from the instruction operand edit dialog.
Also, updated the code list double-click handler so that, if you
double-click on the opcode of an instruction that uses a local
variable reference, the selection and view will jump to the place
where that variable was defined.
Also, tweaked the way the References window refers to references
to an address that didn't use a symbol at that address. Updated
the explanation in the manual, which was a bit confusing.
Also, fixed some odds and ends in the manual.
Also, fixed a nasty infinite recursion bug (issue #47).
2019-09-08 01:57:22 +00:00
|
|
|
|
SymbolTable symbolTable, bool isVariable, bool lockValueAndType) {
|
2019-07-05 21:53:45 +00:00
|
|
|
|
InitializeComponent();
|
|
|
|
|
Owner = owner;
|
|
|
|
|
DataContext = this;
|
|
|
|
|
|
|
|
|
|
mNumFormatter = formatter;
|
|
|
|
|
mDefSymbolList = defList;
|
2019-08-26 00:25:15 +00:00
|
|
|
|
mOldSym = defSym;
|
|
|
|
|
mSymbolTable = symbolTable;
|
2019-10-15 23:37:14 +00:00
|
|
|
|
IsVariable = isVariable;
|
Instruction operand editor rework, part 2
Implemented local variable editing. Operands that have a local
variable reference, or are eligible to have one, can now be edited
directly from the instruction operand edit dialog.
Also, updated the code list double-click handler so that, if you
double-click on the opcode of an instruction that uses a local
variable reference, the selection and view will jump to the place
where that variable was defined.
Also, tweaked the way the References window refers to references
to an address that didn't use a symbol at that address. Updated
the explanation in the manual, which was a bit confusing.
Also, fixed some odds and ends in the manual.
Also, fixed a nasty infinite recursion bug (issue #47).
2019-09-08 01:57:22 +00:00
|
|
|
|
mReadOnlyValueAndType = lockValueAndType;
|
2019-08-26 00:25:15 +00:00
|
|
|
|
|
2019-08-26 23:58:53 +00:00
|
|
|
|
Label = Value = VarWidth = Comment = string.Empty;
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
|
2019-10-28 04:29:44 +00:00
|
|
|
|
int maxWidth;
|
2019-08-26 23:58:53 +00:00
|
|
|
|
if (isVariable) {
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
ConstantLabel = (string)FindResource("str_VariableConstant");
|
2021-07-20 20:08:19 +00:00
|
|
|
|
maxWidth = MAX_VAR_WIDTH;
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
} else {
|
|
|
|
|
ConstantLabel = (string)FindResource("str_ProjectConstant");
|
|
|
|
|
maxWidth = 65536;
|
2019-08-26 23:58:53 +00:00
|
|
|
|
}
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
mIsWidthOptional = !isVariable;
|
|
|
|
|
|
|
|
|
|
string fmt = (string)FindResource("str_WidthLimitFmt");
|
|
|
|
|
WidthLimitLabel = string.Format(fmt, maxWidth);
|
2019-07-05 21:53:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Window_Loaded(object sender, RoutedEventArgs e) {
|
2019-08-26 00:25:15 +00:00
|
|
|
|
if (mOldSym != null) {
|
2019-11-13 01:24:41 +00:00
|
|
|
|
Label = mOldSym.GenerateDisplayLabel(mNumFormatter);
|
2019-08-26 00:25:15 +00:00
|
|
|
|
Value = mNumFormatter.FormatValueInBase(mOldSym.Value,
|
|
|
|
|
mOldSym.DataDescriptor.NumBase);
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
if (mOldSym.HasWidth) {
|
|
|
|
|
VarWidth = mOldSym.DataDescriptor.Length.ToString();
|
|
|
|
|
}
|
2019-08-26 00:25:15 +00:00
|
|
|
|
Comment = mOldSym.Comment;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
2019-10-23 04:27:49 +00:00
|
|
|
|
if (mOldSym.IsConstant) {
|
2019-08-29 00:34:29 +00:00
|
|
|
|
IsConstant = true;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
} else {
|
2019-08-29 00:34:29 +00:00
|
|
|
|
IsAddress = true;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
}
|
2019-10-15 23:37:14 +00:00
|
|
|
|
|
|
|
|
|
if (mOldSym.Direction == DefSymbol.DirectionFlags.Read) {
|
|
|
|
|
IsReadChecked = true;
|
|
|
|
|
} else if (mOldSym.Direction == DefSymbol.DirectionFlags.Write) {
|
|
|
|
|
IsWriteChecked = true;
|
|
|
|
|
} else {
|
|
|
|
|
IsReadChecked = IsWriteChecked = true;
|
|
|
|
|
}
|
2019-07-05 21:53:45 +00:00
|
|
|
|
} else {
|
2019-10-15 23:37:14 +00:00
|
|
|
|
IsAddress = IsReadChecked = IsWriteChecked = true;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UpdateControls();
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-15 00:48:54 +00:00
|
|
|
|
private void Window_ContentRendered(object sender, EventArgs e) {
|
2020-04-23 17:42:54 +00:00
|
|
|
|
TextBox field;
|
|
|
|
|
switch (InitialFocusField) {
|
|
|
|
|
case InputField.Value:
|
|
|
|
|
field = valueTextBox;
|
|
|
|
|
break;
|
|
|
|
|
case InputField.Comment:
|
|
|
|
|
field = commentTextBox;
|
|
|
|
|
break;
|
|
|
|
|
case InputField.Label:
|
|
|
|
|
default:
|
|
|
|
|
field = labelTextBox;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
field.SelectAll();
|
|
|
|
|
field.Focus();
|
2019-09-15 00:48:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Validates input and updates controls appropriately.
|
|
|
|
|
/// </summary>
|
2019-07-05 21:53:45 +00:00
|
|
|
|
private void UpdateControls() {
|
2019-08-26 00:25:15 +00:00
|
|
|
|
if (!IsLoaded) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
2019-08-31 01:33:05 +00:00
|
|
|
|
// Label must be valid and not already exist in the table we're editing. (For project
|
2019-08-26 00:25:15 +00:00
|
|
|
|
// symbols, it's okay if an identical label exists elsewhere.)
|
2019-11-13 01:24:41 +00:00
|
|
|
|
string trimLabel = Symbol.TrimAndValidateLabel(Label, string.Empty,
|
|
|
|
|
out bool labelValid, out bool unused1, out bool unused2, out bool unused3,
|
|
|
|
|
out Symbol.LabelAnnotation unused4);
|
2019-08-26 00:25:15 +00:00
|
|
|
|
bool labelUnique;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
2019-11-09 04:44:45 +00:00
|
|
|
|
if (mDefSymbolList.TryGetValue(trimLabel, out DefSymbol existing)) {
|
2022-01-12 22:07:30 +00:00
|
|
|
|
// We found a match. See if we're just seeing the symbol we're editing.
|
|
|
|
|
//
|
2022-02-28 23:03:09 +00:00
|
|
|
|
// We mostly want to check the label, not the entire symbol, because otherwise
|
2022-01-12 22:07:30 +00:00
|
|
|
|
// things can go funny when multiple edits are done without flushing the data
|
|
|
|
|
// back to the symbol table. For example, when this is invoked from the
|
|
|
|
|
// Edit Project Symbol button in the instruction operand editor, the user might
|
|
|
|
|
// edit the comment field of an existing project symbol, hit OK here, then try
|
|
|
|
|
// to edit it again before closing the operand editor. In that case we get
|
|
|
|
|
// passed the edited DefSymbol, which no longer fully matches what's in the
|
|
|
|
|
// symbol table.
|
|
|
|
|
//
|
2022-02-28 23:03:09 +00:00
|
|
|
|
// We want to check the value as well, because of a weird case when the user
|
|
|
|
|
// edits an instruction operand with a user-modified symbol. For example, if
|
|
|
|
|
// the operand needs to be "FOO-1", so the user hand-edited the label to FOO.
|
|
|
|
|
// This allows the user to "create project symbol" with the symbol as the initial
|
|
|
|
|
// value, but the symbol would be for address FOO not FOO-1. (It would be best
|
|
|
|
|
// to disable "create project symbol" in this case.)
|
|
|
|
|
//
|
2022-01-12 22:07:30 +00:00
|
|
|
|
// TODO: we still don't handle the case where the user changes the label from
|
|
|
|
|
// FOO to FOO1 and then back to FOO without closing the instruction edit dialog.
|
|
|
|
|
// The problem is that we find a match for FOO in the symbol table without
|
|
|
|
|
// realizing that it was the original name before the edits began. To fix this
|
|
|
|
|
// we need to pass in the original label as well as the recently-edited symbol,
|
|
|
|
|
// and allow the new name to match either.
|
|
|
|
|
|
2022-02-28 23:03:09 +00:00
|
|
|
|
// If there's no "previous" symbol, then any match means the label is not unique.
|
|
|
|
|
// Otherwise, we consider it unique if the label and value match what they were
|
|
|
|
|
// when this edit dialog was opened.
|
2022-01-12 22:07:30 +00:00
|
|
|
|
//labelUnique = (existing == mOldSym);
|
2022-02-28 23:03:09 +00:00
|
|
|
|
labelUnique = mOldSym != null &&
|
|
|
|
|
(Asm65.Label.LABEL_COMPARER.Equals(existing.Label, mOldSym.Label) &&
|
|
|
|
|
existing.Value == mOldSym.Value);
|
2019-07-05 21:53:45 +00:00
|
|
|
|
} else {
|
|
|
|
|
labelUnique = true;
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-29 00:34:29 +00:00
|
|
|
|
// For local variables, do a secondary uniqueness check across the full symbol table.
|
2019-08-26 00:25:15 +00:00
|
|
|
|
if (labelUnique && mSymbolTable != null) {
|
2019-11-09 04:44:45 +00:00
|
|
|
|
labelUnique = !mSymbolTable.TryGetValue(trimLabel, out Symbol sym);
|
2019-08-31 01:33:05 +00:00
|
|
|
|
|
|
|
|
|
// It's okay if this and the other are both variables.
|
2019-10-15 23:37:14 +00:00
|
|
|
|
if (!labelUnique && IsVariable && sym.IsVariable) {
|
2019-08-31 01:33:05 +00:00
|
|
|
|
labelUnique = true;
|
|
|
|
|
}
|
2019-08-26 00:25:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-05 21:53:45 +00:00
|
|
|
|
// Value must be blank, meaning "erase any earlier definition", or valid value.
|
|
|
|
|
// (Hmm... don't currently have a way to specify "no symbol" in DefSymbol.)
|
|
|
|
|
//if (!string.IsNullOrEmpty(valueTextBox.Text)) {
|
2019-11-13 01:24:41 +00:00
|
|
|
|
bool valueValid = ParseValue(out int thisValue, out int unused5);
|
2019-07-05 21:53:45 +00:00
|
|
|
|
//} else {
|
|
|
|
|
// valueValid = true;
|
|
|
|
|
//}
|
|
|
|
|
|
2019-08-26 00:25:15 +00:00
|
|
|
|
bool widthValid = true;
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
int thisWidth = -1;
|
2019-10-15 23:37:14 +00:00
|
|
|
|
if (IsConstant && !IsVariable) {
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
// width field is ignored
|
|
|
|
|
} else if (string.IsNullOrEmpty(VarWidth)) {
|
|
|
|
|
// blank field is okay if the width is optional
|
|
|
|
|
widthValid = mIsWidthOptional;
|
|
|
|
|
} else if (!Asm65.Number.TryParseInt(VarWidth, out thisWidth, out int unusedBase) ||
|
|
|
|
|
thisWidth < DefSymbol.MIN_WIDTH || thisWidth > DefSymbol.MAX_WIDTH ||
|
2021-07-20 20:08:19 +00:00
|
|
|
|
(IsVariable && thisWidth > MAX_VAR_WIDTH)) {
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
// All widths must be between 1 and 65536. For a variable, the full thing must
|
2021-07-20 20:08:19 +00:00
|
|
|
|
// fit on zero page, except on 65816 where a 16-bit access at $ff can extend
|
|
|
|
|
// off the end of the direct page.
|
|
|
|
|
//
|
|
|
|
|
// We test the variable width here so that we highlight the "width limit" label,
|
|
|
|
|
// rather than the "value range" label.
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
widthValid = false;
|
2019-08-26 00:25:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-29 20:32:45 +00:00
|
|
|
|
bool valueRangeValid = true;
|
2019-10-15 23:37:14 +00:00
|
|
|
|
if (IsVariable && valueValid && widthValid) {
|
2021-07-20 20:08:19 +00:00
|
|
|
|
// $ff with width 1 is okay, $ff with width 2 is okay on 65816, width=3 is bad
|
|
|
|
|
if (thisValue < 0 || thisValue + thisWidth > MAX_VAR_WIDTH) {
|
2019-08-29 20:32:45 +00:00
|
|
|
|
valueRangeValid = false;
|
|
|
|
|
}
|
2019-10-27 19:26:34 +00:00
|
|
|
|
} else if (IsAddress && valueValid) {
|
|
|
|
|
// limit to positive 24-bit integers; use a long for value+width so we
|
|
|
|
|
// don't get fooled by overflow
|
|
|
|
|
long lvalue = thisValue;
|
|
|
|
|
if (thisWidth > 0) {
|
|
|
|
|
lvalue += thisWidth - 1;
|
|
|
|
|
}
|
|
|
|
|
if (thisValue < 0 || lvalue > 0x00ffffff) {
|
|
|
|
|
valueRangeValid = false;
|
|
|
|
|
}
|
2019-08-29 20:32:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-29 00:34:29 +00:00
|
|
|
|
Symbol.Type symbolType = IsConstant ? Symbol.Type.Constant : Symbol.Type.ExternalAddr;
|
|
|
|
|
|
|
|
|
|
// For a variable, the value must also be unique within the table. Values have
|
|
|
|
|
// width, so we need to check for overlap.
|
|
|
|
|
bool valueUniqueValid = true;
|
2019-10-15 23:37:14 +00:00
|
|
|
|
if (IsVariable && valueValid && widthValid) {
|
2019-08-29 00:34:29 +00:00
|
|
|
|
foreach (KeyValuePair<string, DefSymbol> kvp in mDefSymbolList) {
|
2019-09-01 03:32:43 +00:00
|
|
|
|
if (kvp.Value != mOldSym &&
|
|
|
|
|
DefSymbol.CheckOverlap(kvp.Value, thisValue, thisWidth, symbolType)) {
|
2019-08-29 00:34:29 +00:00
|
|
|
|
valueUniqueValid = false;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-15 23:37:14 +00:00
|
|
|
|
bool rwValid = true;
|
|
|
|
|
if (!IsVariable && IsAddress) {
|
|
|
|
|
rwValid = IsReadChecked || IsWriteChecked;
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-05 21:53:45 +00:00
|
|
|
|
labelNotesLabel.Foreground = labelValid ? mDefaultLabelColor : Brushes.Red;
|
2019-08-26 00:25:15 +00:00
|
|
|
|
labelUniqueLabel.Foreground = projectLabelUniqueLabel.Foreground =
|
|
|
|
|
labelUnique ? mDefaultLabelColor : Brushes.Red;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
valueNotesLabel.Foreground = valueValid ? mDefaultLabelColor : Brushes.Red;
|
2019-10-27 19:26:34 +00:00
|
|
|
|
addrValueRangeLabel.Foreground = valueRangeValid ? mDefaultLabelColor : Brushes.Red;
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
varValueRangeLabel.Foreground = valueRangeValid ? mDefaultLabelColor : Brushes.Red;
|
|
|
|
|
varValueUniqueLabel.Foreground = valueUniqueValid ? mDefaultLabelColor : Brushes.Red;
|
2019-08-26 00:25:15 +00:00
|
|
|
|
widthNotesLabel.Foreground = widthValid ? mDefaultLabelColor : Brushes.Red;
|
2019-10-15 23:37:14 +00:00
|
|
|
|
checkReadWriteLabel.Foreground = rwValid ? mDefaultLabelColor : Brushes.Red;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
2019-08-29 00:34:29 +00:00
|
|
|
|
IsValid = labelValid && labelUnique && valueValid && valueRangeValid &&
|
2019-10-15 23:37:14 +00:00
|
|
|
|
valueUniqueValid && widthValid && rwValid;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private bool ParseValue(out int value, out int numBase) {
|
2019-08-26 00:25:15 +00:00
|
|
|
|
string str = Value;
|
2019-07-05 21:53:45 +00:00
|
|
|
|
if (str.IndexOf('/') >= 0) {
|
|
|
|
|
// treat as address
|
|
|
|
|
numBase = 16;
|
|
|
|
|
return Asm65.Address.ParseAddress(str, (1 << 24) - 1, out value);
|
|
|
|
|
} else {
|
|
|
|
|
return Asm65.Number.TryParseInt(str, out value, out numBase);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void OkButton_Click(object sender, RoutedEventArgs e) {
|
|
|
|
|
ParseValue(out int value, out int numBase);
|
|
|
|
|
FormatDescriptor.SubType subType = FormatDescriptor.GetSubTypeForBase(numBase);
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
int width = -1;
|
2019-10-15 23:37:14 +00:00
|
|
|
|
if (IsConstant && !IsVariable) {
|
Allow explicit widths in project/platform symbols, part 1
The ability to give explicit widths to local variables worked out
pretty well, so we're going to try adding the same thing to project
and platform symbols.
The first step is to allow widths to be specified in platform files,
and set with the project symbol editor. The DefSymbol editor is
also used for local variables, so a bit of dancing is required.
For platform/project symbols the width is optional, and is totally
ignored for constants. (For variables, constants are used for the
StackRel args, so the width is meaningful and required.)
We also now show the symbol's type (address or constant) and width
in the listing. This gets really distracting when overused, so we
only show it when the width is explicitly set. The default width
is 1, which most things will be, so users can make an aesthetic
choice there. (The place where widths make very little sense is when
the symbol represents a code entry point, rather than a data item.)
The maximum width of a local variable is now 256, but it's not
allowed to overlap with other variables or run of the end of the
direct page. The maximum width of a platform/project symbol is
65536, with bank-wrap behavior TBD.
The local variable table editor now refers to stack-relative
constants as such, rather than simply "constant", to make it clear
that it's not just defining an 8-bit constant.
Widths have been added to a handful of Apple II platform defs.
2019-10-01 21:58:24 +00:00
|
|
|
|
// width field is ignored, don't bother parsing
|
|
|
|
|
} else if (!string.IsNullOrEmpty(VarWidth)) {
|
|
|
|
|
bool ok = Asm65.Number.TryParseInt(VarWidth, out width, out int unusedNumBase);
|
|
|
|
|
Debug.Assert(ok);
|
2019-08-26 00:25:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-15 23:37:14 +00:00
|
|
|
|
DefSymbol.DirectionFlags direction;
|
|
|
|
|
if (IsReadChecked && IsWriteChecked) {
|
|
|
|
|
direction = DefSymbol.DirectionFlags.ReadWrite;
|
|
|
|
|
} else if (IsReadChecked) {
|
|
|
|
|
direction = DefSymbol.DirectionFlags.Read;
|
|
|
|
|
} else if (IsWriteChecked) {
|
|
|
|
|
direction = DefSymbol.DirectionFlags.Write;
|
|
|
|
|
} else {
|
|
|
|
|
Debug.Assert(false);
|
|
|
|
|
direction = DefSymbol.DirectionFlags.None;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-09 04:44:45 +00:00
|
|
|
|
// Parse and strip the annotation.
|
2019-11-13 01:24:41 +00:00
|
|
|
|
string trimLabel = Symbol.TrimAndValidateLabel(Label, string.Empty, out bool unused1,
|
|
|
|
|
out bool unused2, out bool unused3, out bool unused4,
|
|
|
|
|
out Symbol.LabelAnnotation anno);
|
2019-11-09 04:44:45 +00:00
|
|
|
|
NewSym = new DefSymbol(trimLabel, value,
|
2019-10-15 23:37:14 +00:00
|
|
|
|
IsVariable ? Symbol.Source.Variable : Symbol.Source.Project,
|
2019-11-09 04:44:45 +00:00
|
|
|
|
IsConstant ? Symbol.Type.Constant : Symbol.Type.ExternalAddr, anno,
|
2019-10-15 23:37:14 +00:00
|
|
|
|
subType, width, width > 0, Comment, direction, null, string.Empty);
|
2019-07-05 21:53:45 +00:00
|
|
|
|
|
|
|
|
|
DialogResult = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|