public override void Compile(Emitter.Emitter emitter)
{
var leftType = Left.GetExpressionType(emitter);
var rightType = Right.GetExpressionType(emitter);
var type = GetExpressionType(emitter);
// subtract matrices
if(type == "matrix")
{
Left.Compile(emitter);
Right.Compile(emitter);
var matrixType = typeof(MN.Matrix<double>);
var method = emitter.AssemblyImport(matrixType.GetMethod("Subtract", new [] { matrixType } ));
emitter.EmitCall(method);
}
// subtract dicts
else if (type == "dict")
{
Left.Compile(emitter);
Right.Compile(emitter);
var dictType = typeof(Dict);
var method = emitter.AssemblyImport(dictType.GetMethod("Subtract", new[] { dictType }));
emitter.EmitCall(method);
}
// subtract complex numbers
else if (type == "complex")
{
Left.Compile(emitter);
if (leftType != "complex")
{
emitter.EmitUpcastBasicType(leftType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
Right.Compile(emitter);
if (rightType != "complex")
{
emitter.EmitUpcastBasicType(rightType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Subtraction", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
}
// add floating point numbers or integers
else if (type.IsAnyOf("int", "float"))
{
Left.Compile(emitter);
emitter.EmitUpcastBasicType(leftType, type);
Right.Compile(emitter);
emitter.EmitUpcastBasicType(rightType, type);
emitter.EmitSub();
}
}
public override void Compile(Emitter.Emitter emitter)
{
var leftType = Left.GetExpressionType(emitter);
var rightType = Right.GetExpressionType(emitter);
var type = GetExpressionType(emitter);
// divide matrix by a number
if(type == "matrix")
{
Left.Compile(emitter);
// division is broken, therefore multiply by an inverse value
emitter.EmitLoadFloat(1);
Right.Compile(emitter);
if (rightType != "float")
emitter.EmitConvertToFloat();
emitter.EmitDiv();
var matrixType = typeof(MN.Matrix<double>);
var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { typeof(double) }));
emitter.EmitCall(method);
}
// divide complex numbers
else if (type == "complex")
{
Left.Compile(emitter);
if (leftType != "complex")
{
emitter.EmitUpcastBasicType(leftType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
Right.Compile(emitter);
if (rightType != "complex")
{
emitter.EmitUpcastBasicType(rightType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Division", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
}
// divide floating point numbers or integers
else if (type.IsAnyOf("int", "float"))
{
Left.Compile(emitter);
emitter.EmitUpcastBasicType(leftType, type);
Right.Compile(emitter);
emitter.EmitUpcastBasicType(rightType, type);
emitter.EmitDiv();
}
}
public override void Compile(Emitter.Emitter emitter)
{
var leftType = Left.GetExpressionType(emitter);
var rightType = Right.GetExpressionType(emitter);
var type = GetExpressionType(emitter);
Left.Compile(emitter);
emitter.EmitUpcastBasicType(leftType, type);
Right.Compile(emitter);
emitter.EmitUpcastBasicType(rightType, type);
emitter.EmitRem();
}
public override void Compile(Emitter.Emitter emitter)
{
try
{
Resolve(emitter);
}
catch (CompilerException ex)
{
ex.AffixToLexem(Lexem);
throw;
}
var method = emitter.FindMethod(OwnerType, Name, GetSignature(emitter));
// load 'this'
if (ExpressionPrefix != null)
ExpressionPrefix.Compile(emitter);
else if (!Static)
emitter.EmitLoadThis();
// load parameters
for (int idx = 0; idx < Parameters.Count; idx++)
{
Parameters[idx].Compile(emitter);
emitter.EmitUpcastBasicType(Parameters[idx].GetExpressionType(emitter), method.Parameters[idx].Type.Signature);
}
// invoke
emitter.EmitCall(method);
}
public override void Compile(Emitter.Emitter emitter)
{
var leftType = Left.GetExpressionType(emitter);
var rightType = Right.GetExpressionType(emitter);
// ensure objects can be compared or issue an exception
CheckComparable(leftType, rightType, emitter);
// compile arguments and ensure their types
Left.Compile(emitter);
emitter.EmitUpcastBasicType(leftType, rightType);
Right.Compile(emitter);
emitter.EmitUpcastBasicType(rightType, leftType);
// emity comparison opcodes
if (ComparisonType == LexemType.Equal || ComparisonType == LexemType.NotEqual)
CompileEquality(emitter, leftType, rightType);
else
CompileRelation(emitter, leftType, rightType);
}
public override void Compile(Emitter.Emitter emitter)
{
// check if constructor exists
TypeNode type = null;
try
{
type = emitter.FindType(Name);
}
catch
{
Error(String.Format(Resources.errTypeNotFound, Name));
}
// check if type is an enum?
if (type.Enum)
{
// the constructor in an enum is pseudo-private
// so that it can only be called from another method
// of the same enum type
if(emitter.CurrentMethod == null || emitter.CurrentMethod.Owner != type)
Error(String.Format(Resources.errConstructEnum, Name));
}
MethodNode method = null;
var signature = GetSignature(emitter);
try
{
method = emitter.FindMethod(Name, ".ctor", signature);
}
catch
{
Error(String.Format(Resources.errConstructorNotFound, Name, signature.Join(" ")));
}
// parameters
for (int idx = 0; idx < Parameters.Count; idx++)
{
Parameters[idx].Compile(emitter);
emitter.EmitUpcastBasicType(Parameters[idx].GetExpressionType(emitter), method.Parameters[idx].Type.Signature);
}
emitter.EmitNewObj(method);
}
public override void Compile(Emitter.Emitter emitter)
{
var leftType = Left.GetExpressionType(emitter);
var rightType = Right.GetExpressionType(emitter);
var type = GetExpressionType(emitter);
// concat strings
if (type == "string")
{
Left.Compile(emitter);
Right.Compile(emitter);
emitter.EmitCall(emitter.FindMethod("string", "concat", "string", "string"));
}
// add matrices
else if(type == "matrix")
{
Left.Compile(emitter);
Right.Compile(emitter);
var matrixType = typeof(MN.Matrix<double>);
var method = emitter.AssemblyImport(matrixType.GetMethod("Add", new [] { matrixType } ));
emitter.EmitCall(method);
}
// add dicts
else if (type == "dict")
{
Left.Compile(emitter);
Right.Compile(emitter);
var dictType = typeof(Dict);
var method = emitter.AssemblyImport(dictType.GetMethod("Add", new[] { dictType }));
emitter.EmitCall(method);
}
// add complex numbers
else if(type == "complex")
{
Left.Compile(emitter);
if(leftType != "complex")
{
emitter.EmitUpcastBasicType(leftType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
Right.Compile(emitter);
if (rightType != "complex")
{
emitter.EmitUpcastBasicType(rightType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Addition", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
}
// add floating point numbers or integers
else if(type.IsAnyOf("int", "float"))
{
Left.Compile(emitter);
emitter.EmitUpcastBasicType(leftType, type);
Right.Compile(emitter);
emitter.EmitUpcastBasicType(rightType, type);
emitter.EmitAdd();
}
// array addition
else if(type.Contains("[]"))
{
Left.Compile(emitter);
Right.Compile(emitter);
var method = emitter.AssemblyImport(typeof(ArrayHelper).GetMethod("AddArrays", new[] { typeof(object), typeof(object) } ));
emitter.EmitCall(method);
}
}
public override void Compile(Emitter.Emitter emitter)
{
var leftType = Left.GetExpressionType(emitter);
var rightType = Right.GetExpressionType(emitter);
var type = GetExpressionType(emitter);
// repeat a string
if (type == "string")
{
Left.Compile(emitter);
Right.Compile(emitter);
emitter.EmitCall(emitter.FindMethod("string", "repeat", "int"));
}
// multiply matrices
else if(type == "matrix")
{
var matrixType = typeof(MN.Matrix<double>);
// matrix by matrix
if(leftType == rightType)
{
Left.Compile(emitter);
Right.Compile(emitter);
var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { matrixType }));
emitter.EmitCall(method);
}
else
{
// matrix should be the first in stack
if(leftType == "matrix")
{
Left.Compile(emitter);
Right.Compile(emitter);
if (rightType != "float")
emitter.EmitConvertToFloat();
}
else
{
Right.Compile(emitter);
Left.Compile(emitter);
if (leftType != "float")
emitter.EmitConvertToFloat();
}
var method = emitter.AssemblyImport(matrixType.GetMethod("Multiply", new[] { typeof(double) }));
emitter.EmitCall(method);
}
}
// multiply complex numbers
else if (type == "complex")
{
Left.Compile(emitter);
if (leftType != "complex")
{
emitter.EmitUpcastBasicType(leftType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
Right.Compile(emitter);
if (rightType != "complex")
{
emitter.EmitUpcastBasicType(rightType, "float");
emitter.EmitLoadFloat(0);
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("op_Multiply", new[] { typeof(SN.Complex), typeof(SN.Complex) })));
}
// repeat array
else if (leftType.EndsWith("[]"))
{
Left.Compile(emitter);
Right.Compile(emitter);
var method = emitter.AssemblyImport(typeof(MirelleStdlib.ArrayHelper).GetMethod("RepeatArray", new[] { typeof(object), typeof(int) }));
emitter.EmitCall(method);
}
// multiply floating point numbers or integers
else if (type.IsAnyOf("int", "float"))
{
Left.Compile(emitter);
emitter.EmitUpcastBasicType(leftType, type);
Right.Compile(emitter);
emitter.EmitUpcastBasicType(rightType, type);
emitter.EmitMul();
}
}