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