public override void OnActivate(string searchContext, VisualElement rootElement)
{
base.OnActivate(searchContext, rootElement);
RuntimeSerializationSettingsUtils.ClearExceptionCache();
m_AssemblyRows.Clear();
ReflectionUtils.ForEachAssembly(assembly =>
{
if (CodeGenUtils.IsTestAssembly(assembly))
{
return;
}
if (k_IgnoredAssemblies.Contains(assembly.GetName().Name))
{
return;
}
var assemblyRow = new AssemblyRow(assembly);
if (assemblyRow.GetTypeCount() > 0)
{
m_AssemblyRows.Add(assemblyRow);
}
});
m_AssemblyRows.Sort((a, b) => a.DisplayName.CompareTo(b.DisplayName));
}
public override ParseResult Resolve(AssemblyRow row)
{
if (row.Operands == null || row.Operands.Count == 0)
{
return(new ParseResult(ParseResultCode.Error, 0, $" Az {row.Instruction.Mnemonic} utasításnak szüksége van operandusra. Az operandus egy vagy több két byte-os érték lehet vesszővel elválasztva!"));
}
bool rowContainsFutureSymbol = false;
foreach (Operand operand in row.Operands)
{
if (SymbolTable.Any(s => s.Value.Name.Equals(operand.Value)))
{
operand.State = OperandState.FutureSymbol;
}
if (operand.Info.DataType != OperandType.Decimal && operand.Info.DataType != OperandType.Word &&
operand.Info.DataType != OperandType.Byte && operand.Info.DataType != OperandType.Expression)
{
if (operand.State != OperandState.Valid &&
operand.State != OperandState.FutureSymbol)
{
return(new ParseResult(ParseResultCode.Error, 0,
$"Az operandus adat típusa({operand.Info.DataType}) a {row.Instruction.Mnemonic} utasításban nem támogatott!"));
}
}
if (operand.Info.DataType == OperandType.Expression ||
operand.State == OperandState.FutureSymbol)
{
var expressionParser = new ExpressionParser(operand.Value, SymbolTable);
var result = expressionParser.Parse();
if (result.ResultCode == ParseResultCode.Error)
{
return(result);
}
InstructionBytes.Add((byte)(result.ResultValue & 0xFF));
InstructionBytes.Add((byte)(result.ResultValue >> 8));
if (result.ResultCode == ParseResultCode.ContainsFutureSymbol)
{
rowContainsFutureSymbol = true;
}
}
else
{
ushort value = operand.ToString().ResolveUshortConstant();
byte highByte = (byte)(value >> 8);
byte lowByte = (byte)(value & 0xFF);
InstructionBytes.Add(lowByte);
InstructionBytes.Add(highByte);
}
}
return(new ParseResult(rowContainsFutureSymbol? ParseResultCode.ContainsFutureSymbol : ParseResultCode.Ok));
}
public override void FromRawData(byte [] buff, int offs, int numRows)
{
for (int i = numRows; --i >= 0;)
{
Row row = new AssemblyRow(this);
row.FromRawData(buff, offs);
Add(row);
offs += AssemblyRow.LogicalSize;
}
}
public string FormatLine(string inputLine)
{
string result = inputLine.TrimStart(' ', '\t');
// Ignore comment only lines
if (result.StartsWith(";"))
{
return(inputLine);
}
if (result.StartsWith("#"))
{
return(result.PadLeft(m_Settings.PreprocessorIndentSize + result.Length));
}
try
{
AssemblyRowTokenizer tokenizer = new AssemblyRowTokenizer(result, true);
tokenizer.TokenizeRow();
if (tokenizer.Tokens.Count == 0)
{
return(inputLine);
}
AssemblyRowInterpreter interpreter = new AssemblyRowInterpreter(tokenizer.Tokens);
interpreter.InterpretRow();
AssemblyRow row = interpreter.InterpretedAssemblyRow;
string joinedOperands = string.Join(",", row.Operands);
int labelPaddingSize = row.Label.Length > m_Settings.LabelSectionPaddingSize
? 1
: m_Settings.LabelSectionPaddingSize - row.Label.Length;
int instructionPaddingSize = row.Instruction.Mnemonic.Length > m_Settings.InstructionSectionPaddingSize
? 1
: m_Settings
.InstructionSectionPaddingSize - row.Instruction.Mnemonic.Length;
int operandPaddingSize = joinedOperands.Length > m_Settings.OperandSectionPaddingSize
? 1
: m_Settings.OperandSectionPaddingSize - joinedOperands.Length;
result = $"{row.Label.PadRight(labelPaddingSize + row.Label.Length)}" +
$"{row.Instruction.Mnemonic.PadRight(instructionPaddingSize + row.Instruction.Mnemonic.Length)}" +
$"{joinedOperands.PadRight(operandPaddingSize + joinedOperands.Length)}" +
$"{row.Comment}";
return(result.PadLeft(m_Settings.AssemblyRowIndentSize + result.Length));
}
catch (Z80AssemblerException)
{
return(inputLine);
}
}
/// <summary>
/// Reads the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="result">The result.</param>
public void Read(TokenTypes token, out AssemblyRow result)
{
if ((token & TokenTypes.TableMask) != TokenTypes.Assembly)
{
throw new ArgumentException("Invalid token type for AssemblyRow.", "token");
}
using (BinaryReader reader = CreateReaderForToken(token))
{
result = new AssemblyRow((AssemblyHashAlgorithm)reader.ReadUInt32(), reader.ReadUInt16(), reader.ReadUInt16(), reader.ReadUInt16(), reader.ReadUInt16(), (AssemblyFlags)reader.ReadUInt32(), ReadIndexValue(reader, IndexType.BlobHeap), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.StringHeap));
}
}
public override ParseResult Resolve(AssemblyRow row)
{
if (row.Operands == null || row.Operands.Count == 0)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A {row.Instruction.Mnemonic} utasításnak szüksége van operandusra!"));
}
if (row.Operands.Count > 3)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A {row.Instruction.Mnemonic} utasításnak maximum három operandusa lehet!"));
}
if (row.Operands[0].Info.DataType != OperandType.Literal)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A {row.Instruction.Mnemonic} utasítás első operandusa kötelezően file név string!"));
}
foreach (string includeDirectory in m_IncludeDirectories)
{
var filePath = Path.Combine(includeDirectory, row.Operands[0].Value.Replace("\"", ""));
if (File.Exists(filePath))
{
try
{
FileInfo info = new FileInfo(filePath);
var result = ParseOperands(row, info.Length, out var position, out var count);
if (result.ResultCode != ParseResultCode.Ok)
{
return(result);
}
count = (int)(count == -1 || count > info.Length ? info.Length : count);
using (FileStream fs = new FileStream(filePath, FileMode.Open))
{
using (BinaryReader br = new BinaryReader(fs))
{
br.BaseStream.Position = position;
InstructionBytes.AddRange(br.ReadBytes(count));
}
}
return(new ParseResult(ParseResultCode.Ok));
}
catch (Exception e)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A file '{row.Operands[0].Value}' feldolgozása sikertelen:{e.Message}"));
}
}
}
return(new ParseResult(ParseResultCode.Error, 0, $"Nem találom a megadott file-t: '{row.Operands[0].Value}'"));
}
public override void VisitAssemblyNameDefinition(AssemblyNameDefinition name)
{
AssemblyTable atable = m_tableReader.GetAssemblyTable();
AssemblyRow arow = atable [0];
name.Name = ReadString(arow.Name);
name.Flags = arow.Flags;
name.PublicKey = ReadBlob(arow.PublicKey);
name.Culture = ReadString(arow.Culture);
name.Version = new Version(
arow.MajorVersion, arow.MinorVersion,
arow.BuildNumber, arow.RevisionNumber);
name.HashAlgorithm = arow.HashAlgId;
name.MetadataToken = new MetadataToken(TokenType.Assembly, 1);
}
/// <summary>
/// Computes the AssemblyIdentifier of the PE File. This requires that peFile is an assembly.
/// </summary>
/// <param name="peFileReader"></param>
/// <returns></returns>
internal AssemblyIdentity GetAssemblyIdentifier(PEFileReader peFileReader)
//^ requires peFileReader.ReaderState >= ReaderState.Metadata && peFileReader.IsAssembly;
//^ ensures (result.Location != null && result.Location.Length != 0);
{
AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
IName assemblyName = this.metadataReaderHost.NameTable.GetNameFor(peFileReader.StringStream[assemblyRow.Name]);
string cultureName = peFileReader.StringStream[assemblyRow.Culture];
Version version = new Version(assemblyRow.MajorVersion, assemblyRow.MinorVersion, assemblyRow.BuildNumber, assemblyRow.RevisionNumber);
byte[] publicKeyArray = TypeCache.EmptyByteArray;
byte[] publicKeyTokenArray = TypeCache.EmptyByteArray;
if (assemblyRow.PublicKey != 0)
{
publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
if (publicKeyArray.Length > 0)
{
publicKeyTokenArray = UnitHelper.ComputePublicKeyToken(publicKeyArray);
}
}
return(new AssemblyIdentity(assemblyName, cultureName, version, publicKeyTokenArray, peFileReader.BinaryDocumentMemoryBlock.BinaryDocument.Location));
}
public override void VisitAssemblyNameDefinition(AssemblyNameDefinition name)
{
AssemblyTable asmTable = m_tableWriter.GetAssemblyTable();
if (name.PublicKey != null && name.PublicKey.Length > 0)
{
name.Flags |= AssemblyFlags.PublicKey;
}
AssemblyRow asmRow = m_rowWriter.CreateAssemblyRow(
name.HashAlgorithm,
(ushort)name.Version.Major,
(ushort)name.Version.Minor,
(ushort)name.Version.Build,
(ushort)name.Version.Revision,
name.Flags,
m_mdWriter.AddBlob(name.PublicKey),
m_mdWriter.AddString(name.Name),
m_mdWriter.AddString(name.Culture));
asmTable.Rows.Add(asmRow);
}
public virtual void VisitAssemblyRow(AssemblyRow row)
{
}
public OrgInstructionParser(AssemblyRow row, IReadOnlyDictionary <string, Symbol> symbolTable)
{
m_SymbolTable = symbolTable;
m_Row = row;
}
public abstract ParseResult Resolve(AssemblyRow row);
public AssemblyRowExt(IMetadataProvider metadata, AssemblyRow row)
: base(metadata)
{
this.row = row;
}
public static AssemblyDefinition Resolve(uint rid, AssemblyRow row, MetadataSystem metadata)
{
var resolver = new AssemblyDefinitionResolver(rid, row, metadata);
return(new AssemblyDefinition(resolver));
}
private AssemblyDefinitionResolver(uint rid, AssemblyRow row, MetadataSystem metadata)
{
_token = new MetadataToken(MetadataTokenType.Assembly, rid);
_row = row;
_metadata = metadata;
}
public override ParseResult Resolve(AssemblyRow row)
{
if (row.Operands == null || row.Operands.Count == 0)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A {row.Instruction.Mnemonic} utasításnak szüksége van operandusa!"));
}
foreach (Operand operand in row.Operands)
{
if (operand.Info.DataType != OperandType.Byte && operand.Info.DataType != OperandType.Character &&
operand.Info.DataType != OperandType.Literal && operand.Info.DataType != OperandType.Decimal &&
operand.Info.DataType != OperandType.Expression)
{
Symbol symbol = SymbolTable.Where(s => s.Key.Equals(operand.Value)).Select(s => s.Value).FirstOrDefault();
if (symbol == null)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A(z) {operand} operandus típusa({operand.Info.DataType}) a {row.Instruction.Mnemonic} utasításban nem támogatott!"));
}
if (symbol.State == SymbolState.Unresolved)
{
return(new ParseResult(ParseResultCode.ContainsFutureSymbol));
}
if (symbol.Value > 0xff)
{
return(new ParseResult(ParseResultCode.Error, 0, $"Az operandusként megadott szimbúlum '{symbol.Name}' értéke nem fér el egy byte-on!"));
}
InstructionBytes.Add((byte)symbol.Value);
continue;
}
switch (operand.Info.DataType)
{
case OperandType.Byte:
InstructionBytes.Add(operand.ToString().ResolveByteConstant());
break;
case OperandType.Character:
InstructionBytes.AddRange(operand.Value.ToTvcAsciiBytes());
break;
case OperandType.Decimal:
{
ushort v = operand.ToString().ResolveUshortConstant();
if (v > 0xFF)
{
return(new ParseResult(ParseResultCode.Error, 0, $"Helytelen decimális érték '{operand}' a {row.Instruction.Mnemonic} utasításban! Az értéknek 0 és 255 közé kell esnie!"));
}
InstructionBytes.Add((byte)v);
}
break;
case OperandType.Expression:
{
var expressionParser = new ExpressionParser(operand.Value, SymbolTable);
var result = expressionParser.Parse();
if (result.ResultCode == ParseResultCode.Error || result.ResultCode == ParseResultCode.ContainsFutureSymbol)
{
return(result);
}
if (result.ResultValue > 0xff)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A kifejezés '{operand}' eredménye nem fért el egy byte-on!"));
}
InstructionBytes.Add((byte)result.ResultValue);
}
break;
case OperandType.Literal:
InstructionBytes.AddRange(operand.Value.ToTvcAsciiBytes());
break;
default:
return(new ParseResult(ParseResultCode.Error, 0, $"A(z) {operand} operandus típusa({operand.Info.DataType}) a {row.Instruction.Mnemonic} utasításban nem támogatott!"));
}
}
return(new ParseResult(ParseResultCode.Ok));
}
public virtual void VisitAssemblyRow(AssemblyRow row)
{
}
private ParseResult ParseOperands(AssemblyRow row, long fileLength, out int position, out int count)
{
position = 0;
count = -1;
if (row.Operands.Count == 2 || row.Operands.Count == 3)
{
Operand secondOperand = row.Operands[1];
switch (secondOperand.Info.DataType)
{
case OperandType.Decimal:
position = Convert.ToInt32(secondOperand.Value);
break;
case OperandType.Byte:
position = secondOperand.Value.ResolveByteConstant();
break;
case OperandType.Word:
position = secondOperand.Value.ResolveUshortConstant();
break;
default: return(new ParseResult(ParseResultCode.Error, 0, $"Az utasítás '{row.Instruction.Mnemonic}' második operandusa csak szám lehet!"));
}
if (position < 0 || position > fileLength)
{
return(new ParseResult(ParseResultCode.Error, 0, $"Az utasítás '{row.Instruction.Mnemonic}' második operandusa nem lehet kisebb nullánál, vagy nagyobb a file hosszánál!"));
}
count = (int)(fileLength - position);
}
if (row.Operands.Count == 3)
{
Operand thirdOperand = row.Operands[2];
switch (thirdOperand.Info.DataType)
{
case OperandType.Decimal:
count = Convert.ToInt32(thirdOperand.Value);
break;
case OperandType.Byte:
count = thirdOperand.Value.ResolveByteConstant();
break;
case OperandType.Word:
count = thirdOperand.Value.ResolveUshortConstant();
break;
default: return(new ParseResult(ParseResultCode.Error, 0, $"Az utasítás '{row.Instruction.Mnemonic}' harmadik operandusa csak szám lehet!"));
}
if (count < 1 || count > fileLength)
{
return(new ParseResult(ParseResultCode.Error, 0, $"Az utasítás '{row.Instruction.Mnemonic}' harmadik operandusa nem lehet kisebb egynél vagy nagyobb a file hosszánál!"));
}
}
return(new ParseResult(ParseResultCode.Ok));
}
void IMetadataProvider.Read(TokenTypes token, out AssemblyRow result)
{
TableHeap theap = (TableHeap)_streams[(int)HeapType.Tables];
theap.Read(token, out result);
}
public override ParseResult Resolve(AssemblyRow row)
{
if (row.Operands == null || row.Operands.Count == 0)
{
return(new ParseResult(ParseResultCode.Error, 0, $" Az {row.Instruction.Mnemonic} utasításnak a következő operandusai lehetnek: byte-ok száma[,alapérték]"));
}
byte[] initialValue = { 0x00 };
if (row.Operands.Count == 2)
{
switch (row.Operands[1].Info.DataType)
{
case OperandType.Byte:
initialValue = new[] { row.Operands[1].Value.ResolveByteConstant() };
break;
case OperandType.Decimal:
{
ushort value = row.Operands[1].Value.ResolveUshortConstant();
if (value > 0xFF)
{
byte highByte = (byte)(value >> 8);
byte lowByte = (byte)(value & 0xFF);
initialValue = new[] { lowByte, highByte };
}
else
{
initialValue = new[] { (byte)value };
}
}
break;
case OperandType.Word:
{
ushort value = row.Operands[1].Value.ResolveUshortConstant();
byte highByte = (byte)(value >> 8);
byte lowByte = (byte)(value & 0xFF);
initialValue = new[] { lowByte, highByte };
}
break;
case OperandType.Character:
case OperandType.Literal:
initialValue = row.Operands[1].Value.ToTvcAsciiBytes();
break;
case OperandType.Expression:
{
var expressionParser = new ExpressionParser(row.Operands[1].Value, SymbolTable);
var result = expressionParser.Parse();
if (result.ResultCode == ParseResultCode.Error || result.ResultCode == ParseResultCode.ContainsFutureSymbol)
{
return(result);
}
initialValue = result.ResultValue <= 0xff ? new[] { (byte)result.ResultValue } : new[] { (byte)(result.ResultValue & 0xFF), (byte)(result.ResultValue >> 8) };
}
break;
default:
{
Symbol symbol = SymbolTable.Where(s => s.Key.Equals(row.Operands[1].Value)).Select(s => s.Value).FirstOrDefault();
if (symbol == null)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A(z) {row.Operands[1]} operandus típusa({row.Operands[1].Info.DataType}) a {row.Instruction.Mnemonic} utasításban nem támogatott!"));
}
if (symbol.State == SymbolState.Unresolved)
{
return(new ParseResult(ParseResultCode.ContainsFutureSymbol));
}
initialValue = symbol.Value <= 0xff ? new[] { (byte)symbol.Value } : new[] { (byte)(symbol.Value & 0xFF), (byte)(symbol.Value >> 8) };
break;
}
}
}
ushort byteCount;
if (row.Operands[0].Info.DataType != OperandType.Decimal &&
row.Operands[0].Info.DataType != OperandType.Byte &&
row.Operands[0].Info.DataType != OperandType.Word &&
row.Operands[0].Info.DataType != OperandType.Expression)
{
Symbol symbol = SymbolTable.Where(s => s.Key.Equals(row.Operands[0].Value)).Select(s => s.Value).FirstOrDefault();
if (symbol == null)
{
return(new ParseResult(ParseResultCode.Error, 0, $"A(z) {row.Operands[0]} operandus típusa({row.Operands[0].Info.DataType}) a {row.Instruction.Mnemonic} utasításban nem támogatott!"));
}
if (symbol.State == SymbolState.Unresolved)
{
return(new ParseResult(ParseResultCode.ContainsFutureSymbol));
}
byteCount = symbol.Value;
}
else if (row.Operands[0].Info.DataType == OperandType.Expression)
{
var expressionParser = new ExpressionParser(row.Operands[0].Value, SymbolTable);
var result = expressionParser.Parse();
if (result.ResultCode == ParseResultCode.Error || result.ResultCode == ParseResultCode.ContainsFutureSymbol)
{
return(result);
}
byteCount = result.ResultValue;
}
else
{
byteCount = row.Operands[0].ToString().ResolveUshortConstant();
}
for (int i = 1; i <= byteCount; i++)
{
InstructionBytes.AddRange(initialValue);
}
return(new ParseResult(ParseResultCode.Ok));
}
