////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// private void dumpVariable(ProgramVariable v) { string name = removeAtSigns(v.name); Debug.Assert(!name.Contains('@')); file.WriteLine("var " + name + " : " + toBoogie(v.type) + ";"); }
/////////////////////////////////////////////////////////////////////// public ProgramVariable findVariable(string name) { ProgramVariable result = tryFindVariable(name); Debug.Assert(result != null); return(result); }
////////////////////////////////////////////////////////////// public void include(ProgramVariable v) { if (!value.ContainsKey(v.name)) { value.Add(v.name, v); } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////// private static void getOwnAssume(BasicBlock bb, out Expression assumeE) { assumeE = null; ProgramVariable cv = (bb.getControlStatement() as ConditionalBranch).condition; { if (bb.statements.Count > 1) { var pa = bb.statements[bb.statements.Count - 2].statement as Assume; if (pa != null) { var fae = pa.expression as FAE; if (fae != null && BFunction.isEquality(fae.function)) { var apv = fae.arguments[0] as ProgramVariableExpression; if (apv != null && ReferenceEquals(apv.programVariable, cv)) { assumeE = fae.arguments[1]; } } } } } }
public override ProgramVariable visitReadProgramVariable(ProgramVariable v) { if (!v.isConstant && !v.isGlobal && !v.isInput) { liveVariables.Add(v.name); } return(v); }
//////////////////////////////////////////////////////// //////////////////////////////////////////////////////// public override ProgramVariable visitReadProgramVariable(ProgramVariable v) { if (isMap(v)) { maps.add(v); } return(v); }
private void addFirstOccurenceIfNotInitialized(ProgramVariable v) { if (!firstOccurence.ContainsKey(v.name)) { firstOccurence.Add(v.name, new Dictionary <string, Tuple <PropositionalFormula, StatementId> >()); firstOccurence[v.name].Add(currentStatement.ToString(), new Tuple <PropositionalFormula, StatementId>(pathCondition, currentStatement)); } }
//////////////////////////////////////////////////////////////////////////// public override Statement visit(ConditionalBranch s) { ControlStatement result = s; // var ne = si.fae.visit(this); ProgramVariable oc = s.condition; ProgramVariable nc = s.condition; EqualityDatabase.Representative rep = database.tryGetRepresentative(s.condition); if (rep != null) { Expression ne = rep.expression; if (ne is LiteralExpression) { if (((ne as LiteralExpression).value as BooleanValue).value) { result = new UnconditionalBranch(s.trueBranch.source, s.trueBranch.target); } else { result = new UnconditionalBranch(s.falseBranch.source, s.falseBranch.target); } nc = null; } else { if (ne is ProgramVariableExpression) { s.condition = (ne as ProgramVariableExpression).programVariable; nc = s.condition; } else { nc = (EqualityDatabase.getCompactNegationIfBoolean(ne) as ProgramVariableExpression). programVariable; result = new ConditionalBranch( database.statementId.basicBlock, nc, s.falseBranch.target, s.trueBranch.target ); } } } if (nc != null && !database.conditionVariableIndices.ContainsKey(nc.name)) { database.addConditionVariable(nc); } return(result); }
internal void add(ProgramVariable v) { string name = procedure.getBaseIncarnation(v.name).name; if (!mapData.ContainsKey(name)) { mapData.Add(name, new MapData(name)); } mapData[name].add(v); }
////////////////////////////////////////////////////////////// public void apply(ModifyingVisitor visitor) { var newValue = new Dictionary <string, ProgramVariable>(); foreach (var kv in value) { ProgramVariable v = visitor(kv.Value); newValue.Add(v.name, v); } value = newValue; }
////////////////////////////////////////////// public BoogieProgramVariableExpression(IdentifierExpr boogieExpression, ProgramVariable variable) : base(variable) { Debug.Assert(boogieExpression != null); Debug.Assert( boogieExpression.Decl is GlobalVariable || boogieExpression.Decl is LocalVariable || boogieExpression.Decl is Formal || boogieExpression.Decl is Constant ); boogieIdentifierExpression = boogieExpression; }
public virtual Expression visit(ProgramVariableExpression e) { ProgramVariable newV = visitReadProgramVariable(e.programVariable); if (!ReferenceEquals(e.programVariable, newV)) { return(new BasicProgramVariableExpression(newV)); } else { return(e); } }
public GameObject AddVariable(ProgramVariable variable) { GameObject newProgramFileGraphic = GameObject.Instantiate(programVariableGraphicPrefab); ProgramGUIVariableGraphic newGraphic = newProgramFileGraphic.GetComponent <ProgramGUIVariableGraphic> (); programVariableGraphics.Add(newGraphic); newProgramFileGraphic.GetComponent <RectTransform> ().parent = variableParent; newProgramFileGraphic.GetComponent <RectTransform> ().anchoredPosition = new Vector2( 0, 150 + (-100 * (programVariableGraphics.Count - 1))); return(newProgramFileGraphic); }
public ConditionalBranch(BasicBlock source, ProgramVariable condition, BasicBlock trueTarget, BasicBlock falseTarget) { Debug.Assert(source != null); Debug.Assert(trueTarget != null); Debug.Assert(falseTarget != null); Debug.Assert(condition != null); trueBranch = new BasicEdge(source, trueTarget, new BasicEdge.Guard(new BasicProgramVariableExpression(condition))); falseBranch = new BasicEdge(source, falseTarget, new BasicEdge.Guard(makeNegation(new BasicProgramVariableExpression(condition)))); this.condition = condition; }
////////////////////////////////////////////////////////////// //Exclude v if in set, nop otherwise public void exclude(ProgramVariable v) { if (value.ContainsKey(v.name)) { if (value[v.name] == v) { value.Remove(v.name); } else { throw new Exception("Internal error - scoping error with programVariable \"" + v.name + "\""); } } }
/* /////////////////////////////////////////////////////////////////////// * public ProgramVariable makeFreshProgramVariable(DataType type) * { * if (parentScope != null) * return parentScope.makeFreshProgramVariable(type); * * string name = "$t_" + freshProgramVariableIndex.ToString(); * freshProgramVariableIndex++; * ProgramVariable result = new ProgramVariable(name,type,false,false,false,false); * addVariable(result); * return result; * } */ /////////////////////////////////////////////////////////////////////// public ProgramVariable makeFreshProgramVariable(string baseName, IType type) { int index = 0; string name = baseName; while (tryFindVariable(name) != null) { name = baseName + "_$" + (index++).ToString(); } var result = new ProgramVariable(name, type, false, false, false, false); addVariable(result); return(result); }
/////////////////////////////////////////////////////////////////////// /* public void addVariable(Scope scope,Microsoft.Boogie.NamedDeclaration d, bool isInput, bool isOutput, bool isGlobal, bool isConstant) * { * // addVariable(new ProgramVariable(d.Name,makeType()) * }*/ public void addVariable(ProgramVariable variable) { if (variableMap.ContainsKey(variable.name)) { return; } Debug.Assert(!variableMap.ContainsKey(variable.name)); #if DEBUG // if (variable.name.StartsWith(@"call5")) // Debugger.Break(); #endif variableMap[variable.name] = variable; // if (variable.isInput) // addInitialIncarnation(variable); }
/////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// #region Scope Members public ProgramVariable tryFindVariable(string name) { ProgramVariable result = null; variableMap.TryGetValue(name, out result); #if DEBUG // if (name.StartsWith(@"call5")) // Debugger.Break(); #endif if (result == null && parentScope != null) { result = parentScope.tryFindVariable(name); } // Debug.Assert(result != null); return(result); }
public BlockEntry(BasicBlock bb, IEnumerable <BlockEntry> successors) { this.bb = bb; var variables = new HashSet <ProgramVariable>(); foreach (var s in successors) { variables.UnionWith(s.variableMap.Keys); } foreach (var v in variables) { variableMap.Add(v, new ConditionVariableEntry(bb, v, from s in successors select (s.variableMap.ContainsKey(v) ? s.variableMap[v] : null))); } var cb = bb.getControlStatement() as ConditionalBranch; if (cb != null) { ProgramVariable cv = cb.condition; Assignment assignment = null; if (bb.statements.Count > 1) { assignment = getAssignment(cv, bb.statements[bb.statements.Count - 2].statementId); } else { assignment = new Assignment(bb, cv); } if (variableMap.ContainsKey(cv)) { variableMap[cv].add(assignment); } else { variableMap.Add(cv, new ConditionVariableEntry(assignment)); } } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////// private static void redirectFriend(BasicBlock f, BasicBlock assumeInsertion) { bool polarity = true; var fcb = f.getControlStatement() as ConditionalBranch; Debug.Assert(fcb != null); var icb = assumeInsertion.getControlStatement() as ConditionalBranch; Debug.Assert(icb != null); ProgramVariable icv = icb.condition; Debug.Assert( (fcb.trueBranch.target == icb.trueBranch.target && fcb.falseBranch.target == icb.falseBranch.target) || (fcb.trueBranch.target == icb.falseBranch.target && fcb.falseBranch.target == icb.trueBranch.target) ); if (fcb.trueBranch.target == icb.trueBranch.target) { polarity = true; } else { polarity = false; } Expression assumeE; getOwnAssume(f, out assumeE); if (assumeE != null) { var assume = f.statements[f.statements.Count - 2].statement as Assume; Expression newAssumeE = (polarity) ? assumeE : EqualityDatabase.getCompactNegationIfBoolean(assumeE); assume.expression = new BasicFAE( BFunction.equivalence, //eq(BooleanType.booleanType), new ExpressionList( new BasicProgramVariableExpression(icv), newAssumeE ) ); } f.setControlStatement(new UnconditionalBranch(f, assumeInsertion)); }
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); }
public ConditionVariableEntry(BasicBlock bb, ProgramVariable v, IEnumerable <ConditionVariableEntry> successors) { // TODO: Complete member initialization Debug.Assert(bb != null); Debug.Assert(v != null); Debug.Assert(successors != null); Debug.Assert(successors.Count() > 0); this.v = v; foreach (var s in successors) { if (s != null) { assignments.UnionWith(s.assignments); } } definition = null; foreach (var s in successors) { if (s != null) { if (definition == null) { definition = s.definition; } else if (definition != s.definition) { definition = bb; break; } } } { Assignment e = assignments.First(); foreach (var a in assignments) { Debug.Assert(a.variable == v); Debug.Assert((e.value == null && a.value == null) || e.value.ToString() == a.value.ToString()); } } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////// private static bool getVariable(Expression e, out ProgramVariable v) { if (e is ProgramVariableExpression) { v = (e as ProgramVariableExpression).programVariable; return(true); } else { var fae = e as FAE; Debug.Assert(fae != null); Debug.Assert(BFunction.isNegation(fae.function)); v = (fae.arguments[0] as ProgramVariableExpression).programVariable; Debug.Assert(v != null); return(false); } }
public static void appendSubexpressions(Procedure p) { var subExpressionLeaves = new Dictionary <string, SubExpressionOrderNode>(); foreach (var sec in p.cfg.startNode.getPreState(0).subexpressionCounter.subexpressionCounts) { if (sec.Value.contexts.Count > 1 || (sec.Value.contexts.First().Key == null && sec.Value.contexts.First().Value.Count > 1)) { subExpressionLeaves.Add(sec.Key, new SubExpressionOrderNode(sec.Value)); } } foreach (var ses in subExpressionLeaves.Values) /* process(subExpressionLeaves,ses.Value); * * Queue<SubExpressionOrderNode> q = new Queue<SubExpressionOrderNode>(); * * foreach (var ses in subExpressionLeaves) * if (ses.Value.numDescendants==0) * q.Enqueue(ses.Value); * * int numStatements = 0; * while (q.Count>0)*/ { Expression e = ses.subExpression.expression; IType t = e.type; ProgramVariable nv = p.makeFreshProgramVariable("se", t); var s = new Assume( new BasicFAE( BFunction.eq(t), new ExpressionList( new BasicProgramVariableExpression(nv), e ) ) ); ses.subExpression.definition.prependStatement(s); } }
private void treeViewTestBtn_Click(object sender, RoutedEventArgs e) { //System.GC.Collect(); DataBaseConnectManager.DBConnection_ = DataBaseConnectManager.ConnectionFactory(EnvironmentVariable.MarketDataDBFile_); //EVENT_INFO_Table_DAOManager d = new EVENT_INFO_Table_DAOManager(); //d.delete(DataBaseConnectManager.DBConnection_); ProgramVariable.initialize_CurrencyStringList(); RootBookViewModel.setRootBookReferenceDate(DateTime.Now); BookFolderView bfv = new BookFolderView(); bfv.ReferenceDate_ = this.loadLastPositionDate(); bfv.positionXmlReload(); //RootBookViewModel root_bvm = new RootBookViewModel(); //root_bvm.loadPosition(); //RootFavoriteViewModel root_fvm = new RootFavoriteViewModel(); //root_fvm.loadPosition(); //bfv.RootBookViewModel_ = root_bvm; //bfv.RootFavoriteViewModel_ = root_fvm; Window w = new Window(); w.Width = 600; w.Height = 400; w.Content = bfv; w.Visibility = 0; }
private Assignment getAssignment(ProgramVariable v, StatementId statementId) { StatementId si = statementId; var assume = statementId.statement as Assume; if (assume == null) { si = null; } else { var fae = assume.expression as FAE; if (fae == null || !BFunction.isEquality(fae.function)) { si = null; } else { var dest = fae.arguments[0] as ProgramVariableExpression; if (dest == null || (dest.programVariable != v)) { si = null; } } } if (si == null) { return(new Assignment(statementId.basicBlock, v)); } else { return(new Assignment(si)); } }
public void DeleteVariable(ProgramVariable variable) { }
public virtual ProgramVariable visitHavokProgramVariable(ProgramVariable v) { v.type.visit(this); return(v); }
public override ProgramVariable visitWriteProgramVariable(ProgramVariable v) { liveVariables.Remove(v.name); return(v); }
///////////////////////////////////////////////////////////////////////////////////// private void setControlStatement(BasicBlock current, GotoCmd gotoCmd, BasicBlock next) { if (gotoCmd.labelNames.Count == 0) { current.setControlStatement(new Programs.Statements.Block(current)); } else if (gotoCmd.labelNames.Count == 1) { BasicBlock target = cfg.lookupOrAddNode(gotoCmd.labelNames[0]); current.setControlStatement(new UnconditionalBranch(current, target)); } else { var conditionVariables = new List <ProgramVariable>(); while ((1 << conditionVariables.Count) < gotoCmd.labelNames.Count) { ProgramVariable nd = scope.makeFreshProgramVariable(pathConditionPrefix, makeBooleanType()); conditionVariables.Add(nd); nondeterministicConditionVariables.Add(nd); } string basicLabel = "$cascade_" + labelIndex.ToString(); labelIndex++; int currentTarget = 0; for (int i = 0; (1 << i) <= gotoCmd.labelNames.Count; i++) { for (int j = 0; (j < (1 << i)) && ((1 << i) + j < gotoCmd.labelNames.Count); j += 2) { int index = (1 << i) + j; string label = basicLabel + "_$" + i.ToString() + "_$" + j.ToString(); BasicBlock block = (i == 0) ? current : cfg.lookupOrAddNode(label); string targetLabel1 = (index * 2 < gotoCmd.labelNames.Count) ? basicLabel + "_$" + (i + 1).ToString() + "_$" + (j * 2).ToString() : gotoCmd.labelNames[currentTarget++]; string targetLabel2 = (index * 2 + 1 < gotoCmd.labelNames.Count) ? basicLabel + "_$" + (i + 1).ToString() + "_$" + (j * 2 + 1).ToString() : ( (currentTarget < gotoCmd.labelNames.Count) ? gotoCmd.labelNames[currentTarget++] : null ); BasicBlock target1 = cfg.lookupOrAddNode(targetLabel1); BasicBlock target2 = (targetLabel2 == null) ? null : cfg.lookupOrAddNode(targetLabel2); if (target2 != null) { block.setControlStatement(new ConditionalBranch(block, conditionVariables[i], target1, target2)); } else { block.setControlStatement(new UnconditionalBranch(block, target1)); } } } } }