public override void Generate(ILGenerator gen)
{
if (field.IsStatic)
{
gen.Emit(OpCodes.Ldsfld, field);
}
else
{
target.Generate(gen);
gen.Emit(OpCodes.Ldfld, field);
}
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
if (type.IsByRef) {
gen.Emit (OpCodes.Ldarg, argNum);
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, type.GetElementType (), value.GetResultType ());
CodeGenerationHelper.SaveToPtr (gen, type.GetElementType ());
}
else {
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, type, value.GetResultType ());
gen.Emit (OpCodes.Starg, argNum);
}
}
public override void GenerateSet (ILGenerator gen, CodeExpression value)
{
if (field.IsStatic) {
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, field.FieldType, value.GetResultType ());
gen.Emit (OpCodes.Stsfld, field);
}
else {
target.Generate (gen);
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, field.FieldType, value.GetResultType ());
gen.Emit (OpCodes.Stfld, field);
}
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
if (field.IsStatic)
{
value.Generate(gen);
CodeGenerationHelper.GenerateSafeConversion(gen, field.FieldType, value.GetResultType());
gen.Emit(OpCodes.Stsfld, field);
}
else
{
target.Generate(gen);
value.Generate(gen);
CodeGenerationHelper.GenerateSafeConversion(gen, field.FieldType, value.GetResultType());
gen.Emit(OpCodes.Stfld, field);
}
}
public override void Generate(ILGenerator gen)
{
if (t1.IsPrimitive)
{
exp1.Generate(gen);
exp2.Generate(gen);
gen.Emit(OpCodes.Ceq);
}
else
{
exp1.Generate(gen);
exp2.Generate(gen);
// gen.Emit (OpCodes.Ceq);
gen.EmitCall(OpCodes.Callvirt, t1.GetMethod("Equals", new Type[] { t2 }), null);
}
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
if (type.IsByRef)
{
gen.Emit(OpCodes.Ldarg, argNum);
value.Generate(gen);
CodeGenerationHelper.GenerateSafeConversion(gen, type.GetElementType(), value.GetResultType());
CodeGenerationHelper.SaveToPtr(gen, type.GetElementType());
}
else
{
value.Generate(gen);
CodeGenerationHelper.GenerateSafeConversion(gen, type, value.GetResultType());
gen.Emit(OpCodes.Starg, argNum);
}
}
public override void Generate(ILGenerator gen)
{
if (!object.ReferenceEquals(retValue, null))
{
retValue.Generate(gen);
}
gen.Emit(OpCodes.Br, codeBuilder.ReturnLabel);
}
public override void Generate(ILGenerator gen)
{
Type typeObj = exp.GetResultType();
if (type.IsAssignableFrom(typeObj))
{
gen.Emit(OpCodes.Ldc_I4_1);
return;
}
else if (!typeObj.IsAssignableFrom(type))
{
gen.Emit(OpCodes.Ldc_I4_0);
return;
}
exp.Generate(gen);
gen.Emit(OpCodes.Isinst, type);
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Cgt_Un);
}
static void GenerateMethodCall(ILGenerator gen, CodeExpression target, MethodBase method, Type[] parameterTypes, params CodeExpression[] parameters)
{
OpCode callOp;
if (parameterTypes.Length != parameters.Length)
{
throw GetMethodException(method, "Invalid number of parameters, expected " + parameterTypes.Length + ", found " + parameters.Length + ".");
}
if (!object.ReferenceEquals(target, null))
{
target.Generate(gen);
Type targetType = target.GetResultType();
if (targetType.IsValueType)
{
LocalBuilder lb = gen.DeclareLocal(targetType);
gen.Emit(OpCodes.Stloc, lb);
gen.Emit(OpCodes.Ldloca, lb);
callOp = OpCodes.Call;
}
else
{
callOp = OpCodes.Callvirt;
}
}
else
{
callOp = OpCodes.Call;
}
for (int n = 0; n < parameterTypes.Length; n++)
{
try
{
CodeExpression par = parameters[n];
par.Generate(gen);
GenerateSafeConversion(gen, parameterTypes[n], par.GetResultType());
}
catch (InvalidOperationException ex)
{
throw GetMethodException(method, "Parameter " + n + ". " + ex.Message);
}
}
if (method is MethodInfo)
{
gen.Emit(callOp, (MethodInfo)method);
}
else if (method is ConstructorInfo)
{
gen.Emit(callOp, (ConstructorInfo)method);
}
}
public override void Generate(ILGenerator gen)
{
Label falseLabel = gen.DefineLabel();
Label endLabel = gen.DefineLabel();
if (exp1 is CodeConditionExpression)
{
((CodeConditionExpression)exp1).GenerateForBranch(gen, falseLabel, false);
}
else
{
exp1.Generate(gen);
gen.Emit(OpCodes.Brfalse, falseLabel);
}
exp2.Generate(gen);
gen.Emit(OpCodes.Br, endLabel);
gen.MarkLabel(falseLabel);
gen.Emit(OpCodes.Ldc_I4_0);
gen.MarkLabel(endLabel);
}
void GenerateCondition(ILGenerator gen, Label falseLabel)
{
if (condition is CodeConditionExpression)
{
((CodeConditionExpression)condition).GenerateForBranch(gen, falseLabel, false);
}
else
{
condition.Generate(gen);
gen.Emit(OpCodes.Brfalse, falseLabel);
}
}
public override void Generate(ILGenerator gen)
{
Label falseLabel = gen.DefineLabel();
Label endLabel = gen.DefineLabel();
GenerateCondition(gen, falseLabel);
trueBlock.Generate(gen);
gen.Emit(OpCodes.Br, endLabel);
gen.MarkLabel(falseLabel);
falseBlock.Generate(gen);
gen.MarkLabel(endLabel);
}
public override void Generate(ILGenerator gen)
{
Label startLabel = gen.DefineLabel();
Label checkLabel = gen.DefineLabel();
gen.Emit(OpCodes.Br, checkLabel);
gen.MarkLabel(startLabel);
whileBlock.Generate(gen);
gen.MarkLabel(checkLabel);
if (condition is CodeConditionExpression)
{
((CodeConditionExpression)condition).GenerateForBranch(gen, startLabel, true);
}
else
{
condition.Generate(gen);
gen.Emit(OpCodes.Brtrue, startLabel);
}
}
static void GenerateMethodCall (ILGenerator gen, CodeExpression target, MethodBase method, Type[] parameterTypes, params CodeExpression[] parameters)
{
OpCode callOp;
if (parameterTypes.Length != parameters.Length)
throw GetMethodException (method, "Invalid number of parameters, expected " + parameterTypes.Length + ", found " + parameters.Length + ".");
if (!object.ReferenceEquals (target, null))
{
target.Generate (gen);
Type targetType = target.GetResultType();
if (targetType.IsValueType) {
LocalBuilder lb = gen.DeclareLocal (targetType);
gen.Emit (OpCodes.Stloc, lb);
gen.Emit (OpCodes.Ldloca, lb);
callOp = OpCodes.Call;
}
else
callOp = OpCodes.Callvirt;
}
else
callOp = OpCodes.Call;
for (int n=0; n<parameterTypes.Length; n++) {
try {
CodeExpression par = parameters[n];
par.Generate (gen);
GenerateSafeConversion (gen, parameterTypes[n], par.GetResultType());
}
catch (InvalidOperationException ex) {
throw GetMethodException (method, "Parameter " + n + ". " + ex.Message);
}
}
if (method is MethodInfo)
gen.Emit (callOp, (MethodInfo)method);
else if (method is ConstructorInfo)
gen.Emit (callOp, (ConstructorInfo)method);
}
public override void Generate(ILGenerator gen)
{
array.Generate(gen);
gen.Emit(OpCodes.Ldlen);
}
public override void Generate(ILGenerator gen)
{
array.Generate(gen);
index.Generate(gen);
Type t = array.GetResultType().GetElementType();
if (t.IsEnum && t != typeof(Enum))
{
t = t.UnderlyingSystemType;
}
switch (Type.GetTypeCode(t))
{
case TypeCode.Byte:
gen.Emit(OpCodes.Ldelem_U1);
break;
case TypeCode.Double:
gen.Emit(OpCodes.Ldelem_R8);
break;
case TypeCode.Int16:
gen.Emit(OpCodes.Ldelem_I2);
break;
case TypeCode.UInt32:
gen.Emit(OpCodes.Ldelem_U4);
break;
case TypeCode.Int32:
gen.Emit(OpCodes.Ldelem_I4);
break;
case TypeCode.UInt64:
case TypeCode.Int64:
gen.Emit(OpCodes.Ldelem_I8);
break;
case TypeCode.SByte:
gen.Emit(OpCodes.Ldelem_I1);
break;
case TypeCode.Single:
gen.Emit(OpCodes.Ldelem_R4);
break;
case TypeCode.UInt16:
gen.Emit(OpCodes.Ldelem_U2);
break;
default:
if (t.IsValueType)
{
gen.Emit(OpCodes.Ldelema, t);
CodeGenerationHelper.LoadFromPtr(gen, t);
}
else
{
gen.Emit(OpCodes.Ldelem_Ref);
}
break;
}
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
Type t = array.GetResultType().GetElementType();
if (t.IsEnum && t != typeof(Enum))
{
t = t.UnderlyingSystemType;
}
array.Generate(gen);
index.Generate(gen);
switch (Type.GetTypeCode(t))
{
case TypeCode.Byte:
case TypeCode.SByte:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I1);
break;
case TypeCode.Double:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_R8);
break;
case TypeCode.UInt16:
case TypeCode.Int16:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I2);
break;
case TypeCode.UInt32:
case TypeCode.Int32:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I4);
break;
case TypeCode.UInt64:
case TypeCode.Int64:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I8);
break;
case TypeCode.Single:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_R4);
break;
default:
if (t.IsValueType)
{
gen.Emit(OpCodes.Ldelema, t);
value.Generate(gen);
gen.Emit(OpCodes.Stobj, t);
}
else
{
value.Generate(gen);
gen.Emit(OpCodes.Stelem_Ref);
}
break;
}
}
public override void Generate(ILGenerator gen)
{
exp.Generate(gen);
gen.Emit(OpCodes.Neg);
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
value.Generate(gen);
CodeGenerationHelper.GenerateSafeConversion(gen, type, value.GetResultType());
gen.Emit(OpCodes.Stloc, localBuilder);
}
public override void GenerateSet (ILGenerator gen, CodeExpression value)
{
if (value == null)
throw new ArgumentNullException ("value");
Type t = array.GetResultType().GetElementType();
if (t.IsEnum && t != typeof(Enum)) t = t.UnderlyingSystemType;
array.Generate (gen);
index.Generate (gen);
switch (Type.GetTypeCode (t))
{
case TypeCode.Byte:
case TypeCode.SByte:
value.Generate (gen);
gen.Emit (OpCodes.Stelem_I1);
break;
case TypeCode.Double:
value.Generate (gen);
gen.Emit (OpCodes.Stelem_R8);
break;
case TypeCode.UInt16:
case TypeCode.Int16:
value.Generate (gen);
gen.Emit (OpCodes.Stelem_I2);
break;
case TypeCode.UInt32:
case TypeCode.Int32:
value.Generate (gen);
gen.Emit (OpCodes.Stelem_I4);
break;
case TypeCode.UInt64:
case TypeCode.Int64:
value.Generate (gen);
gen.Emit (OpCodes.Stelem_I8);
break;
case TypeCode.Single:
value.Generate (gen);
gen.Emit (OpCodes.Stelem_R4);
break;
default:
if (t.IsValueType) {
gen.Emit (OpCodes.Ldelema, t);
value.Generate (gen);
gen.Emit (OpCodes.Stobj, t);
}
else {
value.Generate (gen);
gen.Emit (OpCodes.Stelem_Ref);
}
break;
}
}
public override void Generate(ILGenerator gen)
{
var.GenerateSet(gen, exp);
exp.Generate(gen);
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, type, value.GetResultType ());
gen.Emit (OpCodes.Stloc, localBuilder);
}
public override void Generate(ILGenerator gen)
{
size.Generate(gen);
gen.Emit(OpCodes.Newarr, elemType);
}
public override void Generate(ILGenerator gen)
{
exp.Generate(gen);
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Ceq);
}
public override void Generate(ILGenerator gen)
{
if (decMet != null)
{
CodeGenerationHelper.GenerateMethodCall(gen, null, decMet, exp);
return;
}
exp.Generate(gen);
Type t = exp.GetResultType();
switch (Type.GetTypeCode(t))
{
case TypeCode.Byte:
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
gen.Emit(OpCodes.Conv_U1);
break;
case TypeCode.Double:
gen.Emit(OpCodes.Ldc_R8, 1);
gen.Emit(OpCodes.Sub);
break;
case TypeCode.Int16:
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
gen.Emit(OpCodes.Conv_I2);
break;
case TypeCode.UInt32:
case TypeCode.Int32:
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
break;
case TypeCode.UInt64:
case TypeCode.Int64:
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Conv_U8);
gen.Emit(OpCodes.Sub);
break;
case TypeCode.SByte:
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
gen.Emit(OpCodes.Conv_I1);
break;
case TypeCode.Single:
gen.Emit(OpCodes.Ldc_R4, 1);
gen.Emit(OpCodes.Sub);
break;
case TypeCode.UInt16:
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
gen.Emit(OpCodes.Conv_U2);
break;
}
}
public override void Generate(ILGenerator gen)
{
exp.Generate(gen);
Type typeObj = exp.GetResultType();
if (type.IsAssignableFrom(typeObj))
{
if (typeObj.IsValueType)
{
gen.Emit(OpCodes.Box, typeObj);
}
return;
}
else if (type.IsValueType && typeObj == typeof(object))
{
// Unbox
gen.Emit(OpCodes.Unbox, type);
CodeGenerationHelper.LoadFromPtr(gen, type);
return;
}
else if (typeObj.IsAssignableFrom(type))
{
// Sub s = (Sub)base
gen.Emit(OpCodes.Castclass, type);
return;
}
else if (CodeGenerationHelper.IsNumber(type) && CodeGenerationHelper.IsNumber(typeObj))
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Byte:
gen.Emit(OpCodes.Conv_U1);
return;
case TypeCode.Double:
gen.Emit(OpCodes.Conv_R8);
return;
case TypeCode.Int16:
gen.Emit(OpCodes.Conv_I2);
return;
case TypeCode.Int32:
gen.Emit(OpCodes.Conv_I4);
return;
case TypeCode.Int64:
gen.Emit(OpCodes.Conv_I8);
return;
case TypeCode.SByte:
gen.Emit(OpCodes.Conv_I1);
return;
case TypeCode.Single:
gen.Emit(OpCodes.Conv_R4);
return;
case TypeCode.UInt16:
gen.Emit(OpCodes.Conv_U2);
return;
case TypeCode.UInt32:
gen.Emit(OpCodes.Conv_U4);
return;
case TypeCode.UInt64:
gen.Emit(OpCodes.Conv_U8);
return;
}
}
MethodInfo imp = type.GetMethod("op_Implicit", new Type[] { typeObj });
if (imp != null)
{
gen.Emit(OpCodes.Call, imp);
return;
}
foreach (MethodInfo m in typeObj.GetMember("op_Explicit"))
{
if (m.ReturnType == type)
{
gen.Emit(OpCodes.Call, m);
return;
}
}
throw new InvalidOperationException("Can't cast from " + typeObj + " to " + type);
}
