public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek to make sure next character is a register delimiter, otherwise we return
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
RegisterAddress targetRegister = sourceCrawler.ReadRegister();
// Eat the whitespace leading to next parameter
sourceCrawler.EatWhitespace();
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress sourceRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += 3;
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x37
output.Write((byte)targetRegister);
output.Write((byte)sourceRegister);
}
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek to make sure next character is a register delimiter, otherwise we return
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
RegisterAddress targetRegister = sourceCrawler.ReadRegister();
// Eat the whitespace leading to next parameter
sourceCrawler.EatWhitespace();
// Peek at the next character, if it is a literal delimiter, we parse a literal, otherwise we parse a register
if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read hard-coded location
uint location = sourceCrawler.ReadWordValue();
// Add the correct size to the assembly length
sourceCrawler.AssemblyLength += (uint)(1 + 1 + CompilerSettings.WORD_LENGTH);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x18
output.Write((byte)targetRegister);
output.Write(location);
}
}
// This is not a literal location, check for register
else if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress sourceRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += 3;
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[1]); // 0x19
output.Write((byte)targetRegister);
output.Write((byte)sourceRegister);
}
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
uint localSize = 0;
if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
localSize = sourceCrawler.ReadWordValue();
}
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += (1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x37
output.Write(localSize);
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek to make sure next character is a register delimiter, otherwise we return
if (sourceCrawler.Peek() == CompilerSettings.LabelDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
uint location = sourceCrawler.ReadLabelLocation();
// This instruction is 1 byte for instruction, and 1 word for location
sourceCrawler.AssemblyLength += (uint)(1 + CompilerSettings.WORD_LENGTH);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x0C
output.Write(location);
}
}
else if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
uint location = sourceCrawler.ReadWordValue();
// This instruction is 1 byte for instruction, and 1 word for location
sourceCrawler.AssemblyLength += (uint)(1 + CompilerSettings.WORD_LENGTH);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x0C
output.Write(location);
}
}
else
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
RegisterAddress sourceRegister = sourceCrawler.ReadRegister();
// This instruction is 1 byte for instruction, and 1 word for location
sourceCrawler.AssemblyLength += (uint)(1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[1]); // 0x4C
output.Write((byte)sourceRegister);
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek to make sure next character is a register delimiter, otherwise we return
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
RegisterAddress targetRegister = sourceCrawler.ReadRegister();
// Add the correct size to the assembly length
sourceCrawler.AssemblyLength += (uint)(1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x17
output.Write((byte)targetRegister);
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress destinationRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += (1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x35
output.Write((byte)destinationRegister);
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek to make sure next character is a register delimiter, otherwise we return
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
RegisterAddress sourceRegister = sourceCrawler.ReadRegister();
// Eat the whitespace leading to next parameter
sourceCrawler.EatWhitespace();
// Peek at the next character, if it is a literal delimiter, we parse a literal, otherwise we parse a register
if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read hard-coded location
byte deviceId = sourceCrawler.ReadByteValue();
// Add the correct size to the assembly length
sourceCrawler.AssemblyLength += (uint)(1 + 1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x32
output.Write((byte)sourceRegister);
output.Write(deviceId);
}
}
// This is not a literal location, check for register
else if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress destinationRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += (uint)(1 + 1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[1]); // 0x33
output.Write((byte)sourceRegister);
output.Write((byte)destinationRegister);
}
}
}
// Well it didn't start with a register, so we must be comparing a value
else if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the value
uint value = sourceCrawler.ReadWordValue();
// Eat the whitespace leading to next parameter
sourceCrawler.EatWhitespace();
// Peek at the next character, if it is a literal delimiter, we parse a literal, otherwise we parse a register
if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read hard-coded location
byte deviceId = sourceCrawler.ReadByteValue();
// Add the correct size to the assembly length
sourceCrawler.AssemblyLength += (uint)(1 + CompilerSettings.WORD_LENGTH + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[2]); // 0x30
output.Write(value);
output.Write(deviceId);
}
}
// This is not a literal location, check for register
else if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress destinationRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += (uint)(1 + CompilerSettings.WORD_LENGTH + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[3]); // 0x31
output.Write(value);
output.Write((byte)destinationRegister);
}
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek at the next character, if it is a literal delimiter, we parse a literal, otherwise we parse a register
if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read hard-coded location
uint value = sourceCrawler.ReadWordValue();
// Add the correct size to the assembly length
sourceCrawler.AssemblyLength += (uint)(1 + CompilerSettings.WORD_LENGTH);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x34
output.Write(value);
}
}
// This is not a literal location, check for register
else if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress sourceRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += (1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[1]); // 0x35
output.Write((byte)sourceRegister);
}
}
else if (sourceCrawler.Peek() == CompilerSettings.ConstantDelimiter)
{
string constant = "";
while (!char.IsWhiteSpace(sourceCrawler.Peek()))
{
constant += sourceCrawler.Get();
}
if (constant.Equals("_ret_addr_"))
{
sourceCrawler.AssemblyLength += 1 + 1;
if (!isLabelScan)
{
output.Write(ByteCodes[1]); // 0x35
output.Write((byte)0xF0);
}
}
}
}
public override void Interpret(SourceCrawler sourceCrawler, BinaryWriter output, bool isLabelScan)
{
// Eat whitespace to right of mnemonic
sourceCrawler.EatWhitespace();
// Peek to make sure next character is a register delimiter, otherwise we return
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over the register delimiter
sourceCrawler.CurrentNdx++;
// Read the register
RegisterAddress targetRegister = sourceCrawler.ReadRegister();
// Eat the whitespace leading to next parameter
sourceCrawler.EatWhitespace();
// Peek at the next character, if it is a literal delimiter, we parse a literal, otherwise we parse a register
if (sourceCrawler.Peek() == CompilerSettings.LiteralDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read hard-coded location
uint value = sourceCrawler.ReadWordValue();
// Eat whitepace to next delimiter
sourceCrawler.EatWhitespace();
// Make sure we have a target register
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
sourceCrawler.CurrentNdx++;
RegisterAddress destinationRegister = sourceCrawler.ReadRegister();
// Add the correct size to the assembly length
sourceCrawler.AssemblyLength += (uint)(1 + 1 + CompilerSettings.WORD_LENGTH + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[0]); // 0x20
output.Write((byte)targetRegister);
output.Write(value);
output.Write((byte)destinationRegister);
}
}
}
// This is not a literal location, check for register
else if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
// Pass over delimiter
sourceCrawler.CurrentNdx++;
// Read register
RegisterAddress sourceRegister = sourceCrawler.ReadRegister();
sourceCrawler.EatWhitespace();
// Make sure we have a target register
if (sourceCrawler.Peek() == CompilerSettings.RegisterDelimiter)
{
sourceCrawler.CurrentNdx++;
RegisterAddress destinationRegister = sourceCrawler.ReadRegister();
// This instruction is 3 bytes wide
sourceCrawler.AssemblyLength += (1 + 1 + 1 + 1);
// If this is not a label scanning pass, write to output
if (!isLabelScan)
{
output.Write(ByteCodes[1]); // 0x21
output.Write((byte)targetRegister);
output.Write((byte)sourceRegister);
output.Write((byte)destinationRegister);
}
}
}
else
{
throw new InvalidDataException("Bad bytecode at line {0}, arguments should be ADDS ,X ,Y ,Z or ADDS ,X #val ,Y");
}
}
}