public override IExpression Rewrite(IEquality operation)
{
_log.Info("Rewriting IEquality: " + operation + " Pass: "******"Left")
{
thisArgument = operation.LeftOperand;
argument = operation.RightOperand;
}
else
{
thisArgument = operation.RightOperand;
argument = operation.LeftOperand;
}
methodCall.ThisArgument = thisArgument;
methodCall.MethodToCall = TypeHelper.GetMethod(Host.PlatformType.SystemObject.ResolvedType.Members,
Host.NameTable.GetNameFor("Equals"),
Host.PlatformType.SystemObject);
methodCall.Arguments = argument.InList();
return(methodCall);
}
public override void Visit(IEquality equality)
{
if (Process(equality))
{
visitor.Visit(equality);
}
base.Visit(equality);
}
private HLLocation ProcessEqualityExpression(IEquality pExpression)
{
HLLocation locationLeftOperand = ProcessExpression(pExpression.LeftOperand);
HLLocation locationRightOperand = ProcessExpression(pExpression.RightOperand);
HLLocation locationTemporary = HLTemporaryLocation.Create(CreateTemporary(HLDomain.GetOrCreateType(pExpression.Type)));
mCurrentBlock.EmitCompare(HLCompareType.Equal, locationTemporary, locationLeftOperand, locationRightOperand);
return(pExpression.ResultIsUnmodifiedLeftOperand ? locationLeftOperand : locationTemporary);
}
public override Boolean Equals(object o)
{
if (_map is IEquality)
{
IEquality map = (IEquality)_map;
return((o is PersistentMapProxy) ? map.eq(((PersistentMapProxy)o).innerMap()) : map.eq(o));
}
return(base.Equals(o));
}
public override IExpression Rewrite(IEquality equality)
{
base.Rewrite(equality);
var cc2 = equality.RightOperand as CompileTimeConstant;
if (cc2 != null && ExpressionHelper.IsNumericZero(cc2) && equality.LeftOperand.Type.TypeCode == PrimitiveTypeCode.Boolean)
{
return(IfThenElseReplacer.InvertCondition(equality.LeftOperand));
}
return(equality);
}
public override void Visit(IEquality operation)
{
_log.Info("Visiting IEquality: " + operation);
var passes = new List<string>();
foreach (Tuple<IExpression, string> pair in
Collections.Pairs<IExpression, string>(operation.LeftOperand, "Left", operation.RightOperand, "Right"))
{
ITypeDefinition operandType = pair.Item1.Type.ResolvedType;
if (operandType != Host.PlatformType.SystemString &&
operandType != Host.PlatformType.SystemObject &&
!operandType.IsValueType &&
operandType.BaseClasses.Any() && operandType.IsClass
&& TypeHelper.GetMethod(operandType.Members,
Host.NameTable.GetNameFor("Equals"), Host.PlatformType.SystemObject) != Dummy.MethodDefinition)
{
passes.Add(pair.Item2);
}
}
if (passes.Any())
{
MarkMutationTarget(operation, passes);
}
}
public override void Visit(IEquality operation)
{
_log.Info("Visiting IEquality: " + operation);
var passes = new List <string>();
foreach (Tuple <IExpression, string> pair in
Collections.Pairs <IExpression, string>(operation.LeftOperand, "Left", operation.RightOperand, "Right"))
{
ITypeDefinition operandType = pair.Item1.Type.ResolvedType;
if (operandType != Host.PlatformType.SystemString &&
operandType != Host.PlatformType.SystemObject &&
!operandType.IsValueType &&
operandType.BaseClasses.Any() && operandType.IsClass &&
TypeHelper.GetMethod(operandType.Members,
Host.NameTable.GetNameFor("Equals"), Host.PlatformType.SystemObject) != Dummy.MethodDefinition)
{
passes.Add(pair.Item2);
}
}
if (passes.Any())
{
MarkMutationTarget(operation, passes);
}
}
/// <summary>
/// Determines if the specified point is feasible
/// for the equality, c.
/// </summary>
/// <param name="c">The c.</param>
/// <param name="point">The point.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private bool feasible(IEquality c, double[] point)
{
return(calculate(c, point) == 0);
}
public override void Visit(IEquality binary)
{
_formattedValue = Format(binary.LeftOperand) + " == " + Format(binary.RightOperand);
}
public override void Visit(IEquality operation)
{
ProcessOperation(operation);
}
public override void Visit(IEquality equal) {
base.Visit(equal);
Bpl.Expr rexp = TranslatedExpressions.Pop();
Bpl.Expr lexp = TranslatedExpressions.Pop();
TranslatedExpressions.Push(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, lexp, rexp));
}
public override void TraverseChildren(IEquality equality)
{
base.TraverseChildren(equality);
((Equality)equality).Type = this.platformType.SystemBoolean;
}
public virtual void onASTElement(IEquality equality)
{
}
public override void TraverseChildren(IEquality equal)
{
if ((equal.LeftOperand.Type.TypeCode != PrimitiveTypeCode.NotPrimitive || equal.RightOperand.Type.TypeCode != PrimitiveTypeCode.NotPrimitive)
&& !TypeHelper.TypesAreEquivalent(equal.LeftOperand.Type, equal.RightOperand.Type)
&& (!(IsConstantNull(equal.LeftOperand) || IsConstantNull(equal.RightOperand))) // null is "polymorphic": it can be compared against any reference type.
) {
throw new TranslationException(
String.Format("Decompiler messed up: equality's left operand is of type '{0}' but right operand is of type '{1}'.",
TypeHelper.GetTypeName(equal.LeftOperand.Type),
TypeHelper.GetTypeName(equal.RightOperand.Type)
));
}
base.TraverseChildren(equal);
Bpl.Expr rexp = TranslatedExpressions.Pop();
Bpl.Expr lexp = TranslatedExpressions.Pop();
TranslatedExpressions.Push(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, lexp, rexp));
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given equality expression.
/// </summary>
/// <param name="equality"></param>
public virtual void Visit(IEquality equality)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(equality);
this.Visit(equality.LeftOperand);
this.Visit(equality.RightOperand);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
/// <summary>
/// Rewrites the given equality expression.
/// </summary>
/// <param name="equality"></param>
public virtual IExpression Rewrite(IEquality equality)
{
return equality;
}
public override void Visit(IEquality equality)
{
if(Process(equality)){visitor.Visit(equality);}
base.Visit(equality);
}
public override void Visit(IEquality equality)
{
allElements.Add(new InvokInfo(Traverser, "IEquality", equality));
}
public override IExpression Rewrite(IEquality operation)
{
_log.Info("Rewriting IEquality: " + operation + " Pass: "******"Left")
{
thisArgument = operation.LeftOperand;
argument = operation.RightOperand;
}
else
{
thisArgument = operation.RightOperand;
argument = operation.LeftOperand;
}
methodCall.ThisArgument = thisArgument;
methodCall.MethodToCall = TypeHelper.GetMethod(Host.PlatformType.SystemObject.ResolvedType.Members,
Host.NameTable.GetNameFor("Equals"),
Host.PlatformType.SystemObject);
methodCall.Arguments = argument.InList();
return methodCall;
}
public virtual void onASTElement(IEquality equality) { }
/// <summary>
/// Traverses the equality expression.
/// </summary>
public void Traverse(IEquality equality)
{
Contract.Requires(equality != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(equality);
if (this.StopTraversal) return;
this.TraverseChildren(equality);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(equality);
}
public void Visit(IEquality equality)
{
this.result = this.rewriter.Rewrite(equality);
}
public void Visit(IEquality equality)
{
this.traverser.Traverse(equality);
}
private HLLocation ProcessEqualityExpression(IEquality pExpression)
{
HLLocation locationLeftOperand = ProcessExpression(pExpression.LeftOperand);
HLLocation locationRightOperand = ProcessExpression(pExpression.RightOperand);
HLLocation locationTemporary = HLTemporaryLocation.Create(CreateTemporary(HLDomain.GetOrCreateType(pExpression.Type)));
mCurrentBlock.EmitCompare(HLCompareType.Equal, locationTemporary, locationLeftOperand, locationRightOperand);
return pExpression.ResultIsUnmodifiedLeftOperand ? locationLeftOperand : locationTemporary;
}
public void Visit(IEquality equality)
{
Contract.Requires(equality != null);
throw new NotImplementedException();
}
public override void TraverseChildren(IEquality equality)
{ MethodEnter(equality);
base.TraverseChildren(equality);
MethodExit(); }
/// <summary>
/// Generates IL for the specified equality.
/// </summary>
/// <param name="equality">The equality.</param>
public override void TraverseChildren(IEquality equality)
{
this.Traverse(equality.LeftOperand);
this.Traverse(equality.RightOperand);
this.generator.Emit(OperationCode.Ceq);
this.StackSize--;
}
/// <summary>
/// Performs some computation with the given equality expression.
/// </summary>
/// <param name="equality"></param>
public virtual void Visit(IEquality equality)
{
}
public override void TraverseChildren(IEquality equality) {
base.TraverseChildren(equality);
((Equality)equality).Type = this.platformType.SystemBoolean;
}
/// <summary>
/// Traverses the children of the equality expression.
/// </summary>
public virtual void TraverseChildren(IEquality equality)
{
Contract.Requires(equality != null);
this.TraverseChildren((IBinaryOperation)equality);
}
/// <summary>
/// Returns a deep copy of the given equality expression.
/// </summary>
/// <param name="equality"></param>
public Equality Copy(IEquality equality) {
Contract.Requires(equality != null);
Contract.Ensures(Contract.Result<Equality>() != null);
var mutableCopy = this.shallowCopier.Copy(equality);
this.CopyChildren((BinaryOperation)mutableCopy);
return mutableCopy;
}
/// <summary>
/// Performs some computation with the given equality expression.
/// </summary>
/// <param name="equality"></param>
public virtual void Visit(IEquality equality)
{
this.Visit((IBinaryOperation)equality);
}
/// <summary>
/// Returns a shallow copy of the given equality expression.
/// </summary>
/// <param name="equality"></param>
public Equality Copy(IEquality equality) {
Contract.Requires(equality != null);
Contract.Ensures(Contract.Result<Equality>() != null);
return new Equality(equality);
}
public void Visit(IEquality equality)
{
throw new NotImplementedException();
}
/// <summary>
/// Performs some computation with the given equality expression.
/// </summary>
/// <param name="equality"></param>
public virtual void Visit(IEquality equality)
{
}
public override IExpression Rewrite(IEquality operation)
{
return(ReplaceOperation(operation));
}
/// <summary>
/// Visits the specified equality.
/// </summary>
/// <param name="equality">The equality.</param>
public override void Visit(IEquality equality)
{
Equality mutableEquality = new Equality(equality);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableEquality);
}
/// <summary>
///
/// </summary>
/// <param name="equality"></param>
public Equality(IEquality equality)
: base(equality)
{
}
/// <summary>
/// Returns a deep copy of the given equality expression.
/// </summary>
/// <param name="equality"></param>
public Equality Copy(IEquality equality)
{
var mutableCopy = this.shallowCopier.Copy(equality);
this.CopyChildren((BinaryOperation)mutableCopy);
return mutableCopy;
}
public override IExpression Rewrite(IEquality equality) {
base.Rewrite(equality);
var cc2 = equality.RightOperand as CompileTimeConstant;
if (cc2 != null && ExpressionHelper.IsNumericZero(cc2) && equality.LeftOperand.Type.TypeCode == PrimitiveTypeCode.Boolean) {
return IfThenElseReplacer.InvertCondition(equality.LeftOperand);
}
return equality;
}
/// <summary>
/// Returns a shallow copy of the given equality expression.
/// </summary>
/// <param name="equality"></param>
public Equality Copy(IEquality equality)
{
return new Equality(equality);
}
public override void TraverseChildren(IEquality equality) {
var needsParen = LowerPrecedenceThanParentExpression(equality);
var savedCurrentPrecedence = this.currentPrecedence;
this.currentPrecedence = this.Precedence(equality);
if (needsParen) this.sourceEmitterOutput.Write("(");
this.Traverse(equality.LeftOperand);
this.sourceEmitterOutput.Write(" == ");
this.Traverse(equality.RightOperand);
if (needsParen) this.sourceEmitterOutput.Write(")");
this.currentPrecedence = savedCurrentPrecedence;
}
public void Visit(IEquality equality)
{
this.result = this.copier.Copy(equality);
}
public override void TraverseChildren(IEquality equality)
{
MethodEnter(equality);
base.TraverseChildren(equality);
MethodExit();
}
/// <summary>
/// Rewrites the given equality expression.
/// </summary>
/// <param name="equality"></param>
public virtual IExpression Rewrite(IEquality equality)
{
var mutableEquality = equality as Equality;
if (mutableEquality == null) return equality;
this.RewriteChildren(mutableEquality);
return mutableEquality;
}
