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); }