private void attachEnsures(Implementation impl)
{
List <Variable> functionInterfaceVars = new List <Variable>();
foreach (Variable v in BoogieUtil.GetGlobalVariables(vcgen.program))
{
functionInterfaceVars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", v.TypedIdent.Type), true));
}
foreach (Variable v in impl.InParams)
{
functionInterfaceVars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", v.TypedIdent.Type), true));
}
foreach (Variable v in impl.OutParams)
{
functionInterfaceVars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", v.TypedIdent.Type), true));
}
foreach (IdentifierExpr e in impl.Proc.Modifies)
{
if (e.Decl == null)
{
continue;
}
functionInterfaceVars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", e.Decl.TypedIdent.Type), true));
}
Formal returnVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Bpl.Type.Bool), false);
var function = new Function(Token.NoToken, impl.Name + summaryPredSuffix, functionInterfaceVars, returnVar);
prover.Context.DeclareFunction(function, "");
List <Expr> exprs = new List <Expr>();
foreach (Variable v in BoogieUtil.GetGlobalVariables(vcgen.program))
{
Contract.Assert(v != null);
exprs.Add(new OldExpr(Token.NoToken, new IdentifierExpr(Token.NoToken, v)));
}
foreach (Variable v in impl.Proc.InParams)
{
Contract.Assert(v != null);
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
foreach (Variable v in impl.Proc.OutParams)
{
Contract.Assert(v != null);
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
foreach (IdentifierExpr ie in impl.Proc.Modifies)
{
Contract.Assert(ie != null);
if (ie.Decl == null)
{
continue;
}
exprs.Add(ie);
}
Expr postExpr = new NAryExpr(Token.NoToken, new FunctionCall(function), exprs);
impl.Proc.Ensures.Add(
new Ensures(Token.NoToken, false, postExpr, ""));
}
static void Main(string[] args)
{
var Basket = new Basket();
var Shirt = new Shirt(); //Adding test data
Shirt.Name = "Armani";
Shirt.Size = "l";
Basket.shirts.Add(Shirt);
var Golf = new Golfer();
Golf.Name = "White";
Golf.Size = "m";
Basket.golfers.Add(Golf);
var jean = new Jeans();
jean.Name = "Skinny";
jean.Size = "s";
Basket.jeans.Add(jean);
var formal = new Formal();
formal.Name = "Guess";
formal.Size = "l";
Basket.formals.Add(formal);
Console.WriteLine("Your total is : R" + Basket.CalcCost()); //output
Console.ReadKey();
}
private CallCmd makeRecordCall(IdentifierExpr v)
{
var ins = new List <Expr>();
ins.Add(v);
if (v.Type.IsInt)
{
return(new CallCmd(Token.NoToken, recordProcNameInt, ins, new List <IdentifierExpr>()));
}
else if (v.Type.IsBool)
{
return(new CallCmd(Token.NoToken, recordProcNameBool, ins, new List <IdentifierExpr>()));
}
else if (v.Type.IsCtor)
{
var t = v.Type.AsCtor.Decl.Name;
if (!typeToRecordProc.ContainsKey(t))
{
var inpVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "x", v.Type), true);
var reProc = new Procedure(Token.NoToken, recordProcNameCtor + t, new List <TypeVariable>(), new List <Variable> {
inpVar
}, new List <Variable>(), new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>());
typeToRecordProc.Add(t, reProc);
}
return(new CallCmd(Token.NoToken, typeToRecordProc[t].Name, ins, new List <IdentifierExpr>()));
}
else
{
Debug.Assert(false);
return(null);
}
}
/// <summary>
/// Sets the value of the named flag.
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <exception cref="ArgumentException">Thrown when name does not exist as flag or when string value cannot be converted to desired type.</exception>
public void Set(string name, string value)
{
var flagExists = Formal.TryGetValue(name, out var flag);
if (!flagExists)
{
throw new ArgumentException("No such flag", nameof(name));
}
if (!flag.TrySetValue(value, out var err))
{
throw new ArgumentException($"Could not set value: {err}", nameof(value));
}
if (Actual == null)
{
Actual = new Dictionary <string, IFlag>();
}
if (Actual.ContainsKey(name))
{
Actual[name] = flag;
}
else
{
Actual.Add(name, flag);
}
}
public override Node VisitBranch([NotNull] coolgrammarParser.BranchContext context)
{
Formal formal = (Formal)Visit(context.formal());
Expr exp = (Expr)Visit(context.expr());
return(new Branch(formal, exp));
}
private static void replaceFECalls(Program prog)
{
prog.AddTopLevelDeclaration(new Procedure(Token.NoToken, "corral_atomic_begin", new List <TypeVariable>(), new List <Variable>(), new List <Variable>(), new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>()));
prog.AddTopLevelDeclaration(new Procedure(Token.NoToken, "corral_atomic_end", new List <TypeVariable>(), new List <Variable>(), new List <Variable>(), new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>()));
Formal id = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "id", Microsoft.Boogie.Type.Int), false);
prog.AddTopLevelDeclaration(new Procedure(Token.NoToken, "corral_getThreadID", new List <TypeVariable>(), new List <Variable>(), new List <Variable>(new Variable[] { id }), new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>()));
HashSet <Declaration> declsToRemove = new HashSet <Declaration>();
foreach (Declaration decl in prog.TopLevelDeclarations)
{
Procedure proc = decl as Procedure;
if (proc != null)
{
if (proc.Name == "Poirot.Poirot.BeginAtomic" || proc.Name == "Poirot.Poirot.EndAtomic" || proc.Name == "Poirot.Poirot.CurrentThreadId")
{
declsToRemove.Add(decl);
}
}
Implementation impl = decl as Implementation;
if (impl == null)
{
continue;
}
foreach (Block b in impl.Blocks)
{
List <Cmd> newCmds = new List <Cmd>();
foreach (Cmd c in b.Cmds)
{
CallCmd cc = c as CallCmd;
if (cc == null)
{
newCmds.Add(c);
continue;
}
if (cc.callee == "Poirot.Poirot.BeginAtomic")
{
newCmds.Add(new CallCmd(cc.tok, "corral_atomic_begin", cc.Ins, cc.Outs));
}
else if (cc.callee == "Poirot.Poirot.EndAtomic")
{
newCmds.Add(new CallCmd(cc.tok, "corral_atomic_end", cc.Ins, cc.Outs));
}
else if (cc.callee == "Poirot.Poirot.CurrentThreadId")
{
newCmds.Add(new CallCmd(cc.tok, "corral_getThreadID", cc.Ins, cc.Outs));
}
else
{
newCmds.Add(cc);
}
}
b.Cmds = newCmds;
}
}
foreach (Declaration decl in declsToRemove)
{
prog.RemoveTopLevelDeclaration(decl);
}
}
public VCExpr ControlFlowFunctionApplication(VCExpr e1, VCExpr e2)
{
Contract.Requires(e1 != null);
Contract.Requires(e2 != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
if (ControlFlowFunction == null)
{
Formal /*!*/
first = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), true);
Formal /*!*/
second = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), true);
List <Variable> inputs = new List <Variable>();
inputs.Add(first);
inputs.Add(second);
Formal /*!*/
returnVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), false);
ControlFlowFunction = new Function(Token.NoToken, "ControlFlow", inputs, returnVar);
}
List <VCExpr /*!*/> args = new List <VCExpr /*!*/>();
args.Add(e1);
args.Add(e2);
return(Function(BoogieFunctionOp(ControlFlowFunction), args));
}
public override Expr VisitNAryExpr(NAryExpr node)
{
var nArgs = node.Args.Select(x => base.VisitExpr(x)).ToList();
node.Args = nArgs;
var fcall = node.Fun as FunctionCall;
if (fcall != null && fcall.Func.HasAttribute(ExprMatchVisitor.BoogieKeyWords.MkUniqueFn))
{
var formals = new List <Variable>();
fcall.Func.InParams.Iter(a =>
{
var z = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, a.Name, a.TypedIdent.Type), true);
formals.Add(z);
});
var r = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "r", fcall.Func.OutParams[0].TypedIdent.Type), false);
var f = new Function(Token.NoToken, fcall.FunctionName + "__" + uniqFuncs.Count,
formals, r);
//inherit all attributes other than mkUniqueFn
f.Attributes = BoogieUtil.removeAttr(ExprMatchVisitor.BoogieKeyWords.MkUniqueFn, fcall.Func.Attributes);
f.Body = fcall.Func.Body;
uniqFuncs.Add(f);
program.AddTopLevelDeclaration(f);
node.Fun = new FunctionCall(f);
}
return(node);
}
public void Visit(Formal node)
{
builder.AppendLine($"Formal({node.Name})");
builder.Indent();
node.TypeDeclaration.Accept(this);
builder.Outdent();
}
internal void AddFlag <T>(Flag <T> flag)
{
foreach (var name in flag.Name.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
{
Formal.Add(name.Trim(), flag);
}
}
private void GenerateRecordFunctions()
{
foreach (var proc in program.Procedures)
{
if (!proc.Name.StartsWith(recordProcName)) continue;
Contract.Assert(proc.InParams.Count == 1);
// Make a new function
TypedIdent ti = new TypedIdent(Token.NoToken, "", Bpl.Type.Bool);
Contract.Assert(ti != null);
Formal returnVar = new Formal(Token.NoToken, ti, false);
Contract.Assert(returnVar != null);
// Get record type
var argtype = proc.InParams[0].TypedIdent.Type;
var ins = new List<Variable>();
ins.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "x", argtype), true));
var recordFunc = new Function(Token.NoToken, proc.Name, ins, returnVar);
prover.Context.DeclareFunction(recordFunc, "");
var exprs = new List<Expr>();
exprs.Add(new IdentifierExpr(Token.NoToken, proc.InParams[0]));
Expr freePostExpr = new NAryExpr(Token.NoToken, new FunctionCall(recordFunc), exprs);
proc.Ensures.Add(new Ensures(true, freePostExpr));
}
}
private AtomicActionDuplicator(string prefix, AtomicAction action)
{
this.prefix = prefix;
subst = new Dictionary <Variable, Expr>();
bound = new Dictionary <Variable, Expr>();
inParamsCopy = new List <Variable>();
outParamsCopy = new List <Variable>();
localsCopy = new List <Variable>();
foreach (Variable x in action.impl.InParams)
{
Variable xCopy = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, prefix + x.Name, x.TypedIdent.Type), true, x.Attributes);
inParamsCopy.Add(xCopy);
subst[x] = Expr.Ident(xCopy);
}
foreach (Variable x in action.impl.OutParams)
{
Variable xCopy = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, prefix + x.Name, x.TypedIdent.Type), false, x.Attributes);
outParamsCopy.Add(xCopy);
subst[x] = Expr.Ident(xCopy);
}
foreach (Variable x in action.impl.LocVars)
{
Variable xCopy = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, prefix + x.Name, x.TypedIdent.Type));
subst[x] = Expr.Ident(xCopy);
localsCopy.Add(xCopy);
}
}
public static Expr Extract(Expr expr, Program program, List <Axiom> axioms)
{
Contract.Requires(expr != null && program != null && !program.TopLevelDeclarationsAreFrozen && axioms != null);
if (expr is LiteralExpr)
{
return(expr);
}
var extractor = new FunctionExtractor();
var body = extractor.VisitExpr(expr);
var name = program.FreshExtractedFunctionName();
var originalVars = extractor.Substitutions.Keys.ToList();
var formalInArgs = originalVars.Select(v => new Formal(Token.NoToken, new TypedIdent(Token.NoToken, extractor.Substitutions[v].Name, extractor.Substitutions[v].TypedIdent.Type), true)).ToList <Variable>();
var formalOutArg = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, name + "$result$", expr.Type), false);
var func = new Function(Token.NoToken, name, formalInArgs, formalOutArg);
func.AddAttribute("never_pattern");
var boundVars = originalVars.Select(k => extractor.Substitutions[k]);
var axiomCall = new NAryExpr(Token.NoToken, new FunctionCall(func), boundVars.Select(b => new IdentifierExpr(Token.NoToken, b)).ToList <Expr>());
axiomCall.Type = expr.Type;
axiomCall.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
var eq = LiteralExpr.Eq(axiomCall, body);
eq.Type = body.Type;
eq.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
if (0 < formalInArgs.Count)
{
var forallExpr = new ForallExpr(Token.NoToken, boundVars.ToList <Variable>(), new Trigger(Token.NoToken, true, new List <Expr> {
axiomCall
}), eq);
body = forallExpr;
forallExpr.Attributes = new QKeyValue(Token.NoToken, "weight", new List <object> {
new LiteralExpr(Token.NoToken, Basetypes.BigNum.FromInt(30))
}, null);
body.Type = Type.Bool;
}
else
{
body = eq;
}
var axiom = new Axiom(Token.NoToken, body);
func.DefinitionAxiom = axiom;
program.AddTopLevelDeclaration(func);
program.AddTopLevelDeclaration(axiom);
axioms.Add(axiom);
var call = new NAryExpr(Token.NoToken, new FunctionCall(func), originalVars.Select(v => new IdentifierExpr(Token.NoToken, v)).ToList <Expr>());
call.Type = expr.Type;
call.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
return(call);
}
public void ParseFormalTest()
{
FunctionParser functionParser = new FunctionParser(Init("param1"));
Formal parsedFormal = functionParser.ParseFormal();
//Test identifier
Assert.AreEqual("param1", parsedFormal.ToString());
}
public Formal AddFormal(InputElement id, MessageWriter msg)
{
Formal f = new Formal(id, locals);
f.Add(id, msg);
signature.Add(f);
return(f);
}
/// <summary>
/// Parser for Formal
/// </summary>
/// <returns>Parsed Formal</returns>
public Formal ParseFormal()
{
Formal formal = new Formal();
CurrentToken = TokenStream.NextToken();
formal.SetIdentifier(CurrentToken.GetValue().ToString());
return(formal);
}
public void Formal_ShouldPrint()
{
var ast = new Formal(identifier: new Identifier(0, "arg1"), typeDeclaration: new BooleanTypeDeclaration(0));
Assert.That(PrettyPrinter.ToString(ast), Is.EqualTo(
@"Formal(arg1)
Type(Boolean)
"));
}
// replace havoc statements by calls to nondets
public static void ReplaceHavocsWithNonDet(Program program)
{
var nonDetProcs = new HashSet <Procedure>();
var mkOrLookupNonDetProc = new Func <Variable, Procedure>(d =>
{
var dt = ((Variable)d).TypedIdent.Type;
var op = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "o", dt), false);
var procName = "havocNonDetAvh." + dt.ToString();
var found = nonDetProcs.Where(x => x.Name == procName).FirstOrDefault();
if (found != null)
{
return(found);
}
var proc = new Procedure(Token.NoToken, procName,
new List <TypeVariable>(), new List <Variable>(), new List <Variable>()
{
op
},
new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>());
nonDetProcs.Add(proc);
return(proc);
});
foreach (Implementation impl in program.TopLevelDeclarations.OfType <Implementation>())
{
foreach (Block blk in impl.Blocks)
{
var newCmds = new List <Cmd>();
foreach (Cmd cmd in blk.Cmds)
{
if (!(cmd is HavocCmd))
{
newCmds.Add(cmd);
}
else
{
var hVars = ((HavocCmd)cmd).Vars;
hVars.Iter(hv =>
{
var cCmd = new CallCmd(Token.NoToken, mkOrLookupNonDetProc(hv.Decl).ToString(),
new List <Expr>(), new List <IdentifierExpr>()
{
hv
});
newCmds.Add(cCmd);
});
}
}
blk.Cmds = newCmds;
}
}
nonDetProcs.Iter(x => program.AddTopLevelDeclaration(x));
}
internal void Set <T>(string name, T value)
{
if (!Formal.ContainsKey(name))
{
throw new MissingFlagException(name);
}
var flag = Formal[name];
((IFlag <T>)flag).Value = value;
Actual[name] = flag;
}
internal void Set(string name, string value)
{
if (!Formal.ContainsKey(name))
{
throw new MissingFlagException(name);
}
var flag = Formal[name];
flag.Set(value);
Actual[name] = flag;
}
private void MakeNewCopy(Variable v)
{
varLastCopyId[v] = varLastCopyId.ContainsKey(v) ? varLastCopyId[v] + 1 : 0;
int id = varLastCopyId[v];
var copyVar = new Formal(
Token.NoToken,
new TypedIdent(Token.NoToken, string.Format(copierFormat, v.Name, id), v.TypedIdent.Type),
false, null);
varCopies[id][v] = copyVar;
copyToOriginalVar[copyVar] = v;
}
protected override void EmitDestructor(string source, Formal dtor, int formalNonGhostIndex, DatatypeCtor ctor, List <Type> typeArgs, TargetWriter wr)
{
if (ctor.EnclosingDatatype is TupleTypeDecl)
{
wr.Write("({0})[{1}]", source, formalNonGhostIndex);
}
else
{
var dtorName = FormalName(dtor, formalNonGhostIndex);
wr.Write("({0}).{1}", source, dtorName);
}
}
private Formal ReplaceOutVarwithIn(Formal outV, List <Formal> ins)
{
int n;
for (int j = 0; j < ins.Count; j++)
{
if (ins[j].Name.Contains(outV.Name) && int.TryParse(ins[j].Name.Substring(outV.Name.Length), out n))
{
return(ins[j]);
}
}
return(outV);
}
private Procedure GetInitLocalsProc(Microsoft.Boogie.Type ty)
{
var typeToStr = ty.ToString().Replace('[', '_').Replace(']', '_');
if (!typeToInitLocalsProc.ContainsKey(typeToStr))
{
var outVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "x", ty), false);
var reProc = new Procedure(Token.NoToken, initLocProcName + typeToStr, new List <TypeVariable>(), new List <Variable>(), new List <Variable> {
outVar
}, new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>());
typeToInitLocalsProc.Add(typeToStr, reProc);
}
return(typeToInitLocalsProc[typeToStr]);
}
// No caching
public FunctionCall CreateUninterpretedFunctionCall(string Name, Microsoft.Boogie.Type returnType, IList <Microsoft.Boogie.Type> argTypes)
{
var returnVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", returnType), false);
var vars = new List <Variable>();
foreach (var T in argTypes)
{
vars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", T), true));
}
// Finally build the function and the function call
var funcCall = new FunctionCall(new Function(Token.NoToken, Name, vars, returnVar));
return(funcCall);
}
/// <summary>
/// Pass a user-implemented IFlag directly to the FlagSet
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="flag"></param>
/// <returns></returns>
public T Var <T>(T flag) where T : IFlag
{
if (Formal != null && Formal.ContainsKey(flag.Name))
{
var msg = Name == "" ? $"flag redefined: {flag.Name}" : $"{Name} flag redefined: {flag.Name}";
Output().WriteLine(msg);
throw new InvalidOperationException(msg);
}
if (Formal == null)
{
Formal = new Dictionary <string, IFlag>();
}
Formal.Add(flag.Name, flag);
return(flag);
}
public override string Print(int depth)
{
if (IsEmpty)
{
return("");
}
if (Tail.IsEmpty)
{
return(Formal.Print(depth).ToString());
}
else
{
return(Formal.Print(depth) + "," + Tail.Print(depth));
}
}
////////////////////////////////////////////////////////////////////////////
// Used to axiomatise the disjoint-sub-dag specs that are
// described by parents with the "unique" flag
private Function OneStepFunFor(Type t)
{
Contract.Requires(t != null);
Contract.Ensures(Contract.Result <Function>() != null);
if (!OneStepFuns.TryGetValue(t, out var res))
{
List <Variable> args = new List <Variable>();
args.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "arg0", t), true));
args.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "arg1", t), true));
Formal result = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "res", t), false);
res = new Function(Token.NoToken, "oneStep", new List <TypeVariable>(), args, result);
OneStepFuns.Add(t, res);
}
return(cce.NonNull(res));
}
Method GetMethod(Method m, MethodBase info)
{
m.Modifiers = GetMethodModifiers(info);
if (info is MethodInfo)
{
m.Type = GetType(((MethodInfo)info).ReturnType);
}
else
{
m.Type = global.Types.Void;
}
Formal f = null;
foreach (ParameterInfo x in info.GetParameters())
{
f = m.AddFormal(new InputElement(x.Name), msg);
f.Type = GetType(x.ParameterType);
if (x.IsOut)
{
f.modifier = new InputElement("out");
}
else if (f.Type is ManagedPointerType)
{
f.modifier = new InputElement("ref");
}
if (f.Type is ManagedPointerType)
{
f.Type = ((ManagedPointerType)f.Type).elementType;
}
else
{
object[] attrs = x.GetCustomAttributes(paramArrayType, false);
if (attrs.Length > 0)
{
Debug.Assert(attrs.Length == 1);
f.IsParams = true;
}
}
}
if (f != null && m.Name == "set_Item")
{
m.signature.formals.Remove(f);
}
return(m);
}
public static void Predicate(Program p,
bool createCandidateInvariants = true,
bool useProcedurePredicates = true)
{
foreach (var decl in p.TopLevelDeclarations.ToList())
{
if (useProcedurePredicates && decl is DeclWithFormals && !(decl is Function))
{
var dwf = (DeclWithFormals)decl;
var fpVar = new Formal(Token.NoToken,
new TypedIdent(Token.NoToken, "_P",
Microsoft.Boogie.Type.Bool),
/*incoming=*/ true);
dwf.InParams = new List <Variable>(
(new Variable[] { fpVar }.Concat(dwf.InParams.Cast <Variable>()))
.ToArray());
if (dwf is Procedure)
{
var proc = (Procedure)dwf;
var newRequires = new List <Requires>();
foreach (Requires r in proc.Requires)
{
newRequires.Add(new Requires(r.Free,
new EnabledReplacementVisitor(new IdentifierExpr(Token.NoToken, fpVar), Expr.True).VisitExpr(r.Condition)));
}
var newEnsures = new List <Ensures>();
foreach (Ensures e in proc.Ensures)
{
newEnsures.Add(new Ensures(e.Free,
new EnabledReplacementVisitor(new IdentifierExpr(Token.NoToken, fpVar), Expr.True).VisitExpr(e.Condition)));
}
}
}
try {
var impl = decl as Implementation;
if (impl != null)
{
new BlockPredicator(p, impl, createCandidateInvariants, useProcedurePredicates).PredicateImplementation();
}
}
catch (Program.IrreducibleLoopException) { }
}
}
public Formal CloneFormal(Formal formal) {
Formal f = new Formal(Tok(formal.tok), formal.Name, CloneType(formal.Type), formal.InParam, formal.IsGhost);
//if (f.Type is UserDefinedType && formal.Type is UserDefinedType)
// ((UserDefinedType)f.Type).ResolvedClass = ((UserDefinedType)(formal.Type)).ResolvedClass;
return f;
}
public void visit(Formal n) {
ClassRec c;
Class astType = n.t.getClass();
// If the formal type is object type, we must check that the class definition exists
if (astType == ObjType.class) {
String s = ((ObjType)n.t).cid.s;
if (null == (c = symTable.getClass(new Id(s)))) {
throw new TypeException("Class " + s + " not defined");
}
}
}
