private DynamicMetaObject IncrDecr(DynamicMetaObject target, int valueToAdd, 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(valueToAdd).Cast(typeof(object)), target.PSGetTypeRestriction())); } if (target.LimitType.IsNumeric()) { DynamicMetaObject arg = new DynamicMetaObject(ExpressionCache.Constant(valueToAdd), BindingRestrictions.Empty, valueToAdd); return(new DynamicMetaObject(PSBinaryOperationBinder.Get(ExpressionType.Add, true, false).FallbackBinaryOperation(target, arg, errorSuggestion).Expression, target.PSGetTypeRestriction())); } return(errorSuggestion ?? target.ThrowRuntimeError(new DynamicMetaObject[0], BindingRestrictions.Empty, "OperatorRequiresNumber", ParserStrings.OperatorRequiresNumber, new Expression[] { Expression.Constant(((base.Operation == ExpressionType.Increment) ? TokenKind.PlusPlus : TokenKind.MinusMinus).Text()), Expression.Constant(target.LimitType) })); }
public override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args) { Expression expression3; BindingRestrictions expressionRestriction; if (!target.HasValue) { return(base.Defer(target, new DynamicMetaObject[0]).WriteToDebugLog(this)); } IList list = target.Value as IList; Expression expression = target.Expression; if (!typeof(IList).Equals(expression.Type)) { expression = Expression.Convert(expression, typeof(IList)); } MemberExpression left = Expression.Property(Expression.Convert(expression, typeof(ICollection)), CachedReflectionInfo.ICollection_Count); switch (list.Count) { case 0: expression3 = ExpressionCache.Constant(false); expressionRestriction = BindingRestrictions.GetExpressionRestriction(Expression.Equal(left, ExpressionCache.Constant(0))); break; case 1: expression3 = Expression.Call(expression, CachedReflectionInfo.IList_get_Item, new Expression[] { ExpressionCache.Constant(0) }).Convert(typeof(bool)); expressionRestriction = BindingRestrictions.GetExpressionRestriction(Expression.Equal(left, ExpressionCache.Constant(1))); break; default: expression3 = ExpressionCache.Constant(true); expressionRestriction = BindingRestrictions.GetExpressionRestriction(Expression.GreaterThan(left, ExpressionCache.Constant(1))); break; } return(new DynamicMetaObject(expression3, expressionRestriction).WriteToDebugLog(this)); }
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)); } } }
public override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args) { if (!target.HasValue) { return(base.Defer(target, args)); } if (target.Value == AutomationNull.Value) { return(new DynamicMetaObject(Expression.Block(typeof(void), new Expression[] { Expression.Call(CachedReflectionInfo.PipelineOps_Nop, new Expression[0]) }), BindingRestrictions.GetInstanceRestriction(target.Expression, AutomationNull.Value)).WriteToDebugLog(this)); } DynamicMetaObject obj2 = PSEnumerableBinder.IsEnumerable(target); if (obj2 == null) { DynamicMetaObject obj3 = PSVariableAssignmentBinder.Get().Bind(target, new DynamicMetaObject[0]); BindingRestrictions restrictions = target.LimitType.IsValueType ? obj3.Restrictions : target.PSGetTypeRestriction(); return(new DynamicMetaObject(Expression.Call(args[0].Expression, CachedReflectionInfo.Pipe_Add, new Expression[] { obj3.Expression.Cast(typeof(object)) }), restrictions).WriteToDebugLog(this)); } bool b = !(PSObject.Base(target.Value) is IEnumerator); return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.EnumerableOps_WriteEnumerableToPipe, obj2.Expression, args[0].Expression, args[1].Expression, ExpressionCache.Constant(b)), obj2.Restrictions).WriteToDebugLog(this)); }
private DynamicMetaObject UnaryPlus(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.LimitType.IsNumeric()) { return(new DynamicMetaObject(Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Add, true, false), typeof(object), ExpressionCache.Constant(0), target.Expression), target.PSGetTypeRestriction())); } Expression expr = target.Expression.Cast(target.LimitType); if (target.LimitType.Equals(typeof(byte)) || target.LimitType.Equals(typeof(sbyte))) { expr = expr.Cast(typeof(int)); } return(new DynamicMetaObject(Expression.UnaryPlus(expr).Cast(typeof(object)), target.PSGetTypeRestriction())); }
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 Bind(DynamicMetaObject target, DynamicMetaObject[] args) { int i; if (target.HasValue) { if (target.Value as PSObject == null || PSObject.Base(target.Value) == target.Value) { IList value = target.Value as IList; if (value == null) { return(new DynamicMetaObject(Expression.NewArrayInit(typeof(object), Enumerable.Repeat <Expression>(ExpressionCache.NullConstant, this._elements - 1).Prepend <Expression>(target.Expression.Cast(typeof(object)))), target.PSGetTypeRestriction()).WriteToDebugLog(this)); } else { MemberExpression memberExpression = Expression.Property(target.Expression.Cast(typeof(ICollection)), CachedReflectionInfo.ICollection_Count); BindingRestrictions bindingRestriction = target.PSGetTypeRestriction().Merge(BindingRestrictions.GetExpressionRestriction(Expression.Equal(memberExpression, ExpressionCache.Constant(value.Count)))); if (value.Count != this._elements) { Expression[] nullConstant = new Expression[this._elements]; ParameterExpression parameterExpression = Expression.Variable(typeof(IList)); if (value.Count >= this._elements) { for (i = 0; i < this._elements - 1; i++) { Expression[] expressionArray = new Expression[1]; expressionArray[0] = ExpressionCache.Constant(i); nullConstant[i] = Expression.Call(parameterExpression, CachedReflectionInfo.IList_get_Item, expressionArray); } nullConstant[this._elements - 1] = Expression.Call(CachedReflectionInfo.EnumerableOps_GetSlice, parameterExpression, ExpressionCache.Constant(this._elements - 1)).Cast(typeof(object)); } else { for (i = 0; i < value.Count; i++) { Expression[] expressionArray1 = new Expression[1]; expressionArray1[0] = ExpressionCache.Constant(i); nullConstant[i] = Expression.Call(parameterExpression, CachedReflectionInfo.IList_get_Item, expressionArray1); } while (i < this._elements) { nullConstant[i] = ExpressionCache.NullConstant; i++; } } ParameterExpression[] parameterExpressionArray = new ParameterExpression[1]; parameterExpressionArray[0] = parameterExpression; Expression[] expressionArray2 = new Expression[2]; expressionArray2[0] = Expression.Assign(parameterExpression, target.Expression.Cast(typeof(IList))); expressionArray2[1] = Expression.NewArrayInit(typeof(object), nullConstant); return(new DynamicMetaObject(Expression.Block(parameterExpressionArray, expressionArray2), bindingRestriction).WriteToDebugLog(this)); } else { return(new DynamicMetaObject(target.Expression.Cast(typeof(IList)), bindingRestriction).WriteToDebugLog(this)); } } } else { DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1]; dynamicMetaObjectArray[0] = target; return(this.DeferForPSObject(dynamicMetaObjectArray).WriteToDebugLog(this)); } } else { return(base.Defer(target, new DynamicMetaObject[0]).WriteToDebugLog(this)); } }
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); } }
internal static Expression InvokeConverter(LanguagePrimitives.ConversionData conversion, Expression value, Type resultType, bool debase, Expression formatProvider) { Expression expression; if ((conversion.Rank == ConversionRank.Identity) || (conversion.Rank == ConversionRank.Assignable)) { expression = debase ? Expression.Call(CachedReflectionInfo.PSObject_Base, value) : value; } else { Expression expression2; Expression nullPSObject; if (debase) { expression2 = Expression.Call(CachedReflectionInfo.PSObject_Base, value); nullPSObject = value.Cast(typeof(PSObject)); } else { expression2 = value.Cast(typeof(object)); nullPSObject = ExpressionCache.NullPSObject; } expression = Expression.Call(Expression.Constant(conversion.Converter), conversion.Converter.GetType().GetMethod("Invoke"), new Expression[] { expression2, Expression.Constant(resultType), ExpressionCache.Constant(true), nullPSObject, formatProvider, ExpressionCache.NullTypeTable }); } if (expression.Type.Equals(resultType) || resultType.Equals(typeof(LanguagePrimitives.InternalPSCustomObject))) { return(expression); } if (resultType.IsValueType && (Nullable.GetUnderlyingType(resultType) == null)) { return(Expression.Unbox(expression, resultType)); } return(Expression.Convert(expression, resultType)); }
private DynamicMetaObject PropertyDoesntExist(DynamicMetaObject target, BindingRestrictions restrictions) { if (!this._nonEnumerating && (target.Value != AutomationNull.Value)) { DynamicMetaObject obj2 = PSEnumerableBinder.IsEnumerable(target); if (obj2 != null) { return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.EnumerableOps_PropertyGetter, Expression.Constant(this.GetNonEnumeratingBinder()), obj2.Expression), restrictions)); } } if (base.Name.Equals("Length", StringComparison.OrdinalIgnoreCase) || base.Name.Equals("Count", StringComparison.OrdinalIgnoreCase)) { int i = (PSObject.Base(target.Value) == null) ? 0 : 1; return(new DynamicMetaObject(Expression.Condition(Compiler.IsStrictMode(2, null), this.ThrowPropertyNotFoundStrict(), ExpressionCache.Constant(i).Cast(typeof(object))), restrictions)); } return(new DynamicMetaObject(Expression.Condition(Compiler.IsStrictMode(2, null), this.ThrowPropertyNotFoundStrict(), this._nonEnumerating ? ExpressionCache.AutomationNullConstant : ExpressionCache.NullConstant), restrictions)); }
internal static BindingRestrictions GetVersionCheck(int expectedVersionNumber) { return(BindingRestrictions.GetExpressionRestriction(Expression.Equal(Expression.Field(null, CachedReflectionInfo.PSVariableAssignmentBinder__mutableValueWithInstanceMemberVersion), ExpressionCache.Constant(expectedVersionNumber)))); }
private DynamicMetaObject IndexWithNegativeChecks(DynamicMetaObject target, DynamicMetaObject index, PropertyInfo lengthProperty, Func <Expression, Expression, Expression> generateIndexOperation) { ParameterExpression expression2; ParameterExpression expression3; ParameterExpression left = Expression.Parameter(target.LimitType, "target"); Expression expr = Expression.Block(new ParameterExpression[] { left, expression2 = Expression.Parameter(typeof(int), "len"), expression3 = Expression.Parameter(typeof(int), "index") }, new Expression[] { Expression.Assign(left, target.Expression.Cast(target.LimitType)), Expression.Assign(expression2, Expression.Property(left, lengthProperty)), Expression.Assign(expression3, index.Expression), Expression.IfThen(Expression.LessThan(expression3, ExpressionCache.Constant(0)), Expression.Assign(expression3, Expression.Add(expression3, expression2))), generateIndexOperation(left, expression3) }); return(new DynamicMetaObject(this.SafeIndexResult(expr), target.CombineRestrictions(new DynamicMetaObject[] { index }))); }
private DynamicMetaObject GetIndexMultiDimensionArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion) { Array array = (Array)target.Value; if (indexes.Length == 1) { if (PSEnumerableBinder.IsEnumerable(indexes[0]) == null) { return(target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, new Expression[] { ExpressionCache.Constant(array.Rank), Expression.Dynamic(PSToStringBinder.Get(), typeof(string), indexes[0].Expression, ExpressionCache.GetExecutionContextFromTLS) })); } return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetMDArrayValueOrSlice, Expression.Convert(target.Expression, typeof(Array)), indexes[0].Expression.Cast(typeof(object))), target.CombineRestrictions(indexes))); } IEnumerable <Expression> source = from index in indexes select ConvertIndex(index, typeof(int)) into i where i != null select i; if (source.Count <Expression>() == indexes.Length) { return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetMDArrayValue, Expression.Convert(target.Expression, typeof(Array)), Expression.NewArrayInit(typeof(int), source), ExpressionCache.Constant(!this._allowSlicing)), target.CombineRestrictions(indexes))); } if (this._allowSlicing) { return(this.InvokeSlicingIndexer(target, indexes)); } return(errorSuggestion ?? this.CannotIndexTarget(target, indexes)); }
public override Expression Reduce() { List <Expression> expressions = new List <Expression>(); if (this._debugSymbolDocument != null) { expressions.Add(Expression.DebugInfo(this._debugSymbolDocument, this._extent.StartLineNumber, this._extent.StartColumnNumber, this._extent.EndLineNumber, this._extent.EndColumnNumber)); } expressions.Add(Expression.Assign(Expression.Field(Compiler._functionContext, CachedReflectionInfo.FunctionContext__currentSequencePointIndex), ExpressionCache.Constant(this._sequencePoint))); if (this._checkBreakpoints) { expressions.Add(Expression.IfThen(Expression.GreaterThan(Expression.Field(Compiler._executionContextParameter, CachedReflectionInfo.ExecutionContext_DebuggingMode), ExpressionCache.Constant(0)), Expression.Call(Expression.Field(Compiler._executionContextParameter, CachedReflectionInfo.ExecutionContext_Debugger), CachedReflectionInfo.Debugger_OnSequencePointHit, new Expression[] { Compiler._functionContext }))); } expressions.Add(ExpressionCache.Empty); return(Expression.Block(expressions)); }
private DynamicMetaObject InvokeDotNetMethod(DynamicMetaObject target, DynamicMetaObject[] args, BindingRestrictions restrictions, MethodInformation[] mi, Type errorExceptionType) { bool flag = false; object obj; string str = null; string str1 = null; int length = (int)args.Length; if (this._propertySetter) { length--; } object[] objArray = new object[length]; for (int i = 0; i < length; i++) { object value = args[i].Value; object[] objArray1 = objArray; int num = i; if (value == AutomationNull.Value) { obj = null; } else { obj = value; } objArray1[num] = obj; } MethodInformation methodInformation = Adapter.FindBestMethod(mi, this._invocationConstraints, objArray, ref str, ref str1, out flag); if (methodInformation == null) { Type[] typeArray = new Type[4]; typeArray[0] = typeof(string); typeArray[1] = typeof(Exception); typeArray[2] = typeof(string); typeArray[3] = typeof(object[]); object[] objArray2 = new object[4]; objArray2[0] = str; objArray2[2] = str1; object[] name = new object[2]; name[0] = base.Name; name[1] = base.CallInfo.ArgumentCount; objArray2[3] = name; return(new DynamicMetaObject(Compiler.CreateThrow(typeof(object), errorExceptionType, typeArray, objArray2), restrictions)); } else { MethodInfo methodInfo = (MethodInfo)methodInformation.method; Expression expression = PSInvokeMemberBinder.InvokeMethod(methodInfo, target, args, flag); if (expression.Type.Equals(typeof(void))) { expression = Expression.Block(expression, ExpressionCache.AutomationNullConstant); } if ((!(methodInfo.DeclaringType == typeof(SteppablePipeline)) || !methodInfo.Name.Equals("Begin", StringComparison.Ordinal)) && !methodInfo.Name.Equals("Process", StringComparison.Ordinal) && !methodInfo.Name.Equals("End", StringComparison.Ordinal)) { ParameterExpression parameterExpression = Expression.Variable(typeof(Exception)); CatchBlock[] catchBlockArray = new CatchBlock[1]; catchBlockArray[0] = Expression.Catch(parameterExpression, Expression.Block(Expression.Call(CachedReflectionInfo.ExceptionHandlingOps_ConvertToMethodInvocationException, parameterExpression, Expression.Constant(errorExceptionType), Expression.Constant(methodInfo.Name), ExpressionCache.Constant((int)args.Length), Expression.Constant(methodInfo)), Expression.Rethrow(typeof(object)))); expression = Expression.TryCatch(expression.Cast(typeof(object)), catchBlockArray); return(new DynamicMetaObject(expression, restrictions)); } else { return(new DynamicMetaObject(expression, restrictions)); } } }
internal static BindingRestrictions GetVersionCheck(DynamicMetaObjectBinder binder, int expectedVersionNumber) { return(BindingRestrictions.GetExpressionRestriction(Expression.Equal(Expression.Field(Expression.Constant(binder), "_version"), ExpressionCache.Constant(expectedVersionNumber)))); }
private DynamicMetaObject IndexWithNegativeChecks(DynamicMetaObject target, DynamicMetaObject index, DynamicMetaObject value, PropertyInfo lengthProperty, Func <Expression, Expression, Expression, Expression> generateIndexOperation) { DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1]; dynamicMetaObjectArray[0] = index; BindingRestrictions bindingRestriction = target.CombineRestrictions(dynamicMetaObjectArray).Merge(value.Restrictions); bindingRestriction = bindingRestriction.Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(this, target.LimitType, this._version)); ParameterExpression parameterExpression = Expression.Parameter(target.LimitType, "target"); ParameterExpression parameterExpression1 = Expression.Parameter(typeof(int), "len"); Expression expression = value.Expression; ParameterExpression parameterExpression2 = Expression.Parameter(expression.Type, "value"); ParameterExpression parameterExpression3 = Expression.Parameter(typeof(int), "index"); ParameterExpression[] parameterExpressionArray = new ParameterExpression[4]; parameterExpressionArray[0] = parameterExpression; parameterExpressionArray[1] = parameterExpression2; parameterExpressionArray[2] = parameterExpression1; parameterExpressionArray[3] = parameterExpression3; Expression[] expressionArray = new Expression[7]; expressionArray[0] = Expression.Assign(parameterExpression, target.Expression.Cast(target.LimitType)); expressionArray[1] = Expression.Assign(parameterExpression2, expression); expressionArray[2] = Expression.Assign(parameterExpression1, Expression.Property(parameterExpression, lengthProperty)); expressionArray[3] = Expression.Assign(parameterExpression3, index.Expression); expressionArray[4] = Expression.IfThen(Expression.LessThan(parameterExpression3, ExpressionCache.Constant(0)), Expression.Assign(parameterExpression3, Expression.Add(parameterExpression3, parameterExpression1))); expressionArray[5] = generateIndexOperation(parameterExpression, parameterExpression3, parameterExpression2); expressionArray[6] = parameterExpression2.Cast(typeof(object)); return(new DynamicMetaObject(Expression.Block(parameterExpressionArray, expressionArray), bindingRestriction)); }
public Expression SetValue(Compiler compiler, Expression rhs) { ParameterExpression left = Expression.Variable(rhs.Type); int count = this.ArrayLiteral.Elements.Count; List <Expression> expressions = new List <Expression> { Expression.Assign(left, rhs) }; for (int i = 0; i < count; i++) { Expression expression2 = Expression.Call(left, CachedReflectionInfo.IList_get_Item, new Expression[] { ExpressionCache.Constant(i) }); ExpressionAst ast = this.ArrayLiteral.Elements[i]; ArrayLiteralAst pureExpression = ast as ArrayLiteralAst; if (ast is ParenExpressionAst) { pureExpression = ((ParenExpressionAst)ast).Pipeline.GetPureExpression() as ArrayLiteralAst; } if (pureExpression != null) { expression2 = Expression.Dynamic(PSArrayAssignmentRHSBinder.Get(pureExpression.Elements.Count), typeof(IList), expression2); } expressions.Add(compiler.ReduceAssignment((ISupportsAssignment)ast, TokenKind.Equals, expression2)); } expressions.Add(left); return(Expression.Block(new ParameterExpression[] { left }, expressions)); }
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)); }
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))); }