public override Function VisitFunction(Function node)
{
Debug.Assert(node != null);
if (InAxiom)
{
Debug.Assert(CurrentAxiom != null);
if (IgnoreInterpretedFunctionsInAxioms && ExprUtil.AsUninterpretedFunction(node) == null)
{
// This FunctionCall does not call an uninterpreted function. Therefore it must call an
// an interpreted function
return(node);
}
if (FuncsUsedInAxiom[CurrentAxiom].Contains(node))
{
// We've already visited this function before
// in the context of this axiom. So don't visit again.
// This means we might travserse the same function
// body multiple times in the context of different axioms.
// I think that means we'll never get stuck traversing
// recursive function bodies but I'm not sure.
return(node);
}
// Record the mapping both ways
if (!AxiomsUsingFunc.ContainsKey(node))
{
AxiomsUsingFunc[node] = new HashSet <Axiom>();
}
AxiomsUsingFunc[node].Add(CurrentAxiom);
// Assume Hash set has already been initialised
FuncsUsedInAxiom[CurrentAxiom].Add(node);
}
else
{
if (FuncsUsedInCode.Contains(node))
{
// We've visited this function before in the context
// of code so we don't need to add it to `FuncsUsedInCode`
// or travserse its body again. Traversing again might
// get us stuck in a loop with recursive functions.
return(node);
}
FuncsUsedInCode.Add(node);
}
// Now if the function has a body traverse that because
// this function depends on functions that this function calls
if (node.Body != null)
{
Visit(node.Body);
}
return(node);
}
public void NotUninterpretedFunction()
{
var sb = GetSimpleBuilder();
var constant = sb.ConstantBV(0, 32); // 0bv32
var addConstants = sb.BVADD(constant, constant);
var asUF = ExprUtil.AsUninterpretedFunctionCall(addConstants);
Assert.IsNull(asUF);
// Yuck...
var func = ((addConstants as NAryExpr).Fun as FunctionCall).Func;
Assert.IsNull(ExprUtil.AsUninterpretedFunction(func));
}
public void UninterpretedFunction()
{
var FCB = new Symbooglix.FunctionCallBuilder();
var funcCall = FCB.CreateCachedUninterpretedFunctionCall(
"foo",
BType.Bool, // Return type
new List <Microsoft.Boogie.Type>()
{
BType.GetBvType(32), BType.GetBvType(32)
}
);
Assert.IsNotNull(ExprUtil.AsUninterpretedFunction(funcCall.Func));
var sb = GetSimpleBuilder();
var callFunc = sb.UFC(funcCall, sb.ConstantBV(0, 32), sb.ConstantBV(1, 32));
var asUF = ExprUtil.AsUninterpretedFunctionCall(callFunc);
Assert.IsNotNull(asUF);
}
