private void CompileMethod(MethodDefinition method, AstMethodDefinitionBase methodAst, DefinitionBuildingContext parentContext)
{
var body = method.Body.GetILProcessor();
var context = new CilCompilationContext(method, methodAst, (e, c) => CompileCil(body, e, c), parentContext);
foreach (var element in methodAst.Body)
{
CompileCil(body, element, context);
}
}
public override void Compile(ILProcessor processor, PrimitiveValue value, CilCompilationContext context)
{
var compile = typeBasedCompilers.GetValueOrDefault(((AstReflectedType)value.ExpressionType).ActualType);
if (compile == null)
{
throw new NotImplementedException("PrimitiveValueCompiler: cannot compile " + value.ExpressionType + ".");
}
compile(processor, value, context);
}
private void CompileCil(ILProcessor body, IAstElement element, CilCompilationContext context)
{
var compiler = this.cilCompilers.SingleOrDefault(c => c.CanCompile(body, element));
if (compiler == null)
{
throw new NotImplementedException("LightCompiler: No CilCompiler for " + element);
}
compiler.Compile(body, element, context);
}
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, 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));
}
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, 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, 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);
}
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, AstVariableReference variable, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldloc, context.ConvertReference(variable));
}
public override void Compile(ILProcessor processor, AssignmentStatement assignment, CilCompilationContext context)
{
var property = assignment.Target as AstPropertyExpression;
if (property != null)
{
CompileFieldOrPropertyAssignment(processor, property, assignment.Value, context);
return;
}
throw new NotImplementedException("AssignmentCompiler: Assignment to " + assignment.Target + " is not yet supported.");
}
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 override void Compile(ILProcessor processor, AstVariableDefinition variable, CilCompilationContext context)
{
var variableDefinition = context.DefineVariable(variable.Name, variable.Type);
context.MapDefinition(variable, variableDefinition);
if (variable.AssignedValue == null)
{
return;
}
context.Compile(variable.AssignedValue);
processor.Emit(OpCodes.Stloc, variableDefinition);
}
private static void CompileString(ILProcessor processor, PrimitiveValue value, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldstr, (string)value.Value);
}
public override void Compile(ILProcessor processor, AstParameterReference reference, CilCompilationContext context)
{
var parameterIndex = context.MethodAst.Parameters.IndexOf(reference.Parameter);
if (!context.MethodAst.Compilation.Static)
{
parameterIndex += 1;
}
processor.Emit(OpCodes.Ldarg, parameterIndex);
}
public override void Compile(ILProcessor processor, AstBaseConstructorCall call, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldarg_0);
processor.Emit(OpCodes.Call, context.ConvertReference(call.Constructor));
}
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);
}
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 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);
}
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));
}
}
private static void CompileBoolean(ILProcessor processor, PrimitiveValue value, CilCompilationContext context)
{
var opCode = (bool)value.Value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0;
processor.Emit(opCode);
}
private void EmitStelem(ILProcessor processor, TypeReference elementType, IAstExpression element, CilCompilationContext context)
{
if (elementType.IsPrimitive)
{
if (!StelemCodes.ContainsKey(elementType.MetadataType))
{
throw new NotImplementedException("ListInitializerCompiler.EmitStelem: Element metadata type " + elementType.MetadataType + " is not yet supported.");
}
context.Compile(element);
processor.Emit(StelemCodes[elementType.MetadataType]);
return;
}
if (elementType.IsValueType)
{
processor.Emit(OpCodes.Ldelema, elementType);
context.Compile(element);
processor.Emit(OpCodes.Stobj, elementType);
return;
}
context.Compile(element);
processor.Emit(OpCodes.Stelem_Ref);
}
public override void Compile(ILProcessor processor, AstThisExpression @this, CilCompilationContext context)
{
processor.Emit(OpCodes.Ldarg_0);
}
