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 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));
}
internal static object AsOperator(object left, Type type)
{
bool flag;
if (type == null)
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, "AsOperatorRequiresType", ParserStrings.AsOperatorRequiresType, new object[0]);
}
LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(left, type, out flag);
if (data.Rank == ConversionRank.None)
{
return(null);
}
try
{
if (flag)
{
return(data.Invoke(PSObject.Base(left), type, false, (PSObject)left, NumberFormatInfo.InvariantInfo, null));
}
return(data.Invoke(left, type, false, null, NumberFormatInfo.InvariantInfo, null));
}
catch (PSInvalidCastException)
{
return(null);
}
}
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);
}
internal bool IsMatchingType(PSTypeName psTypeName)
{
Type fromType = psTypeName.Type;
if (fromType != null)
{
bool flag = LanguagePrimitives.FigureConversion(typeof(object), this.ParameterType).Rank >= ConversionRank.AssignableS2A;
if (fromType.Equals(typeof(object)))
{
return(flag);
}
if (flag)
{
return((psTypeName.Type != null) && psTypeName.Type.Equals(typeof(object)));
}
LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(fromType, this.ParameterType);
return((data != null) && (data.Rank >= ConversionRank.NumericImplicitS2A));
}
WildcardPattern pattern = new WildcardPattern("*" + (psTypeName.Name ?? ""), WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase);
if (pattern.IsMatch(this.ParameterType.FullName))
{
return(true);
}
if (this.ParameterType.IsArray && pattern.IsMatch(this.ParameterType.GetElementType().FullName))
{
return(true);
}
if (this.Attributes != null)
{
PSTypeNameAttribute attribute = this.Attributes.OfType <PSTypeNameAttribute>().FirstOrDefault <PSTypeNameAttribute>();
if ((attribute != null) && pattern.IsMatch(attribute.PSTypeName))
{
return(true);
}
}
return(false);
}
public override DynamicMetaObject FallbackConvert(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
{
bool flag;
if (!target.HasValue)
{
return(base.Defer(target, new DynamicMetaObject[0]).WriteToDebugLog(this));
}
if (target.Value == AutomationNull.Value)
{
return(new DynamicMetaObject(Expression.Default(base.Type), target.PSGetTypeRestriction()).WriteToDebugLog(this));
}
Type resultType = base.Type;
LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(target.Value, resultType, out flag);
if ((errorSuggestion != null) && (target.Value is DynamicObject))
{
return(errorSuggestion.WriteToDebugLog(this));
}
BindingRestrictions restrictions = target.PSGetTypeRestriction().Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(this, resultType, this._version));
return(new DynamicMetaObject(InvokeConverter(conversion, target.Expression, resultType, flag, ExpressionCache.InvariantCulture), restrictions).WriteToDebugLog(this));
}
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));
}
internal DynamicMetaObject BNot(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
{
if (!target.HasValue)
{
return(base.Defer(target, new DynamicMetaObject[0]));
}
if ((target.Value is PSObject) && (PSObject.Base(target.Value) != target.Value))
{
return(this.DeferForPSObject(new DynamicMetaObject[] { target }));
}
if (target.Value == null)
{
return(new DynamicMetaObject(ExpressionCache.Constant(-1).Cast(typeof(object)), target.PSGetTypeRestriction()));
}
MethodInfo method = target.LimitType.GetMethod("op_OnesComplement", BindingFlags.Public | BindingFlags.Static, null, new Type[] { target.LimitType }, null);
if (method != null)
{
return(new DynamicMetaObject(Expression.OnesComplement(target.Expression.Cast(target.LimitType), method).Cast(typeof(object)), target.PSGetTypeRestriction()));
}
if (target.LimitType.Equals(typeof(string)))
{
return(new DynamicMetaObject(Expression.Dynamic(this, this.ReturnType, PSBinaryOperationBinder.ConvertStringToNumber(target.Expression, typeof(int))), target.PSGetTypeRestriction()));
}
Expression expression = null;
if (!target.LimitType.IsNumeric())
{
bool flag;
Type resultType = typeof(int);
LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(target.Value, resultType, out flag);
if (conversion.Rank != ConversionRank.None)
{
expression = PSConvertBinder.InvokeConverter(conversion, target.Expression, resultType, flag, ExpressionCache.InvariantCulture);
}
else
{
resultType = typeof(long);
conversion = LanguagePrimitives.FigureConversion(target.Value, resultType, out flag);
if (conversion.Rank != ConversionRank.None)
{
expression = PSConvertBinder.InvokeConverter(conversion, target.Expression, resultType, flag, ExpressionCache.InvariantCulture);
}
}
}
else
{
TypeCode typeCode = LanguagePrimitives.GetTypeCode(target.LimitType);
if (typeCode < TypeCode.Int32)
{
expression = target.Expression.Cast(typeof(int));
}
else if (typeCode <= TypeCode.UInt64)
{
expression = target.Expression.Cast(target.LimitType);
}
else
{
Type type2 = (typeCode == TypeCode.Decimal) ? typeof(DecimalOps) : typeof(DoubleOps);
Type type = (typeCode == TypeCode.Decimal) ? typeof(decimal) : typeof(double);
return(new DynamicMetaObject(Expression.Call(type2.GetMethod("BNot", BindingFlags.NonPublic | BindingFlags.Static), target.Expression.Convert(type)), target.PSGetTypeRestriction()));
}
}
if ((expression == null) && (errorSuggestion == null))
{
return(PSConvertBinder.ThrowNoConversion(target, typeof(int), this, -1, new DynamicMetaObject[0]));
}
return(new DynamicMetaObject(Expression.OnesComplement(expression).Cast(typeof(object)), target.PSGetTypeRestriction()));
}
public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
bool flag;
Type type = (Type)target.Value;
MethodInformation[] methodInformationArray = DotNetAdapter.GetMethodInformationArray(type.GetConstructors());
target = new DynamicMetaObject(target.Expression, BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value), target.Value);
string errorId = null;
string errorMsg = null;
int count = base.CallInfo.ArgumentCount - base.CallInfo.ArgumentNames.Count;
MethodInformation information = Adapter.FindBestMethod(methodInformationArray, null, (from arg in args.Take <DynamicMetaObject>(count) select arg.Value).ToArray <object>(), ref errorId, ref errorMsg, out flag);
if (information == null)
{
if (errorSuggestion == null)
{
}
return(new DynamicMetaObject(Expression.Throw(Expression.New(CachedReflectionInfo.MethodException_ctor, new Expression[] { Expression.Constant(errorId), Expression.Constant(null, typeof(Exception)), Expression.Constant(errorMsg), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(".ctor").Cast(typeof(object)), ExpressionCache.Constant(count).Cast(typeof(object)) }) }), this.ReturnType), target.CombineRestrictions(args)));
}
ConstructorInfo method = (ConstructorInfo)information.method;
ParameterInfo[] parameters = method.GetParameters();
Expression[] arguments = new Expression[parameters.Length];
int index = 0;
while (index < parameters.Length)
{
bool flag3;
Type parameterType = parameters[index].ParameterType;
if (parameters[index].GetCustomAttributes(typeof(ParamArrayAttribute), true).Any <object>() && flag)
{
Type elementType = parameters[index].ParameterType.GetElementType();
List <Expression> initializers = new List <Expression>();
int num3 = index;
int num4 = index;
while (num4 < count)
{
bool flag2;
LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(args[index].Value, elementType, out flag2);
initializers.Add(PSConvertBinder.InvokeConverter(data, args[num4].Expression, elementType, flag2, ExpressionCache.InvariantCulture));
num4++;
index++;
}
arguments[num3] = Expression.NewArrayInit(elementType, initializers);
break;
}
LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(args[index].Value, parameterType, out flag3);
arguments[index] = PSConvertBinder.InvokeConverter(conversion, args[index].Expression, parameterType, flag3, ExpressionCache.InvariantCulture);
index++;
}
Expression right = Expression.New(method, arguments);
if (base.CallInfo.ArgumentNames.Any <string>())
{
ParameterExpression expr = Expression.Parameter(right.Type);
List <Expression> expressions = new List <Expression>();
foreach (string str3 in base.CallInfo.ArgumentNames)
{
Expression expression3;
Type propertyType;
bool flag4;
MemberInfo[] infoArray3 = type.GetMember(str3, MemberTypes.Property | MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if ((infoArray3.Length != 1) || (!(infoArray3[0] is PropertyInfo) && !(infoArray3[0] is FieldInfo)))
{
return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, new Expression[] { Expression.Constant(str3), Expression.Constant(type) }));
}
MemberInfo info2 = infoArray3[0];
if (info2 is PropertyInfo)
{
PropertyInfo property = (PropertyInfo)info2;
if (property.GetSetMethod() == null)
{
return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyIsReadOnly", ParserStrings.PropertyIsReadOnly, new Expression[] { Expression.Constant(str3) }));
}
propertyType = property.PropertyType;
expression3 = Expression.Property(expr.Cast(info2.DeclaringType), property);
}
else
{
propertyType = ((FieldInfo)info2).FieldType;
expression3 = Expression.Field(expr.Cast(info2.DeclaringType), (FieldInfo)info2);
}
LanguagePrimitives.ConversionData data3 = LanguagePrimitives.FigureConversion(args[index].Value, propertyType, out flag4);
if (data3.Rank == ConversionRank.None)
{
return(PSConvertBinder.ThrowNoConversion(args[index], propertyType, this, -1, args.Except <DynamicMetaObject>(new DynamicMetaObject[] { args[index] }).Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()));
}
expressions.Add(Expression.Assign(expression3, PSConvertBinder.InvokeConverter(data3, args[index].Expression, propertyType, flag4, ExpressionCache.InvariantCulture)));
index++;
}
ParameterExpression variable = Expression.Parameter(typeof(Exception));
BlockExpression expression5 = Expression.Block(Expression.Assign(expr, right), Expression.TryCatch(Expression.Block(typeof(void), expressions), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, variable), Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Property(variable, "Message"), variable, typeof(void), new Expression[0]))) }), expr);
right = Expression.Block(new ParameterExpression[] { expr }, new Expression[] { expression5 });
}
return(new DynamicMetaObject(right, target.CombineRestrictions(args)));
}
