private static void CompileInteger(ILProcessor processor, PrimitiveValue value, CilCompilationContext context)
{
var integer = (Integer)value.Value;
if (integer.Kind == IntegerKind.Int32)
{
processor.EmitLdcI4(integer.Int32Value);
processor.Emit(OpCodes.Newobj, context.ConvertReference(NewIntegerFromInt32));
}
else
{
EmitBigIntegerBytes(processor, integer.BigIntegerValue, context);
processor.Emit(OpCodes.Newobj, context.ConvertReference(NewIntegerFromBytes));
}
}
public override void Compile(ILProcessor processor, AstFunctionReferenceExpression reference, CilCompilationContext context)
{
if (reference.Target != null && !(reference.Target is IAstTypeReference))
{
context.Compile(reference.Target);
}
else
{
processor.Emit(OpCodes.Ldnull);
}
var delegateType = context.ConvertReference(reference.ExpressionType);
var delegateConstructor = context.Method.Module.Import(delegateType.Resolve().Methods.Single(m => m.Name == ".ctor"));
delegateConstructor.DeclaringType = delegateType; // fixes issue with delegateType.Resolve() eliminating generic arguments
processor.Emit(OpCodes.Ldftn, context.ConvertReference(reference.Function));
processor.Emit(OpCodes.Newobj, delegateConstructor);
}
private static void CompileDecimal(ILProcessor processor, PrimitiveValue value, CilCompilationContext context)
{
var @decimal = (Decimal)value.Value;
var bits = @decimal.GetBits();
var bitsVariable = context.DefineVariable("t", Int32Array); // temporary cheating
processor.EmitLdcI4(bits.Length);
processor.Emit(OpCodes.Newarr, context.ConvertReference(Int32));
processor.Emit(OpCodes.Stloc, bitsVariable);
for (var i = 0; i < bits.Length; i++)
{
processor.Emit(OpCodes.Ldloc, bitsVariable);
processor.EmitLdcI4(i);
processor.EmitLdcI4(bits[i]);
processor.Emit(OpCodes.Stelem_I4);
}
processor.Emit(OpCodes.Ldloc, bitsVariable);
processor.Emit(OpCodes.Newobj, context.ConvertReference(NewDecimalFromBits));
}
private void CompileFieldOrPropertyAssignment(ILProcessor processor, AstPropertyExpression property, IAstExpression value, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldarg_0);
context.Compile(value);
var fieldOrProperty = context.ConvertReference(property.Reference);
var field = fieldOrProperty.As <FieldReference>();
if (field == null)
{
throw new NotImplementedException("AssignmentCompiler: Assignment to " + fieldOrProperty + " is not yet supported.");
}
processor.Emit(OpCodes.Stfld, field);
}
public static void CompileTarget(ILProcessor processor, IAstExpression target, IAstMethodReference function, CilCompilationContext context)
{
context.Compile(target);
if (function.Location == MethodLocation.Extension)
return;
var targetType = context.ConvertReference(target.ExpressionType);
if (!targetType.IsValueType)
return;
var variable = context.DefineVariable("x", targetType);
processor.Emit(OpCodes.Stloc, variable);
processor.Emit(OpCodes.Ldloca_S, variable);
}
public override void Compile(ILProcessor processor, AstListInitializer initializer, CilCompilationContext context)
{
var temporaryVariable = context.DefineVariable("temp", initializer.ExpressionType);
var elementType = context.ConvertReference(initializer.Elements[0].ExpressionType); // temporary cheating
processor.EmitLdcI4(initializer.Elements.Count);
processor.Emit(OpCodes.Newarr, elementType);
processor.Emit(OpCodes.Stloc, temporaryVariable);
for (var i = 0; i < initializer.Elements.Count; i++)
{
processor.Emit(OpCodes.Ldloc, temporaryVariable);
processor.EmitLdcI4(i);
EmitStelem(processor, elementType, initializer.Elements[i], context);
}
processor.Emit(OpCodes.Ldloc, temporaryVariable);
}
public override void Compile(ILProcessor processor, BinaryExpression binary, CilCompilationContext context)
{
var builtIn = binary.Operator as AstBuiltInOperator;
if (builtIn != null)
{
context.Compile(binary.Left);
context.Compile(binary.Right);
EmitBuiltInOperator(processor, builtIn);
return;
}
context.Compile(binary.Left);
context.Compile(binary.Right);
processor.Emit(OpCodes.Call, context.ConvertReference(binary.Operator));
}
private static void EmitBigIntegerBytes(ILProcessor processor, BigInteger value, CilCompilationContext context)
{
var bytes = value.ToByteArray();
var bytesVariable = context.DefineVariable("t", ByteArray); // temporary cheating
processor.EmitLdcI4(bytes.Length);
processor.Emit(OpCodes.Newarr, context.ConvertReference(Byte));
processor.Emit(OpCodes.Stloc, bytesVariable);
for (var i = 0; i < bytes.Length; i++)
{
processor.Emit(OpCodes.Ldloc, bytesVariable);
processor.EmitLdcI4(i);
processor.EmitLdcI4(bytes[i]);
processor.Emit(OpCodes.Stelem_I1);
}
processor.Emit(OpCodes.Ldloc, bytesVariable);
}
public static void CompileTarget(ILProcessor processor, IAstExpression target, IAstMethodReference function, CilCompilationContext context)
{
context.Compile(target);
if (function.Location == MethodLocation.Extension)
{
return;
}
var targetType = context.ConvertReference(target.ExpressionType);
if (!targetType.IsValueType)
{
return;
}
var variable = context.DefineVariable("x", targetType);
processor.Emit(OpCodes.Stloc, variable);
processor.Emit(OpCodes.Ldloca_S, variable);
}
public override void Compile(ILProcessor processor, AstPropertyExpression expression, CilCompilationContext context)
{
if (expression.Target != null)
{
context.Compile(expression.Target);
}
var fieldOrProperty = context.ConvertReference(expression.Reference);
var field = fieldOrProperty.As <FieldReference>();
if (field != null)
{
processor.Emit(OpCodes.Ldfld, field);
return;
}
var property = (PropertyReferenceContainer)fieldOrProperty;
processor.Emit(OpCodes.Call, property.GetMethod);
}
public override void Compile(ILProcessor processor, CallExpression call, CilCompilationContext context)
{
var function = call.Callee as AstFunctionReferenceExpression;
if (function == null)
{
throw new NotImplementedException("CallCompiler: " + call.Callee.GetType().Name + " is not yet supported as call.Callee.");
}
if (function.Target != null && !(function.Target is IAstTypeReference))
{
CallCompilerHelper.CompileTarget(processor, (IAstExpression)function.Target, function.Function, context);
}
foreach (var argument in call.Arguments)
{
context.Compile(argument);
}
processor.Emit(OpCodes.Call, context.ConvertReference(function.Function));
}
public override void Compile(ILProcessor processor, AstVariableReference variable, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldloc, context.ConvertReference(variable));
}
public override void Compile(ILProcessor processor, AstBaseConstructorCall call, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldarg_0);
processor.Emit(OpCodes.Call, context.ConvertReference(call.Constructor));
}
