public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 2)
{
cgen.CreateError("{0} does not take {1} arguments!", ins.Name, ins.Operands.Count);
}
else if (!(ins.Operands[0] is TokenIntLiteral || ins.Operands[0] is TokenRegister) && !(ins.Operands[1] is TokenRegister))
{
cgen.CreateError("Unsupported addressing mode for instruction '{0}'", ins.Name);
}
else
{
TokenRegister op2 = ins.Operands[1] as TokenRegister;
Opcode opcode = Opcode.OUT;
if (ins.Operands[0] is TokenRegister)
{
TokenRegister op1 = ins.Operands[0] as TokenRegister;
str.Emit(new QuasarInstruction(opcode, new RegisterOperand(op1.Register), new RegisterOperand(op2.Register)));
}
else if (ins.Operands[0] is TokenIntLiteral)
{
TokenIntLiteral op1 = ins.Operands[0] as TokenIntLiteral;
str.Emit(new QuasarInstruction(opcode, new IntegerOperand((int)op1.Value), new RegisterOperand(op2.Register)));
}
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 2)
{
cgen.CreateError("{0} does not take {1} arguments!", ins.Name, ins.Operands.Count);
}
else if (!(ins.Operands[0] is TokenRegister) || (!(ins.Operands[1] is TokenRegister) && !(ins.Operands[1] is TokenIntLiteral) && !(ins.Operands[1] is TokenIdentifier)))
{
cgen.CreateError("Unsupported addressing mode for instruction '{0}'", ins.Name);
}
else
{
TokenRegister op1 = ins.Operands[0] as TokenRegister;
Opcode opcode = Opcode.ADD;
if (ins.Operands[1] is TokenRegister)
{
TokenRegister op2 = ins.Operands[1] as TokenRegister;
str.Emit(new QuasarInstruction(opcode, new RegisterOperand(op1.Register), new RegisterOperand(op2.Register)));
}
else if (ins.Operands[1] is TokenIntLiteral)
{
TokenIntLiteral op2 = ins.Operands[1] as TokenIntLiteral;
Console.WriteLine("Add with " + op1.Register);
str.Emit(new QuasarInstruction(opcode, new RegisterOperand(op1.Register), new IntegerOperand((int)op2.Value)));
}
else if (ins.Operands[1] is TokenIdentifier)
{
TokenIdentifier ident = ins.Operands[1] as TokenIdentifier;
str.Emit(new QuasarInstruction(opcode, new RegisterOperand(op1.Register), new SymbolReferenceOperand(ident.Value)));
}
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 0)
{
cgen.CreateError("{0} does not take {1} arguments!", ins.Name, ins.Operands.Count);
}
else
{
str.Emit(new QuasarInstruction(Opcode.IRTN));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 1)
{
cgen.CreateError("Instruction {0} does not take {1} operand(s)!", ins.Name, ins.Operands.Count);
}
else if (ins.Operands[0] is TokenIdentifier)
{
TokenIdentifier label = ins.Operands[0] as TokenIdentifier;
str.Emit(new QuasarInstruction(Opcode.BSR, new SymbolReferenceOperand(label.Value, true)));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 1)
{
cgen.CreateError("Directive {0} does not take {1} operands!", ins.Name, ins.Operands.Count);
}
else if (!(ins.Operands[0] is TokenIntLiteral))
{
cgen.CreateError("Integer size expected!");
}
else
{
str.Emit(new QuasarData(new byte[((TokenIntLiteral)ins.Operands[0]).Value]));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 1)
{
cgen.CreateError("{0} does not take {1} arguments!", ins.Name, ins.Operands.Count);
}
else if (!(ins.Operands[0] is TokenRegister))
{
cgen.CreateError("Unsupported addressing mode for instruction '{0}'", ins.Name);
}
else
{
TokenRegister src = ins.Operands[0] as TokenRegister;
str.Emit(new QuasarInstruction(Opcode.LCTL, new RegisterOperand(src.Register)));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
using (MemoryStream ms = new MemoryStream())
{
BinaryWriter bw = new BinaryWriter(ms);
foreach (AbstractToken tok in ins.Operands)
{
if (tok is TokenIntLiteral)
{
bw.Write((byte)((TokenIntLiteral)tok).Value);
}
}
str.Emit(new QuasarData(ms.ToArray()));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 1)
{
cgen.CreateError("{0} does not take {1} arguments!", ins.Name, ins.Operands.Count);
}
else if (!(ins.Operands[0] is TokenIntLiteral))
{
cgen.CreateError("Unsupported addressing mode for instruction '{0}'", ins.Name);
}
else
{
TokenIntLiteral il = ins.Operands[0] as TokenIntLiteral;
str.Emit(new OrgDirective((uint)il.Value));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 1)
{
cgen.CreateError("Instruction {0} does not take {1} operand(s)!", ins.Name, ins.Operands.Count);
}
else if (ins.Operands[0] is TokenIdentifier)
{
TokenIdentifier label = ins.Operands[0] as TokenIdentifier;
QuasarConditionCode code = QuasarConditionCode.NONE;
switch (ins.Name)
{
case "bc":
code = QuasarConditionCode.C;
break;
case "bs":
code = QuasarConditionCode.N;
break;
case "bv":
code = QuasarConditionCode.V;
break;
case "bz":
code = QuasarConditionCode.Z;
break;
case "be":
code = QuasarConditionCode.EQ;
break;
case "bne":
code = QuasarConditionCode.NE;
break;
case "ba":
code = QuasarConditionCode.AB;
break;
case "bb":
code = QuasarConditionCode.BL;
break;
case "bl":
code = QuasarConditionCode.LT;
break;
case "bg":
code = QuasarConditionCode.GT;
break;
case "ble":
code = QuasarConditionCode.LE;
break;
case "bge":
code = QuasarConditionCode.GE;
break;
}
str.Emit(new QuasarInstruction(Opcode.BR, new ConditionCodeOperand(code), new SymbolReferenceOperand(label.Value, true)));
}
}
public override void Assemble(CodeGenerator cgen, Instruction ins, BytecodeStream str)
{
if (ins.Operands.Count != 2)
{
cgen.CreateError("Instruction {0} does not take {1} operand(s)!", ins.Name, ins.Operands.Count);
}
else if (ins.Name == "movb")
{
if (ins.Operands[0] is TokenIndirectRegister &&
ins.Operands[1] is TokenRegister)
{
TokenIndirectRegister r1 = ins.Operands[0] as TokenIndirectRegister;
TokenRegister r2 = ins.Operands[1] as TokenRegister;
str.Emit(new QuasarInstruction(Opcode.MOV, new IndirectRegisterOffsetOperand(r1.Register, AddressingMode.REGISTER_INDIRECT_BYTE, r1.Offset),
new RegisterOperand(r2.Register)));
}
else if (ins.Operands[0] is TokenIndirectRegister &&
ins.Operands[1] is TokenRegister)
{
TokenIndirectRegister r1 = ins.Operands[0] as TokenIndirectRegister;
TokenRegister r2 = ins.Operands[1] as TokenRegister;
str.Emit(new QuasarInstruction(Opcode.MOV, new IndirectRegisterOffsetOperand(r1.Register, AddressingMode.REGISTER_INDIRECT_BYTE, r1.Offset),
new RegisterOperand(r2.Register)));
}
}
else if (ins.Name == "movw")
{
if (ins.Operands[0] is TokenIndirectRegister &&
ins.Operands[1] is TokenRegister)
{
TokenIndirectRegister r1 = ins.Operands[0] as TokenIndirectRegister;
TokenRegister r2 = ins.Operands[1] as TokenRegister;
str.Emit(new QuasarInstruction(Opcode.MOV, new IndirectRegisterOffsetOperand(r1.Register, AddressingMode.REGISTER_INDIRECT_WORD, r1.Offset),
new RegisterOperand(r2.Register)));
}
}
else
{
if (ins.Operands[0] is TokenRegister &&
ins.Operands[1] is TokenRegister)
{
TokenRegister r1 = ins.Operands[0] as TokenRegister;
TokenRegister r2 = ins.Operands[1] as TokenRegister;
str.Emit(new QuasarInstruction(Opcode.MOV, new RegisterOperand(r1.Register),
new RegisterOperand(r2.Register)));
}
else if (ins.Operands[0] is TokenRegister &&
ins.Operands[1] is TokenIntLiteral)
{
TokenRegister r1 = ins.Operands[0] as TokenRegister;
TokenIntLiteral i1 = ins.Operands[1] as TokenIntLiteral;
str.Emit(new QuasarInstruction(Opcode.MOV, new RegisterOperand(r1.Register),
new IntegerOperand((int)i1.Value)));
}
else if (ins.Operands[0] is TokenRegister &&
ins.Operands[1] is TokenIdentifier)
{
TokenRegister r1 = ins.Operands[0] as TokenRegister;
TokenIdentifier i1 = ins.Operands[1] as TokenIdentifier;
str.Emit(new QuasarInstruction(Opcode.MOV, new RegisterOperand(r1.Register),
new SymbolReferenceOperand(i1.Value)));
}
else if (ins.Operands[0] is TokenRegister &&
ins.Operands[1] is TokenIndirectRegister)
{
TokenRegister r1 = ins.Operands[0] as TokenRegister;
TokenIndirectRegister r2 = ins.Operands[1] as TokenIndirectRegister;
str.Emit(new QuasarInstruction(Opcode.MOV, new RegisterOperand(r1.Register),
new IndirectRegisterOffsetOperand(r2.Register, r2.Offset)));
}
else if (ins.Operands[0] is TokenIndirectRegister &&
ins.Operands[1] is TokenRegister)
{
TokenIndirectRegister r1 = ins.Operands[0] as TokenIndirectRegister;
TokenRegister r2 = ins.Operands[1] as TokenRegister;
str.Emit(new QuasarInstruction(Opcode.MOV, new IndirectRegisterOffsetOperand(r1.Register, AddressingMode.REGISTER_INDIRECT, r1.Offset),
new RegisterOperand(r2.Register)));
}
else
{
cgen.CreateError("Unsupported addressing mode for instruction {0}", ins.Name);
}
}
}
