protected void RegMathVar(Register aReg, string aOpMath, Address aVal)
{
switch (aOpMath)
{
case "+=":
Asm.Emit(OpCode.Add, aReg, aReg.RegSize, aVal.AddPrefix($"{Compiler.CurrentNamespace}_"));
break;
case "-=":
Asm.Emit(OpCode.Sub, aReg, aReg.RegSize, aVal.AddPrefix($"{Compiler.CurrentNamespace}_"));
break;
case "*=":
Asm.Emit(OpCode.Mul, aReg, aReg.RegSize, aVal.AddPrefix($"{Compiler.CurrentNamespace}_"));
break;
case "/=":
Asm.Emit(OpCode.Div, aReg, aReg.RegSize, aVal.AddPrefix($"{Compiler.CurrentNamespace}_"));
break;
case "%=":
Asm.Emit(OpCode.Rem, aReg, aReg.RegSize, aVal.AddPrefix($"{Compiler.CurrentNamespace}_"));
break;
default:
throw new Exception("Unsupported math operator");
}
}
protected void RegMathVar(Register aReg, string aOpMath, Address aVal)
{
// TODO: Do this better? Use Compiler.GetFullName() so things are consistent.
aVal.AddPrefix(Compiler.CurrentNamespace);
switch (aOpMath)
{
case "+=":
Asm.Emit(OpCode.Add, aReg, aReg.RegSize, aVal);
break;
case "-=":
Asm.Emit(OpCode.Sub, aReg, aReg.RegSize, aVal);
break;
case "*=":
Asm.Emit(OpCode.Mul, aReg, aReg.RegSize, aVal);
break;
case "/=":
Asm.Emit(OpCode.Div, aReg, aReg.RegSize, aVal);
break;
case "%=":
Asm.Emit(OpCode.Rem, aReg, aReg.RegSize, aVal);
break;
default:
throw new Exception("Unsupported math operator");
}
}
protected void VariableAssignment(Address aVariableName, string aOpEquals, object aValue)
{
// TODO: Do this better? Use Compiler.GetFullName() so things are consistent.
aVariableName.AddPrefix(Compiler.CurrentNamespace);
string size;
switch (aValue)
{
case uint _:
size = "dword";
Asm.Emit(OpCode.Mov, size, aVariableName, aValue);
break;
case Register aValueReg:
size = aValueReg.RegSize;
Asm.Emit(OpCode.Mov, size, aVariableName, aValue);
break;
case string _:
//TODO: verify this
aValue = Compiler.GetFullName($"Const_{aValue}");
Asm.Emit(OpCode.Mov, aVariableName, aValue);
break;
}
}
protected void IfSizeRegisterConditionVariableReturn(string aOpIf, string aSize, Register aRegister, string aOpCompare, Address aValue, object aOpReturn)
{
var xJumpOpCode = GetJumpOpCode(aOpCompare);
aValue.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Cmp, aSize, aRegister, aValue);
Asm.Emit(xJumpOpCode, Compiler.CurrentFunctionExitLabel);
}
protected void IfRegisterConditionVariable(string aOpIf, Register aRegister, string aOpCompare, Address aValue, object aOpOpenBrace)
{
Compiler.Blocks.StartBlock(Compiler.BlockType.If);
var xJumpOpCode = GetOppositeJumpOpCode(aOpCompare);
aValue.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Cmp, aRegister, aValue);
Asm.Emit(xJumpOpCode, Compiler.Blocks.EndBlockLabel);
}
protected void IfRegisterConditionVariable(string aOpIf, Register aRegister, string aOpCompare, Address aValue, string aGotoKeyword, string aLabel)
{
var xJumpOpCode = GetJumpOpCode(aOpCompare);
aValue.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Cmp, aRegister, aValue);
string xLabel = Compiler.GetFullName(aLabel, true);
Asm.Emit(xJumpOpCode, xLabel);
}
protected void IfSizeAdressConditionConst(string aOpIf, string aSize, Address aAdress, string aOpCompare, string aConstant, object aOpOpenBrace)
{
Compiler.Blocks.StartBlock(Compiler.BlockType.If);
var xJumpOpCode = GetOppositeJumpOpCode(aOpCompare);
aAdress.AddPrefix(Compiler.CurrentNamespace);
string xConstant = Compiler.GetFullName($"Const_{aConstant}");
Asm.Emit(OpCode.Cmp, aSize, aAdress, xConstant);
Asm.Emit(xJumpOpCode, Compiler.Blocks.EndBlockLabel);
}
protected void VariableAssignment(Address aVariableName, string aOpEquals, object aValue)
{
string size;
switch (aValue)
{
case uint _:
size = "dword";
Asm.Emit(OpCode.Mov, size, aVariableName.AddPrefix(Compiler.GetPrefixForVar), aValue);
break;
case Register aValueReg:
size = aValueReg.RegSize;
Asm.Emit(OpCode.Mov, size, aVariableName.AddPrefix(Compiler.GetPrefixForVar), aValue);
break;
case string _:
//TODO: verify this
aValue = $"{Compiler.GetPrefixForConst}{aValue}";
Asm.Emit(OpCode.Mov, aVariableName.AddPrefix(Compiler.GetPrefixForVar), aValue);
break;
}
}
protected void PopVar(string aOpPlus, Address value)
{
// TODO: Do this better? Use Compiler.GetFullName() so things are consistent.
value.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Pop, value);
}
protected void RegAssignVar(Register aReg, string aEquals, Address aVal)
{
// TODO: Do this better? Use Compiler.GetFullName() so things are consistent.
aVal.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Mov, aReg, aReg.RegSize, aVal);
}
protected void VariableAssignToMemory(string aOpOpenBracket, Register aTargetRegisterRoot, string aOpCloseBracket, string aOpEquals, Address source)
{
source.AddPrefix(Compiler.CurrentNamespace);
Asm.Emit(OpCode.Mov, "dword", new Address(aTargetRegisterRoot), source);
}
protected void RegAssigVar(Register aReg, string aEquals, Address aVal)
{
Asm.Emit(OpCode.Mov, aReg, aReg.RegSize, aVal.AddPrefix(Compiler.GetPrefixForVar));
}
protected void PopVar(string aOpPlus, Address value)
{
Asm.Emit(OpCode.Pop, value.AddPrefix(Compiler.GetPrefixForVar));
}
protected void RegAssignVar(Register aReg, string aEquals, Address aVal)
{
Asm.Emit(OpCode.Mov, aReg, aReg.RegSize, aVal.AddPrefix($"{Compiler.CurrentNamespace}_"));
}
protected void PopVar(string aOpPlus, Address value)
{
Asm.Emit(OpCode.Pop, value.AddPrefix($"{Compiler.CurrentNamespace}_"));
}
