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)); }