private void EmitDecimal()
{
var primitiveOperand = PrimitiveInstruction.Operand;
var methodReference = primitiveOperand as MethodReference;
var ctor = methodReference.GetActualMethod <ConstructorInfo>();
var types = ctor.GetParameters();
var instructions = InstructionsIndexer.GetPrevoiusRangeOfInstructions(PrimitiveInstruction, types.Length);
instructions.ForEach((instruction, i) => {
var mapped = OpCodesMapper.Map(instruction.OpCode);
var operand = instruction.Operand;
if (operand == null)
{
ILGenerator.Emit(mapped);
}
else
{
var typeCode = Type.GetTypeCode(operand.GetType());
ILGenerator.EmitPrimitiveByTypeCode(operand, typeCode);
}
});
ILGenerator.Emit(OpCodes.Newobj, ctor);
}
internal PrimitiveEmitter(PrimitiveExpression primitiveExpression, ILGenerator ilGenerator, IOpCodeIndexer instructionsIndexer)
: base(ilGenerator, instructionsIndexer)
{
PrimitiveExpression = primitiveExpression;
Type = PrimitiveExpression.Value.GetType();
PrimitiveInstruction = InstructionsIndexer.GetInstruction(PrimitiveExpression);
}
public override AstNode Emit()
{
if (IgnoreLeftOperand())
{
Node.Right.AcceptVisitor(Visitor, ILGenerator);
}
else
{
var memberReference = Node.Left as MemberReferenceExpression;
if (memberReference != null)
{
return(new MultipuleAssignmentEmitter(memberReference, Node.Right, ILGenerator, InstructionsIndexer, Visitor, Locals).Emit());
}
var instruction = InstructionsIndexer.GetLastInstructionInRange(Node);
Node.Right.AcceptVisitor(Visitor, ILGenerator);
Node.Left.AcceptVisitor(Visitor, ILGenerator);
if (instruction.Operand != null)
{
var methodReference = instruction.Operand as MethodReference;
if (methodReference != null)
{
var methodInfo = methodReference.GetActualMethod <MethodInfo>();
ILGenerator.Emit(OpCodes.Call, methodInfo);
}
}
}
return(new AstNodeDecorator(Node, null));
}
private bool TryEmitNewObject()
{
Cil.Instruction instruction;
if (InstructionsIndexer.TryGetNewObjectInstruction(Node, out instruction))
{
var methodReference = instruction.Operand as MethodReference;
var constructorInfo = methodReference.GetActualMethod <ConstructorInfo>();
ILGenerator.Emit(OpCodes.Newobj, constructorInfo);
return(true);
}
return(false);
}
private void EmitLoadFieldReference()
{
var instruction = InstructionsIndexer.GetInstruction(MemberReference);
if (instruction == null || !IsPrimitive())
{
if (NonPublic)
{
EmitPrivateReference();
}
else
{
var opCode = GetLoadFieldOpCode();
ILGenerator.Emit(opCode, Member as FieldInfo);
}
MemberReference.Children.ForEach(c => c.AcceptVisitor(ILGenerator, Visitor));
}
else
{
EmitPrimitive(ILGenerator, instruction);
}
}
private AstNode EmitNewObjectInitializer()
{
Type parameterType = null;
bool requiresPop = false;
MethodInfo methodInfo = null;
AstNodeDecorator nodeDecorator = null;
var callOpCode = _isPrimitive ? OpCodes.Call : OpCodes.Callvirt;
var firstChild = Node.Elements.First();
var methodReference = Node.Elements.First().Annotation <MethodReference>();
if (methodReference == null)
{
Cil.Instruction instruction;
InstructionsIndexer.TryGetCallInstruction(firstChild, out instruction);
methodReference = instruction.Operand as MethodReference;
}
methodInfo = methodReference.GetActualMethod <MethodInfo>();
parameterType = methodInfo.GetParameters()[0].ParameterType;
requiresPop = !methodInfo.ReturnType.Equals(TypeSystem.Void);
Node.Elements.ForEach((node, i) => {
ILGenerator.EmitLoadLocal(_localBuilder);
nodeDecorator = node.AcceptVisitor(ILGenerator, Visitor);
ILGenerator.EmitCastIfNeeded(nodeDecorator.Type, parameterType);
ILGenerator.Emit(callOpCode, methodInfo);
if (requiresPop)
{
ILGenerator.Emit(OpCodes.Pop);
}
});
ILGenerator.EmitLoadLocal(_localBuilder, true);
return(new AstNodeDecorator(Node, Type));
}
