private DynamicMetaObject GetIndexDictionary(DynamicMetaObject target, DynamicMetaObject[] indexes, Type idictionary)
        {
            bool flag;

            if (indexes.Length > 1)
            {
                return(null);
            }
            MethodInfo method = idictionary.GetMethod("TryGetValue");

            ParameterInfo[] parameters    = method.GetParameters();
            Type            parameterType = parameters[0].ParameterType;

            LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(indexes[0].Value, parameterType, out flag);
            if (conversion.Rank == ConversionRank.None)
            {
                return(null);
            }
            if (indexes[0].LimitType.IsArray && !parameterType.IsArray)
            {
                return(null);
            }
            BindingRestrictions restrictions = target.CombineRestrictions(indexes).Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(this, parameterType, this._version));
            Expression          expression   = PSConvertBinder.InvokeConverter(conversion, indexes[0].Expression, parameterType, flag, ExpressionCache.InvariantCulture);
            ParameterExpression expression2  = Expression.Parameter(parameters[1].ParameterType.GetElementType(), "outParam");

            return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { expression2 }, new Expression[] { Expression.Condition(Expression.Call(target.Expression.Cast(idictionary), method, expression, expression2), expression2.Cast(typeof(object)), this.GetNullResult()) }), restrictions));
        }
        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))));
        }
Exemple #3
0
        internal static Expression CastOrConvertMethodArgument(this DynamicMetaObject target, Type parameterType, string parameterName, string methodName, List <ParameterExpression> temps, List <Expression> initTemps)
        {
            bool flag;

            if (target.Value == AutomationNull.Value)
            {
                return(Expression.Constant(null, parameterType));
            }
            Type limitType = target.LimitType;

            if (parameterType.Equals(typeof(object)) && limitType.Equals(typeof(PSObject)))
            {
                return(Expression.Call(CachedReflectionInfo.PSObject_Base, target.Expression.Cast(typeof(PSObject))));
            }
            if (parameterType.IsAssignableFrom(limitType))
            {
                return(target.Expression.Cast(parameterType));
            }
            ParameterExpression variable    = Expression.Variable(typeof(Exception));
            ParameterExpression expression2 = Expression.Variable(target.Expression.Type);
            Expression          expression3 = PSConvertBinder.InvokeConverter(LanguagePrimitives.FigureConversion(target.Value, parameterType, out flag), expression2, parameterType, flag, ExpressionCache.InvariantCulture);
            BlockExpression     right       = Expression.Block(new ParameterExpression[] { expression2 }, new Expression[] { Expression.TryCatch(Expression.Block(Expression.Assign(expression2, target.Expression), expression3), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.ExceptionHandlingOps_ConvertToArgumentConversionException, variable, Expression.Constant(parameterName), expression2.Cast(typeof(object)), Expression.Constant(methodName), Expression.Constant(parameterType)), Expression.Default(expression3.Type))) }) });
            ParameterExpression item        = Expression.Variable(right.Type);

            temps.Add(item);
            initTemps.Add(Expression.Assign(item, right));
            return(item);
        }
Exemple #4
0
        internal static Expression CastOrConvert(this DynamicMetaObject target, Type type)
        {
            bool flag;

            if (target.LimitType.Equals(type))
            {
                return(target.Expression.Cast(type));
            }
            return(PSConvertBinder.InvokeConverter(LanguagePrimitives.FigureConversion(target.Value, type, out flag), target.Expression, type, flag, ExpressionCache.InvariantCulture));
        }
        internal static Expression ConvertIndex(DynamicMetaObject index, Type resultType)
        {
            bool flag;

            LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(index.Value, resultType, out flag);
            if (conversion.Rank != ConversionRank.None)
            {
                return(PSConvertBinder.InvokeConverter(conversion, index.Expression, resultType, flag, ExpressionCache.InvariantCulture));
            }
            return(null);
        }
        public override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args)
        {
            bool flag;

            if (!target.HasValue)
            {
                return(base.Defer(target, new DynamicMetaObject[0]).WriteToDebugLog(this));
            }
            Type resultType = ((target.Value is OrderedDictionary) || (target.Value is Hashtable)) ? typeof(LanguagePrimitives.InternalPSCustomObject) : typeof(PSObject);

            return(new DynamicMetaObject(PSConvertBinder.InvokeConverter(LanguagePrimitives.FigureConversion(target.Value, resultType, out flag), target.Expression, resultType, flag, ExpressionCache.InvariantCulture), target.PSGetTypeRestriction()).WriteToDebugLog(this));
        }
        public override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args)
        {
            DynamicMetaObject obj2 = args[0];

            if (!target.HasValue || !obj2.HasValue)
            {
                return(base.Defer(target, new DynamicMetaObject[] { obj2 }).WriteToDebugLog(this));
            }
            Type instance = target.Value as Type;
            BindingRestrictions restrictions = BindingRestrictions.GetInstanceRestriction(target.Expression, instance).Merge(obj2.PSGetTypeRestriction());

            return(new DynamicMetaObject(Expression.Dynamic(PSConvertBinder.Get(instance), instance, obj2.Expression).Cast(typeof(object)), restrictions).WriteToDebugLog(this));
        }
Exemple #8
0
 public static PSConvertBinder Get(Type type)
 {
     PSConvertBinder binder;
     lock (_binderCache)
     {
         if (!_binderCache.TryGetValue(type, out binder))
         {
             binder = new PSConvertBinder(type);
             _binderCache.Add(type, binder);
         }
     }
     return binder;
 }
        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())));
        }
Exemple #10
0
        public static PSConvertBinder Get(Type type)
        {
            PSConvertBinder binder;

            lock (_binderCache)
            {
                if (!_binderCache.TryGetValue(type, out binder))
                {
                    binder = new PSConvertBinder(type);
                    _binderCache.Add(type, binder);
                }
            }
            return(binder);
        }
 internal static Expression Convert(this Expression expr, Type type)
 {
     if (expr.Type.Equals(type))
     {
         return(expr);
     }
     if (expr.Type.Equals(typeof(void)))
     {
         expr = ExpressionCache.NullConstant;
     }
     if (LanguagePrimitives.GetConversionRank(expr.Type, type) == ConversionRank.Assignable)
     {
         return(Expression.Convert(expr, type));
     }
     if (type.ContainsGenericParameters)
     {
         return(Expression.Call(CachedReflectionInfo.LanguagePrimitives_ThrowInvalidCastException, expr.Cast(typeof(object)), Expression.Constant(type)));
     }
     return(Expression.Dynamic(PSConvertBinder.Get(type), type, expr));
 }
        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);
            }
        }
Exemple #14
0
 public override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args)
 {
     if (!target.HasValue || !args[0].HasValue)
     {
         DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[2];
         dynamicMetaObjectArray[0] = args[0];
         dynamicMetaObjectArray[1] = args[1];
         return(base.Defer(target, dynamicMetaObjectArray).WriteToDebugLog(this));
     }
     else
     {
         BindingRestrictions bindingRestriction = target.PSGetTypeRestriction();
         if (target.Value as PSObject == null)
         {
             if (target.Value != null)
             {
                 if (target.Value as ScriptBlock == null)
                 {
                     Expression        expression        = args[1].Expression;
                     DynamicExpression dynamicExpression = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), args[0].Expression, expression);
                     if (target.Value as Regex != null || (this._flags & SwitchFlags.Regex) != SwitchFlags.None)
                     {
                         MethodCallExpression methodCallExpression = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedRegex, ExpressionCache.Constant((this._flags & SwitchFlags.CaseSensitive) != SwitchFlags.None), target.Expression.Cast(typeof(object)), ExpressionCache.NullExtent, dynamicExpression, expression);
                         return(new DynamicMetaObject(methodCallExpression, bindingRestriction).WriteToDebugLog(this));
                     }
                     else
                     {
                         if (target.Value as WildcardPattern != null || (this._flags & SwitchFlags.Wildcard) != SwitchFlags.None)
                         {
                             MethodCallExpression methodCallExpression1 = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedWildcard, ExpressionCache.Constant((this._flags & SwitchFlags.CaseSensitive) != SwitchFlags.None), target.Expression.Cast(typeof(object)), dynamicExpression, expression);
                             return(new DynamicMetaObject(methodCallExpression1, bindingRestriction).WriteToDebugLog(this));
                         }
                         else
                         {
                             DynamicExpression dynamicExpression1 = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), target.Expression, expression);
                             return(new DynamicMetaObject(Compiler.CallStringEquals(dynamicExpression1, dynamicExpression, (this._flags & SwitchFlags.CaseSensitive) == SwitchFlags.None), bindingRestriction).WriteToDebugLog(this));
                         }
                     }
                 }
                 else
                 {
                     Expression[] automationNullConstant = new Expression[6];
                     automationNullConstant[0] = ExpressionCache.Constant(true);
                     automationNullConstant[1] = Expression.Constant(ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe);
                     automationNullConstant[2] = args[0].CastOrConvert(typeof(object));
                     automationNullConstant[3] = ExpressionCache.AutomationNullConstant;
                     automationNullConstant[4] = ExpressionCache.AutomationNullConstant;
                     automationNullConstant[5] = ExpressionCache.NullObjectArray;
                     MethodCallExpression methodCallExpression2 = Expression.Call(target.Expression.Cast(typeof(ScriptBlock)), CachedReflectionInfo.ScriptBlock_DoInvokeReturnAsIs, automationNullConstant);
                     return(new DynamicMetaObject(Expression.Dynamic(PSConvertBinder.Get(typeof(bool)), typeof(bool), methodCallExpression2), bindingRestriction).WriteToDebugLog(this));
                 }
             }
             else
             {
                 return(new DynamicMetaObject(Expression.Equal(args[0].Expression.Cast(typeof(object)), ExpressionCache.NullConstant), target.PSGetTypeRestriction()).WriteToDebugLog(this));
             }
         }
         else
         {
             return(new DynamicMetaObject(Expression.Dynamic(this, this.ReturnType, Expression.Call(CachedReflectionInfo.PSObject_Base, target.Expression.Cast(typeof(object))), args[0].Expression, args[1].Expression), bindingRestriction).WriteToDebugLog(this));
         }
     }
 }
        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()));
        }
        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);
            }
        }
        public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
        {
            PSMemberInfo        info;
            BindingRestrictions restrictions2;
            bool flag3;
            Type type4;

            if (!target.HasValue || !value.HasValue)
            {
                return(base.Defer(target, new DynamicMetaObject[] { value }));
            }
            object obj2 = PSObject.Base(target.Value);

            if (obj2 == null)
            {
                return(target.ThrowRuntimeError(new DynamicMetaObject[] { value }, BindingRestrictions.Empty, "PropertyNotFound", ParserStrings.PropertyNotFound, new Expression[] { Expression.Constant(base.Name) }).WriteToDebugLog(this));
            }
            if (value.Value == AutomationNull.Value)
            {
                value = new DynamicMetaObject(ExpressionCache.NullConstant, value.PSGetTypeRestriction(), null);
            }
            if (this._getMemberBinder.HasInstanceMember && PSGetMemberBinder.TryGetInstanceMember(target.Value, base.Name, out info))
            {
                ParameterExpression   expression   = Expression.Variable(typeof(PSMemberInfo));
                ParameterExpression   expression2  = Expression.Variable(typeof(object));
                ConditionalExpression expression3  = Expression.Condition(Expression.Call(CachedReflectionInfo.PSGetMemberBinder_TryGetInstanceMember, target.Expression.Cast(typeof(object)), Expression.Constant(base.Name), expression), Expression.Assign(Expression.Property(expression, "Value"), value.Expression.Cast(typeof(object))), base.GetUpdateExpression(typeof(object)));
                BindingRestrictions   restrictions = BinderUtils.GetVersionCheck(this._getMemberBinder, this._getMemberBinder._version).Merge(value.PSGetTypeRestriction());
                return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { expression, expression2 }, new Expression[] { expression3 }), restrictions).WriteToDebugLog(this));
            }
            if (obj2 is IDictionary)
            {
                Type genericTypeArg = null;
                bool flag           = PSGetMemberBinder.IsGenericDictionary(obj2, ref genericTypeArg);
                if (!flag || (genericTypeArg != null))
                {
                    bool                flag2;
                    Type                type       = flag ? typeof(IDictionary <,>).MakeGenericType(new Type[] { typeof(string), genericTypeArg }) : typeof(IDictionary);
                    MethodInfo          method     = type.GetMethod("set_Item");
                    ParameterExpression left       = Expression.Variable(genericTypeArg ?? typeof(object));
                    Type                resultType = left.Type;
                    LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(value.Value, resultType, out flag2);
                    if (conversion.Rank != ConversionRank.None)
                    {
                        Expression right = PSConvertBinder.InvokeConverter(conversion, value.Expression, resultType, flag2, ExpressionCache.InvariantCulture);
                        return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { left }, new Expression[] { Expression.Assign(left, right), Expression.Call(PSGetMemberBinder.GetTargetExpr(target).Cast(type), method, Expression.Constant(base.Name), right), right.Cast(typeof(object)) }), target.CombineRestrictions(new DynamicMetaObject[] { value })).WriteToDebugLog(this));
                    }
                }
            }
            info          = this._getMemberBinder.GetPSMemberInfo(target, out restrictions2, out flag3, out type4, null, null);
            restrictions2 = restrictions2.Merge(value.PSGetTypeRestriction());
            if (ExecutionContext.HasEverUsedConstrainedLanguage)
            {
                restrictions2 = restrictions2.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
                DynamicMetaObject obj3 = PSGetMemberBinder.EnsureAllowedInLanguageMode(LocalPipeline.GetExecutionContextFromTLS().LanguageMode, target, obj2, base.Name, this._static, new DynamicMetaObject[] { value }, restrictions2, "PropertySetterNotSupportedInConstrainedLanguage", ParserStrings.PropertySetConstrainedLanguage);
                if (obj3 != null)
                {
                    return(obj3.WriteToDebugLog(this));
                }
            }
            if (flag3)
            {
                if (info == null)
                {
                    return((errorSuggestion ?? new DynamicMetaObject(Compiler.ThrowRuntimeError("PropertyAssignmentException", ParserStrings.PropertyNotFound, this.ReturnType, new Expression[] { Expression.Constant(base.Name) }), restrictions2)).WriteToDebugLog(this));
                }
                PSPropertyInfo info3 = info as PSPropertyInfo;
                if (info3 != null)
                {
                    if (!info3.IsSettable)
                    {
                        Expression innerException = Expression.New(CachedReflectionInfo.SetValueException_ctor, new Expression[] { Expression.Constant("PropertyAssignmentException"), Expression.Constant(null, typeof(Exception)), Expression.Constant(ParserStrings.PropertyIsReadOnly), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(base.Name) }) });
                        return(new DynamicMetaObject(Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Constant(ParserStrings.PropertyIsReadOnly), innerException, this.ReturnType, new Expression[] { Expression.Constant(base.Name) }), restrictions2).WriteToDebugLog(this));
                    }
                    PSProperty property = info3 as PSProperty;
                    if (property != null)
                    {
                        DotNetAdapter.PropertyCacheEntry adapterData = property.adapterData as DotNetAdapter.PropertyCacheEntry;
                        if (adapterData != null)
                        {
                            Expression expression10;
                            Type       propertyType;
                            if (adapterData.member.DeclaringType.IsGenericTypeDefinition)
                            {
                                Expression expression9 = Expression.New(CachedReflectionInfo.SetValueException_ctor, new Expression[] { Expression.Constant("PropertyAssignmentException"), Expression.Constant(null, typeof(Exception)), Expression.Constant(ExtendedTypeSystem.CannotInvokeStaticMethodOnUninstantiatedGenericType), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(adapterData.member.DeclaringType.FullName) }) });
                                return(new DynamicMetaObject(Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Constant(ExtendedTypeSystem.CannotInvokeStaticMethodOnUninstantiatedGenericType), expression9, this.ReturnType, new Expression[] { Expression.Constant(adapterData.member.DeclaringType.FullName) }), restrictions2).WriteToDebugLog(this));
                            }
                            PropertyInfo member = adapterData.member as PropertyInfo;
                            if (member != null)
                            {
                                propertyType = member.PropertyType;
                                Expression expression11 = this._static ? null : PSGetMemberBinder.GetTargetExpr(target);
                                expression10 = Expression.Property(expression11, member);
                            }
                            else
                            {
                                FieldInfo field = (FieldInfo)adapterData.member;
                                propertyType = field.FieldType;
                                Expression expression12 = this._static ? null : PSGetMemberBinder.GetTargetExpr(target);
                                expression10 = Expression.Field(expression12, field);
                            }
                            Type underlyingType = Nullable.GetUnderlyingType(propertyType);
                            Type type7          = underlyingType ?? propertyType;
                            ParameterExpression expression13 = Expression.Variable(type7);
                            Expression          expression14 = (underlyingType != null) ? ((value.Value == null) ? ((Expression)Expression.Constant(null, propertyType)) : ((Expression)Expression.New(propertyType.GetConstructor(new Type[] { underlyingType }), new Expression[] { expression13 }))) : ((Expression)expression13);
                            Expression          expression15 = (type7.Equals(typeof(object)) && value.LimitType.Equals(typeof(PSObject))) ? Expression.Call(CachedReflectionInfo.PSObject_Base, value.Expression.Cast(typeof(PSObject))) : value.CastOrConvert(type7);
                            Expression          expr         = Expression.Block(new ParameterExpression[] { expression13 }, new Expression[] { Expression.Assign(expression13, expression15), Expression.Assign(expression10, expression14), expression13.Cast(typeof(object)) });
                            ParameterExpression variable     = Expression.Variable(typeof(Exception));
                            return(new DynamicMetaObject(Expression.TryCatch(expr.Cast(typeof(object)), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.ExceptionHandlingOps_ConvertToMethodInvocationException, variable, Expression.Constant(typeof(SetValueInvocationException)), Expression.Constant(base.Name), ExpressionCache.Constant(0), Expression.Constant(null, typeof(MemberInfo))), Expression.Rethrow(typeof(object)))) }), restrictions2).WriteToDebugLog(this));
                        }
                    }
                    PSCodeProperty property2 = info3 as PSCodeProperty;
                    if (property2 != null)
                    {
                        ParameterExpression expression17 = Expression.Variable(typeof(object));
                        return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { expression17 }, new Expression[] { Expression.Assign(expression17, value.CastOrConvert(expression17.Type)), PSInvokeMemberBinder.InvokeMethod(property2.SetterCodeReference, null, new DynamicMetaObject[] { target, value }, false), expression17 }), restrictions2).WriteToDebugLog(this));
                    }
                    PSScriptProperty property3 = info3 as PSScriptProperty;
                    if (property3 != null)
                    {
                        return(new DynamicMetaObject(Expression.Call(Expression.Constant(property3), CachedReflectionInfo.PSScriptProperty_InvokeSetter, PSGetMemberBinder.GetTargetExpr(target), value.Expression.Cast(typeof(object))), restrictions2).WriteToDebugLog(this));
                    }
                }
                if (errorSuggestion != null)
                {
                    return(errorSuggestion.WriteToDebugLog(this));
                }
            }
            return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.PSSetMemberBinder_SetAdaptedValue, PSGetMemberBinder.GetTargetExpr(target).Cast(typeof(object)), Expression.Constant(base.Name), value.Expression.Cast(typeof(object))), restrictions2).WriteToDebugLog(this));
        }
Exemple #18
0
        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)));
        }