void WriteExpression (Expression expression)
{
_expressionPrinter.Visit (expression);
}
private CecilMethodAnalyser(ActionFlowGraph graph)
{
if (graph == null) throw new ArgumentNullException("graph");
_queryExpression = QueryExpressionFinder.FindIn(graph);
}
void PushUnaryExpression (UnaryOperator op, Expression expression)
{
Push (new UnaryExpression (op, expression));
}
public void Add (Expression element)
{
if (element == null) throw new ArgumentNullException ("element");
InnerList.Add (element);
}
static bool IsFalse (Expression expression)
{
LiteralExpression literal = expression as LiteralExpression;
return literal != null && literal.Value.Equals (0);
}
public void Negate (Expression expression)
{
switch (expression.CodeElementType) {
case CodeElementType.BinaryExpression:
BinaryExpression be = (BinaryExpression) expression;
BinaryOperator op = GetInverseOperator (be.Operator);
if (BinaryOperator.None != op) {
Push (new BinaryExpression (op, be.Left, be.Right));
} else {
if (BinaryOperator.LogicalAnd == be.Operator) {
Negate (be.Left);
Negate (be.Right);
PushBinaryExpression (BinaryOperator.LogicalOr);
} else {
PushNotExpression (expression);
}
}
break;
case CodeElementType.UnaryExpression:
UnaryExpression ue = (UnaryExpression) expression;
switch (ue.Operator) {
case UnaryOperator.Not:
Push (ue.Operand);
break;
default:
throw new ArgumentException ("expression");
}
break;
default:
PushNotExpression (expression);
break;
}
}
public PropertyReferenceExpression (Expression target, PropertyReference property)
{
_target = target;
_property = property;
}
private static void CannotOptimize(Expression expression)
{
throw new QueryOptimizationException(ExpressionPrinter.ToString(expression));
}
public MethodInvocationExpression (Expression target, ExpressionCollection arguments)
{
_target = target;
_arguments = arguments;
}
public BinaryExpression (BinaryOperator operator_, Expression left, Expression right)
{
_operator = operator_;
_left = left;
_right = right;
}
public MethodReferenceExpression (Expression target, MethodReference method)
{
_target = target;
_method = method;
}
public static string ToString (Expression expression)
{
ExpressionPrinter printer = new ExpressionPrinter ();
expression.Accept (printer);
return printer.Writer.ToString ();
}
public void Insert (int index, Expression element)
{
if (element == null) throw new ArgumentNullException ("element");
InnerList.Insert (index, element);
}
public ConditionalBranchActionBlock (Instruction sourceInstruction, Expression condition)
: base (sourceInstruction)
{
if (null == condition) throw new ArgumentNullException ("condition");
_condition = condition;
}
public FieldReferenceExpression (Expression target, FieldReference field)
{
_target = target;
_field = field;
}
private ActionBlock OnReturn(ReturnActionBlock block)
{
Expression expression = block.Expression;
VariableReferenceExpression variable = expression as VariableReferenceExpression;
_queryExpression =
variable != null
? _variables[GetVariableIndex(variable)]
: expression;
return null;
}
public UnaryExpression (UnaryOperator operator_, Expression operand)
{
_operator = operator_;
_operand = operand;
}
private void PushAssignment (Expression lvalue, Expression rvalue)
{
Push (
new AssignExpression (
lvalue,
rvalue));
}
public TryCastExpression (Expression target, TypeReference toType)
{
_target = target;
_toType = toType;
}
bool IsBooleanExpression (Expression expression)
{
switch (expression.CodeElementType) {
case CodeElementType.BinaryExpression:
return IsComparisonOperator (((BinaryExpression) expression).Operator);
case CodeElementType.MethodInvocationExpression:
MethodReferenceExpression mre = ((MethodInvocationExpression) expression).Target as MethodReferenceExpression;
if (null != mre) return mre.Method.ReturnType.ReturnType == _SystemBoolean;
break;
}
return false;
}
public ReturnActionBlock (Instruction sourceInstruction, Expression expression)
: base (sourceInstruction)
{
_expression = expression;
}
void PushNotExpression (Expression expression)
{
PushUnaryExpression (UnaryOperator.Not, expression);
}
static bool IsTrueOrFalse (Expression expression)
{
LiteralExpression literal = expression as LiteralExpression;
return literal != null
&& literal.Value != null
&& (literal.Value.Equals (1)
|| literal.Value.Equals (0));
}
void Push (Expression expression)
{
if (null == expression) throw new ArgumentNullException ("expression");
_expressionStack.Push (expression);
}
public ReturnStatement (Expression expression)
{
_expression = expression;
}
