public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// This can be used for a denial of service
// Write-Output (((((("AAAAAAAAAAAAAAAAAAAAAA"*2)*2)*2)*2)*2)*2)
// Keep on going with that pattern, and we're generating gigabytes of strings.
throw PSTraceSource.NewArgumentException("ast");
}
private static bool IsNullDivisor(ExpressionAst operand)
{
VariableExpressionAst ast = operand as VariableExpressionAst;
if (ast != null)
{
BinaryExpressionAst parent = operand.Parent as BinaryExpressionAst;
if ((parent == null) || (parent.Right != operand))
{
return(false);
}
switch (parent.Operator)
{
case TokenKind.Divide:
case TokenKind.Rem:
case TokenKind.DivideEquals:
case TokenKind.RemainderEquals:
{
string unqualifiedPath = ast.VariablePath.UnqualifiedPath;
if (!unqualifiedPath.Equals("false", StringComparison.OrdinalIgnoreCase))
{
return(unqualifiedPath.Equals("null", StringComparison.OrdinalIgnoreCase));
}
return(true);
}
}
}
return(false);
}
private bool IncorrectComparisonWithNull(BinaryExpressionAst binExpressionAst, Ast ast)
{
if ((binExpressionAst.Operator.Equals(TokenKind.Equals) || binExpressionAst.Operator.Equals(TokenKind.Ceq)
|| binExpressionAst.Operator.Equals(TokenKind.Cne) || binExpressionAst.Operator.Equals(TokenKind.Ine) || binExpressionAst.Operator.Equals(TokenKind.Ieq))
&& binExpressionAst.Right.Extent.Text.Equals("$null", StringComparison.OrdinalIgnoreCase))
{
if (binExpressionAst.Left.StaticType.IsArray)
{
return true;
}
else if (binExpressionAst.Left is VariableExpressionAst)
{
// ignores if the variable is a special variable
if (!Helper.Instance.HasSpecialVars((binExpressionAst.Left as VariableExpressionAst).VariablePath.UserPath))
{
Type lhsType = Helper.Instance.GetTypeFromAnalysis(binExpressionAst.Left as VariableExpressionAst, ast);
if (lhsType == null)
{
return true;
}
else if (lhsType.IsArray || lhsType == typeof(object) || lhsType == typeof(Undetermined) || lhsType == typeof(Unreached))
{
return true;
}
}
}
else if (binExpressionAst.Left.StaticType == typeof(object))
{
return true;
}
}
return false;
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// This can be used for a denial of service
// Write-Output (((((("AAAAAAAAAAAAAAAAAAAAAA"*2)*2)*2)*2)*2)*2)
// Keep on going with that pattern, and we're generating gigabytes of strings.
return(false);
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if ((binaryExpressionAst.Operator == TokenKind.AndAnd) || (binaryExpressionAst.Operator == TokenKind.OrOr))
{
this._parser.ReportError(binaryExpressionAst.ErrorPosition, ParserStrings.InvalidEndOfLine, new object[] { binaryExpressionAst.Operator.Text() });
}
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if (binaryExpressionAst.Operator.HasTrait(TokenFlags.DisallowedInRestrictedMode))
{
this.ReportError(binaryExpressionAst.ErrorPosition, () => ParserStrings.OperatorNotSupportedInDataSection, new object[] { binaryExpressionAst.Operator.Text() });
}
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// Important: never enumerate when writing to pipeline
// Array replication is a binary expression. Replicated arrays might be huge, writing all
// elements to pipeline can cause crucial performance issues if the array is needed again
this._pipelineCommandRuntime.WriteObject(EvaluateBinaryExpression(binaryExpressionAst), false);
return AstVisitAction.SkipChildren;
}
public System.Object VisitBinaryExpression(System.Management.Automation.Language.BinaryExpressionAst binaryExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(binaryExpressionAst.Extent);
IScriptExtent mappedErrorExtent = MapExtent(binaryExpressionAst.ErrorPosition);
ExpressionAst mappedLeft = _VisitExpression(binaryExpressionAst.Left);
ExpressionAst mappedRight = _VisitExpression(binaryExpressionAst.Right);
return(new BinaryExpressionAst(mappedExtent, mappedLeft, binaryExpressionAst.Operator, mappedRight, mappedErrorExtent));
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if ((binaryExpressionAst.Operator == TokenKind.And) || (binaryExpressionAst.Operator == TokenKind.Or))
{
binaryExpressionAst.Left.Accept(this);
Block next = new Block();
Block block2 = new Block();
this._currentBlock.FlowsTo(next);
this._currentBlock.FlowsTo(block2);
this._currentBlock = block2;
binaryExpressionAst.Right.Accept(this);
this._currentBlock.FlowsTo(next);
this._currentBlock = next;
}
else
{
binaryExpressionAst.Left.Accept(this);
binaryExpressionAst.Right.Accept(this);
}
return(null);
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return CompileAndInvoke(binaryExpressionAst);
}
private ExpressionAst ExpressionRule()
{
//G expression:
//G logical-expression
//G
//G logical-expression:
//G bitwise-expression
//G logical-expression '-and' new-lines:opt bitwise-expression
//G logical-expression '-or' new-lines:opt bitwise-expression
//G logical-expression '-xor' new-lines:opt bitwise-expression
//G
//G bitwise-expression:
//G comparison-expression
//G bitwise-expression '-band' new-lines:opt comparison-expression
//G bitwise-expression '-bor' new-lines:opt comparison-expression
//G bitwise-expression '-bxor' new-lines:opt comparison-expression
//G
//G comparison-expression:
//G additive-expression
//G comparison-expression comparison-operator new-lines:opt additive-expression
//G
//G additive-expression:
//G multiplicative-expression
//G additive-expression '+' new-lines:opt multiplicative-expression
//G additive-expression dash new-lines:opt multiplicative-expression
//G
//G multiplicative-expression:
//G format-expression
//G multiplicative-expression '*' new-lines:opt format-expression
//G multiplicative-expression '/' new-lines:opt format-expression
//G multiplicative-expression '%' new-lines:opt format-expression
//G
//G format-expression:
//G range-expression
//G format-expression format-operator new-lines:opt range-expression
//G
//G range-expression:
//G array-literal-expression
//G range-expression '..' new-lines:opt array-literal-expression
RuntimeHelpers.EnsureSufficientExecutionStack();
var oldTokenizerMode = _tokenizer.Mode;
try
{
SetTokenizerMode(TokenizerMode.Expression);
ExpressionAst lhs, rhs;
ExpressionAst expr = ArrayLiteralRule();
if (expr == null)
{
return null;
}
ParameterToken paramToken;
Token token = PeekToken();
if (!token.Kind.HasTrait(TokenFlags.BinaryOperator))
{
paramToken = token as ParameterToken;
if (paramToken != null)
{
return ErrorRecoveryParameterInExpression(paramToken, expr);
}
return expr;
}
SkipToken();
Stack<ExpressionAst> operandStack = new Stack<ExpressionAst>();
Stack<Token> operatorStack = new Stack<Token>();
operandStack.Push(expr);
operatorStack.Push(token);
int precedence = token.Kind.GetBinaryPrecedence();
while (true)
{
SkipNewlines();
expr = ArrayLiteralRule();
if (expr == null)
{
// ErrorRecovery: create an error expression to fill out the ast and keep parsing.
IScriptExtent extent = After(token);
// Use token.Text, not token.Kind.Text() b/c the kind might not match the actual operator used
// when a case insensitive operator is used.
ReportIncompleteInput(extent, () => ParserStrings.ExpectedValueExpression, token.Text);
expr = new ErrorExpressionAst(extent);
}
operandStack.Push(expr);
token = NextToken();
if (!token.Kind.HasTrait(TokenFlags.BinaryOperator))
{
// Remember the token that we stopped on, but only parameters, used for error recovery
paramToken = token as ParameterToken;
UngetToken(token);
break;
}
int newPrecedence = token.Kind.GetBinaryPrecedence();
while (newPrecedence <= precedence)
{
rhs = operandStack.Pop();
lhs = operandStack.Pop();
Token op = operatorStack.Pop();
operandStack.Push(new BinaryExpressionAst(ExtentOf(lhs, rhs), lhs, op.Kind, rhs, op.Extent));
if (operatorStack.Count == 0)
break;
precedence = operatorStack.Peek().Kind.GetBinaryPrecedence();
}
operatorStack.Push(token);
precedence = newPrecedence;
}
rhs = operandStack.Pop();
Diagnostics.Assert(operandStack.Count == operatorStack.Count, "Stacks out of sync");
while (operandStack.Count > 0)
{
lhs = operandStack.Pop();
token = operatorStack.Pop();
rhs = new BinaryExpressionAst(ExtentOf(lhs, rhs), lhs, token.Kind, rhs, token.Extent);
}
if (paramToken != null)
{
return ErrorRecoveryParameterInExpression(paramToken, rhs);
}
return rhs;
}
finally
{
SetTokenizerMode(oldTokenizerMode);
}
}
object EvaluateBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
var leftOperand = EvaluateAst(binaryExpressionAst.Left);
var rightOperand = EvaluateAst(binaryExpressionAst.Right);
if (leftOperand is PSObject) leftOperand = ((PSObject)leftOperand).BaseObject;
if (rightOperand is PSObject) rightOperand = ((PSObject)rightOperand).BaseObject;
int? leftOperandInt = leftOperand is int ? ((int?)leftOperand) : null;
int? rightOperandInt = rightOperand is int ? ((int?)rightOperand) : null;
bool? leftOperandBool = leftOperand is bool ? ((bool?)leftOperand) : null;
bool? rightOperandBool = rightOperand is bool ? ((bool?)rightOperand) : null;
switch (binaryExpressionAst.Operator)
{
case TokenKind.DotDot:
return Range((int)leftOperand, (int)rightOperand);
case TokenKind.Plus:
return Add(leftOperand, rightOperand);
case TokenKind.Ieq:
if (leftOperandInt.HasValue) return leftOperandInt == rightOperandInt;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Ine:
if (leftOperandInt.HasValue) return leftOperandInt != rightOperandInt;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Igt:
if (leftOperandInt.HasValue) return leftOperandInt > rightOperandInt;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Or:
if (leftOperandBool.HasValue) return leftOperandBool.Value || rightOperandBool.Value;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Xor:
if (leftOperandBool.HasValue) return leftOperandBool != rightOperandBool;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.And:
if (leftOperandBool.HasValue) return leftOperandBool.Value && rightOperandBool.Value;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Ilt:
if (leftOperandInt.HasValue) return leftOperandInt < rightOperandInt;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Ile:
if (leftOperandInt.HasValue) return leftOperandInt <= rightOperandInt;
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Multiply:
case TokenKind.Divide:
case TokenKind.Minus:
case TokenKind.Equals:
case TokenKind.PlusEquals:
case TokenKind.MinusEquals:
case TokenKind.MultiplyEquals:
case TokenKind.DivideEquals:
case TokenKind.RemainderEquals:
case TokenKind.Format:
case TokenKind.Not:
case TokenKind.Bnot:
case TokenKind.Band:
case TokenKind.Bor:
case TokenKind.Bxor:
case TokenKind.Join:
case TokenKind.Ige:
case TokenKind.Ilike:
case TokenKind.Inotlike:
case TokenKind.Imatch:
case TokenKind.Inotmatch:
case TokenKind.Ireplace:
case TokenKind.Icontains:
case TokenKind.Inotcontains:
case TokenKind.Iin:
case TokenKind.Inotin:
case TokenKind.Isplit:
case TokenKind.Ceq:
case TokenKind.Cne:
case TokenKind.Cge:
case TokenKind.Cgt:
case TokenKind.Clt:
case TokenKind.Cle:
case TokenKind.Clike:
case TokenKind.Cnotlike:
case TokenKind.Cmatch:
case TokenKind.Cnotmatch:
case TokenKind.Creplace:
case TokenKind.Ccontains:
case TokenKind.Cnotcontains:
case TokenKind.Cin:
case TokenKind.Cnotin:
case TokenKind.Csplit:
case TokenKind.Is:
case TokenKind.IsNot:
case TokenKind.As:
case TokenKind.Shl:
case TokenKind.Shr:
throw new NotImplementedException(binaryExpressionAst.ToString());
default:
throw new InvalidOperationException(binaryExpressionAst.ToString());
}
}
/// <summary/>
public virtual object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return _decorated.VisitBinaryExpression(binaryExpressionAst);
}
object EvaluateBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
var leftOperand = EvaluateAst(binaryExpressionAst.Left);
var rightOperand = EvaluateAst(binaryExpressionAst.Right);
if (leftOperand is PSObject) leftOperand = ((PSObject)leftOperand).BaseObject;
if (rightOperand is PSObject) rightOperand = ((PSObject)rightOperand).BaseObject;
switch (binaryExpressionAst.Operator)
{
case TokenKind.DotDot:
return Range(LanguagePrimitives.ConvertTo<int>(leftOperand), LanguagePrimitives.ConvertTo<int>(rightOperand));
case TokenKind.Plus:
return ArithmeticOperations.Add(leftOperand, rightOperand);
case TokenKind.Ieq:
case TokenKind.Ceq:
if (leftOperand is string || rightOperand is string)
{
StringComparison ignoreCaseComparision =
(TokenKind.Ceq == binaryExpressionAst.Operator)
? StringComparison.CurrentCulture
: StringComparison.CurrentCultureIgnoreCase;
var left = LanguagePrimitives.ConvertTo<string>(leftOperand);
var right = LanguagePrimitives.ConvertTo<string>(rightOperand);
return String.Equals(left, right, ignoreCaseComparision);
}
return Object.Equals(leftOperand, rightOperand);
case TokenKind.Ine:
case TokenKind.Cne:
if (leftOperand is string || rightOperand is string)
{
StringComparison ignoreCaseComparision =
(TokenKind.Cne == binaryExpressionAst.Operator)
? StringComparison.CurrentCulture
: StringComparison.CurrentCultureIgnoreCase;
var left = LanguagePrimitives.ConvertTo<string>(leftOperand);
var right = LanguagePrimitives.ConvertTo<string>(rightOperand);
return !String.Equals(left, right, ignoreCaseComparision);
}
return !Object.Equals(leftOperand, rightOperand);
case TokenKind.Igt:
case TokenKind.Cgt:
return ComparisonOperations.GreaterThan(
leftOperand,
rightOperand,
(TokenKind.Cgt != binaryExpressionAst.Operator));
case TokenKind.Ige:
case TokenKind.Cge:
return ComparisonOperations.GreaterThanEquals(
leftOperand,
rightOperand,
(TokenKind.Cge != binaryExpressionAst.Operator));
case TokenKind.Or:
return LanguagePrimitives.ConvertTo<bool>(leftOperand) || LanguagePrimitives.ConvertTo<bool>(rightOperand);
case TokenKind.Xor:
return LanguagePrimitives.ConvertTo<bool>(leftOperand) != LanguagePrimitives.ConvertTo<bool>(rightOperand);
case TokenKind.And:
return LanguagePrimitives.ConvertTo<bool>(leftOperand) && LanguagePrimitives.ConvertTo<bool>(rightOperand);
case TokenKind.Ilt:
case TokenKind.Clt:
return ComparisonOperations.LessThan(
leftOperand,
rightOperand,
(TokenKind.Clt != binaryExpressionAst.Operator));
case TokenKind.Ile:
case TokenKind.Cle:
return ComparisonOperations.LessThanEquals(
leftOperand,
rightOperand,
(TokenKind.Clt != binaryExpressionAst.Operator));
case TokenKind.Band:
return BitwiseOperation.And(leftOperand, rightOperand);
case TokenKind.Bor:
return BitwiseOperation.Or(leftOperand, rightOperand);
case TokenKind.Bxor:
return BitwiseOperation.Xor(leftOperand, rightOperand);
case TokenKind.Imatch:
return Match(leftOperand, rightOperand, RegexOptions.IgnoreCase);
case TokenKind.Inotmatch:
return NotMatch(leftOperand, rightOperand, RegexOptions.IgnoreCase);
case TokenKind.Cmatch:
return Match(leftOperand, rightOperand, RegexOptions.None);
case TokenKind.Cnotmatch:
return NotMatch(leftOperand, rightOperand, RegexOptions.None);
case TokenKind.Multiply:
return ArithmeticOperations.Multiply(leftOperand, rightOperand);
case TokenKind.Divide:
return ArithmeticOperations.Divide(leftOperand, rightOperand);
case TokenKind.Minus:
return ArithmeticOperations.Subtract(leftOperand, rightOperand);
case TokenKind.Rem:
return ArithmeticOperations.Remainder(leftOperand, rightOperand);
case TokenKind.Format:
{
var left = LanguagePrimitives.ConvertTo<string>(leftOperand);
var right = LanguagePrimitives.ConvertTo<object[]>(rightOperand);
return string.Format(left, right);
}
case TokenKind.Equals:
case TokenKind.PlusEquals:
case TokenKind.MinusEquals:
case TokenKind.MultiplyEquals:
case TokenKind.DivideEquals:
case TokenKind.RemainderEquals:
case TokenKind.Not:
case TokenKind.Bnot:
case TokenKind.Join:
case TokenKind.Ilike:
case TokenKind.Inotlike:
case TokenKind.Ireplace:
case TokenKind.Icontains:
case TokenKind.Inotcontains:
case TokenKind.Iin:
case TokenKind.Inotin:
case TokenKind.Isplit:
case TokenKind.Clike:
case TokenKind.Cnotlike:
case TokenKind.Creplace:
case TokenKind.Ccontains:
case TokenKind.Cnotcontains:
case TokenKind.Cin:
case TokenKind.Cnotin:
case TokenKind.Csplit:
case TokenKind.Is:
case TokenKind.IsNot:
case TokenKind.As:
case TokenKind.Shl:
case TokenKind.Shr:
throw new NotImplementedException(binaryExpressionAst.ToString());
default:
throw new InvalidOperationException(binaryExpressionAst.ToString());
}
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst ast) { return CheckParent(ast); }
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if ((binaryExpressionAst.Operator == TokenKind.And) || (binaryExpressionAst.Operator == TokenKind.Or))
{
binaryExpressionAst.Left.Accept(this);
Block next = new Block();
Block block2 = new Block();
this._currentBlock.FlowsTo(next);
this._currentBlock.FlowsTo(block2);
this._currentBlock = block2;
binaryExpressionAst.Right.Accept(this);
this._currentBlock.FlowsTo(next);
this._currentBlock = next;
}
else
{
binaryExpressionAst.Left.Accept(this);
binaryExpressionAst.Right.Accept(this);
}
return null;
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if (binaryExpressionAst.Operator == TokenKind.AndAnd
|| binaryExpressionAst.Operator == TokenKind.OrOr)
{
_parser.ReportError(binaryExpressionAst.ErrorPosition, () => ParserStrings.InvalidEndOfLine,
binaryExpressionAst.Operator.Text());
}
return AstVisitAction.Continue;
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
throw new UnexpectedElementException();
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// match and notmatch disallowed because they can set $matches
// -join/-split disallowed because they can be used in tandem to build very large strings, like:
// -split (-split ( ('a','a') -join " a a a a a ") -join " a a a a a ")
// -replace disallowed because it too can be used to build very large strings, like:
// ('x' -replace '.','xx') -replace '.','xx'
// -as disallowed because it can invoke arbitrary code (similar to why some casts are disallowed,
// but -as is completely disallowed because in some cases, we don't know the type at parse time.
// Format disallowed because of unbounded results, like ("{0," + 1MB + ":0}") -f 1
// Range disallowed because it has iteration semantics.
if (binaryExpressionAst.Operator.HasTrait(TokenFlags.DisallowedInRestrictedMode))
{
ReportError(binaryExpressionAst.ErrorPosition, () => ParserStrings.OperatorNotSupportedInDataSection, binaryExpressionAst.Operator.Text());
}
return AstVisitAction.Continue;
}
/// <summary/> public virtual AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst) => DefaultVisit(binaryExpressionAst);
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
object obj2;
if (!this.CompilingConstantExpression && IsConstantValueVisitor.IsConstant(binaryExpressionAst, out obj2, false, false))
{
return Expression.Constant(obj2);
}
Expression expr = this.CompileExpressionOperand(binaryExpressionAst.Left);
Expression expression2 = this.CompileExpressionOperand(binaryExpressionAst.Right);
switch (binaryExpressionAst.Operator)
{
case TokenKind.DotDot:
return Expression.Call(CachedReflectionInfo.IntOps_Range, expr.Convert(typeof(int)), expression2.Convert(typeof(int)));
case TokenKind.Multiply:
if (!expr.Type.Equals(typeof(double)) || !expression2.Type.Equals(typeof(double)))
{
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Multiply, true, false), typeof(object), expr, expression2);
}
return Expression.Multiply(expr, expression2);
case TokenKind.Divide:
if (!expr.Type.Equals(typeof(double)) || !expression2.Type.Equals(typeof(double)))
{
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Divide, true, false), typeof(object), expr, expression2);
}
return Expression.Divide(expr, expression2);
case TokenKind.Rem:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Modulo, true, false), typeof(object), expr, expression2);
case TokenKind.Plus:
if (!expr.Type.Equals(typeof(double)) || !expression2.Type.Equals(typeof(double)))
{
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Add, true, false), typeof(object), expr, expression2);
}
return Expression.Add(expr, expression2);
case TokenKind.Minus:
if (!expr.Type.Equals(typeof(double)) || !expression2.Type.Equals(typeof(double)))
{
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Subtract, true, false), typeof(object), expr, expression2);
}
return Expression.Subtract(expr, expression2);
case TokenKind.Format:
if (!expr.Type.Equals(typeof(string)))
{
expr = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), expr, _executionContextParameter);
}
return Expression.Call(CachedReflectionInfo.StringOps_FormatOperator, expr, expression2.Cast(typeof(object)));
case TokenKind.And:
return Expression.AndAlso(expr.Convert(typeof(bool)), expression2.Convert(typeof(bool)));
case TokenKind.Or:
return Expression.OrElse(expr.Convert(typeof(bool)), expression2.Convert(typeof(bool)));
case TokenKind.Xor:
return Expression.NotEqual(expr.Convert(typeof(bool)), expression2.Convert(typeof(bool)));
case TokenKind.Band:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.And, true, false), typeof(object), expr, expression2);
case TokenKind.Bor:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Or, true, false), typeof(object), expr, expression2);
case TokenKind.Bxor:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.ExclusiveOr, true, false), typeof(object), expr, expression2);
case TokenKind.Join:
return Expression.Call(CachedReflectionInfo.ParserOps_JoinOperator, _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)));
case TokenKind.Ieq:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Equal, true, false), typeof(object), expr, expression2);
case TokenKind.Ine:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.NotEqual, true, false), typeof(object), expr, expression2);
case TokenKind.Ige:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.GreaterThanOrEqual, true, false), typeof(object), expr, expression2);
case TokenKind.Igt:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.GreaterThan, true, false), typeof(object), expr, expression2);
case TokenKind.Ilt:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.LessThan, true, false), typeof(object), expr, expression2);
case TokenKind.Ile:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.LessThanOrEqual, true, false), typeof(object), expr, expression2);
case TokenKind.Ilike:
return Expression.Call(CachedReflectionInfo.ParserOps_LikeOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(false), ExpressionCache.Constant(true) });
case TokenKind.Inotlike:
return Expression.Call(CachedReflectionInfo.ParserOps_LikeOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(true), ExpressionCache.Constant(true) });
case TokenKind.Imatch:
return Expression.Call(CachedReflectionInfo.ParserOps_MatchOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(false), ExpressionCache.Constant(true) });
case TokenKind.Inotmatch:
return Expression.Call(CachedReflectionInfo.ParserOps_MatchOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(true), ExpressionCache.Constant(true) });
case TokenKind.Ireplace:
return Expression.Call(CachedReflectionInfo.ParserOps_ReplaceOperator, _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(true));
case TokenKind.Icontains:
return this.GenerateCallContains(expr, expression2, true);
case TokenKind.Inotcontains:
return Expression.Not(this.GenerateCallContains(expr, expression2, true));
case TokenKind.Iin:
return this.GenerateCallContains(expression2, expr, true);
case TokenKind.Inotin:
return Expression.Not(this.GenerateCallContains(expression2, expr, true));
case TokenKind.Isplit:
return Expression.Call(CachedReflectionInfo.ParserOps_SplitOperator, _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(true));
case TokenKind.Ceq:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.Equal, false, false), typeof(object), expr, expression2);
case TokenKind.Cne:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.NotEqual, false, false), typeof(object), expr, expression2);
case TokenKind.Cge:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.GreaterThanOrEqual, false, false), typeof(object), expr, expression2);
case TokenKind.Cgt:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.GreaterThan, false, false), typeof(object), expr, expression2);
case TokenKind.Clt:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.LessThan, false, false), typeof(object), expr, expression2);
case TokenKind.Cle:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.LessThanOrEqual, false, false), typeof(object), expr, expression2);
case TokenKind.Clike:
return Expression.Call(CachedReflectionInfo.ParserOps_LikeOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(false), ExpressionCache.Constant(false) });
case TokenKind.Cnotlike:
return Expression.Call(CachedReflectionInfo.ParserOps_LikeOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(true), ExpressionCache.Constant(false) });
case TokenKind.Cmatch:
return Expression.Call(CachedReflectionInfo.ParserOps_MatchOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(false), ExpressionCache.Constant(false) });
case TokenKind.Cnotmatch:
return Expression.Call(CachedReflectionInfo.ParserOps_MatchOperator, new Expression[] { _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(true), ExpressionCache.Constant(false) });
case TokenKind.Creplace:
return Expression.Call(CachedReflectionInfo.ParserOps_ReplaceOperator, _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(false));
case TokenKind.Ccontains:
return this.GenerateCallContains(expr, expression2, false);
case TokenKind.Cnotcontains:
return Expression.Not(this.GenerateCallContains(expr, expression2, false));
case TokenKind.Cin:
return this.GenerateCallContains(expression2, expr, false);
case TokenKind.Cnotin:
return Expression.Not(this.GenerateCallContains(expression2, expr, false));
case TokenKind.Csplit:
return Expression.Call(CachedReflectionInfo.ParserOps_SplitOperator, _executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), expr.Cast(typeof(object)), expression2.Cast(typeof(object)), ExpressionCache.Constant(false));
case TokenKind.Is:
case TokenKind.IsNot:
{
if (!(expression2 is ConstantExpression) || !expression2.Type.Equals(typeof(Type)))
{
break;
}
Type type = (Type) ((ConstantExpression) expression2).Value;
if (type.Equals(typeof(PSCustomObject)) || type.Equals(typeof(PSObject)))
{
break;
}
expr = expr.Type.IsValueType ? expr : Expression.Call(CachedReflectionInfo.PSObject_Base, expr);
if (binaryExpressionAst.Operator != TokenKind.Is)
{
return Expression.Not(Expression.TypeIs(expr, type));
}
return Expression.TypeIs(expr, type);
}
case TokenKind.As:
return Expression.Call(CachedReflectionInfo.TypeOps_AsOperator, expr.Cast(typeof(object)), expression2.Convert(typeof(Type)));
case TokenKind.Shl:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.LeftShift, true, false), typeof(object), expr, expression2);
case TokenKind.Shr:
return Expression.Dynamic(PSBinaryOperationBinder.Get(ExpressionType.RightShift, true, false), typeof(object), expr, expression2);
default:
throw new InvalidOperationException("Unknown token in binary operator.");
}
Expression expression = Expression.Call(CachedReflectionInfo.TypeOps_IsInstance, expr.Cast(typeof(object)), expression2.Cast(typeof(object)));
if (binaryExpressionAst.Operator == TokenKind.IsNot)
{
expression = Expression.Not(expression);
}
return expression;
}
private ExpressionAst ExpressionRule()
{
ExpressionAst expressionAst;
ExpressionAst binaryExpressionAst;
ParameterToken parameterToken;
ExpressionAst expressionAst1;
RuntimeHelpers.EnsureSufficientExecutionStack();
TokenizerMode mode = this._tokenizer.Mode;
try
{
this.SetTokenizerMode(TokenizerMode.Expression);
ExpressionAst errorExpressionAst = this.ArrayLiteralRule();
if (errorExpressionAst != null)
{
Token token = this.PeekToken();
if (token.Kind.HasTrait(TokenFlags.BinaryOperator))
{
this.SkipToken();
Stack<ExpressionAst> expressionAsts = new Stack<ExpressionAst>();
Stack<Token> tokens = new Stack<Token>();
expressionAsts.Push(errorExpressionAst);
tokens.Push(token);
int binaryPrecedence = token.Kind.GetBinaryPrecedence();
while (true)
{
this.SkipNewlines();
errorExpressionAst = this.ArrayLiteralRule();
if (errorExpressionAst == null)
{
IScriptExtent scriptExtent = Parser.After(token);
object[] text = new object[1];
text[0] = token.Text;
this.ReportIncompleteInput(scriptExtent, ParserStrings.ExpectedValueExpression, text);
errorExpressionAst = new ErrorExpressionAst(scriptExtent, null);
}
expressionAsts.Push(errorExpressionAst);
token = this.NextToken();
if (!token.Kind.HasTrait(TokenFlags.BinaryOperator))
{
break;
}
int num = token.Kind.GetBinaryPrecedence();
while (num <= binaryPrecedence)
{
binaryExpressionAst = expressionAsts.Pop();
expressionAst = expressionAsts.Pop();
Token token1 = tokens.Pop();
expressionAsts.Push(new BinaryExpressionAst(Parser.ExtentOf(expressionAst, binaryExpressionAst), expressionAst, token1.Kind, binaryExpressionAst, token1.Extent));
if (tokens.Count == 0)
{
break;
}
binaryPrecedence = tokens.Peek().Kind.GetBinaryPrecedence();
}
tokens.Push(token);
binaryPrecedence = num;
}
parameterToken = token as ParameterToken;
this.UngetToken(token);
binaryExpressionAst = expressionAsts.Pop();
while (expressionAsts.Any<ExpressionAst>())
{
expressionAst = expressionAsts.Pop();
token = tokens.Pop();
binaryExpressionAst = new BinaryExpressionAst(Parser.ExtentOf(expressionAst, binaryExpressionAst), expressionAst, token.Kind, binaryExpressionAst, token.Extent);
}
if (parameterToken == null)
{
expressionAst1 = binaryExpressionAst;
}
else
{
expressionAst1 = this.ErrorRecoveryParameterInExpression(parameterToken, binaryExpressionAst);
}
}
else
{
parameterToken = token as ParameterToken;
if (parameterToken == null)
{
expressionAst1 = errorExpressionAst;
}
else
{
expressionAst1 = this.ErrorRecoveryParameterInExpression(parameterToken, errorExpressionAst);
}
}
}
else
{
expressionAst1 = null;
}
}
finally
{
this.SetTokenizerMode(mode);
}
return expressionAst1;
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if ((binaryExpressionAst.Operator == TokenKind.AndAnd) || (binaryExpressionAst.Operator == TokenKind.OrOr))
{
this._parser.ReportError(binaryExpressionAst.ErrorPosition, ParserStrings.InvalidEndOfLine, new object[] { binaryExpressionAst.Operator.Text() });
}
return AstVisitAction.Continue;
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if (binaryExpressionAst.Operator.HasTrait(TokenFlags.DisallowedInRestrictedMode))
{
this.ReportError(binaryExpressionAst.ErrorPosition, () => ParserStrings.OperatorNotSupportedInDataSection, new object[] { binaryExpressionAst.Operator.Text() });
}
return AstVisitAction.Continue;
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst ast)
{
return this.Check(ast);
}
/// <summary>
/// Visit binary expression
/// </summary>
/// <param name="binaryExpressionAst"></param>
/// <returns></returns>
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
if (binaryExpressionAst == null) return null;
if (binaryExpressionAst.Operator == TokenKind.And || binaryExpressionAst.Operator == TokenKind.Or)
{
// Logical and/or are short circuit operators, so we need to simulate the control flow. The
// left operand is always evaluated, visit it's expression in the current block.
binaryExpressionAst.Left.Visit(this.Decorator);
// The right operand is conditionally evaluated. We aren't generating any code here, just
// modeling the flow graph, so we just visit the right operand in a new block, and have
// both the current and new blocks both flow to a post-expression block.
var targetBlock = new Block();
var nextBlock = new Block();
_currentBlock.FlowsTo(targetBlock);
_currentBlock.FlowsTo(nextBlock);
_currentBlock = nextBlock;
binaryExpressionAst.Right.Visit(this.Decorator);
_currentBlock.FlowsTo(targetBlock);
_currentBlock = targetBlock;
}
else
{
binaryExpressionAst.Left.Visit(this.Decorator);
binaryExpressionAst.Right.Visit(this.Decorator);
}
return null;
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return (!((bool) binaryExpressionAst.Left.Accept(this)) ? ((object) 0) : ((object) ((bool) binaryExpressionAst.Right.Accept(this))));
}
object EvaluateBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
var leftOperand = EvaluateAst(binaryExpressionAst.Left);
var rightOperand = EvaluateAst(binaryExpressionAst.Right);
switch (binaryExpressionAst.Operator)
{
case TokenKind.DotDot:
return Range((int)leftOperand, (int)rightOperand);
case TokenKind.Plus:
return Add(leftOperand, rightOperand);
case TokenKind.Ieq:
if (leftOperand.GetType() == typeof(int)) return ((int)leftOperand) == ((int)rightOperand);
throw new NotImplementedException(binaryExpressionAst.ToString());
case TokenKind.Multiply:
case TokenKind.Divide:
case TokenKind.Minus:
case TokenKind.Equals:
case TokenKind.PlusEquals:
case TokenKind.MinusEquals:
case TokenKind.MultiplyEquals:
case TokenKind.DivideEquals:
case TokenKind.RemainderEquals:
case TokenKind.Format:
case TokenKind.Not:
case TokenKind.Bnot:
case TokenKind.And:
case TokenKind.Or:
case TokenKind.Xor:
case TokenKind.Band:
case TokenKind.Bor:
case TokenKind.Bxor:
case TokenKind.Join:
case TokenKind.Ine:
case TokenKind.Ige:
case TokenKind.Igt:
case TokenKind.Ilt:
case TokenKind.Ile:
case TokenKind.Ilike:
case TokenKind.Inotlike:
case TokenKind.Imatch:
case TokenKind.Inotmatch:
case TokenKind.Ireplace:
case TokenKind.Icontains:
case TokenKind.Inotcontains:
case TokenKind.Iin:
case TokenKind.Inotin:
case TokenKind.Isplit:
case TokenKind.Ceq:
case TokenKind.Cne:
case TokenKind.Cge:
case TokenKind.Cgt:
case TokenKind.Clt:
case TokenKind.Cle:
case TokenKind.Clike:
case TokenKind.Cnotlike:
case TokenKind.Cmatch:
case TokenKind.Cnotmatch:
case TokenKind.Creplace:
case TokenKind.Ccontains:
case TokenKind.Cnotcontains:
case TokenKind.Cin:
case TokenKind.Cnotin:
case TokenKind.Csplit:
case TokenKind.Is:
case TokenKind.IsNot:
case TokenKind.As:
case TokenKind.Shl:
case TokenKind.Shr:
throw new NotImplementedException(binaryExpressionAst.ToString());
default:
throw new InvalidOperationException(binaryExpressionAst.ToString());
}
}
/// <summary/>
public virtual object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(null);
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(CompileAndInvoke(binaryExpressionAst));
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return (((!binaryExpressionAst.Operator.HasTrait(TokenFlags.CanConstantFold) || !((bool) binaryExpressionAst.Left.Accept(this))) || !((bool) binaryExpressionAst.Right.Accept(this))) ? ((object) false) : ((object) !IsNullDivisor(binaryExpressionAst.Right)));
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
this._pipelineCommandRuntime.WriteObject(EvaluateBinaryExpression(binaryExpressionAst), true);
return AstVisitAction.SkipChildren;
}
/// <summary/>
public virtual object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst) { return null; }
public virtual AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return AstVisitAction.Continue;
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(binaryExpressionAst.Operator.HasTrait(TokenFlags.CanConstantFold) &&
(bool)binaryExpressionAst.Left.Accept(this) && (bool)binaryExpressionAst.Right.Accept(this) &&
!IsNullDivisor(binaryExpressionAst.Right));
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return binaryExpressionAst.Operator.HasTrait(TokenFlags.CanConstantFold) &&
(bool)binaryExpressionAst.Left.Accept(this) && (bool)binaryExpressionAst.Right.Accept(this)
&& !IsNullDivisor(binaryExpressionAst.Right);
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(((!binaryExpressionAst.Operator.HasTrait(TokenFlags.CanConstantFold) || !((bool)binaryExpressionAst.Left.Accept(this))) || !((bool)binaryExpressionAst.Right.Accept(this))) ? ((object)false) : ((object)!IsNullDivisor(binaryExpressionAst.Right)));
}
public override AstVisitAction VisitBinaryExpression(BinaryExpressionAst ast)
{
return(Check(ast));
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
CheckIsConstant(binaryExpressionAst, "Caller to verify ast is constant");
return CompileAndInvoke(binaryExpressionAst);
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// This can be used for a denial of service
// Write-Output (((((("AAAAAAAAAAAAAAAAAAAAAA"*2)*2)*2)*2)*2)*2)
// Keep on going with that pattern, and we're generating gigabytes of strings.
return false;
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
// This can be used for a denial of service
// Write-Output (((((("AAAAAAAAAAAAAAAAAAAAAA"*2)*2)*2)*2)*2)*2)
// Keep on going with that pattern, and we're generating gigabytes of strings.
throw PSTraceSource.NewArgumentException("ast");
}
/// <summary/>
public virtual AstVisitAction VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
return(AstVisitAction.Continue);
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
object constantValue;
if (!CompilingConstantExpression && IsConstantValueVisitor.IsConstant(binaryExpressionAst, out constantValue))
{
return Expression.Constant(constantValue);
}
DynamicMetaObjectBinder binder;
var lhs = CompileExpressionOperand(binaryExpressionAst.Left);
var rhs = CompileExpressionOperand(binaryExpressionAst.Right);
switch (binaryExpressionAst.Operator)
{
case TokenKind.And:
return Expression.AndAlso(lhs.Convert(typeof(bool)), rhs.Convert(typeof(bool)));
case TokenKind.Or:
return Expression.OrElse(lhs.Convert(typeof(bool)), rhs.Convert(typeof(bool)));
case TokenKind.Is:
case TokenKind.IsNot:
if (rhs is ConstantExpression && rhs.Type == typeof(Type))
{
var isType = (Type)((ConstantExpression)rhs).Value;
if (!(isType == typeof(PSCustomObject)) && !(isType == typeof(PSObject)))
{
lhs = lhs.Type.GetTypeInfo().IsValueType ? lhs : Expression.Call(CachedReflectionInfo.PSObject_Base, lhs);
if (binaryExpressionAst.Operator == TokenKind.Is)
return Expression.TypeIs(lhs, isType);
return Expression.Not(Expression.TypeIs(lhs, isType));
}
}
Expression result = Expression.Call(CachedReflectionInfo.TypeOps_IsInstance, lhs.Cast(typeof(object)), rhs.Cast(typeof(object)));
if (binaryExpressionAst.Operator == TokenKind.IsNot)
{
result = Expression.Not(result);
}
return result;
case TokenKind.As:
return Expression.Call(CachedReflectionInfo.TypeOps_AsOperator, lhs.Cast(typeof(object)), rhs.Convert(typeof(Type)));
case TokenKind.DotDot:
return Expression.Call(CachedReflectionInfo.IntOps_Range,
lhs.Convert(typeof(int)),
rhs.Convert(typeof(int)));
case TokenKind.Multiply:
if (lhs.Type == typeof(double) && rhs.Type == typeof(double))
{
return Expression.Multiply(lhs, rhs);
}
binder = PSBinaryOperationBinder.Get(ExpressionType.Multiply);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Divide:
if (lhs.Type == typeof(double) && rhs.Type == typeof(double))
{
return Expression.Divide(lhs, rhs);
}
binder = PSBinaryOperationBinder.Get(ExpressionType.Divide);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Rem:
binder = PSBinaryOperationBinder.Get(ExpressionType.Modulo);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Plus:
if (lhs.Type == typeof(double) && rhs.Type == typeof(double))
{
return Expression.Add(lhs, rhs);
}
binder = PSBinaryOperationBinder.Get(ExpressionType.Add);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Minus:
if (lhs.Type == typeof(double) && rhs.Type == typeof(double))
{
return Expression.Subtract(lhs, rhs);
}
binder = PSBinaryOperationBinder.Get(ExpressionType.Subtract);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Format:
if (lhs.Type != typeof(string))
{
lhs = DynamicExpression.Dynamic(PSToStringBinder.Get(), typeof(string), lhs, _executionContextParameter);
}
return Expression.Call(CachedReflectionInfo.StringOps_FormatOperator, lhs, rhs.Cast(typeof(object)));
case TokenKind.Xor:
return Expression.NotEqual(lhs.Convert(typeof(bool)), rhs.Convert(typeof(bool)));
case TokenKind.Shl:
binder = PSBinaryOperationBinder.Get(ExpressionType.LeftShift);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Shr:
binder = PSBinaryOperationBinder.Get(ExpressionType.RightShift);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Band:
binder = PSBinaryOperationBinder.Get(ExpressionType.And);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Bor:
binder = PSBinaryOperationBinder.Get(ExpressionType.Or);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Bxor:
binder = PSBinaryOperationBinder.Get(ExpressionType.ExclusiveOr);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Join:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_JoinOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)));
case TokenKind.Ieq:
binder = PSBinaryOperationBinder.Get(ExpressionType.Equal);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Ine:
binder = PSBinaryOperationBinder.Get(ExpressionType.NotEqual);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Ige:
binder = PSBinaryOperationBinder.Get(ExpressionType.GreaterThanOrEqual);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Igt:
binder = PSBinaryOperationBinder.Get(ExpressionType.GreaterThan);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Ilt:
binder = PSBinaryOperationBinder.Get(ExpressionType.LessThan);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Ile:
binder = PSBinaryOperationBinder.Get(ExpressionType.LessThanOrEqual);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Ilike:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_LikeOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition),
lhs.Cast(typeof(object)),
GetLikeRHSOperand(WildcardOptions.IgnoreCase, rhs).Cast(typeof(object)),
Expression.Constant(binaryExpressionAst.Operator));
case TokenKind.Inotlike:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_LikeOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition),
lhs.Cast(typeof(object)),
GetLikeRHSOperand(WildcardOptions.IgnoreCase, rhs).Cast(typeof(object)),
Expression.Constant(binaryExpressionAst.Operator));
case TokenKind.Imatch:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_MatchOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(false), ExpressionCache.Constant(true));
case TokenKind.Inotmatch:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_MatchOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(true), ExpressionCache.Constant(true));
case TokenKind.Ireplace:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_ReplaceOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(true));
case TokenKind.Icontains:
return GenerateCallContains(lhs, rhs, true);
case TokenKind.Inotcontains:
return Expression.Not(GenerateCallContains(lhs, rhs, true));
case TokenKind.Iin:
return GenerateCallContains(rhs, lhs, true);
case TokenKind.Inotin:
return Expression.Not(GenerateCallContains(rhs, lhs, true));
case TokenKind.Isplit:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_SplitOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(true));
case TokenKind.Ceq:
binder = PSBinaryOperationBinder.Get(ExpressionType.Equal, false);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Cne:
binder = PSBinaryOperationBinder.Get(ExpressionType.NotEqual, false);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Cge:
binder = PSBinaryOperationBinder.Get(ExpressionType.GreaterThanOrEqual, false);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Cgt:
binder = PSBinaryOperationBinder.Get(ExpressionType.GreaterThan, false);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Clt:
binder = PSBinaryOperationBinder.Get(ExpressionType.LessThan, false);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Cle:
binder = PSBinaryOperationBinder.Get(ExpressionType.LessThanOrEqual, false);
return DynamicExpression.Dynamic(binder, typeof(object), lhs, rhs);
case TokenKind.Clike:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_LikeOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition),
lhs.Cast(typeof(object)),
GetLikeRHSOperand(WildcardOptions.None, rhs).Cast(typeof(object)),
Expression.Constant(binaryExpressionAst.Operator));
case TokenKind.Cnotlike:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_LikeOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition),
lhs.Cast(typeof(object)),
GetLikeRHSOperand(WildcardOptions.None, rhs).Cast(typeof(object)),
Expression.Constant(binaryExpressionAst.Operator));
case TokenKind.Cmatch:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_MatchOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(false), ExpressionCache.Constant(false));
case TokenKind.Cnotmatch:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_MatchOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(true), ExpressionCache.Constant(false));
case TokenKind.Creplace:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_ReplaceOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(false));
case TokenKind.Ccontains:
return GenerateCallContains(lhs, rhs, false);
case TokenKind.Cnotcontains:
return Expression.Not(GenerateCallContains(lhs, rhs, false));
case TokenKind.Cin:
return GenerateCallContains(rhs, lhs, false);
case TokenKind.Cnotin:
return Expression.Not(GenerateCallContains(rhs, lhs, false));
case TokenKind.Csplit:
// TODO: replace this with faster code
return Expression.Call(
CachedReflectionInfo.ParserOps_SplitOperator,
_executionContextParameter, Expression.Constant(binaryExpressionAst.ErrorPosition), lhs.Cast(typeof(object)), rhs.Cast(typeof(object)),
ExpressionCache.Constant(false));
}
throw new InvalidOperationException("Unknown token in binary operator.");
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
CheckIsConstant(binaryExpressionAst, "Caller to verify ast is constant");
return(CompileAndInvoke(binaryExpressionAst));
}
public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
{
throw new NotImplementedException();
}
