public override IAstNode VisitAssignFieldStmt(MicroCParser.AssignFieldStmtContext context)
{
var label = ++_label;
string recName = context.name.Text;
string fieldName = context.field.Text;
var recSymbol = _symbolTable.LookupSymbol(recName);
if (recSymbol == null)
{
throw new ArgumentException($"Record: {recName} does not exist");
}
var fieldSymbol = recSymbol.Children.SingleOrDefault(f => f.Name == fieldName);
if (fieldSymbol == null)
{
throw new ArgumentException($"Record: {recName} does not include a field: {fieldName}");
}
var recIdent = new Identifier(recName, recSymbol.Type, recSymbol.Id);
var fieldIdent = new Identifier(fieldName, fieldSymbol.Type, fieldSymbol.Id);
RecordAccess left = new RecordAccess(recIdent, fieldIdent);
IAExpr right = Visit(context.a_expr()) as IAExpr;
var assignStmt = new AssignStmt(left, right);
assignStmt.Label = label;
return(assignStmt);
}
Stmt parseAssignTo(Exp start)
{
AssignStmt stmtassign = new AssignStmt();
stmtassign.IsAssignTo = true;
stmtassign.RightValueExp = start;
MoveNext();
stmtassign.LeftToExp = parseExp();
matchSemiOrNewLine();//match(TokenKind.Semi);
return(stmtassign);
}
private (VariableAccessExpr, IPStmt) SaveInTemporary(IPExpr expr, PLanguageType tempType)
{
Antlr4.Runtime.ParserRuleContext location = expr.SourceLocation;
Variable temp = function.Scope.Put($"$tmp{numTemp++}", location, VariableRole.Local | VariableRole.Temp);
Debug.Assert(tempType.IsAssignableFrom(expr.Type));
temp.Type = tempType;
function.AddLocalVariable(temp);
AssignStmt stmt = new AssignStmt(location, new VariableAccessExpr(location, temp), expr);
return(new VariableAccessExpr(location, temp), stmt);
}
private IADomain AssignTransfer(AssignStmt assignStmt, IADomain domain)
{
var newDomain = CopyDomain(domain);
if (domain.IsBottom())
{
return(newDomain);
}
var ident = assignStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
var newValue = assignStmt.Left switch
{
VarAccess varAccess => IAUtil.Arithmetic(assignStmt.Right, domain),
RecordAccess recordAccess => IAUtil.Arithmetic(assignStmt.Right, domain),
ArrayAccess arrayAccess => IAUtil.Arithmetic(assignStmt.Right, domain)
.Join(domain[ident]),
//.Join(IAUtil.Arithmetic(arrayAccess.Right, domain)),
};
if (assignStmt.Left is ArrayAccess)
{
var ra = assignStmt.Left as ArrayAccess;
var indexInterval = IAUtil.Arithmetic(ra.Right, domain);
if (indexInterval.IsBottom)
{
return(Bottom().GetDomain());
}
var arrayIndices = new Interval(new ExtendedZ(0), new ExtendedZ(ra.Left.Size - 1));
var meet = indexInterval.Meet(arrayIndices);
if (indexInterval.Meet(arrayIndices).IsBottom)
{
return(Bottom().GetDomain());
}
}
if (newValue.IsBottom)
{
return(Bottom().GetDomain());
}
newDomain[ident] = newValue.ToIntervalK(_program);
return(newDomain);
}
Stmt parseAssign(Exp start)
{
AssignStmt stmtassign = new AssignStmt();
stmtassign.LeftToExp = start;
//if(start is FTextExp)
//{
// FTextExp idexp = start as FTextExp;
// //spliter.Add(idexp.IdToken);
//}
MoveNext();
stmtassign.RightValueExp = parseExp();
matchSemiOrNewLine();//match(TokenKind.Semi);
return(stmtassign);
}
public override IAstNode VisitAssignStmt(MicroCParser.AssignStmtContext context)
{
var label = ++_label;
var name = context.IDENT().GetText();
var symbol = _symbolTable.LookupSymbol(name);
var ident = new Identifier(name, symbol.Type, symbol.Id);
// TODO: Type check the symbol
VarAccess left = new VarAccess(ident);
IAExpr right = Visit(context.a_expr()) as IAExpr;
var assignStmt = new AssignStmt(left, right);
assignStmt.Label = label;
return(assignStmt);
}
public string GenerateString(AssignStmt statement, int tabs)
{
var bob = new StringBuilder();
if (statement.Rhs is ExprRhs)
{
ApplyIndentation(bob, tabs);
bob.Append(GenerateString(statement.Lhs) +
" " +
statement.Tok.val +
" " +
GenerateString((statement.Rhs as ExprRhs).Expr) +
statement.EndTok.val);
}
return(bob.ToString());
}
private List <IPStmt> SimplifyStatement(IPStmt statement)
{
Antlr4.Runtime.ParserRuleContext location = statement?.SourceLocation;
switch (statement)
{
case null:
throw new ArgumentNullException(nameof(statement));
case AnnounceStmt announceStmt:
(IExprTerm annEvt, List <IPStmt> annEvtDeps) = SimplifyExpression(announceStmt.PEvent);
(IExprTerm annPayload, List <IPStmt> annPayloadDeps) = announceStmt.Payload == null
? (null, new List <IPStmt>())
: SimplifyExpression(announceStmt.Payload);
return(annEvtDeps.Concat(annPayloadDeps)
.Concat(new[]
{
new AnnounceStmt(location, annEvt, annPayload)
})
.ToList());
case AssertStmt assertStmt:
(IExprTerm assertExpr, List <IPStmt> assertDeps) = SimplifyExpression(assertStmt.Assertion);
(IExprTerm messageExpr, List <IPStmt> messageDeps) = SimplifyExpression(assertStmt.Message);
return(assertDeps.Concat(messageDeps).Concat(new[]
{
new AssertStmt(location, assertExpr, messageExpr)
})
.ToList());
case AssignStmt assignStmt:
(IPExpr assignLV, List <IPStmt> assignLVDeps) = SimplifyLvalue(assignStmt.Location);
(IExprTerm assignRV, List <IPStmt> assignRVDeps) = SimplifyRvalue(assignStmt.Value);
IPStmt assignment;
// If temporary returned, then automatically move.
if (assignRV is VariableAccessExpr variableRef &&
variableRef.Variable.Role.HasFlag(VariableRole.Temp))
{
assignment = new MoveAssignStmt(location, assignLV, variableRef.Variable);
}
else
{
assignment = new AssignStmt(location, assignLV, new CloneExpr(assignRV));
}
return(assignLVDeps.Concat(assignRVDeps).Concat(new[] { assignment }).ToList());
public override IAstNode VisitAssignArrayStmt(MicroCParser.AssignArrayStmtContext context)
{
var label = ++_label;
string name = context.IDENT().GetText();
var symbol = _symbolTable.LookupSymbol(name);
var ident = new Identifier(name, symbol.Type, symbol.Id, symbol.Size);
// TODO: Type check the symbol
IAExpr index = Visit(context.index) as IAExpr;
ArrayAccess left = new ArrayAccess(ident, index);
IAExpr right = Visit(context.value) as IAExpr;
var assignStmt = new AssignStmt(left, right);
assignStmt.Label = label;
return(assignStmt);
}
protected override ILattice <FVDomain> TransferFunctions(int label)
{
var block = GetBlock(label);
var domain = _analysisCircle[label].GetDomain();
var newDomain = block switch
{
AssignStmt assignStmt => AssignTransfer(assignStmt, domain),
RecAssignStmt recAssignStmt => RecAssignTransfer(recAssignStmt, domain),
IfStmt ifStmt => ConditionTransfer(ifStmt.Condition, domain),
IfElseStmt ifElseStmt => ConditionTransfer(ifElseStmt.Condition, domain),
WhileStmt whileStmt => ConditionTransfer(whileStmt.Condition, domain),
WriteStmt writeStmt => WriteTransfer(writeStmt, domain),
ReadStmt readStmt => ReadTransfer(readStmt, domain),
_ => new FVDomain(),
};
return(new FVLattice(newDomain));
}
protected override ILattice <IADomain> TransferFunctions(int label)
{
var block = GetBlock(label);
var domain = _analysisCircle[label].GetDomain();
var newDomain = block switch
{
IntDecl intDecl => IntDeclTransfer(intDecl, domain),
ArrayDecl arrayDecl => ArrayDeclTransfer(arrayDecl, domain),
RecordDecl recordDecl => RecDeclTransfer(recordDecl, domain),
AssignStmt assignStmt => AssignTransfer(assignStmt, domain),
RecAssignStmt recAssignStmt => RecAssignTransfer(recAssignStmt, domain),
IfStmt ifStmt => IdTransfer(ifStmt, domain),
IfElseStmt ifElseStmt => IdTransfer(ifElseStmt, domain),
WhileStmt whileStmt => IdTransfer(whileStmt, domain),
WriteStmt writeStmt => IdTransfer(writeStmt, domain),
ReadStmt readStmt => ReadTransfer(readStmt, domain),
_ => Bottom().GetDomain(),
};
return(new IALattice(newDomain));
}
private DSDomain AssignTransfer(AssignStmt assignStmt, DSDomain domain)
{
var ident = assignStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
var newDomain = CopyDomain(domain);
var newValue = assignStmt.Left switch
{
VarAccess varAccess => DSUtil.Arithmetic(assignStmt.Right, domain),
RecordAccess recordAccess => DSUtil.Arithmetic(assignStmt.Right, domain),
ArrayAccess arrayAccess => DSUtil.Arithmetic(assignStmt.Right, domain)
.Union(domain[ident])
//.Union(DSUtil.Arithmetic(arrayAccess.Right, domain)),
};
newDomain[ident] = newValue.ToHashSet();
return(newDomain);
}
private FVDomain AssignTransfer(AssignStmt assignStmt, FVDomain domain)
{
var ident = assignStmt.Left switch
{
VarAccess varAccess => varAccess.Left,
ArrayAccess arrayAccess => arrayAccess.Left,
RecordAccess recordAccess => recordAccess.Right,
};
if (!domain.Contains(ident))
{
return(domain);
}
var fv = AnalysisUtil.FreeVariables(assignStmt.Right);
var fv2 = assignStmt.Left switch
{
ArrayAccess arrayAccess => AnalysisUtil.FreeVariables(arrayAccess.Right),
_ => new HashSet <Identifier>(),
};
var freeVariables = fv.Union(fv2);
return(domain.Except(ident.Singleton()).Union(freeVariables).ToFVDomain());
}
public void FinalizeStatement()
{
Statement = new AssignStmt(Id, Exp.GetExp());
}
public virtual Statement CloneStmt(Statement stmt) {
if (stmt == null) {
return null;
}
Statement r;
if (stmt is AssertStmt) {
var s = (AssertStmt)stmt;
r = new AssertStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null);
} else if (stmt is AssumeStmt) {
var s = (AssumeStmt)stmt;
r = new AssumeStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null);
} else if (stmt is TacticInvariantStmt) {
var s = (TacticInvariantStmt)stmt;
r = new TacticInvariantStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null, s.IsObjectLevel);
} else if (stmt is TacticAssertStmt) {
var s = (TacticAssertStmt)stmt;
r = new TacticAssertStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null, s.IsObjectLevel);
} else if (stmt is PrintStmt) {
var s = (PrintStmt)stmt;
r = new PrintStmt(Tok(s.Tok), Tok(s.EndTok), s.Args.ConvertAll(CloneExpr));
} else if (stmt is BreakStmt) {
var s = (BreakStmt)stmt;
if (s.TargetLabel != null) {
r = new BreakStmt(Tok(s.Tok), Tok(s.EndTok), s.TargetLabel);
} else {
r = new BreakStmt(Tok(s.Tok), Tok(s.EndTok), s.BreakCount);
}
} else if (stmt is ReturnStmt) {
var s = (ReturnStmt)stmt;
r = new ReturnStmt(Tok(s.Tok), Tok(s.EndTok), s.rhss == null ? null : s.rhss.ConvertAll(CloneRHS));
} else if (stmt is YieldStmt) {
var s = (YieldStmt)stmt;
r = new YieldStmt(Tok(s.Tok), Tok(s.EndTok), s.rhss == null ? null : s.rhss.ConvertAll(CloneRHS));
} else if (stmt is AssignStmt) {
var s = (AssignStmt)stmt;
r = new AssignStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Lhs), CloneRHS(s.Rhs));
} else if (stmt is BlockStmt) {
r = CloneBlockStmt((BlockStmt)stmt);
} else if (stmt is IfStmt) {
var s = (IfStmt)stmt;
r = new IfStmt(Tok(s.Tok), Tok(s.EndTok), s.IsExistentialGuard, CloneExpr(s.Guard), CloneBlockStmt(s.Thn), CloneStmt(s.Els));
} else if (stmt is AlternativeStmt) {
var s = (AlternativeStmt)stmt;
r = new AlternativeStmt(Tok(s.Tok), Tok(s.EndTok), s.Alternatives.ConvertAll(CloneGuardedAlternative));
} else if (stmt is WhileStmt) {
var s = (WhileStmt)stmt;
r = new WhileStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Guard), s.Invariants.ConvertAll(CloneMayBeFreeExpr), CloneSpecExpr(s.Decreases), CloneSpecFrameExpr(s.Mod), CloneBlockStmt(s.Body));
((WhileStmt)r).TacAps = s.TacAps;
} else if (stmt is AlternativeLoopStmt) {
var s = (AlternativeLoopStmt)stmt;
r = new AlternativeLoopStmt(Tok(s.Tok), Tok(s.EndTok), s.Invariants.ConvertAll(CloneMayBeFreeExpr), CloneSpecExpr(s.Decreases), CloneSpecFrameExpr(s.Mod), s.Alternatives.ConvertAll(CloneGuardedAlternative));
} else if (stmt is ForallStmt) {
var s = (ForallStmt)stmt;
r = new ForallStmt(Tok(s.Tok), Tok(s.EndTok), s.BoundVars.ConvertAll(CloneBoundVar), null, CloneExpr(s.Range), s.Ens.ConvertAll(CloneMayBeFreeExpr), CloneStmt(s.Body));
if (s.ForallExpressions != null) {
((ForallStmt)r).ForallExpressions = s.ForallExpressions.ConvertAll(CloneExpr);
}
} else if (stmt is CalcStmt) {
var s = (CalcStmt)stmt;
// calc statements have the unusual property that the last line is duplicated. If that is the case (which
// we expect it to be here), we share the clone of that line as well.
var lineCount = s.Lines.Count;
var lines = new List<Expression>(lineCount);
for (int i = 0; i < lineCount; i++) {
lines.Add(i == lineCount - 1 && 2 <= lineCount && s.Lines[i] == s.Lines[i - 1] ? lines[i - 1] : CloneExpr(s.Lines[i]));
}
Contract.Assert(lines.Count == lineCount);
r = new CalcStmt(Tok(s.Tok), Tok(s.EndTok), CloneCalcOp(s.Op), lines, s.Hints.ConvertAll(CloneBlockStmt), s.StepOps.ConvertAll(CloneCalcOp), CloneCalcOp(s.ResultOp), CloneAttributes(s.Attributes));
} else if (stmt is MatchStmt) {
var s = (MatchStmt)stmt;
r = new MatchStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Source),
s.Cases.ConvertAll(CloneMatchCaseStmt), s.UsesOptionalBraces);
} else if (stmt is AssignSuchThatStmt) {
var s = (AssignSuchThatStmt)stmt;
r = new AssignSuchThatStmt(Tok(s.Tok), Tok(s.EndTok), s.Lhss.ConvertAll(CloneExpr), CloneExpr(s.Expr), s.AssumeToken == null ? null : Tok(s.AssumeToken), null);
} else if (stmt is UpdateStmt) {
var s = (UpdateStmt)stmt;
r = new UpdateStmt(Tok(s.Tok), Tok(s.EndTok), s.Lhss.ConvertAll(CloneExpr), s.Rhss.ConvertAll(CloneRHS), s.CanMutateKnownState);
} else if (stmt is VarDeclStmt) {
var s = (VarDeclStmt)stmt;
var lhss = s.Locals.ConvertAll(c => new LocalVariable(Tok(c.Tok), Tok(c.EndTok), c.Name, CloneType(c.OptionalType), c.IsGhost));
r = new VarDeclStmt(Tok(s.Tok), Tok(s.EndTok), lhss, (ConcreteUpdateStatement)CloneStmt(s.Update));
} else if (stmt is LetStmt) {
var s = (LetStmt)stmt;
r = new LetStmt(Tok(s.Tok), Tok(s.EndTok), s.LHSs.ConvertAll(CloneCasePattern), s.RHSs.ConvertAll(CloneExpr));
} else if (stmt is ModifyStmt) {
var s = (ModifyStmt)stmt;
var mod = CloneSpecFrameExpr(s.Mod);
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new ModifyStmt(Tok(s.Tok), Tok(s.EndTok), mod.Expressions, mod.Attributes, body);
} else if (stmt is TacnyCasesBlockStmt) {
var s = (TacnyCasesBlockStmt)stmt;
var guard = CloneExpr(s.Guard);
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnyCasesBlockStmt(Tok(s.Tok), Tok(s.EndTok), guard, body);
} else if (stmt is TacnyChangedBlockStmt) {
var s = (TacnyChangedBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnyChangedBlockStmt(Tok(s.Tok), Tok(s.EndTok), body);
} else if (stmt is TacnySolvedBlockStmt) {
var s = (TacnySolvedBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnySolvedBlockStmt(Tok(s.Tok), Tok(s.EndTok), body);
} else if (stmt is TacnyTryCatchBlockStmt) {
var s = (TacnyTryCatchBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
var c = s.Ctch == null ? null : CloneBlockStmt(s.Ctch);
r = new TacnyTryCatchBlockStmt(Tok(s.Tok), Tok(s.EndTok), body, c);
} else if (stmt is TacticVarDeclStmt) {
var s = (TacticVarDeclStmt)stmt;
var lhss = s.Locals.ConvertAll(c => new LocalVariable(Tok(c.Tok), Tok(c.EndTok), c.Name, CloneType(c.OptionalType), c.IsGhost));
r = new TacticVarDeclStmt(Tok(s.Tok), Tok(s.EndTok), lhss, (ConcreteUpdateStatement)CloneStmt(s.Update));
} else {
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected statement
}
// add labels to the cloned statement
AddStmtLabels(r, stmt.Labels);
r.Attributes = CloneAttributes(stmt.Attributes);
return r;
}
public virtual void AddResolvedGhostStatement(Statement stmt)
{
BlockStmt block = stmt as BlockStmt;
IfStmt ifStmt = stmt as IfStmt;
AssertStmt assertStmt = stmt as AssertStmt;
AssignStmt assignStmt = stmt as AssignStmt;
CallStmt callStmt = stmt as CallStmt;
VarDecl varDecl = stmt as VarDecl;
CalcStmt calcStmt = stmt as CalcStmt;
ForallStmt forallStmt = stmt as ForallStmt;
AssignSuchThatStmt existsStmt = stmt as AssignSuchThatStmt;
if (block != null)
{
var oldRenamer = PushRename();
block.Body.ForEach(AddGhostStatement);
PopRename(oldRenamer);
}
else if (varDecl != null)
{
AddGhostVarDecl(varDecl.Name, varDecl.Type, varDecl.IsGhost);
}
else if (minVerify)
{
return;
}
else if (assignStmt != null)
{
ExprRhs expRhs = assignStmt.Rhs as ExprRhs;
if (expRhs != null)
{
FieldSelectExpr fieldSelect = assignStmt.Lhs as FieldSelectExpr;
RtlVar destVar;
if (fieldSelect != null)
{
destVar = new RtlVar(GhostVar(fieldSelect.FieldName), true, fieldSelect.Type);
}
else
{
destVar = AsVar(assignStmt.Lhs);
Util.Assert(destVar != null);
}
stmts.Add(new RtlGhostMove(new RtlVar[] { destVar },
new RtlExp[] { GhostExpression(expRhs.Expr) }));
}
else
{
throw new Exception("not implemented: " + assignStmt.Rhs);
}
}
else if (callStmt != null)
{
AddGhostCall(callStmt.Lhs.ConvertAll(AsVar), callStmt.Args,
dafnySpec.Compile_Method(callStmt.Method,
callStmt.TypeArgumentSubstitutions.ToDictionary(p => p.Key, p => AppType(p.Value))),
DafnySpec.IsHeapMethod(callStmt.Method));
SymdiffLinearityPoint();
}
else if (ifStmt != null)
{
stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ") {",
new RtlExp[] { GhostExpression(ifStmt.Guard) }));
Indent();
AddGhostStatement(ifStmt.Thn);
Unindent();
stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0]));
if (ifStmt.Els != null)
{
stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ") {",
new RtlExp[] {
GhostExpression(new UnaryExpr(Bpl.Token.NoToken, UnaryExpr.Opcode.Not, ifStmt.Guard))
}));
Indent();
AddGhostStatement(ifStmt.Els);
Unindent();
stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0]));
}
}
else if (assertStmt != null)
{
stmts.Add(new RtlAssert(GhostExpression(assertStmt.Expr)));
}
else if (forallStmt != null)
{
var oldRenamer = PushRename(forallStmt.BoundVars.Select(v => v.Name));
RtlExp ens = new RtlLiteral("true");
foreach (var e in forallStmt.Ens)
{
ens = new RtlBinary("&&", ens, GhostExpression(e.E));
}
RtlExp range = (forallStmt.Range == null) ? new RtlLiteral("true")
: GhostExpression(forallStmt.Range);
List <RtlExp> wellFormed = GetTypeWellFormed(forallStmt.BoundVars.
Select(x => Tuple.Create(GhostVar(x.Name), x.IsGhost, x.Type)).ToList());
wellFormed.ForEach(e => range = new RtlBinary("&&", e, range));
ens = new RtlBinary("==>", range, ens);
string vars = String.Join(", ", forallStmt.BoundVars.Select(x => GhostVar(x.Name) + ":" +
TypeString(AppType(x.Type))));
stmts.Add(new RtlGhostStmtComputed(s => "forall " + vars + "::(" + s.args[0] + ")",
new List <RtlExp> {
ens
}));
stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0]));
Indent();
stmts.Add(PushForall());
stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ")",
new List <RtlExp> {
range
}));
stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0]));
Indent();
AddGhostStatement(forallStmt.Body);
foreach (var e in forallStmt.Ens)
{
stmts.Add(new RtlAssert(GhostExpression(e.E)));
}
PopForall();
Unindent();
stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0]));
Unindent();
stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0]));
PopRename(oldRenamer);
}
else if (existsStmt != null)
{
List <RtlStmt> assigns = new List <RtlStmt>();
List <RtlVar> tmps = new List <RtlVar>();
List <Tuple <string, bool, Type> > varTuples = new List <Tuple <string, bool, Type> >();
var oldRenamer = PushRename();
foreach (var lhs in existsStmt.Lhss)
{
IdentifierExpr idExp = lhs.Resolved as IdentifierExpr;
RtlVar origVar = AsVar(lhs);
AddRename(idExp.Name);
RtlVar renameVar = AsVar(lhs);
tmps.Add(renameVar);
varTuples.Add(Tuple.Create(renameVar.ToString(), true, idExp.Type));
assigns.Add(new RtlGhostMove(new RtlVar[] { origVar },
new RtlExp[] { renameVar }));
}
string vars = String.Join(", ", tmps.Select(x => x.getName() + ":" + TypeString(AppType(x.type))));
stmts.Add(new RtlGhostStmtComputed(s => "exists " + vars + "::(" + s.args[0] + ");",
new List <RtlExp> {
GetTypeWellFormedExp(varTuples.ToList(), "&&", GhostExpression(existsStmt.Expr))
}));
stmts.AddRange(assigns);
PopRename(oldRenamer);
}
else if (calcStmt != null)
{
Util.Assert(calcStmt.Steps.Count == calcStmt.Hints.Count);
CalcStmt.BinaryCalcOp binOp = calcStmt.Op as CalcStmt.BinaryCalcOp;
bool isImply = binOp != null && binOp.Op == BinaryExpr.Opcode.Imp && calcStmt.Steps.Count > 0;
if (isImply)
{
stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ")",
new RtlExp[] { GhostExpression(CalcStmt.Lhs(calcStmt.Steps[0])) }));
stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0]));
Indent();
}
var stepCount = calcStmt.Hints.Last().Body.Count == 0 ? calcStmt.Steps.Count - 1 : calcStmt.Steps.Count;
for (int i = 0; i < stepCount; i++)
{
if (calcStmt.Hints[i] == null)
{
stmts.Add(new RtlAssert(GhostExpression(calcStmt.Steps[i])));
}
else
{
stmts.Add(new RtlGhostStmtComputed(s => "forall::(" + s.args[0] + ")",
new List <RtlExp> {
GhostExpression(calcStmt.Steps[i])
}));
stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0]));
Indent();
var dict = new Dictionary <string, RtlVar>();
stmts.Add(new RtlGhostStmtComputed(s => String.Concat(dict.Values.Select(
x => "var " + x.x + ":" + TypeString(x.type) + ";")),
new RtlExp[0]));
forallVars.Add(dict);
AddGhostStatement(calcStmt.Hints[i]);
forallVars.RemoveAt(forallVars.Count - 1);
Unindent();
stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0]));
}
}
if (isImply)
{
Unindent();
stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0]));
}
}
else
{
throw new Exception("not implemented in ghost methods: " + stmt);
}
}
static void Main(string[] args)
{
// Example 1
Statement stmt1 = new CompStmt(
new OpenFileStmt("1stFile.txt", "1stFile"),
new CompStmt(new PrintStmt(new ArithmeticExpr('-', new ConstExpr(10), new ConstExpr(5))),
new CompStmt(new AssignStmt(new ConstExpr(11), "b"),
new CompStmt(new IfStmt(new ConstExpr(0),
new PrintStmt(new ConstExpr(1)),
new PrintStmt(new ConstExpr(2))),
new AssignStmt(new ConstExpr(10), "x")))));
PrgState prg1 = new PrgState(stmt1,
new ExeStack <Statement>(),
new SymbolTable <string, int>(),
new FileTable <int, FileStream>(),
new Output <int>());
IRepository repo1 = new Repository("logFile.txt", prg1);
Controller ctrl1 = new Controller(repo1);
// Example 2
Statement stmt2 = new AssignStmt(new ArithmeticExpr('/', new ConstExpr(3), new ConstExpr(0)), "var");
PrgState prg2 = new PrgState(stmt2,
new ExeStack <Statement>(),
new SymbolTable <string, int>(),
new FileTable <int, FileStream>(),
new Output <int>());
IRepository repo2 = new Repository("logFile.txt", prg2);
Controller ctrl2 = new Controller(repo2);
// Example 3
Statement stmt3 = new CompStmt(
new OpenFileStmt("2ndFile.txt", "2ndFile"),
new CompStmt(new ReadFileStmt("2ndFile.txt", "h1"),
new CompStmt(new ReadFileStmt("2ndFile.txt", "h2"), new CloseFileStmt("2ndFile.txt"))));
PrgState prg3 = new PrgState(stmt3,
new ExeStack <Statement>(),
new SymbolTable <string, int>(),
new FileTable <int, FileStream>(),
new Output <int>());
IRepository repo3 = new Repository("logFile.txt", prg3);
Controller ctrl3 = new Controller(repo3);
// Example 4
Statement stmt4 = new CompStmt(
new OpenFileStmt("2ndFile.txt", "2ndFile"),
new CompStmt(new CompStmt(new ReadFileStmt("2ndFile.txt", "h1"),
new CompStmt(new ReadFileStmt("2ndFile.txt", "h2"), new CloseFileStmt("2ndFile.txt"))),
new CompStmt(new OpenFileStmt("1stFile.txt", "1stFile"),
new CompStmt(new ReadFileStmt("1stFile.txt", "h"), new CloseFileStmt("1stFile.txt")))));
PrgState prg4 = new PrgState(stmt4,
new ExeStack <Statement>(),
new SymbolTable <string, int>(),
new FileTable <int, FileStream>(),
new Output <int>());
IRepository repo4 = new Repository("logFile.txt", prg4);
Controller ctrl4 = new Controller(repo4);
// MENU
TextMenu menu = new TextMenu();
menu.addCommand(new ExitCommand("0", "exit"));
menu.addCommand(new RunExample("1", stmt1.ToString(), ctrl1));
menu.addCommand(new RunExample("2", stmt2.ToString(), ctrl2));
menu.addCommand(new RunExample("3", stmt3.ToString(), ctrl3));
menu.addCommand(new RunExample("4", stmt4.ToString(), ctrl4));
menu.show();
}
