private DynamicMetaObject GetIndexArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion) { Array array = (Array)target.Value; if (array.Rank > 1) { return(this.GetIndexMultiDimensionArray(target, indexes, errorSuggestion)); } if (indexes.Length > 1) { if (!this._allowSlicing && (errorSuggestion == null)) { return(this.CannotIndexTarget(target, indexes)); } return(this.InvokeSlicingIndexer(target, indexes)); } DynamicMetaObject obj2 = this.CheckForSlicing(target, indexes); if (obj2 != null) { return(obj2); } Expression expression = ConvertIndex(indexes[0], typeof(int)); if (expression == null) { return(errorSuggestion ?? PSConvertBinder.ThrowNoConversion(target, typeof(int), this, this._version, indexes)); } return(this.IndexWithNegativeChecks(new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction()), new DynamicMetaObject(expression, indexes[0].PSGetTypeRestriction()), target.LimitType.GetProperty("Length"), (t, i) => Expression.ArrayIndex(t, i).Cast(typeof(object)))); }
private DynamicMetaObject InvokeIndexer(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion, string methodName) { Func <Expression, Expression, Expression> generateIndexOperation = null; MethodInfo getter = PSInvokeMemberBinder.FindBestMethod(target, indexes, "get_" + methodName, false, this._constraints); if (getter == null) { return(this.CheckForSlicing(target, indexes) ?? (errorSuggestion ?? this.CannotIndexTarget(target, indexes))); } ParameterInfo[] parameters = getter.GetParameters(); if (parameters.Length != indexes.Length) { if ((parameters.Length == 1) && this._allowSlicing) { return(this.InvokeSlicingIndexer(target, indexes)); } return(errorSuggestion ?? this.CannotIndexTarget(target, indexes)); } if (parameters.Length == 1) { DynamicMetaObject obj2 = this.CheckForSlicing(target, indexes); if (obj2 != null) { return(obj2); } } Expression[] arguments = new Expression[parameters.Length]; for (int j = 0; j < parameters.Length; j++) { Type parameterType = parameters[j].ParameterType; arguments[j] = ConvertIndex(indexes[j], parameterType); if (arguments[j] == null) { return(errorSuggestion ?? PSConvertBinder.ThrowNoConversion(target, parameterType, this, this._version, indexes)); } } if (((parameters.Length == 1) && parameters[0].ParameterType.Equals(typeof(int))) && CanIndexFromEndWithNegativeIndex(target)) { PropertyInfo lengthProperty = target.LimitType.GetProperty("Count") ?? target.LimitType.GetProperty("Length"); if (lengthProperty != null) { if (generateIndexOperation == null) { generateIndexOperation = (t, i) => Expression.Call(t, getter, new Expression[] { i }).Cast(typeof(object)); } return(this.IndexWithNegativeChecks(new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction()), new DynamicMetaObject(arguments[0], indexes[0].PSGetTypeRestriction()), lengthProperty, generateIndexOperation)); } } return(new DynamicMetaObject(this.SafeIndexResult(Expression.Call(target.Expression.Cast(target.LimitType), getter, arguments)), target.CombineRestrictions(indexes).Merge(BinderUtils.GetVersionCheck(this, this._version)).Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage()))); }
private DynamicMetaObject SetIndexMultiDimensionArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion) { Type elementType = target.LimitType.GetElementType(); Expression expression = PSGetIndexBinder.ConvertIndex(value, elementType); if (expression != null) { if ((int)indexes.Length != 1) { Array arrays = (Array)target.Value; if ((int)indexes.Length == arrays.Rank) { Expression[] expressionArray = new Expression[(int)indexes.Length]; int num = 0; while (num < (int)indexes.Length) { expressionArray[num] = PSGetIndexBinder.ConvertIndex(indexes[num], typeof(int)); if (expressionArray[num] != null) { num++; } else { DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1]; dynamicMetaObjectArray[0] = indexes[num]; return(PSConvertBinder.ThrowNoConversion(indexes[num], typeof(int), this, this._version, indexes.Except <DynamicMetaObject>(dynamicMetaObjectArray).Append <DynamicMetaObject>(target).Append <DynamicMetaObject>(value).ToArray <DynamicMetaObject>())); } } return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_SetMDArrayValue, target.Expression.Cast(typeof(Array)), Expression.NewArrayInit(typeof(int), expressionArray), expression.Cast(typeof(object))), target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction()))); } else { DynamicMetaObject dynamicMetaObject = errorSuggestion; DynamicMetaObject dynamicMetaObject1 = dynamicMetaObject; if (dynamicMetaObject == null) { DynamicMetaObject dynamicMetaObject2 = target; DynamicMetaObject[] dynamicMetaObjectArray1 = indexes; BindingRestrictions bindingRestriction = value.PSGetTypeRestriction(); string str = "NeedMultidimensionalIndex"; string needMultidimensionalIndex = ParserStrings.NeedMultidimensionalIndex; Expression[] expressionArray1 = new Expression[2]; expressionArray1[0] = ExpressionCache.Constant(arrays.Rank); Expression[] expressionArray2 = expressionArray1; int num1 = 1; MethodInfo arrayOpsIndexStringMessage = CachedReflectionInfo.ArrayOps_IndexStringMessage; Type type = typeof(object); DynamicMetaObject[] dynamicMetaObjectArray2 = indexes; expressionArray2[num1] = Expression.Call(arrayOpsIndexStringMessage, Expression.NewArrayInit(type, dynamicMetaObjectArray2.Select <DynamicMetaObject, Expression>((DynamicMetaObject i) => i.Expression.Cast(typeof(object))))); dynamicMetaObject1 = dynamicMetaObject2.ThrowRuntimeError(dynamicMetaObjectArray1, bindingRestriction, str, needMultidimensionalIndex, expressionArray1); } return(dynamicMetaObject1); } } else { Expression expression1 = PSGetIndexBinder.ConvertIndex(indexes[0], typeof(int[])); if (expression1 != null) { return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_SetMDArrayValue, target.Expression.Cast(typeof(Array)), expression1, expression.Cast(typeof(object))), target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction()))); } else { DynamicMetaObject dynamicMetaObject3 = errorSuggestion; DynamicMetaObject dynamicMetaObject4 = dynamicMetaObject3; if (dynamicMetaObject3 == null) { DynamicMetaObject[] dynamicMetaObjectArray3 = new DynamicMetaObject[2]; dynamicMetaObjectArray3[0] = target; dynamicMetaObjectArray3[1] = value; dynamicMetaObject4 = PSConvertBinder.ThrowNoConversion(indexes[0], typeof(int[]), this, this._version, dynamicMetaObjectArray3); } return(dynamicMetaObject4); } } } else { DynamicMetaObject dynamicMetaObject5 = errorSuggestion; DynamicMetaObject dynamicMetaObject6 = dynamicMetaObject5; if (dynamicMetaObject5 == null) { dynamicMetaObject6 = PSConvertBinder.ThrowNoConversion(value, elementType, this, this._version, indexes.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()); } return(dynamicMetaObject6); } }
private DynamicMetaObject SetIndexArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion) { Array arrays = (Array)target.Value; if (arrays.Rank <= 1) { if ((int)indexes.Length <= 1) { Expression expression = PSGetIndexBinder.ConvertIndex(indexes[0], typeof(int)); if (expression != null) { Type elementType = target.LimitType.GetElementType(); Expression expression1 = PSGetIndexBinder.ConvertIndex(value, elementType); if (expression1 != null) { PSSetIndexBinder pSSetIndexBinder = this; DynamicMetaObject dynamicMetaObject = new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction()); DynamicMetaObject dynamicMetaObject1 = new DynamicMetaObject(expression, indexes[0].PSGetTypeRestriction()); DynamicMetaObject dynamicMetaObject2 = new DynamicMetaObject(expression1, value.PSGetTypeRestriction()); PropertyInfo property = target.LimitType.GetProperty("Length"); return(pSSetIndexBinder.IndexWithNegativeChecks(dynamicMetaObject, dynamicMetaObject1, dynamicMetaObject2, property, (Expression t, Expression i, Expression v) => { Expression[] expressionArray = new Expression[1]; expressionArray[0] = i; return Expression.Assign(Expression.ArrayAccess(t, expressionArray), v); } )); } else { DynamicMetaObject dynamicMetaObject3 = errorSuggestion; DynamicMetaObject dynamicMetaObject4 = dynamicMetaObject3; if (dynamicMetaObject3 == null) { dynamicMetaObject4 = PSConvertBinder.ThrowNoConversion(value, elementType, this, this._version, indexes.Prepend <DynamicMetaObject>(target).OfType <DynamicMetaObject>().ToArray <DynamicMetaObject>()); } return(dynamicMetaObject4); } } else { DynamicMetaObject dynamicMetaObject5 = errorSuggestion; DynamicMetaObject dynamicMetaObject6 = dynamicMetaObject5; if (dynamicMetaObject5 == null) { DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[2]; dynamicMetaObjectArray[0] = target; dynamicMetaObjectArray[1] = value; dynamicMetaObject6 = PSConvertBinder.ThrowNoConversion(indexes[0], typeof(int), this, this._version, dynamicMetaObjectArray); } return(dynamicMetaObject6); } } else { DynamicMetaObject dynamicMetaObject7 = errorSuggestion; DynamicMetaObject dynamicMetaObject8 = dynamicMetaObject7; if (dynamicMetaObject7 == null) { DynamicMetaObject dynamicMetaObject9 = target; DynamicMetaObject[] dynamicMetaObjectArray1 = indexes; BindingRestrictions bindingRestriction = value.PSGetTypeRestriction(); string str = "ArraySliceAssignmentFailed"; string arraySliceAssignmentFailed = ParserStrings.ArraySliceAssignmentFailed; Expression[] expressionArray1 = new Expression[1]; Expression[] expressionArray2 = expressionArray1; int num = 0; MethodInfo arrayOpsIndexStringMessage = CachedReflectionInfo.ArrayOps_IndexStringMessage; Type type = typeof(object); DynamicMetaObject[] dynamicMetaObjectArray2 = indexes; expressionArray2[num] = Expression.Call(arrayOpsIndexStringMessage, Expression.NewArrayInit(type, dynamicMetaObjectArray2.Select <DynamicMetaObject, Expression>((DynamicMetaObject i) => i.Expression.Cast(typeof(object))))); dynamicMetaObject8 = dynamicMetaObject9.ThrowRuntimeError(dynamicMetaObjectArray1, bindingRestriction, str, arraySliceAssignmentFailed, expressionArray1); } return(dynamicMetaObject8); } } else { return(this.SetIndexMultiDimensionArray(target, indexes, value, errorSuggestion)); } }
private DynamicMetaObject InvokeIndexer(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion, string methodName) { DynamicMetaObject dynamicMetaObject; Func <Expression, Expression, Expression, Expression> func = null; MethodInfo methodInfo = PSInvokeMemberBinder.FindBestMethod(target, indexes.Append <DynamicMetaObject>(value), string.Concat("set_", methodName), false, this._constraints); if (methodInfo != null) { ParameterInfo[] parameters = methodInfo.GetParameters(); if ((int)parameters.Length == (int)indexes.Length + 1) { Expression[] expressionArray = new Expression[(int)parameters.Length]; int num = 0; while (num < (int)parameters.Length) { Type parameterType = parameters[num].ParameterType; Expression[] expressionArray1 = expressionArray; int num1 = num; if (num == (int)parameters.Length - 1) { dynamicMetaObject = value; } else { dynamicMetaObject = indexes[num]; } expressionArray1[num1] = PSGetIndexBinder.ConvertIndex(dynamicMetaObject, parameterType); if (expressionArray[num] != null) { num++; } else { DynamicMetaObject dynamicMetaObject1 = errorSuggestion; DynamicMetaObject dynamicMetaObject2 = dynamicMetaObject1; if (dynamicMetaObject1 == null) { dynamicMetaObject2 = PSConvertBinder.ThrowNoConversion(target, parameterType, this, this._version, indexes.Append <DynamicMetaObject>(value).ToArray <DynamicMetaObject>()); } return(dynamicMetaObject2); } } if ((int)parameters.Length == 2 && parameters[0].ParameterType.Equals(typeof(int)) && target.Value as IDictionary == null) { PropertyInfo property = target.LimitType.GetProperty("Length"); PropertyInfo propertyInfo = property; if (property == null) { propertyInfo = target.LimitType.GetProperty("Count"); } PropertyInfo propertyInfo1 = propertyInfo; if (propertyInfo1 != null) { PSSetIndexBinder pSSetIndexBinder = this; DynamicMetaObject dynamicMetaObject3 = new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction()); DynamicMetaObject dynamicMetaObject4 = new DynamicMetaObject(expressionArray[0], indexes[0].PSGetTypeRestriction()); DynamicMetaObject dynamicMetaObject5 = new DynamicMetaObject(expressionArray[1], value.PSGetTypeRestriction()); PropertyInfo propertyInfo2 = propertyInfo1; if (func == null) { func = (Expression t, Expression i, Expression v) => Expression.Call(t, methodInfo, i, v); } return(pSSetIndexBinder.IndexWithNegativeChecks(dynamicMetaObject3, dynamicMetaObject4, dynamicMetaObject5, propertyInfo2, func)); } } BindingRestrictions bindingRestriction = target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction()); bindingRestriction = bindingRestriction.Merge(BinderUtils.GetVersionCheck(this, this._version)); bindingRestriction = bindingRestriction.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage()); Expression expression = expressionArray[(int)expressionArray.Length - 1]; ParameterExpression parameterExpression = Expression.Parameter(expression.Type, "value"); expressionArray[(int)expressionArray.Length - 1] = parameterExpression; ParameterExpression[] parameterExpressionArray = new ParameterExpression[1]; parameterExpressionArray[0] = parameterExpression; Expression[] expressionArray2 = new Expression[3]; expressionArray2[0] = Expression.Assign(parameterExpression, expression); expressionArray2[1] = Expression.Call(target.Expression.Cast(target.LimitType), methodInfo, expressionArray); expressionArray2[2] = parameterExpression.Cast(typeof(object)); return(new DynamicMetaObject(Expression.Block(parameterExpressionArray, expressionArray2), bindingRestriction)); } else { DynamicMetaObject dynamicMetaObject6 = errorSuggestion; DynamicMetaObject dynamicMetaObject7 = dynamicMetaObject6; if (dynamicMetaObject6 == null) { dynamicMetaObject7 = this.CannotIndexTarget(target, indexes, value); } return(dynamicMetaObject7); } } else { DynamicMetaObject dynamicMetaObject8 = errorSuggestion; DynamicMetaObject dynamicMetaObject9 = dynamicMetaObject8; if (dynamicMetaObject8 == null) { dynamicMetaObject9 = this.CannotIndexTarget(target, indexes, value); } return(dynamicMetaObject9); } }
internal DynamicMetaObject BNot(DynamicMetaObject target, DynamicMetaObject errorSuggestion) { if (!target.HasValue) { return(base.Defer(target, new DynamicMetaObject[0])); } if ((target.Value is PSObject) && (PSObject.Base(target.Value) != target.Value)) { return(this.DeferForPSObject(new DynamicMetaObject[] { target })); } if (target.Value == null) { return(new DynamicMetaObject(ExpressionCache.Constant(-1).Cast(typeof(object)), target.PSGetTypeRestriction())); } MethodInfo method = target.LimitType.GetMethod("op_OnesComplement", BindingFlags.Public | BindingFlags.Static, null, new Type[] { target.LimitType }, null); if (method != null) { return(new DynamicMetaObject(Expression.OnesComplement(target.Expression.Cast(target.LimitType), method).Cast(typeof(object)), target.PSGetTypeRestriction())); } if (target.LimitType.Equals(typeof(string))) { return(new DynamicMetaObject(Expression.Dynamic(this, this.ReturnType, PSBinaryOperationBinder.ConvertStringToNumber(target.Expression, typeof(int))), target.PSGetTypeRestriction())); } Expression expression = null; if (!target.LimitType.IsNumeric()) { bool flag; Type resultType = typeof(int); LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(target.Value, resultType, out flag); if (conversion.Rank != ConversionRank.None) { expression = PSConvertBinder.InvokeConverter(conversion, target.Expression, resultType, flag, ExpressionCache.InvariantCulture); } else { resultType = typeof(long); conversion = LanguagePrimitives.FigureConversion(target.Value, resultType, out flag); if (conversion.Rank != ConversionRank.None) { expression = PSConvertBinder.InvokeConverter(conversion, target.Expression, resultType, flag, ExpressionCache.InvariantCulture); } } } else { TypeCode typeCode = LanguagePrimitives.GetTypeCode(target.LimitType); if (typeCode < TypeCode.Int32) { expression = target.Expression.Cast(typeof(int)); } else if (typeCode <= TypeCode.UInt64) { expression = target.Expression.Cast(target.LimitType); } else { Type type2 = (typeCode == TypeCode.Decimal) ? typeof(DecimalOps) : typeof(DoubleOps); Type type = (typeCode == TypeCode.Decimal) ? typeof(decimal) : typeof(double); return(new DynamicMetaObject(Expression.Call(type2.GetMethod("BNot", BindingFlags.NonPublic | BindingFlags.Static), target.Expression.Convert(type)), target.PSGetTypeRestriction())); } } if ((expression == null) && (errorSuggestion == null)) { return(PSConvertBinder.ThrowNoConversion(target, typeof(int), this, -1, new DynamicMetaObject[0])); } return(new DynamicMetaObject(Expression.OnesComplement(expression).Cast(typeof(object)), target.PSGetTypeRestriction())); }
public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) { bool flag; Type type = (Type)target.Value; MethodInformation[] methodInformationArray = DotNetAdapter.GetMethodInformationArray(type.GetConstructors()); target = new DynamicMetaObject(target.Expression, BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value), target.Value); string errorId = null; string errorMsg = null; int count = base.CallInfo.ArgumentCount - base.CallInfo.ArgumentNames.Count; MethodInformation information = Adapter.FindBestMethod(methodInformationArray, null, (from arg in args.Take <DynamicMetaObject>(count) select arg.Value).ToArray <object>(), ref errorId, ref errorMsg, out flag); if (information == null) { if (errorSuggestion == null) { } return(new DynamicMetaObject(Expression.Throw(Expression.New(CachedReflectionInfo.MethodException_ctor, new Expression[] { Expression.Constant(errorId), Expression.Constant(null, typeof(Exception)), Expression.Constant(errorMsg), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(".ctor").Cast(typeof(object)), ExpressionCache.Constant(count).Cast(typeof(object)) }) }), this.ReturnType), target.CombineRestrictions(args))); } ConstructorInfo method = (ConstructorInfo)information.method; ParameterInfo[] parameters = method.GetParameters(); Expression[] arguments = new Expression[parameters.Length]; int index = 0; while (index < parameters.Length) { bool flag3; Type parameterType = parameters[index].ParameterType; if (parameters[index].GetCustomAttributes(typeof(ParamArrayAttribute), true).Any <object>() && flag) { Type elementType = parameters[index].ParameterType.GetElementType(); List <Expression> initializers = new List <Expression>(); int num3 = index; int num4 = index; while (num4 < count) { bool flag2; LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(args[index].Value, elementType, out flag2); initializers.Add(PSConvertBinder.InvokeConverter(data, args[num4].Expression, elementType, flag2, ExpressionCache.InvariantCulture)); num4++; index++; } arguments[num3] = Expression.NewArrayInit(elementType, initializers); break; } LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(args[index].Value, parameterType, out flag3); arguments[index] = PSConvertBinder.InvokeConverter(conversion, args[index].Expression, parameterType, flag3, ExpressionCache.InvariantCulture); index++; } Expression right = Expression.New(method, arguments); if (base.CallInfo.ArgumentNames.Any <string>()) { ParameterExpression expr = Expression.Parameter(right.Type); List <Expression> expressions = new List <Expression>(); foreach (string str3 in base.CallInfo.ArgumentNames) { Expression expression3; Type propertyType; bool flag4; MemberInfo[] infoArray3 = type.GetMember(str3, MemberTypes.Property | MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase); if ((infoArray3.Length != 1) || (!(infoArray3[0] is PropertyInfo) && !(infoArray3[0] is FieldInfo))) { return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, new Expression[] { Expression.Constant(str3), Expression.Constant(type) })); } MemberInfo info2 = infoArray3[0]; if (info2 is PropertyInfo) { PropertyInfo property = (PropertyInfo)info2; if (property.GetSetMethod() == null) { return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyIsReadOnly", ParserStrings.PropertyIsReadOnly, new Expression[] { Expression.Constant(str3) })); } propertyType = property.PropertyType; expression3 = Expression.Property(expr.Cast(info2.DeclaringType), property); } else { propertyType = ((FieldInfo)info2).FieldType; expression3 = Expression.Field(expr.Cast(info2.DeclaringType), (FieldInfo)info2); } LanguagePrimitives.ConversionData data3 = LanguagePrimitives.FigureConversion(args[index].Value, propertyType, out flag4); if (data3.Rank == ConversionRank.None) { return(PSConvertBinder.ThrowNoConversion(args[index], propertyType, this, -1, args.Except <DynamicMetaObject>(new DynamicMetaObject[] { args[index] }).Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>())); } expressions.Add(Expression.Assign(expression3, PSConvertBinder.InvokeConverter(data3, args[index].Expression, propertyType, flag4, ExpressionCache.InvariantCulture))); index++; } ParameterExpression variable = Expression.Parameter(typeof(Exception)); BlockExpression expression5 = Expression.Block(Expression.Assign(expr, right), Expression.TryCatch(Expression.Block(typeof(void), expressions), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, variable), Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Property(variable, "Message"), variable, typeof(void), new Expression[0]))) }), expr); right = Expression.Block(new ParameterExpression[] { expr }, new Expression[] { expression5 }); } return(new DynamicMetaObject(right, target.CombineRestrictions(args))); }