public static bool Match_E1aritopE2eq0 <Variable, Expression>(
this IExpressionDecoder <Variable, Expression> decoder,
Expression e1, Expression e2,
out ExpressionOperator op, out Expression e11, out Expression e12)
{
Contract.Requires(decoder != null);
Int32 value;
if (decoder.IsConstantInt(e2, out value) && value == 0)
{
op = decoder.OperatorFor(e1);
if (op.Equals(ExpressionOperator.Addition) || op.Equals(ExpressionOperator.Subtraction))
{
e11 = decoder.LeftExpressionFor(e1);
e12 = decoder.RightExpressionFor(e1);
return(true);
}
}
op = default(ExpressionOperator);
e11 = e12 = default(Expression);
return(false);
}
public static bool TryMatchVarPlusConst <Variable, Expression>(this IExpressionDecoder <Variable, Expression> decoder,
Expression exp, out Variable var, out int k)
{
Contract.Requires(decoder != null);
if (decoder.IsBinaryExpression(exp) && decoder.OperatorFor(exp) == ExpressionOperator.Addition)
{
var left = decoder.LeftExpressionFor(exp);
var right = decoder.RightExpressionFor(exp);
if (decoder.IsConstantInt(left, out k) && decoder.IsVariable(right))
{
var = decoder.UnderlyingVariable(right);
return(true);
}
if (decoder.IsConstantInt(right, out k) && decoder.IsVariable(left))
{
var = decoder.UnderlyingVariable(left);
return(true);
}
}
var = default(Variable);
k = default(int);
return(false);
}
static bool IsVariableEqConstant(Expression guard, IExpressionDecoder <Variable, Expression> decoder)
{
switch (decoder.OperatorFor(guard))
{
case ExpressionOperator.Equal:
case ExpressionOperator.Equal_Obj:
Expression left = decoder.LeftExpressionFor(guard);
Expression right = decoder.RightExpressionFor(guard);
return((decoder.IsVariable(left) && decoder.IsConstant(right)) || (decoder.IsVariable(right) && decoder.IsConstant(right)));
default:
return(false);
}
}
static public Exp <E> Box <E>(E exp, IExpressionDecoder <E> decoder)
{
if (decoder.IsVariable(exp))
{
return(new Var <E>(exp, decoder));
}
else
{
switch (decoder.OperatorFor(exp))
{
case ExpressionOperator.ConvertToInt32:
case ExpressionOperator.ConvertToUInt16:
case ExpressionOperator.ConvertToUInt32:
case ExpressionOperator.ConvertToUInt8:
return(Box(decoder.LeftExpressionFor(exp), decoder));
}
return(new Exp <E>(exp, decoder));
}
}
public virtual Out Visit(Expr expr, In data)
{
var op = Decoder.OperatorFor(expr);
switch (op)
{
case Op.Constant:
return(VisitConstant(expr, data));
case Op.Variable:
return(VisitVariable(Decoder.UnderlyingVariable(expr), expr, data));
case Op.Not:
return(DispatchVisitNot(Decoder.LeftExpressionFor(expr), data));
case Op.And:
return(VisitAnd(Decoder.LeftExpressionFor(expr), Decoder.RightExpressionFor(expr),
expr, data));
case Op.Or:
return(VisitOr(Decoder.LeftExpressionFor(expr), Decoder.RightExpressionFor(expr),
expr, data));
case Op.Xor:
return(VisitXor(Decoder.LeftExpressionFor(expr), Decoder.RightExpressionFor(expr),
expr, data));
case Op.LogicalAnd:
return(VisitLogicalAnd(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.LogicalOr:
return(VisitLogicalOr(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.NotEqual:
return(VisitNotEqual(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.Equal:
case Op.Equal_Obj:
return(DispatchVisitEqual(op, Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.LessThan:
return(DispatchCompare(VisitLessThan, Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.LessEqualThan:
return(DispatchCompare(VisitLessEqualThan, Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.GreaterThan:
return(DispatchCompare(VisitGreaterThan, Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.GreaterEqualThan:
return(DispatchCompare(VisitGreaterEqualThan, Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.Add:
return(VisitAddition(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.Div:
return(VisitDivision(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.Sub:
return(VisitSubtraction(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.Mod:
return(VisitModulus(Decoder.LeftExpressionFor(expr), Decoder.RightExpressionFor(expr),
expr, data));
case Op.Mult:
return(VisitMultiply(Decoder.LeftExpressionFor(expr),
Decoder.RightExpressionFor(expr), expr, data));
case Op.SizeOf:
return(VisitSizeOf(Decoder.LeftExpressionFor(expr), data));
case Op.UnaryMinus:
return(VisitUnaryMinus(Decoder.LeftExpressionFor(expr), expr, data));
case Op.LogicalNot:
return(VisitLogicalNot(Decoder.LeftExpressionFor(expr), expr, data));
case Op.Unknown:
return(VisitUnknown(expr, data));
default:
throw new ArgumentOutOfRangeException();
}
}
private static string ToString <Variable, Expression>(Expression exp, IExpressionDecoder <Variable, Expression> decoder, int height)
{
Contract.Requires(decoder != null);
Contract.Requires(height >= 0);
Contract.Ensures(Contract.Result <string>() != null);
if (height > MaxHeight)
{
return("<too deep in the exp>");
}
else
{
switch (decoder.OperatorFor(exp))
{
#region All the cases...
case ExpressionOperator.Addition:
return(BinaryPrint("+", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.And:
return(BinaryPrint("&", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Constant:
return(ConstantPrint(exp, decoder, height + 1));
case ExpressionOperator.ConvertToInt32:
return(UnaryPrint("(int32)", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ConvertToUInt8:
return(UnaryPrint("(uint8)", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ConvertToUInt16:
return(UnaryPrint("(uint16)", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ConvertToUInt32:
return(UnaryPrint("(uint32)", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ConvertToFloat32:
return(UnaryPrint("(Single)", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ConvertToFloat64:
return(UnaryPrint("(Double)", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Division:
return(BinaryPrint("/", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Equal:
return(BinaryPrint("==", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Equal_Obj:
return(BinaryPrint("=Equals=", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.GreaterEqualThan:
return(BinaryPrint(">=", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.GreaterEqualThan_Un:
return(BinaryPrint(">=_un", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.GreaterThan:
return(BinaryPrint(">", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.GreaterThan_Un:
return(BinaryPrint(">_un", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LessEqualThan:
return(BinaryPrint("<=", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LessEqualThan_Un:
return(BinaryPrint("<=_un", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LessThan:
return(BinaryPrint("<", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LessThan_Un:
return(BinaryPrint("<_un", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LogicalAnd:
return(BinaryPrint("&&", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LogicalNot:
return(UnaryPrint("!", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.LogicalOr:
return(BinaryPrint("||", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Modulus:
return(BinaryPrint("%", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Multiplication:
return(BinaryPrint("*", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Not:
return(UnaryPrint("!", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.NotEqual:
return(BinaryPrint("!=", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Or:
return(BinaryPrint("|", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Xor:
return(BinaryPrint("^", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ShiftLeft:
return(BinaryPrint("<<", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.ShiftRight:
return(BinaryPrint(">>", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.SizeOf:
return(SizeOfPrint(exp, decoder, height + 1));
case ExpressionOperator.Subtraction:
return(BinaryPrint("-", decoder.LeftExpressionFor(exp), decoder.RightExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.UnaryMinus:
return(UnaryPrint("-", decoder.LeftExpressionFor(exp), decoder, height + 1));
case ExpressionOperator.Variable:
return(VariablePrint(decoder.UnderlyingVariable(exp), decoder, height + 1));
case ExpressionOperator.WritableBytes:
return(exp.ToString());
// return UnaryPrint("WritableBytes", decoder.LeftExpressionFor(exp), decoder, height + 1);
case ExpressionOperator.Unknown:
return("<Unknown expression>");
default:
throw new AbstractInterpretationException("Error, unknown case!!!!" + decoder.OperatorFor(exp));
#endregion
}
}
}
