//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
public override Expression visit(FAE f)
{
context.Push(f.ToString());
base.visit(f);
context.Pop();
Expression result = f;
bool add = true;
if (f.arguments.count == 0)
{
add = false;
}
if (f.arguments.count == 1 && (f.arguments[0] is AtomicExpression))
{
add = false;
}
// if (BasicFunction.isBinaryLogical(f.function) /*&& (f.arguments[0] is AtomicExpression) && (f.arguments[1] is AtomicExpression)*/)
// add = false;
// if (BasicFunction.isUnaryLogical(f.function) /*&& (f.arguments[0] is AtomicExpression)*/)
// add = false;
if (add)
{
addSubexpression(f, context.Peek());
}
return(f);
}
private void addFunctionInstantiation(FAE e)
{
if (ExpressionSymbolCounter.isInterpreted(e.function.name))
{
return;
}
var f = e.function as BasicFunctionTemplateInstance;
if (f == null /*|| f.template.mapTypeArguments.Count()==0*/)
{
return;
}
FunctioneTemplateEntry fti;
if (!functionTemplateInstantiations.TryGetValue(e.function.name, out fti))
{
functionTemplateInstantiations[e.function.name] = fti = new FunctioneTemplateEntry(f.template);
}
string s = argumentString(f.typeArguments);
if (!fti.instances.ContainsKey(s))
{
fti.instances[s] = new Dictionary <string, FAE>();
}
fti.instances[s][e.ToString()] = e;
if (f.isGroundInstance())
{
fti.groundInstances.Add(s);
}
}
public override Expression visit(FAE f)
{
Debug.Assert(procedure != null);
// if (f.ToString().Contains(@"read($h,read($h,$o,AVLTree.root),alloc)"))
// Debugger.Break();
Expression result = base.visit(f);
var rfae = result as FAE;
FunctionTemplate template = procedure.findFunctionTemplate(rfae.function.name);
if (rfae != null && template != null && template.body != null && template.attributes.Contains(":inline true"))
{
var fti = rfae.function as BasicFunctionTemplateInstance;
Debug.Assert(fti != null);
Debug.Assert(fti.template == template);
var substitution = new ExpressionSubstitution();
for (int i = 0; i < template.typeParameters.Length; i++)
{
substitution.typeSubstitution.add(template.typeParameters[i], fti.typeArguments[i]);
}
for (int i = 0; i < rfae.arguments.count; i++)
{
substitution.add(template.body.arguments[i].name, rfae.arguments[i]);
}
result = template.body.expression.substitute(substitution);
// var r1 = result;
result = result.visit(this);
// if (!ReferenceEquals(r1, result) && r1.ToString().Contains(@"$inv"))
// Debugger.Break();
}
return(result);
}
private void collectMapWrite(FAE fae)
{
var mu = fae.function as MapWrite;
MapRead ml = mu2ml(mu);
var mlArgs = fae.arguments.Take(fae.arguments.Count() - 1).ToArray();
addInstance(ml, new ExpressionList(mlArgs));
}
////////////////////////////////////////////////////////////////////////////
public override Expression visit(FAE e)
{
Expression result = e;
string oes = e.ToString();
result = base.visit(e);
result = checkReplace(result);
return(result);
}
public override Expression visit(FAE fae)
{
if (!(fae.function is MapWrite))
{
return(base.visit(fae));
}
Expression um = makeMapWriteMap(fae);
return(um);
}
public Expression visit(FAE e)
{
if (!isInterpreted(e.function))
{
symbols.Add(e.function.name);
}
foreach (var a in e.arguments)
{
a.visit(this);
}
return(e);
}
public virtual Expression visit(FAE f)
{
Function newF = visitFunction(f.function);
ExpressionList newA = f.arguments.visit(this);
Expression result;
if (!ReferenceEquals(f.function, newF) || !ReferenceEquals(f.arguments, newA))
{
result = new BasicFAE(newF, newA);
}
else
{
result = f;
}
return(result);
}
private Expression makeMapWriteMap(FAE fae)
{
Debug.Assert(fae.function is MapWrite);
Debug.Assert(fae.arguments[0].type is MapType);
var mu = fae.function as MapWrite;
Expression result;
if (!versionMap.TryGetValue(fae.ToString(), out result))
{
var ot = fae.arguments[0].type as MapType;
Debug.Assert(ot != null);
var s = new TypeParameterInstantiation(ot.typeParameters, mu.typeArguments.Skip(1).ToArray());
// var ots = new MapType(new TypeVariable[0], (from m in ot.domain select m.substitute(s)).ToArray(), ot.range.substitute(s));
Expression m = fae.arguments[0];
Expression[] i = fae.arguments.Take(fae.arguments.count - 1).Skip(1).ToArray();
if (fae.freeVariables.Count > 0)
{
//m(fv)[i(fv):=x(fv)] ==> v(fv) (assume v(fv)[i]==x, assume forall fv : forall j : j!=i(fv) ==> v(fv)[j] == m(fv)[j]
var fvt = TypeTuple.make(from fv in fae.freeVariables select fv.type);
string fn = getFreshMUName("mu");
var ft = new BFunctionTemplate(fn, "", new TypeVariable[0], new BasicFunctionSignature(ot, fvt),
null);
Function f = ft.getInstance();
IEnumerable <BasicBoundVariableExpression> fve = from fv in fae.freeVariables
select new BasicBoundVariableExpression(fv);
result = new BasicFAE(f, new ExpressionList(fve));
}
else
{
//m[i:=x] ==> v (assume v[i]==x, assume forall j : j!=i ==> v[j] == m[j]
string nvn = getFreshMUName("mu");
var nv = new ProgramVariable(nvn, ot, false, false, false, false);
procedure.addVariable(nv);
result = new BasicProgramVariableExpression(nv);
}
Expression[] j =
(from e in i select new BasicBoundVariableExpression(makeBoundVariable(e.type))).ToArray();
//forall j : j!=i ==> v[j]==m[j]
addConditionalMapEqualityAxiom(i, result, m, mu.typeArguments);
//v[i]==x;
Expression x = fae.arguments.Last();
addEqualityAxiom(ml(result, i, mu.typeArguments.Skip(1).ToArray(), x.type), fae.arguments.Last());
}
return(result);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private Expression removeTypeQuantification(FAE e)
{
var na = new Expression[e.arguments.count];
bool changed = false;
for (int i = 0; i < e.arguments.count; i++)
{
na[i] = removeTypeQuantification(e.arguments[i]);
if (!ReferenceEquals(na[i], e.arguments[i]))
{
changed = true;
}
}
if (changed)
{
return(new BasicFAE(e.function, new ExpressionList(na)));
}
return(e);
}
private void collect(FAE fae)
{
foreach (var a in fae.arguments)
{
collect(a);
}
if (fae.function is MapWrite)
{
collectMapWrite(fae);
}
else if (BFunction.isEquality(fae.function) && fae.arguments[0].type is MapType)
{
collectMapEquality(fae);
}
else
{
addInstance(fae.function, fae.arguments);
}
}
public Expression visit(FAE e)
{
addExpression(e);
addFunctionInstantiation(e);
if (e.type.freeTypeVariables.Count > 0)
{
tqStack.Peek().addExpression(e);
}
// else
{
e.type.visit(this);
foreach (var a in e.arguments)
{
a.visit(this);
}
}
return(e);
}
public Expression visit(FAE e)
{
var ml = e.function as MapRead;
if (ml != null)
{
Dictionary <string, ITypeTuple> entry;
if (!srs.mapReads.TryGetValue(ml.mapType.ToStringN(), out entry))
{
srs.mapReads[ml.mapType.ToStringN()] = entry = new Dictionary <string, ITypeTuple>();
}
var dts = TypeTuple.make(ml.mapTypeArguments);
entry[dts.ToString()] = dts;
}
foreach (var a in e.arguments)
{
a.visit(this);
}
return(e);
}
public FieldWriteMapIncarnation(IncarnationAndInequalityMap mapAnalyzer, Expression incarnation,
FAE mapWrite)
: base(mapAnalyzer, incarnation)
{
Debug.Assert(mapWrite != null);
Debug.Assert(mapWrite.function is MapWrite);
Debug.Assert(mapWrite.arguments.count > 2);
Debug.Assert(mapWrite.arguments[0] is ProgramVariableExpression);
this.mapWrite = mapWrite;
predecessor =
mapAnalyzer.mapIncarnationMap[(mapWrite.arguments[0] as ProgramVariableExpression).programVariable.name
];
Debug.Assert(predecessor != null);
var ui = new List <Expression>();
for (var i = 1; i < mapWrite.arguments.count - 1; i++)
{
ui.Add(mapWrite.arguments[i]);
}
updatedIndices = new ExpressionList(ui);
cache = new Dictionary <string, Expression>();
}
private void collectMapEquality(FAE fae)
{
//throw new NotImplementedException();
}
public Expression visit(FAE e)
{
functions.Add(e.function);
return(e);
}
