public ConditionalElement(ExpressionElement condition, ExpressionElement whenTrue, ExpressionElement whenFalse)
{
this.myCondition = condition;
this.myWhenTrue = whenTrue;
this.myWhenFalse = whenFalse;
var flag = this.myCondition.ResultType != typeof(bool);
if (flag)
{
this.ThrowCompileException("FirstArgNotBoolean", CompileExceptionReason.TypeMismatch);
}
var flag2 = ImplicitConverter.EmitImplicitConvert(this.myWhenFalse.ResultType, this.myWhenTrue.ResultType, null);
if (flag2)
{
this.myResultType = this.myWhenTrue.ResultType;
}
else
{
var flag3 = ImplicitConverter.EmitImplicitConvert(this.myWhenTrue.ResultType, this.myWhenFalse.ResultType, null);
if (flag3)
{
this.myResultType = this.myWhenFalse.ResultType;
}
else
{
this.ThrowCompileException("NeitherArgIsConvertibleToTheOther", CompileExceptionReason.TypeMismatch,
this.myWhenTrue.ResultType.Name, this.myWhenFalse.ResultType.Name);
}
}
}
private void EmitCast(FleeIlGenerator ilg, Type sourceType, Type destType, IServiceProvider services)
{
var explicitOperator = this.GetExplictOverloadedOperator(sourceType, destType);
var flag = sourceType == destType;
if (!flag)
{
var flag2 = explicitOperator != null;
if (flag2)
{
ilg.Emit(OpCodes.Call, explicitOperator);
}
else
{
var flag3 = sourceType.IsEnum | destType.IsEnum;
if (flag3)
{
this.EmitEnumCast(ilg, sourceType, destType, services);
}
else
{
var flag4 = ImplicitConverter.EmitImplicitConvert(sourceType, destType, ilg);
if (!flag4)
{
var flag5 = IsCastableNumericType(sourceType) & IsCastableNumericType(destType);
if (flag5)
{
EmitExplicitNumericCast(ilg, sourceType, destType, services);
}
else
{
var isValueType = sourceType.IsValueType;
if (isValueType)
{
Debug.Assert(!destType.IsValueType, "expecting reference type");
ilg.Emit(OpCodes.Box, sourceType);
}
else
{
var isValueType2 = destType.IsValueType;
if (isValueType2)
{
ilg.Emit(OpCodes.Unbox_Any, destType);
}
else
{
var flag6 = !destType.IsAssignableFrom(sourceType);
if (flag6)
{
ilg.Emit(OpCodes.Castclass, destType);
}
}
}
}
}
}
}
}
}
protected static void EmitChildWithConvert(ExpressionElement child, Type resultType, FleeIlGenerator ilg,
IServiceProvider services)
{
child.Emit(ilg, services);
var converted = ImplicitConverter.EmitImplicitConvert(child.ResultType, resultType, ilg);
Debug.Assert(converted, "convert failed");
}
private void EmitCollectionIn(FleeIlGenerator ilg, IServiceProvider services)
{
var mi = this.GetCollectionContainsMethod();
var p = mi.GetParameters()[0];
this.myTargetCollectionElement.Emit(ilg, services);
this.myOperand.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myOperand.ResultType, p.ParameterType, ilg);
ilg.Emit(OpCodes.Callvirt, mi);
}
public override void Emit(FleeIlGenerator ilg, IServiceProvider services)
{
var resultType = this.ResultType;
this.myLeftChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myLeftChild.ResultType, resultType, ilg);
this.myRightChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myRightChild.ResultType, resultType, ilg);
ilg.Emit(OpCodes.Xor);
}
private void Validate()
{
var flag = !ImplicitConverter.EmitImplicitConvert(this.myChild.ResultType, this.myResultType, null);
if (flag)
{
this.ThrowCompileException("CannotConvertTypeToExpressionResult", CompileExceptionReason.TypeMismatch,
this.myChild.ResultType.Name, this.myResultType.Name);
}
}
private void EmitVirtualPropertyLoad(FleeIlGenerator ilg)
{
var index = ilg.GetTempLocalIndex(this.myPrevious.ResultType);
Utility.EmitStoreLocal(ilg, index);
EmitLoadVariables(ilg);
ilg.Emit(OpCodes.Ldstr, this.myName);
Utility.EmitLoadLocal(ilg, index);
ImplicitConverter.EmitImplicitConvert(this.myPrevious.ResultType, typeof(object), ilg);
var mi = VariableCollection.GetVirtualPropertyLoadMethod(this.ResultType);
this.EmitMethodCall(mi, ilg);
}
public override void Emit(FleeIlGenerator ilg, IServiceProvider services)
{
this.myChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myChild.ResultType, this.myResultType, ilg);
var options = (ExpressionOptions)services.GetService(typeof(ExpressionOptions));
var flag = !options.IsGeneric;
if (flag)
{
ImplicitConverter.EmitImplicitConvert(this.myResultType, typeof(object), ilg);
}
ilg.Emit(OpCodes.Ret);
}
private static bool AreValidArgumentsForParameters(Type[] argTypes, ParameterInfo[] parameters)
{
Debug.Assert(argTypes.Length == parameters.Length);
// Match if every given argument is implicitly convertible to the method's corresponding parameter
for (var i = 0; i <= argTypes.Length - 1; i++)
{
if (ImplicitConverter.EmitImplicitConvert(argTypes[i], parameters[i].ParameterType, null) == false)
{
return(false);
}
}
return(true);
}
private void EmitRegularFunctionInternal(ParameterInfo[] parameters, ExpressionElement[] elements, FleeIlGenerator ilg,
IServiceProvider services)
{
Debug.Assert(parameters.Length == elements.Length, "argument count mismatch");
var num = parameters.Length - 1;
for (var i = 0; i <= num; i++)
{
var element = elements[i];
var pi = parameters[i];
element.Emit(ilg, services);
var success = ImplicitConverter.EmitImplicitConvert(element.ResultType, pi.ParameterType, ilg);
Debug.Assert(success, "conversion failed");
}
}
private void EmitArrayLoad(FleeIlGenerator ilg, IServiceProvider services)
{
this.myIndexerElement.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myIndexerElement.ResultType, typeof(int), ilg);
var elementType = this.ResultType;
var flag = !elementType.IsValueType;
if (flag)
{
ilg.Emit(OpCodes.Ldelem_Ref);
}
else
{
this.EmitValueTypeArrayLoad(ilg, elementType);
}
}
public override void Emit(FleeIlGenerator ilg, IServiceProvider services)
{
var resultType = this.ResultType;
var flag = resultType == typeof(bool);
if (flag)
{
this.DoEmitLogical(ilg, services);
}
else
{
this.myLeftChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myLeftChild.ResultType, resultType, ilg);
this.myRightChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myRightChild.ResultType, resultType, ilg);
EmitBitwiseOperation(ilg, this.myOperation);
}
}
public override void Emit(FleeIlGenerator ilg, IServiceProvider services)
{
var resultType = this.ResultType;
this.myChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myChild.ResultType, resultType, ilg);
var mi = Utility.GetSimpleOverloadedOperator("UnaryNegation", resultType, resultType);
var flag = mi == null;
if (flag)
{
ilg.Emit(OpCodes.Neg);
}
else
{
ilg.Emit(OpCodes.Call, mi);
}
}
private void SetupArrayIndexer()
{
this.myIndexerElement = this.myIndexerElements[0];
var flag = this.myIndexerElements.Count > 1;
if (flag)
{
this.ThrowCompileException("MultiArrayIndexNotSupported", CompileExceptionReason.TypeMismatch);
}
else
{
var flag2 = !ImplicitConverter.EmitImplicitConvert(this.myIndexerElement.ResultType, typeof(int), null);
if (flag2)
{
this.ThrowCompileException("ArrayIndexersMustBeOfType", CompileExceptionReason.TypeMismatch, typeof(int).Name);
}
}
}
private void ResolveForCollectionSearch()
{
this.myTargetCollectionType = this.GetTargetCollectionType();
var flag = this.myTargetCollectionType == null;
if (flag)
{
this.ThrowCompileException("SearchArgIsNotKnownCollectionType", CompileExceptionReason.TypeMismatch,
this.myTargetCollectionElement.ResultType.Name);
}
var mi = this.GetCollectionContainsMethod();
var p = mi.GetParameters()[0];
var flag2 = !ImplicitConverter.EmitImplicitConvert(this.myOperand.ResultType, p.ParameterType, null);
if (flag2)
{
this.ThrowCompileException("OperandNotConvertibleToCollectionType", CompileExceptionReason.TypeMismatch,
this.myOperand.ResultType.Name, p.ParameterType.Name);
}
}
private bool IsParamArrayMatch(Type[] argTypes, ParameterInfo[] parameters, ParameterInfo paramArrayParameter)
{
// Get the count of arguments before the paramArray parameter
var fixedParameterCount = paramArrayParameter.Position;
var fixedArgTypes = new Type[fixedParameterCount];
var fixedParameters = new ParameterInfo[fixedParameterCount];
// Get the argument types and parameters before the paramArray
Array.Copy(argTypes, fixedArgTypes, fixedParameterCount);
Array.Copy(parameters, fixedParameters, fixedParameterCount);
// If the fixed arguments don't match, we are not a match
if (AreValidArgumentsForParameters(fixedArgTypes, fixedParameters) == false)
{
return(false);
}
// Get the type of the paramArray
this.paramArrayElementType = paramArrayParameter.ParameterType.GetElementType();
// Get the types of the arguments passed to the paramArray
var paramArrayArgTypes = new Type[argTypes.Length - fixedParameterCount];
Array.Copy(argTypes, fixedParameterCount, paramArrayArgTypes, 0, paramArrayArgTypes.Length);
// Check each argument
foreach (var argType in paramArrayArgTypes)
{
if (ImplicitConverter.EmitImplicitConvert(argType, this.paramArrayElementType, null) == false)
{
return(false);
}
}
this.myFixedArgTypes = fixedArgTypes;
this.myParamArrayArgTypes = paramArrayArgTypes;
// They all match, so we are a match
return(true);
}
private void EmitConditional(FleeIlGenerator ilg, IServiceProvider services, BranchManager bm)
{
var falseLabel = bm.FindLabel("falseLabel");
var endLabel = bm.FindLabel("endLabel");
this.myCondition.Emit(ilg, services);
var isTemp = ilg.IsTemp;
if (isTemp)
{
bm.AddBranch(ilg, falseLabel);
ilg.Emit(OpCodes.Brfalse_S, falseLabel);
}
else
{
var flag = !bm.IsLongBranch(ilg, falseLabel);
ilg.Emit(flag ? OpCodes.Brfalse_S : OpCodes.Brfalse, falseLabel);
}
this.myWhenTrue.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myWhenTrue.ResultType, this.myResultType, ilg);
var isTemp2 = ilg.IsTemp;
if (isTemp2)
{
bm.AddBranch(ilg, endLabel);
ilg.Emit(OpCodes.Br_S, endLabel);
}
else
{
var flag2 = !bm.IsLongBranch(ilg, endLabel);
ilg.Emit(flag2 ? OpCodes.Br_S : OpCodes.Br, endLabel);
}
bm.MarkLabel(ilg, falseLabel);
ilg.MarkLabel(falseLabel);
this.myWhenFalse.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myWhenFalse.ResultType, this.myResultType, ilg);
bm.MarkLabel(ilg, endLabel);
ilg.MarkLabel(endLabel);
}
private static void EmitElementArrayLoad(ExpressionElement[] elements, Type arrayElementType, FleeIlGenerator ilg,
IServiceProvider services)
{
LiteralElement.EmitLoad(elements.Length, ilg);
ilg.Emit(OpCodes.Newarr, arrayElementType);
var local = ilg.DeclareLocal(arrayElementType.MakeArrayType());
var arrayLocalIndex = local.LocalIndex;
Utility.EmitStoreLocal(ilg, arrayLocalIndex);
var num = elements.Length - 1;
for (var i = 0; i <= num; i++)
{
Utility.EmitLoadLocal(ilg, arrayLocalIndex);
LiteralElement.EmitLoad(i, ilg);
var element = elements[i];
element.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(element.ResultType, arrayElementType, ilg);
Utility.EmitArrayStore(ilg, arrayElementType);
}
Utility.EmitLoadLocal(ilg, arrayLocalIndex);
}
private void EmitStringConcat(FleeIlGenerator ilg, IServiceProvider services)
{
var flag = this.AreBothChildrenOfType(typeof(string));
MethodInfo concatMethodInfo;
Type argType;
if (flag)
{
concatMethodInfo = ourStringConcatMethodInfo;
argType = typeof(string);
}
else
{
Debug.Assert(this.IsEitherChildOfType(typeof(string)), "one child must be a string");
concatMethodInfo = ourObjectConcatMethodInfo;
argType = typeof(object);
}
this.myLeftChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myLeftChild.ResultType, argType, ilg);
this.myRightChild.Emit(ilg, services);
ImplicitConverter.EmitImplicitConvert(this.myRightChild.ResultType, argType, ilg);
ilg.Emit(OpCodes.Call, concatMethodInfo);
}
public override MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] types,
ParameterModifier[] modifiers)
{
checked
{
MethodBase selectMethod;
for (var i = 0; i < match.Length; i++)
{
var mi = (MethodInfo)match[i];
var parameters = mi.GetParameters();
var leftValid = ImplicitConverter.EmitImplicitConvert(this.myLeftType, parameters[0].ParameterType, null);
var rightValid = ImplicitConverter.EmitImplicitConvert(this.myRightType, parameters[1].ParameterType, null);
var flag = leftValid & rightValid;
if (flag)
{
selectMethod = mi;
return(selectMethod);
}
}
selectMethod = null;
return(selectMethod);
}
}
private bool IsValidCast(Type sourceType, Type destType)
{
var flag = sourceType == destType;
bool isValidCast;
if (flag)
{
isValidCast = true;
}
else
{
var flag2 = destType.IsAssignableFrom(sourceType);
if (flag2)
{
isValidCast = true;
}
else
{
var flag3 = ImplicitConverter.EmitImplicitConvert(sourceType, destType, null);
if (flag3)
{
isValidCast = true;
}
else
{
var flag4 = IsCastableNumericType(sourceType) & IsCastableNumericType(destType);
if (flag4)
{
isValidCast = true;
}
else
{
var flag5 = sourceType.IsEnum | destType.IsEnum;
if (flag5)
{
isValidCast = this.IsValidExplicitEnumCast(sourceType, destType);
}
else
{
var flag6 = this.GetExplictOverloadedOperator(sourceType, destType) != null;
if (flag6)
{
isValidCast = true;
}
else
{
var isValueType = sourceType.IsValueType;
if (isValueType)
{
isValidCast = false;
}
else
{
var isValueType2 = destType.IsValueType;
if (isValueType2)
{
var interfaces = destType.GetInterfaces();
isValidCast = IsBaseType(destType, sourceType) |
(Array.IndexOf(interfaces, sourceType) != -1);
}
else
{
isValidCast = this.IsValidExplicitReferenceCast(sourceType, destType);
}
}
}
}
}
}
}
}
return(isValidCast);
}
