internal bool AddPathEdge(PathEdgesPartition NewPathEdge, BddManager Manager)
{
Bdd allPaths = GetJointPaths(Manager);
Bdd tempBdd = Manager.LogicalOr(allPaths, NewPathEdge.PathEdges);
if (tempBdd == allPaths)
{
allPaths.FreeBdd();
return(false);
}
allPaths.FreeBdd();
m_PathEdgesByLength.Sort();
int position = m_PathEdgesByLength.BinarySearch(NewPathEdge);
bool updated = false;
if (position >= 0)
{
if (m_PathEdgesByLength[position].AddPaths(NewPathEdge.PathEdges, Manager))
{
updated = true;
}
}
else
{
m_PathEdgesByLength.Add(NewPathEdge);
updated = true;
m_PathEdgesByLength.Sort();
}
return(updated);
}
public static void BuildDeciderTransfers(CommonAST decider, BddManager Manager,
Dictionary <string, int> LocalVarToId, Dictionary <string, int> GlobalVarToId,
out Bdd TransferTrue, out Bdd TransferFalse)
{
Bdd identity = BuildIdentityTransfer(Manager, LocalVarToId, GlobalVarToId);
Debug.Assert(decider.Type == BoolParserTokenTypes.DECIDER);
CommonAST walker = decider.getFirstChild() as CommonAST;
if (walker.Type == BoolParserTokenTypes.QMARK)
{
TransferTrue = identity;
TransferFalse = identity;
}
else
{
Debug.Assert(walker.Type == BoolParserTokenTypes.EXPR);
Bdd expr = ExprToBdd(walker, Manager, LocalVarToId, GlobalVarToId);
TransferTrue = Manager.LogicalAnd(Manager.LogicalXnor(expr, Manager.CreateBddOne()), identity);
TransferFalse = Manager.LogicalAnd(Manager.LogicalXnor(expr, Manager.CreateBddZero()), identity);
identity.FreeBdd();
expr.FreeBdd();
}
}
/*uses the Manager to build an identity between primed and unprimed instance of each variable
* in VariableIDs */
public static Bdd BuildIdentityOverVariableIDs(BddManager Manager, int[] VariableIDs)
{
Bdd identity = null;
if (VariableIDs.Length > 0)
{
identity = Manager.CreateBddOne();
Bdd xnorBdd, tempBdd;
for (int variable = 0; variable < VariableIDs.Length; variable++)
{
xnorBdd = Manager.LogicalXnor(
Manager.GetBddVariableWithID(VariableIDs[variable]),
Manager.GetBddVariableWithID(VariableIDs[variable] + 2)
);
tempBdd = identity;
identity = Manager.LogicalAnd(identity, xnorBdd);
tempBdd.FreeBdd();
xnorBdd.FreeBdd();
}
}
return(identity);
}
internal Bdd GetJointPaths(BddManager Manager)
{
Bdd JointPaths = Manager.CreateBddZero();
foreach (PathEdgesPartition part in m_PathEdgesByLength)
{
Bdd tempBdd = JointPaths;
JointPaths = Manager.LogicalOr(JointPaths, part.PathEdges);
tempBdd.FreeBdd();
}
return(JointPaths);
}
public int AddVar(string varName, BddManager manager, List <string> bddToName)
{
int varID = manager.CreateBddVariableLast().GetBddRootVariableID();
m_VariablesToId.Add(varName, varID);
bddToName.Add(varName);
manager.CreateBddVariableLast();
bddToName.Add(varName + "''");
manager.CreateBddVariableLast();
bddToName.Add(varName + "'");
return(varID);
}
internal bool AddPaths(Bdd newPaths, BddManager Manager)
{
Bdd tempBdd = m_PathEdges;
m_PathEdges = Manager.LogicalOr(m_PathEdges, newPaths);
bool changed = true;
if (tempBdd == m_PathEdges)
{
changed = false;
}
tempBdd.FreeBdd();
return(changed);
}
public MainForm()
{
BddViewForm = new BddViewDialog();
AddOwnedForm(BddViewForm);
TrajectoryViewForm = new TrajectoryView();
AddOwnedForm(TrajectoryViewForm);
BddMemoryInfo = new BddMemoryInfoDialog();
AddOwnedForm(BddMemoryInfo);
InitializeComponent();
MyBMC = new BMC();
m_BddManager = new BddManager();
m_BddVarToName = new List <string>(100);
m_BddVarToName.Insert(0, "");
}
public BMC()
{
CodeInput = new antlr.LexerSharedInputState(new StringReader(String.Empty));
Lexer = new BoolLexer(CodeInput);
Parser = new BoolParser(Lexer);
ErrorLog = String.Empty;
BoolProgAST = (CommonAST)Parser.getAST();
m_BddManager = new BddManager();
ProgramCFG = new CFG(BoolProgAST, m_BddManager);
m_PathEdges = new Dictionary <CFGNode, PathEdges>();
m_SummaryEdges = new Dictionary <CFGNode, Bdd>();
}
public static Bdd BuildIdentityTransfer(BddManager Manager,
Dictionary <string, int> LocalVarToId, Dictionary <string, int> GlobalVarToId)
{
Bdd identityTransfer = null;
if ((LocalVarToId != null) && (LocalVarToId.Values.Count > 0))
{
int[] VariableIDs = new int[LocalVarToId.Values.Count];
LocalVarToId.Values.CopyTo(VariableIDs, 0);
identityTransfer = BuildIdentityOverVariableIDs(Manager, VariableIDs);
}
if ((GlobalVarToId != null) && (GlobalVarToId.Values.Count > 0))
{
int[] VariableIDs = new int[GlobalVarToId.Values.Count];
GlobalVarToId.Values.CopyTo(VariableIDs, 0);
if (identityTransfer != null)
{
Bdd identGlobal = BuildIdentityOverVariableIDs(Manager, VariableIDs);
Bdd tempBdd = identityTransfer;
identityTransfer = Manager.LogicalAnd(identityTransfer, identGlobal);
identGlobal.FreeBdd();
tempBdd.FreeBdd();
}
else
{
identityTransfer = BuildIdentityOverVariableIDs(Manager, VariableIDs);
}
}
if (identityTransfer == null)
{
identityTransfer = Manager.CreateBddZero();
}
return(identityTransfer);
}
public CFG(CommonAST BoolProgram, BddManager manager)
{
BoolProgramAst = BoolProgram;
m_BddManager = manager;
m_BddVariableToName = new List <string>(1000);
m_BddVariableToName.Add("");
ListOfCfgNodes = new List <CFGNode>();
AstToCfgMapping = new Dictionary <CommonAST, CFGNode>();
ASTParentByASTNode = new Dictionary <CommonAST, CommonAST>();
LabelToStatement = new Dictionary <string, CFGNode>();
ProcNameToNode = new Dictionary <string, CFGNodeProcedure>();
m_GlobalVariables = new Variables();
BuildCfgFromAst();
}
public static Bdd ExprToBdd(CommonAST Expr, BddManager Manager,
Dictionary <string, int> LocalVarNameToId, Dictionary <string, int> GlobalVarNameToId)
{
Debug.Assert(Expr.Type == BoolParserTokenTypes.EXPR);
Bdd ExprBdd = null;
CommonAST walker = (CommonAST)Expr.getFirstChild();
switch (walker.Type)
{
case BoolParserTokenTypes.EXPR:
ExprBdd = ExprToBdd(walker, Manager, LocalVarNameToId, GlobalVarNameToId);
break;
case BoolParserTokenTypes.EMARK:
walker = (CommonAST)walker.getNextSibling();
Bdd tempBdd = ExprToBdd(walker, Manager, LocalVarNameToId, GlobalVarNameToId);
ExprBdd = Manager.LogicalNot(tempBdd);
tempBdd.FreeBdd();
break;
case BoolParserTokenTypes.ID:
int VariableID;
if (!LocalVarNameToId.TryGetValue(walker.getText(), out VariableID))
{
if (!GlobalVarNameToId.TryGetValue(walker.getText(), out VariableID))
{
Debug.Assert(false); //Varijabla mora biti ili medju lokalnim ili medju globalnim
}
}
ExprBdd = Manager.GetBddVariableWithID(VariableID);
break;
case BoolParserTokenTypes.CONST:
if (walker.getText() == "1")
{
ExprBdd = Manager.CreateBddOne();
}
else
{
ExprBdd = Manager.CreateBddZero();
}
break;
default:
Debug.Assert(false);
break;
}
if ((walker.getNextSibling() != null) &&
((walker = (CommonAST)walker.getNextSibling()).Type == BoolParserTokenTypes.BINOP))
{
Bdd firstOperand = ExprBdd;
string Operation = walker.getText();
walker = (CommonAST)walker.getNextSibling();
Bdd secondOperand = ExprToBdd(walker, Manager, LocalVarNameToId, GlobalVarNameToId);
switch (Operation)
{
case ("|"):
ExprBdd = Manager.LogicalOr(firstOperand, secondOperand);
break;
case ("&"):
ExprBdd = Manager.LogicalAnd(firstOperand, secondOperand);
break;
case ("^"):
ExprBdd = Manager.LogicalXor(firstOperand, secondOperand);
break;
case ("="):
ExprBdd = Manager.LogicalXnor(firstOperand, secondOperand);
break;
case ("!="):
ExprBdd = Manager.LogicalXor(firstOperand, secondOperand);
break;
case ("=>"):
ExprBdd = Manager.LogicalImplies(firstOperand, secondOperand);
break;
default:
Debug.Assert(false);
break;
}
firstOperand.FreeBdd();
secondOperand.FreeBdd();
}
return(ExprBdd);
}
public static Bdd buildProcCallTransfer(CommonAST procCall, CFGNodeProcedure procedureCalled,
BddManager Manager, Dictionary <string, int> LocalVarToId, Dictionary <string, int> GlobalVarToId)
{
Bdd transfer = Manager.CreateBddOne();
CommonAST walkerExpr = procCall.getFirstChild().getFirstChild() as CommonAST;
CommonAST walkerFormal = procedureCalled.GetAST().getFirstChild() as CommonAST;
#region Build Bdd for FormalParameters = Call Expressions
while (walkerExpr != null)
{
Bdd expr = HelperFunctions.ExprToBdd(walkerExpr, Manager, LocalVarToId, GlobalVarToId);
int varID;
if (!procedureCalled.FormalParameters.VariablesToId.TryGetValue(walkerFormal.getText(), out varID))
{
System.Diagnostics.Debug.Assert(false);
}
Bdd formal = Manager.GetBddVariableWithID(varID + 2);
Bdd tempBdd = Manager.LogicalXnor(formal, expr);
Bdd tempBdd2 = transfer;
transfer = Manager.LogicalAnd(transfer, tempBdd);
expr.FreeBdd();
formal.FreeBdd();
tempBdd.FreeBdd();
tempBdd2.FreeBdd();
walkerExpr = walkerExpr.getNextSibling() as CommonAST;
walkerFormal = walkerFormal.getNextSibling() as CommonAST;
}
#endregion
#region And with an identity over Global variables and true Local variables(non Formals)
/* int variableCount = procedureCalled.LocalVariables.VariablesToId.Values.Count -
* procedureCalled.FormalParameters.VariablesToId.Values.Count;
* int[] variableIDs = new int[variableCount];
* int index = 0;
* Bdd identity;
* foreach (int varID in procedureCalled.LocalVariables.VariablesToId.Values)
* {
* if (!(procedureCalled.FormalParameters.VariablesToId.ContainsValue(varID)))
* {
* variableIDs[index++] = varID;
* }
* }
*
* Bdd identNewLocals = HelperFunctions.BuildIdentityOverVariableIDs(Manager, variableIDs, variableCount);*/
Bdd identGlobals = HelperFunctions.BuildIdentityTransfer(Manager, null, GlobalVarToId);
/* if (identNewLocals != null && identGlobals != null)
* {
* identity = Manager.LogicalAnd(identGlobals, identNewLocals);
* identNewLocals.FreeBdd();
* identGlobals.FreeBdd();
* }
* else if (identNewLocals != null)
* {
* identity = identNewLocals;
* }
* else
* {
* identity = identGlobals;
* }*/
Bdd identity = identGlobals;
Bdd temp = transfer;
transfer = Manager.LogicalAnd(transfer, identity);
//temp.FreeBdd();
#endregion
return(transfer);
}
public static Bdd BuildAssignmentTransfer(CommonAST assignAST, BddManager Manager,
Dictionary <string, int> LocalVarToId, Dictionary <string, int> GlobalVarToId)
{
CommonAST walkerVariable = assignAST.getFirstChild() as CommonAST;
CommonAST walkerExpresion = assignAST.getFirstChild() as CommonAST;
while (walkerExpresion.Type == BoolParserTokenTypes.ID)
{
walkerExpresion = walkerExpresion.getNextSibling() as CommonAST;
}
walkerExpresion = walkerExpresion.getNextSibling() as CommonAST;
List <int> assignedVariables = new List <int>();
Bdd transfer = null;
bool bddTransferIsnull = true;
while (walkerVariable.Type == BoolParserTokenTypes.ID)
{
Bdd tempBdd, varBdd, exprBdd;
int VariableID;
if (!LocalVarToId.TryGetValue(walkerVariable.getText(), out VariableID))
{
if (!GlobalVarToId.TryGetValue(walkerVariable.getText(), out VariableID))
{
Debug.Assert(false);//Varijabla mora biti ili medju lokalnim ili medju globalnim
}
}
assignedVariables.Add(VariableID);
varBdd = Manager.GetBddVariableWithID(VariableID + 2);
exprBdd = HelperFunctions.ExprToBdd(walkerExpresion, Manager, LocalVarToId, GlobalVarToId);
tempBdd = Manager.LogicalXnor(varBdd, exprBdd);
varBdd.FreeBdd();
exprBdd.FreeBdd();
if (bddTransferIsnull)
{
transfer = tempBdd;
bddTransferIsnull = false;
}
else
{
varBdd = transfer;
transfer = Manager.LogicalAnd(transfer, tempBdd);
varBdd.FreeBdd();
tempBdd.FreeBdd();
}
walkerVariable = walkerVariable.getNextSibling() as CommonAST;
walkerExpresion = walkerExpresion.getNextSibling() as CommonAST;
}
#region add identitiy transfer for the rest of the variables
//Now we add the identity over variables that were not assigned to
int[] localVariablesIDs = new int[LocalVarToId.Values.Count];
LocalVarToId.Values.CopyTo(localVariablesIDs, 0);
int[] globalVariablesIDs = new int[GlobalVarToId.Values.Count];
GlobalVarToId.Values.CopyTo(globalVariablesIDs, 0);
int[] unassignedVariables =
new int[LocalVarToId.Values.Count + GlobalVarToId.Values.Count - assignedVariables.Count];
int unAssIndex = 0;
for (int index = 0; index < LocalVarToId.Values.Count; index++)
{
if (!(assignedVariables.Contains(localVariablesIDs[index])))
{
unassignedVariables[unAssIndex++] = localVariablesIDs[index];
}
}
for (int index = 0; index < GlobalVarToId.Values.Count; index++)
{
if (!(assignedVariables.Contains(globalVariablesIDs[index])))
{
unassignedVariables[unAssIndex++] = globalVariablesIDs[index];
}
}
Bdd identitiy = HelperFunctions.BuildIdentityOverVariableIDs(Manager, unassignedVariables);
Bdd tempBdd2 = transfer;
transfer = Manager.LogicalAnd(transfer, identitiy);
identitiy.FreeBdd();
tempBdd2.FreeBdd();
#endregion
return(transfer);
}
