internal static T Operand <T>(this InstructionStatementSyntax instruction, int index) where T : ExpressionSyntax
{
var operand = instruction.Operands.ElementAt(index);
var expression = GetStatementExpression(operand);
Assert.IsType <T>(expression);
return((T)(expression));
}
/// <summary>
/// Assemble an instruction statement into a binary buffer.
/// </summary>
/// <param name="instruction">The instruction statement to assemble.</param>
/// <param name="resolver">Resolves any symbols found in the instruction statement.</param>
/// <returns>The encoded instruction to binary.</returns>
private byte[] Assemble(InstructionStatementSyntax instruction, SymbolResolver resolver)
{
using (var assembler = new Engine(_architecture, _mode))
{
var instructionText = ConvertInstructionToString(instruction, resolver);
var encoded = assembler.Assemble(instructionText, _memory.Address);
return(encoded.Buffer);
}
}
private string ConvertInstructionToString(InstructionStatementSyntax instruction, SymbolResolver resolver)
{
StringBuilder instructionBuilder = new StringBuilder();
instructionBuilder.Append(instruction.InstructionToken.Text);
if (instruction.Operands.Any())
{
int operandIndex = 0;
instructionBuilder.Append(" ");
foreach (var operand in instruction.Operands)
{
instructionBuilder.Append(resolver.ResolveSymbol(operand));
if (++operandIndex != instruction.Operands.Count())
{
instructionBuilder.Append(",");
}
}
}
return(instructionBuilder.ToString());
}
internal static string Token(this InstructionStatementSyntax expression)
{
Assert.NotNull(expression.InstructionToken);
return(expression.InstructionToken.Text);
}
public IBufferWriter <byte> Emit(IBufferWriter <byte> stream, InstructionStatementSyntax instruction, SymbolResolver resolver)
{
stream.Write(Assemble(instruction, resolver));
return(stream);
}
public IntelCompilationUnitSyntax(InstructionStatementSyntax instructionStatement, SyntaxToken endOfFileToken)
{
InstructionStatement = instructionStatement;
EndOfFileToken = endOfFileToken;
}
internal static T Operand3 <T>(this InstructionStatementSyntax instruction) where T : ExpressionSyntax
{
return(Operand <T>(instruction, index: 2));
}
