static Compiler()
{
int num;
DottedLocalsTupleType = MutableTuple.MakeTupleType(SpecialVariables.AutomaticVariableTypes);
DottedScriptCmdletLocalsTupleType = MutableTuple.MakeTupleType(SpecialVariables.AutomaticVariableTypes.Concat<Type>(SpecialVariables.PreferenceVariableTypes).ToArray<Type>());
DottedLocalsNameIndexMap = new Dictionary<string, int>(SpecialVariables.AutomaticVariableTypes.Length, StringComparer.OrdinalIgnoreCase);
DottedScriptCmdletLocalsNameIndexMap = new Dictionary<string, int>(SpecialVariables.AutomaticVariableTypes.Length + SpecialVariables.PreferenceVariableTypes.Length, StringComparer.OrdinalIgnoreCase);
_attributeGeneratorCache = new Dictionary<CallInfo, Delegate>();
_functionContext = Expression.Parameter(typeof(FunctionContext), "funcContext");
_executionContextParameter = Expression.Variable(typeof(System.Management.Automation.ExecutionContext), "context");
_outputPipeParameter = Expression.Variable(typeof(Pipe), "pipe");
_setDollarQuestionToTrue = Expression.Assign(Expression.Property(_executionContextParameter, CachedReflectionInfo.ExecutionContext_QuestionMarkVariableValue), ExpressionCache.TrueConstant);
_callCheckForInterrupts = Expression.Call(CachedReflectionInfo.PipelineOps_CheckForInterrupts, _executionContextParameter);
_getCurrentPipe = Expression.Field(_functionContext, CachedReflectionInfo.FunctionContext__outputPipe);
ParameterExpression variable = Expression.Variable(typeof(Exception), "exception");
_catchFlowControl = Expression.Catch(typeof(FlowControlException), Expression.Rethrow());
CatchBlock block = Expression.Catch(variable, Expression.Block(new Expression[] { Expression.Call(CachedReflectionInfo.ExceptionHandlingOps_CheckActionPreference, _functionContext, variable) }));
_stmtCatchHandlers = new CatchBlock[] { _catchFlowControl, block };
_currentExceptionBeingHandled = Expression.Property(_executionContextParameter, CachedReflectionInfo.ExecutionContext_CurrentExceptionBeingHandled);
for (num = 0; num < SpecialVariables.AutomaticVariables.Length; num++)
{
DottedLocalsNameIndexMap.Add(SpecialVariables.AutomaticVariables[num], num);
DottedScriptCmdletLocalsNameIndexMap.Add(SpecialVariables.AutomaticVariables[num], num);
}
for (num = 0; num < SpecialVariables.PreferenceVariables.Length; num++)
{
DottedScriptCmdletLocalsNameIndexMap.Add(SpecialVariables.PreferenceVariables[num], num + 9);
}
}
private new RemoteLinq.CatchBlock VisitCatch(SystemLinq.CatchBlock catchBlock)
{
var body = Visit(catchBlock.Body).Unwrap();
var filter = Visit(catchBlock.Filter).UnwrapNullable();
var variable = Visit(catchBlock.Variable).UnwrapNullable() as RemoteLinq.ParameterExpression;
return(new RemoteLinq.CatchBlock(_typeInfoProvider.GetTypeInfo(catchBlock.Test), variable, body, filter));
}
internal static CatchBlock Serialize(E.CatchBlock handler)
{
return(new CatchBlock()
{
Test = handler.Variable == null
? TypeRef.Serialize(handler.Test)
: null,
Variable = handler.Variable.Null(v => Node.Parameter(v)),
Filter = handler.Filter.Null(e => Node.Serialize(e)),
Body = Node.Serialize(handler.Body),
});
}
private static System.Linq.Expressions.CatchBlock[] ToCatchBlocks(IReadOnlyList <CatchBlock> hs)
{
if (hs == null)
{
return(Tools.Empty <System.Linq.Expressions.CatchBlock>());
}
var catchBlocks = new System.Linq.Expressions.CatchBlock[hs.Count];
for (var i = 0; i < hs.Count; ++i)
{
catchBlocks[i] = hs[i].ToCatchBlock();
}
return(catchBlocks);
}
/// <summary>
/// Checks if the specified catch <paramref name="block"/> contains an unconditional rethrow statement.
/// </summary>
/// <param name="block">The catch block to check.</param>
/// <returns><c>true</c> if the catch block has an unconditional rethrow; otherwise, <c>false</c>.</returns>
private static bool IsRethrow(CatchBlock block)
{
if (block.Filter == null)
{
if (block.Body.NodeType == ExpressionType.Throw)
{
var @throw = (UnaryExpression)block.Body;
if (@throw.Operand == null)
{
return(true);
}
}
}
return(false);
}
protected override CatchBlock VisitCatchBlock(CatchBlock node)
{
Out(Flow.NewLine, "} catch (" + node.Test.Name);
if (node.Variable != null)
{
Out(Flow.Space, node.Variable.Name ?? "");
}
if (node.Filter != null)
{
Out(") if (", Flow.Break);
Visit(node.Filter);
}
Out(") {", Flow.NewLine);
Indent();
Visit(node.Body);
Dedent();
return(node);
}
protected override CatchBlock VisitCatchBlock(CatchBlock node)
{
this.Out(Flow.NewLine, "} .Catch (" + node.Test.ToString());
if (node.Variable != null)
{
this.Out(Flow.Space, "");
this.VisitParameter(node.Variable);
}
if (node.Filter != null)
{
this.Out(") .If (", Flow.Break);
this.Visit(node.Filter);
}
this.Out(") {", Flow.NewLine);
this.Indent();
this.Visit(node.Body);
this.Dedent();
return(node);
}
protected override MSAst.CatchBlock VisitCatchBlock(MSAst.CatchBlock node)
{
MSAst.ParameterExpression v = VisitAndConvert(node.Variable, "VisitCatchBlock");
MSAst.Expression f;
MSAst.Expression b;
_insideConditionalBlock = true;
try {
f = Visit(node.Filter);
b = Visit(node.Body);
} finally {
_insideConditionalBlock = false;
}
if (v == node.Variable && b == node.Body && f == node.Filter)
{
return(node);
}
return(Ast.MakeCatchBlock(node.Test, v, b, f));
}
protected override CatchBlock VisitCatchBlock(CatchBlock node)
{
if (node.Variable != null)
{
_environment.Push(new[] { node.Variable });
}
//
// Just visit children to perform inlining of constants or defaults. Note that the parent
// try expression requires that non-trivial bindings are satisfied by the protected region
// so we don't have to worry about that over here.
//
var filter = Visit(node.Filter);
var body = Visit(node.Body);
if (node.Variable != null)
{
_environment.Pop();
}
return(node.Update(node.Variable, filter, body));
}
protected override CatchBlock VisitCatchBlock(CatchBlock node)
{
var args = new List <object>();
if (node.Variable != null)
{
args.Add(new XElement(nameof(node.Variable), Visit(node.Variable)));
}
else
{
args.Add(new XAttribute(nameof(node.Test), node.Test));
}
args.Add(new XElement(nameof(node.Body), Visit(node.Body)));
if (node.Filter != null)
{
args.Add(new XElement(nameof(node.Filter), Visit(node.Filter)));
}
_nodes.Push(new XElement(nameof(CatchBlock), args));
return(node);
}
public CatchBlockProxy(CatchBlock node)
{
ArgumentNullException.ThrowIfNull(node);
_node = node;
}
protected virtual new CatchBlock VisitCatchBlock(CatchBlock node)
{
Contract.Requires(node != null);
return(default(CatchBlock));
}
public CatchBlockProxy(CatchBlock node)
{
ContractUtils.RequiresNotNull(node, nameof(node));
_node = node;
}
public CatchBlockProxy(CatchBlock node)
{
_node = node;
}
private static CatchBlock[] GenerateLoopBreakContinueCatchBlocks(string label, LabelTarget breakLabel, LabelTarget continueLabel)
{
ParameterExpression variable = Expression.Parameter(typeof(BreakException));
ParameterExpression expression2 = Expression.Parameter(typeof(ContinueException));
CatchBlock[] blockArray = new CatchBlock[2];
Expression[] arguments = new Expression[] { Expression.Constant(label ?? "", typeof(string)) };
blockArray[0] = Expression.Catch(variable, Expression.IfThenElse(Expression.Call(variable, CachedReflectionInfo.LoopFlowException_MatchLabel, arguments), Expression.Break(breakLabel), Expression.Rethrow()));
Expression[] expressionArray2 = new Expression[] { Expression.Constant(label ?? "", typeof(string)) };
blockArray[1] = Expression.Catch(expression2, Expression.IfThenElse(Expression.Call(expression2, CachedReflectionInfo.LoopFlowException_MatchLabel, expressionArray2), Expression.Continue(continueLabel), Expression.Rethrow()));
return blockArray;
}
protected override CatchBlock VisitCatchBlock(CatchBlock node)
{
return node; // NB: In nested catch blocks, the meaning of a rethrow changes.
}
public override DLR.Expression Generate(AplusScope scope)
{
// TODO: Add usage of Protected Execute Flag
// Save the previous return target
DLR.LabelTarget oldTarget = scope.ReturnTarget;
scope.ReturnTarget = DLR.Expression.Label(typeof(AType), "EXIT");
DLR.Expression protectedCode = DLR.Expression.Label(
scope.ReturnTarget,
this.codeblock.Generate(scope)
);
// Restore the return target;
scope.ReturnTarget = oldTarget;
// Code block contining the strandard execution's result
// wrapped in a strand
DLR.Expression block =
DLR.Expression.Call(
typeof(Runtime.Helpers).GetMethod("BuildStrand"),
DLR.Expression.NewArrayInit(
typeof(AType),
// We need to pass in reverse order
protectedCode,
DLR.Expression.Constant(AInteger.Create(0), typeof(AType))
)
);
// Parameter for Catch block
DLR.ParameterExpression errorVariable = DLR.Expression.Parameter(typeof(Error), "error");
// Catch block, returns the ([errorcode]; [errortext]) strand
DLR.CatchBlock catchBlock = DLR.Expression.Catch(
errorVariable,
DLR.Expression.Call(
typeof(Runtime.Helpers).GetMethod("BuildStrand"),
DLR.Expression.NewArrayInit(
typeof(AType),
// We need to pass in reverse order
// Error Text
DLR.Expression.Call(
typeof(Runtime.Helpers).GetMethod("BuildString"),
DLR.Expression.Property(errorVariable, "ErrorText")
),
// Error Code
DLR.Expression.Call(
typeof(AInteger).GetMethod("Create", new Type[] { typeof(int) }),
DLR.Expression.Convert(
DLR.Expression.Property(errorVariable, "ErrorType"),
typeof(int)
)
)
)
)
);
DLR.Expression result = DLR.Expression.TryCatch(
block,
catchBlock
);
return(result);
}
protected virtual new CatchBlock VisitCatchBlock(CatchBlock node)
{
return(default(CatchBlock));
}
/// <summary>
/// Checks if the specified catch <paramref name="block"/> in unreachable due to a constant filter
/// expression that always returns <c>false</c>.
/// </summary>
/// <param name="block">The catch block to check.</param>
/// <returns><c>true</c> if the catch block is unreachable; otherwise, <c>false</c>.</returns>
private bool HasUnreachableFilter(CatchBlock block)
{
var filter = block.Filter;
return(filter != null && HasConstantValue(filter) && !(bool)GetConstantValue(filter));
}
/// <summary>
/// Gets the debug view for the specified catch block.
/// </summary>
/// <param name="catchBlock">The catch block to get a debug view for.</param>
/// <returns>Debug view for the specified catch block.</returns>
public XNode GetDebugView(CatchBlock catchBlock)
{
return(Visit(catchBlock));
}
protected virtual CatchBlock VisitCatchBlock(CatchBlock node)
{
throw new NotImplementedException();
}
/// <summary>
/// Makes a catch block slim object representing a CatchBlock with the given children.
/// </summary>
/// <param name="node">Original catch block.</param>
/// <param name="variable">Variable expression slim.</param>
/// <param name="body">Body expression slim.</param>
/// <param name="filter">Filter expression slim.</param>
/// <returns>Slim representation of the original catch block.</returns>
protected override CatchBlockSlim MakeCatchBlock(CatchBlock node, ParameterExpressionSlim variable, ExpressionSlim body, ExpressionSlim filter)
{
var test = MakeType(node.Test);
return(_factory.MakeCatchBlock(test, variable, body, filter));
}
private CatchBlock VisitCatchBlockExtracted(CatchBlock node)
{
return(node.Update(node.Variable == null ? null : VisitAndConvert(node.Variable, nameof(VisitCatchBlock)), Visit(node.Filter), Visit(node.Body)));
}
private DynamicMetaObject BinaryComparision(DynamicMetaObject target, DynamicMetaObject arg, Func<Expression, Expression> toResult)
{
bool flag = false;
Expression expression;
Expression boxedTrue;
Expression expression1;
Expression stringComparisonInvariantCultureIgnoreCase;
if (!target.LimitType.Equals(typeof(string)))
{
Type limitType = target.LimitType;
LanguagePrimitives.ConversionData conversionDatum = LanguagePrimitives.FigureConversion(arg.Value, limitType, out flag);
DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
dynamicMetaObjectArray[0] = arg;
BindingRestrictions bindingRestriction = target.CombineRestrictions(dynamicMetaObjectArray);
bindingRestriction = bindingRestriction.Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(this, limitType, this._version));
if (conversionDatum.Rank != ConversionRank.Identity)
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(InvalidCastException));
CatchBlock[] catchBlockArray = new CatchBlock[1];
Expression[] expressionArray = new Expression[3];
expressionArray[0] = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), target.Expression, ExpressionCache.GetExecutionContextFromTLS);
expressionArray[1] = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), arg.Expression, ExpressionCache.GetExecutionContextFromTLS);
expressionArray[2] = Expression.Property(parameterExpression, CachedReflectionInfo.Exception_Message);
catchBlockArray[0] = Expression.Catch(parameterExpression, Compiler.ThrowRuntimeErrorWithInnerException("ComparisonFailure", Expression.Constant(ExtendedTypeSystem.ComparisonFailure), parameterExpression, limitType, expressionArray));
expression = Expression.TryCatch(PSConvertBinder.InvokeConverter(conversionDatum, arg.Expression, limitType, flag, ExpressionCache.InvariantCulture), catchBlockArray);
}
else
{
expression = arg.Expression;
}
if (target.LimitType.Equals(arg.LimitType))
{
Type[] interfaces = target.Value.GetType().GetInterfaces();
int num = 0;
while (num < (int)interfaces.Length)
{
Type type = interfaces[num];
if (!type.IsGenericType || !(type.GetGenericTypeDefinition() == typeof(IComparable<>)))
{
num++;
}
else
{
Expression[] expressionArray1 = new Expression[1];
expressionArray1[0] = expression.Cast(arg.LimitType);
DynamicMetaObject dynamicMetaObject = new DynamicMetaObject(toResult(Expression.Call(Expression.Convert(target.Expression, type), type.GetMethod("CompareTo"), expressionArray1)).Cast(typeof(object)), bindingRestriction);
return dynamicMetaObject;
}
}
}
if (target.Value as IComparable == null)
{
Expression[] expression2 = new Expression[1];
expression2[0] = target.Expression;
Expression expression3 = Compiler.ThrowRuntimeError("NotIcomparable", ExtendedTypeSystem.NotIcomparable, this.ReturnType, expression2);
Expression[] expressionArray2 = new Expression[1];
expressionArray2[0] = arg.Expression.Cast(typeof(object));
MethodCallExpression methodCallExpression = Expression.Call(target.Expression.Cast(typeof(object)), CachedReflectionInfo.Object_Equals, expressionArray2);
if (base.Operation == ExpressionType.GreaterThanOrEqual || base.Operation == ExpressionType.LessThanOrEqual)
{
boxedTrue = ExpressionCache.BoxedTrue;
}
else
{
boxedTrue = ExpressionCache.BoxedFalse;
}
return new DynamicMetaObject(Expression.Condition(methodCallExpression, boxedTrue, expression3), bindingRestriction);
}
else
{
Expression[] expressionArray3 = new Expression[1];
expressionArray3[0] = expression.Cast(typeof(object));
return new DynamicMetaObject(toResult(Expression.Call(target.Expression.Cast(typeof(IComparable)), CachedReflectionInfo.IComparable_CompareTo, expressionArray3)).Cast(typeof(object)), bindingRestriction);
}
}
else
{
Expression expression4 = target.Expression.Cast(typeof(string));
if (!arg.LimitType.Equals(typeof(string)))
{
expression1 = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), arg.Expression, ExpressionCache.GetExecutionContextFromTLS);
}
else
{
expression1 = arg.Expression.Cast(typeof(string));
}
Expression expression5 = expression1;
MethodInfo stringCompare = CachedReflectionInfo.String_Compare;
Expression expression6 = expression4;
Expression expression7 = expression5;
if (this._ignoreCase)
{
stringComparisonInvariantCultureIgnoreCase = ExpressionCache.StringComparisonInvariantCultureIgnoreCase;
}
else
{
stringComparisonInvariantCultureIgnoreCase = ExpressionCache.StringComparisonInvariantCulture;
}
MethodCallExpression methodCallExpression1 = Expression.Call(stringCompare, expression6, expression7, stringComparisonInvariantCultureIgnoreCase);
DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
dynamicMetaObjectArray1[0] = arg;
return new DynamicMetaObject(toResult(methodCallExpression1).Cast(typeof(object)), target.CombineRestrictions(dynamicMetaObjectArray1));
}
}
public CatchBlockProxy(CatchBlock node)
{
ContractUtils.RequiresNotNull(node, nameof(node));
_node = node;
}
private static CatchBlock VisitCatchBlock(CatchBlock node)
{
throw new NotImplementedException();
}
public virtual bool IsEvaluatableCatchBlock (CatchBlock node)
{
ArgumentUtility.CheckNotNull ("node", node);
return true;
}
public virtual void Write (CatchBlock block)
{
VisitCatchBlock (block);
}
public CatchBlockProxy(CatchBlock node) {
_node = node;
}
private DynamicMetaObject BinaryNumericStringOp(DynamicMetaObject target, DynamicMetaObject arg)
{
Expression number;
Expression boxedFalse;
List<ParameterExpression> parameterExpressions = new List<ParameterExpression>();
List<Expression> expressions = new List<Expression>();
Expression expression = target.Expression;
if (target.LimitType.Equals(typeof(string)))
{
expression = PSBinaryOperationBinder.ConvertStringToNumber(target.Expression, arg.LimitType);
}
if (arg.LimitType.Equals(typeof(string)))
{
number = PSBinaryOperationBinder.ConvertStringToNumber(arg.Expression, target.LimitType);
}
else
{
number = arg.Expression;
}
Expression expression1 = number;
expressions.Add(Expression.Dynamic(PSBinaryOperationBinder.Get(base.Operation, true, false), typeof(object), expression, expression1));
Expression expression2 = Expression.Block(parameterExpressions, expressions);
if (base.Operation == ExpressionType.Equal || base.Operation == ExpressionType.NotEqual)
{
Expression expression3 = expression2;
CatchBlock[] catchBlockArray = new CatchBlock[1];
CatchBlock[] catchBlockArray1 = catchBlockArray;
int num = 0;
Type type = typeof(InvalidCastException);
if (base.Operation == ExpressionType.Equal)
{
boxedFalse = ExpressionCache.BoxedFalse;
}
else
{
boxedFalse = ExpressionCache.BoxedTrue;
}
catchBlockArray1[num] = Expression.Catch(type, boxedFalse);
expression2 = Expression.TryCatch(expression3, catchBlockArray);
}
DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
dynamicMetaObjectArray[0] = arg;
return new DynamicMetaObject(expression2, target.CombineRestrictions(dynamicMetaObjectArray));
}
/// <summary>
/// Visits the children of the <see cref="CatchBlock"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected virtual CatchBlock VisitCatchBlock(CatchBlock node)
{
return(node.Update(VisitAndConvert(node.Variable, nameof(VisitCatchBlock)), Visit(node.Filter), Visit(node.Body)));
}
static Compiler()
{
_functionContext = Expression.Parameter(typeof(FunctionContext), "funcContext");
_executionContextParameter = Expression.Variable(typeof(ExecutionContext), "context");
s_setDollarQuestionToTrue = Expression.Assign(
Expression.Property(_executionContextParameter, CachedReflectionInfo.ExecutionContext_QuestionMarkVariableValue),
ExpressionCache.TrueConstant);
s_callCheckForInterrupts = Expression.Call(CachedReflectionInfo.PipelineOps_CheckForInterrupts,
_executionContextParameter);
s_getCurrentPipe = Expression.Field(_functionContext, CachedReflectionInfo.FunctionContext__outputPipe);
_returnPipe = Expression.Variable(s_getCurrentPipe.Type, "returnPipe");
var exception = Expression.Variable(typeof(Exception), "exception");
s_catchFlowControl = Expression.Catch(typeof(FlowControlException), Expression.Rethrow());
var catchAll = Expression.Catch(
exception,
Expression.Block(
Expression.Call(
CachedReflectionInfo.ExceptionHandlingOps_CheckActionPreference,
Compiler._functionContext, exception)));
_stmtCatchHandlers = new CatchBlock[] { s_catchFlowControl, catchAll };
s_currentExceptionBeingHandled = Expression.Property(
_executionContextParameter, CachedReflectionInfo.ExecutionContext_CurrentExceptionBeingHandled);
int i;
for (i = 0; i < SpecialVariables.AutomaticVariables.Length; ++i)
{
DottedLocalsNameIndexMap.Add(SpecialVariables.AutomaticVariables[i], i);
DottedScriptCmdletLocalsNameIndexMap.Add(SpecialVariables.AutomaticVariables[i], i);
}
for (i = 0; i < SpecialVariables.PreferenceVariables.Length; ++i)
{
DottedScriptCmdletLocalsNameIndexMap.Add(SpecialVariables.PreferenceVariables[i],
i + (int)AutomaticVariable.NumberOfAutomaticVariables);
}
s_builtinAttributeGenerator.Add(typeof(CmdletBindingAttribute), NewCmdletBindingAttribute);
s_builtinAttributeGenerator.Add(typeof(ParameterAttribute), NewParameterAttribute);
s_builtinAttributeGenerator.Add(typeof(OutputTypeAttribute), NewOutputTypeAttribute);
s_builtinAttributeGenerator.Add(typeof(AliasAttribute), NewAliasAttribute);
s_builtinAttributeGenerator.Add(typeof(ValidateSetAttribute), NewValidateSetAttribute);
s_builtinAttributeGenerator.Add(typeof(DebuggerHiddenAttribute), NewDebuggerHiddenAttribute);
s_builtinAttributeGenerator.Add(typeof(ValidateNotNullAttribute), NewValidateNotNullAttribute);
s_builtinAttributeGenerator.Add(typeof(ValidateNotNullOrEmptyAttribute), NewValidateNotNullOrEmptyAttribute);
}
protected override CatchBlock VisitCatchBlock(CatchBlock node)
{
throw new NotSupportedException();
}
//protected internal virtual Expression VisitBinary(BinaryExpression node)
//{
// return (Expression)null;
//}
//protected internal virtual Expression VisitBlock(BlockExpression node)
//{
// return (Expression)null;
//}
protected virtual CatchBlock VisitCatchBlock(CatchBlock node)
{
return((CatchBlock)null);
}
private DynamicMetaObject BinaryEqualityComparison(DynamicMetaObject target, DynamicMetaObject arg)
{
bool flag = false;
Func<Expression, Expression> func;
MethodInfo charOpsCompareIeq;
Expression expression;
if (base.Operation == ExpressionType.NotEqual)
{
func = new Func<Expression, Expression>(Expression.Not);
}
else
{
func = (Expression e) => e;
}
Func<Expression, Expression> func1 = func;
if (!target.LimitType.Equals(typeof(string)))
{
if (target.LimitType.Equals(typeof(char)) && this._ignoreCase)
{
Expression expression1 = null;
BindingRestrictions bindingRestriction = null;
if (!arg.LimitType.Equals(typeof(char)))
{
string value = arg.Value as string;
if (value != null && value.Length == 1)
{
Expression[] expressionArray = new Expression[1];
expressionArray[0] = ExpressionCache.Constant(0);
expression1 = Expression.Call(arg.Expression.Cast(typeof(string)), CachedReflectionInfo.String_get_Chars, expressionArray);
bindingRestriction = arg.PSGetTypeRestriction().Merge(BindingRestrictions.GetExpressionRestriction(Expression.Equal(Expression.Property(arg.Expression.Cast(typeof(string)), CachedReflectionInfo.String_Length), ExpressionCache.Constant(1))));
}
}
else
{
expression1 = arg.Expression;
bindingRestriction = arg.PSGetTypeRestriction();
}
if (expression1 != null)
{
if (base.Operation == ExpressionType.Equal)
{
charOpsCompareIeq = CachedReflectionInfo.CharOps_CompareIeq;
}
else
{
charOpsCompareIeq = CachedReflectionInfo.CharOps_CompareIne;
}
return new DynamicMetaObject(Expression.Call(charOpsCompareIeq, target.Expression.Cast(typeof(char)), expression1.Cast(typeof(char))), target.PSGetTypeRestriction().Merge(bindingRestriction));
}
}
Expression[] expressionArray1 = new Expression[1];
expressionArray1[0] = arg.Expression.Cast(typeof(object));
Expression expression2 = Expression.Call(target.Expression.Cast(typeof(object)), CachedReflectionInfo.Object_Equals, expressionArray1);
Type limitType = target.LimitType;
LanguagePrimitives.ConversionData conversionDatum = LanguagePrimitives.FigureConversion(arg.Value, limitType, out flag);
if (conversionDatum.Rank != ConversionRank.Identity)
{
DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
dynamicMetaObjectArray[0] = arg;
BindingRestrictions bindingRestriction1 = target.CombineRestrictions(dynamicMetaObjectArray);
bindingRestriction1 = bindingRestriction1.Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(this, limitType, this._version));
ParameterExpression parameterExpression = Expression.Parameter(typeof(bool));
Expression[] expressionArray2 = new Expression[1];
expressionArray2[0] = PSConvertBinder.InvokeConverter(conversionDatum, arg.Expression, limitType, flag, ExpressionCache.InvariantCulture).Cast(typeof(object));
Expression expression3 = Expression.Call(target.Expression.Cast(typeof(object)), CachedReflectionInfo.Object_Equals, expressionArray2);
ParameterExpression[] parameterExpressionArray = new ParameterExpression[1];
parameterExpressionArray[0] = parameterExpression;
Expression[] expressionArray3 = new Expression[3];
expressionArray3[0] = Expression.Assign(parameterExpression, expression2);
CatchBlock[] catchBlockArray = new CatchBlock[1];
catchBlockArray[0] = Expression.Catch(typeof(InvalidCastException), Expression.Assign(parameterExpression, ExpressionCache.Constant(false)));
expressionArray3[1] = Expression.IfThen(Expression.Not(parameterExpression), Expression.TryCatch(Expression.Assign(parameterExpression, expression3), catchBlockArray));
expressionArray3[2] = func1(parameterExpression);
BlockExpression blockExpression = Expression.Block(parameterExpressionArray, expressionArray3);
return new DynamicMetaObject(blockExpression.Cast(typeof(object)), bindingRestriction1);
}
else
{
DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
dynamicMetaObjectArray1[0] = arg;
return new DynamicMetaObject(func1(expression2).Cast(typeof(object)), target.CombineRestrictions(dynamicMetaObjectArray1));
}
}
else
{
Expression expression4 = target.Expression.Cast(typeof(string));
if (!arg.LimitType.Equals(typeof(string)))
{
expression = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), arg.Expression, ExpressionCache.GetExecutionContextFromTLS);
}
else
{
expression = arg.Expression.Cast(typeof(string));
}
Expression expression5 = expression;
DynamicMetaObject[] dynamicMetaObjectArray2 = new DynamicMetaObject[1];
dynamicMetaObjectArray2[0] = arg;
return new DynamicMetaObject(func1(Compiler.CallStringEquals(expression4, expression5, this._ignoreCase)).Cast(typeof(object)), target.CombineRestrictions(dynamicMetaObjectArray2));
}
}
protected virtual CatchBlock VisitCatchBlock(CatchBlock node)
{
return(node.Update(this.VisitAndConvert <ParameterExpression>(node.Variable, "VisitCatchBlock"), this.Visit(node.Filter), this.Visit(node.Body)));
}
private DynamicMetaObject BinaryNumericOp(string methodName, DynamicMetaObject target, DynamicMetaObject arg)
{
TypeCode typeCode;
Expression boxedFalse;
Type type = null;
Type type1 = null;
TypeCode typeCode1 = LanguagePrimitives.GetTypeCode(target.LimitType);
TypeCode typeCode2 = LanguagePrimitives.GetTypeCode(arg.LimitType);
if (typeCode1 >= typeCode2)
{
typeCode = typeCode1;
}
else
{
typeCode = typeCode2;
}
TypeCode typeCode3 = typeCode;
if (typeCode3 > TypeCode.Int32)
{
if (typeCode3 > TypeCode.UInt32)
{
if (typeCode3 > TypeCode.Int64)
{
if (typeCode3 > TypeCode.UInt64)
{
if (typeCode3 != TypeCode.Decimal)
{
type = typeof(DoubleOps);
type1 = typeof(double);
}
else
{
if (methodName.StartsWith("Compare", StringComparison.Ordinal))
{
if (!LanguagePrimitives.IsFloating(typeCode1))
{
if (LanguagePrimitives.IsFloating(typeCode2))
{
DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
dynamicMetaObjectArray[0] = arg;
return new DynamicMetaObject(Expression.Call(typeof(DecimalOps).GetMethod(string.Concat(methodName, "2"), BindingFlags.Static | BindingFlags.NonPublic), target.Expression.Cast(target.LimitType).Cast(typeof(decimal)), arg.Expression.Cast(arg.LimitType).Cast(typeof(double))), target.CombineRestrictions(dynamicMetaObjectArray));
}
}
else
{
DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
dynamicMetaObjectArray1[0] = arg;
return new DynamicMetaObject(Expression.Call(typeof(DecimalOps).GetMethod(string.Concat(methodName, "1"), BindingFlags.Static | BindingFlags.NonPublic), target.Expression.Cast(target.LimitType).Cast(typeof(double)), arg.Expression.Cast(arg.LimitType).Cast(typeof(decimal))), target.CombineRestrictions(dynamicMetaObjectArray1));
}
}
type = typeof(DecimalOps);
type1 = typeof(decimal);
}
}
else
{
if (!LanguagePrimitives.IsSignedInteger(typeCode1))
{
if (LanguagePrimitives.IsSignedInteger(typeCode2))
{
arg = PSBinaryOperationBinder.FigureSignedUnsignedInt(arg, typeCode2, out type, out type1);
}
}
else
{
target = PSBinaryOperationBinder.FigureSignedUnsignedInt(target, typeCode1, out type, out type1);
}
if (type == null)
{
type = typeof(ULongOps);
type1 = typeof(ulong);
}
}
}
else
{
type = typeof(LongOps);
type1 = typeof(long);
}
}
else
{
if (!LanguagePrimitives.IsSignedInteger(typeCode1))
{
if (LanguagePrimitives.IsSignedInteger(typeCode2))
{
arg = PSBinaryOperationBinder.FigureSignedUnsignedInt(arg, typeCode2, out type, out type1);
}
}
else
{
target = PSBinaryOperationBinder.FigureSignedUnsignedInt(target, typeCode1, out type, out type1);
}
if (type == null)
{
type = typeof(UIntOps);
type1 = typeof(int);
}
}
}
else
{
type = typeof(IntOps);
type1 = typeof(int);
}
Expression expression = Expression.Call(type.GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic), target.Expression.Cast(target.LimitType).Cast(type1), arg.Expression.Cast(arg.LimitType).Cast(type1));
if (base.Operation == ExpressionType.Equal || base.Operation == ExpressionType.NotEqual)
{
Expression expression1 = expression;
CatchBlock[] catchBlockArray = new CatchBlock[1];
CatchBlock[] catchBlockArray1 = catchBlockArray;
int num = 0;
Type type2 = typeof(InvalidCastException);
if (base.Operation == ExpressionType.Equal)
{
boxedFalse = ExpressionCache.BoxedFalse;
}
else
{
boxedFalse = ExpressionCache.BoxedTrue;
}
catchBlockArray1[num] = Expression.Catch(type2, boxedFalse);
expression = Expression.TryCatch(expression1, catchBlockArray);
}
DynamicMetaObject[] dynamicMetaObjectArray2 = new DynamicMetaObject[1];
dynamicMetaObjectArray2[0] = arg;
return new DynamicMetaObject(expression, target.CombineRestrictions(dynamicMetaObjectArray2));
}
private Variable VisitCatchBlock(CatchBlock node)
{
throw new NotSupportedException();
//this.Out("catch (" + node.Test.Name);
//if (node.Variable != null)
//{
// this.Out(node.Variable.Name ?? "");
//}
//this.Out(") { ... }");
}
