void ApplyFindingColoring(AssemblyFindingCollection findings, Severity severity)
{
foreach (AssemblyFinding finding in findings)
{
if (finding.Severity == severity)
{
ApplyFindingColoring(finding, MarkOperation.None);
}
}
}
void SetStatusBarText(AssemblyFindingCollection findings)
{
var severityNames = Enum.GetNames(typeof(Severity));
int[] severityCounts = new int[severityNames.Length];
foreach (AssemblyFinding finding in findings)
{
severityCounts[(int)finding.Severity]++;
}
string message = "0";
int currentSeverityIndex = 0;
for (int i = 0; i < severityCounts.Length; i++)
{
if (severityCounts[i] <= 0)
{
continue;
}
string severityText = severityCounts[i] + " " + severityNames[i].ToLower();
switch (currentSeverityIndex)
{
case 0:
message = severityText;
break;
case 1:
message = severityText + " and " + message;
break;
default:
message = severityText + ", " + message;
break;
}
currentSeverityIndex++;
}
message = "Showing " + message + " message";
if (findings.Count != 1)
{
message += 's';
}
mStatusBarPanel.Text = message;
}
string GetAssemblyErrorsCaption(ParsedSourceLine line, AssemblyFindingCollection findings)
{
string caption = "";
int findingNumber = 1;
foreach (AssemblyFinding finding in findings)
{
string fieldLabel = "";
if (finding.Severity == Severity.Error)
{
switch (finding.LineSection)
{
case LineSection.OpField:
MarkAssemblyError(finding.StartCharIndex, finding.Length);
fieldLabel = "mnemonic";
break;
case LineSection.AddressField:
if (finding.Length != 0)
{
MarkAssemblyError((line.OpField.Length + finding.StartCharIndex) + 1, finding.Length);
}
else
{
MarkAssemblyError(line.OpField.Length + 1, line.AddressField.Length);
}
fieldLabel = "address";
break;
case LineSection.CommentField:
continue;
case LineSection.EntireLine:
MarkAssemblyError(0, TextLength);
fieldLabel = "instruction";
break;
}
}
if (findingNumber != 1)
{
caption = string.Concat(caption, Environment.NewLine, findingNumber, ". ");
}
if (findingNumber == 2)
{
caption = "1. " + caption;
}
caption = caption + fieldLabel + ": " + finding.Message;
findingNumber++;
}
return(findingNumber == 2
? string.Concat("Instruction error: ", caption)
: string.Concat("Instruction errors:", Environment.NewLine, caption));
}
public static InstructionInstanceBase Assemble(string instructionLine, int locationCounter, out ParsedSourceLine parsedLine, SymbolCollection symbols, out AssemblyFindingCollection findings)
{
var status = new ParsingStatus(symbols)
{
LocationCounter = locationCounter,
LineNumber = 0
};
parsedLine = Parser.ParseInstructionLine(instructionLine, status);
findings = status.Findings;
// if errors were found while parsing, abort assembly
if (status.Findings.ContainsErrors)
{
return(null);
}
if (!parsedLine.IsDefined)
{
status.Findings.Add(new AssemblyError(0, LineSection.EntireLine, 0, 0, new ValidationError("line is not an instruction")));
return(null);
}
status.LocationCounter = locationCounter;
status.LineNumber = 0;
var instructionInstance = parsedLine.CreateInstance(status);
// if errors were found while assembling, don't return the instruction instance: it would be useless anyway
if (status.Findings.ContainsErrors)
{
return(null);
}
return(instructionInstance);
}
public static InstructionInstanceBase[] Assemble(string[] sourceLines, out PreInstruction[] preInstructions, out SymbolCollection symbols, out AssemblyFindingCollection findings)
{
var list = new List <InstructionInstanceBase>();
var status = new ParsingStatus();
preInstructions = Parser.ParseSource(sourceLines, status);
findings = status.Findings;
symbols = null;
// if errors were found during parsing, abort assembly
if (status.Findings.ContainsErrors)
{
return(null);
}
status.LocationCounter = 0;
status.LineNumber = 0;
// compose the instruction instances based on the preinstructions returned by the parser
foreach (PreInstruction instruction in preInstructions)
{
if (instruction.IsDefined)
{
var parsedSourceLine = instruction as ParsedSourceLine;
status.LineNumber = parsedSourceLine != null ? parsedSourceLine.LineNumber : sourceLines.Length;
var instructionInstance = instruction.CreateInstance(status);
if (parsedSourceLine != null && instructionInstance != null)
{
string sourceLineText = parsedSourceLine.LocationField + new string(' ', Math.Max(Parser.MinLocLength - parsedSourceLine.LocationField.Length, 0) + Parser.FieldSpacing);
sourceLineText += parsedSourceLine.OpField + new string(' ', Math.Max(Parser.MinOpLength - parsedSourceLine.OpField.Length, 0) + Parser.FieldSpacing);
sourceLineText += parsedSourceLine.AddressField + new string(' ', Math.Max(Parser.MinAddressLength - parsedSourceLine.AddressField.Length, 0) + Parser.FieldSpacing);
sourceLineText += parsedSourceLine.Comment;
instructionInstance.SourceLine = sourceLineText;
}
list.Add(instructionInstance);
if (instructionInstance != null && instructionInstance.Instruction is LoaderInstruction)
{
var loaderInstruction = (LoaderInstruction)instructionInstance.Instruction;
if (loaderInstruction.Operation == LoaderInstruction.Operations.SetLocationCounter)
{
status.LocationCounter = (int)((LoaderInstruction.Instance)instructionInstance).Value.LongValue;
continue;
}
// in case the PC is set by this instruction instance, prevent the location counter from being increased
if (loaderInstruction.Operation == LoaderInstruction.Operations.SetProgramCounter)
{
continue;
}
}
status.LocationCounter++;
}
}
// if errors were found during assembly, don't return the instruction instances: they would be useless anyway
if (status.Findings.ContainsErrors)
{
return(null);
}
symbols = new SymbolCollection();
foreach (SymbolBase symbol in status.Symbols)
{
if (symbol is ValueSymbol)
{
symbols.Add(symbol);
}
}
status.Findings.Add(new AssemblyInfo("assembly completed successfully", int.MinValue, LineSection.EntireLine, 0, 0));
return(list.ToArray());
}
public void SetInstructionsAndFindings(PreInstruction[] instructions, InstructionInstanceBase[] instances, AssemblyFindingCollection findings)
{
mSourceControl.Instructions = instructions;
mSourceControl.Findings = findings;
mFindingListView.Findings = findings;
SetStatusBarText(findings);
mInstances = instances;
mLoadButton.Enabled = !findings.ContainsErrors;
mExportButton.Enabled = mLoadButton.Enabled;
}
