// Initialize for searching a list of values public InElement(ExpressionElement operand, IList listElements) { MyOperand = operand; ExpressionElement[] arr = new ExpressionElement[listElements.Count]; listElements.CopyTo(arr, 0); MyArguments = new List<ExpressionElement>(arr); this.ResolveForListSearch(); }
public void SetChild(ExpressionElement child) { MyChild = child; MyResultType = this.GetResultType(child.ResultType); if (MyResultType == null) { base.ThrowCompileException(CompileErrorResourceKeys.OperationNotDefinedForType, CompileExceptionReason.TypeMismatch, MyChild.ResultType.Name); } }
private void SetupArrayIndexer() { MyIndexerElement = MyIndexerElements[0]; if (MyIndexerElements.Count > 1) { base.ThrowCompileException(CompileErrorResourceKeys.MultiArrayIndexNotSupported, CompileExceptionReason.TypeMismatch); } else if (ImplicitConverter.EmitImplicitConvert(MyIndexerElement.ResultType, typeof(Int32), null) == false) { base.ThrowCompileException(CompileErrorResourceKeys.ArrayIndexersMustBeOfType, CompileExceptionReason.TypeMismatch, typeof(Int32).Name); } }
public CastElement(ExpressionElement castExpression, string[] destTypeParts, bool isArray, IServiceProvider services) { MyCastExpression = castExpression; MyDestType = GetDestType(destTypeParts, services); if (MyDestType == null) { base.ThrowCompileException(CompileErrorResourceKeys.CouldNotResolveType, CompileExceptionReason.UndefinedName, GetDestTypeString(destTypeParts, isArray)); } if (isArray == true) { MyDestType = MyDestType.MakeArrayType(); } if (this.IsValidCast(MyCastExpression.ResultType, MyDestType) == false) { this.ThrowInvalidCastException(); } }
public ConditionalElement(ExpressionElement condition, ExpressionElement whenTrue, ExpressionElement whenFalse) { MyCondition = condition; MyWhenTrue = whenTrue; MyWhenFalse = whenFalse; if ((!object.ReferenceEquals(MyCondition.ResultType, typeof(bool)))) { base.ThrowCompileException(CompileErrorResourceKeys.FirstArgNotBoolean, CompileExceptionReason.TypeMismatch); } // The result type is the type that is common to the true/false operands if (ImplicitConverter.EmitImplicitConvert(MyWhenFalse.ResultType, MyWhenTrue.ResultType, null) == true) { MyResultType = MyWhenTrue.ResultType; } else if (ImplicitConverter.EmitImplicitConvert(MyWhenTrue.ResultType, MyWhenFalse.ResultType, null) == true) { MyResultType = MyWhenFalse.ResultType; } else { base.ThrowCompileException(CompileErrorResourceKeys.NeitherArgIsConvertibleToTheOther, CompileExceptionReason.TypeMismatch, MyWhenTrue.ResultType.Name, MyWhenFalse.ResultType.Name); } }
public ExpressionElement[] ToArray() { ExpressionElement[] arr = new ExpressionElement[MyElements.Count]; MyElements.CopyTo(arr, 0); return arr; }
public ArgumentList(ICollection elements) { ExpressionElement[] arr = new ExpressionElement[elements.Count]; elements.CopyTo(arr, 0); MyElements = arr; }
public void Initialize(ExpressionElement leftChild, ExpressionElement rightChild, LogicalCompareOperation op) { MyLeftChild = leftChild; MyRightChild = rightChild; MyOperation = op; }
private bool FindIndexer(Type targetType) { // Get the default members MemberInfo[] members = targetType.GetDefaultMembers(); List<MethodInfo> methods = new List<MethodInfo>(); // Use the first one that's valid for our indexer type foreach (MemberInfo mi in members) { PropertyInfo pi = mi as PropertyInfo; if ((pi != null)) { methods.Add(pi.GetGetMethod(true)); } } FunctionCallElement func = new FunctionCallElement("Indexer", methods.ToArray(), MyIndexerElements); func.Resolve(MyServices); MyIndexerElement = func; return true; }
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 static void EmitOperand(ExpressionElement operand, ShortCircuitInfo info, FleeILGenerator ilg, IServiceProvider services) { // Is this operand the target of a label? if (info.Branches.HasLabel(operand) == true) { // Yes, so mark it Label leftLabel = info.Branches.FindLabel(operand); ilg.MarkLabel(leftLabel); // Note the label's position MarkBranchTarget(info, leftLabel, ilg); } // Emit the operand operand.Emit(ilg, services); }
// Emit the arguments to a regular method call private void EmitRegularFunctionInternal(ParameterInfo[] parameters, ExpressionElement[] elements, FleeILGenerator ilg, IServiceProvider services) { Debug.Assert(parameters.Length == elements.Length, "argument count mismatch"); // Emit each element and any required conversions to the actual parameter type for (int i = 0; i <= parameters.Length - 1; i++) { var element = elements[i]; var pi = parameters[i]; element.Emit(ilg, services); bool success = ImplicitConverter.EmitImplicitConvert(element.ResultType, pi.ParameterType, ilg); Debug.Assert(success, "conversion failed"); } }
// Emit elements into an array private static void EmitElementArrayLoad(ExpressionElement[] elements, Type arrayElementType, FleeILGenerator ilg, IServiceProvider services) { // Load the array length LiteralElement.EmitLoad(elements.Length, ilg); // Create the array ilg.Emit(OpCodes.Newarr, arrayElementType); // Store the new array in a unique local and remember the index var local = ilg.DeclareLocal(arrayElementType.MakeArrayType()); int arrayLocalIndex = local.LocalIndex; Utility.EmitStoreLocal(ilg, arrayLocalIndex); for (int i = 0; i <= elements.Length - 1; i++) { // Load the array Utility.EmitLoadLocal(ilg, arrayLocalIndex); // Load the index LiteralElement.EmitLoad(i, ilg); // Emit the element (with any required conversions) ExpressionElement element = elements[i]; element.Emit(ilg, services); ImplicitConverter.EmitImplicitConvert(element.ResultType, arrayElementType, ilg); // Store it into the array Utility.EmitArrayStore(ilg, arrayElementType); } // Load the array Utility.EmitLoadLocal(ilg, arrayLocalIndex); }
// Emit the arguments to a paramArray method call private void EmitParamArrayArguments(ParameterInfo[] parameters, ExpressionElement[] elements, FleeILGenerator ilg, IServiceProvider services) { // Get the fixed parameters ParameterInfo[] fixedParameters = new ParameterInfo[MyTargetMethodInfo.MyFixedArgTypes.Length]; Array.Copy(parameters, fixedParameters, fixedParameters.Length); // Get the corresponding fixed parameters ExpressionElement[] fixedElements = new ExpressionElement[MyTargetMethodInfo.MyFixedArgTypes.Length]; Array.Copy(elements, fixedElements, fixedElements.Length); // Emit the fixed arguments this.EmitRegularFunctionInternal(fixedParameters, fixedElements, ilg, services); // Get the paramArray arguments ExpressionElement[] paramArrayElements = new ExpressionElement[elements.Length - fixedElements.Length]; Array.Copy(elements, fixedElements.Length, paramArrayElements, 0, paramArrayElements.Length); // Emit them into an array EmitElementArrayLoad(paramArrayElements, MyTargetMethodInfo.ParamArrayElementType, ilg, services); }
private void EmitOnDemandFunction(ExpressionElement[] elements, FleeILGenerator ilg, IServiceProvider services) { // Load the variable collection EmitLoadVariables(ilg); // Load the function name ilg.Emit(OpCodes.Ldstr, MyName); // Load the arguments array EmitElementArrayLoad(elements, typeof(object), ilg, services); // Call the function to get the result MethodInfo mi = VariableCollection.GetFunctionInvokeMethod(MyOnDemandFunctionReturnType); this.EmitMethodCall(mi, ilg); }
public ExpressionMemberElement(ExpressionElement element) { MyElement = element; }
public RootExpressionElement(ExpressionElement child, Type resultType) { MyChild = child; MyResultType = resultType; this.Validate(); }
protected static bool IsChildOfType(ExpressionElement child, Type t) { return object.ReferenceEquals(child.ResultType, t); }
// Initialize for searching a collection public InElement(ExpressionElement operand, ExpressionElement targetCollection) { MyOperand = operand; MyTargetCollectionElement = targetCollection; this.ResolveForCollectionSearch(); }
// Set the left and right operands, get the operation, and get the result type private void Configure(ExpressionElement leftChild, ExpressionElement rightChild, object op) { MyLeftChild = leftChild; MyRightChild = rightChild; this.GetOperation(op); this.ValidateInternal(op); }