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