private formattedCodeView getFormattedSSEQ(CommonAST sseq, formattedCodeView formattedCode, string tab)
{
CommonAST walker = (CommonAST)sseq.getFirstChild();
while (walker != null)
{
CommonAST statement;
if (walker.Type == BoolParserTokenTypes.STMT)
{
statement = (CommonAST)walker.getFirstChild();
}
else
{
statement = (CommonAST)walker.getFirstChild().getNextSibling();
}
CFGNode stmtNode;
if (AstToCfgMapping.TryGetValue(walker, out stmtNode))
{
if ((stmtNode is CFGNodeStmtIf) || (stmtNode is CFGNodeStmtWhile))
{
if (stmtNode is CFGNodeStmtIf)
{
string line = tab + stmtNode.ToString() + " then";
formattedCode.addLine(line, stmtNode);
statement = (CommonAST)statement.getFirstChild().getNextSibling();
formattedCode = getFormattedSSEQ(statement, formattedCode, tab + " ");
formattedCode.addLine(tab + "else");
statement = (CommonAST)statement.getNextSibling();
formattedCode = getFormattedSSEQ(statement, formattedCode, tab + " ");
formattedCode.addLine(tab + "fi");
}
else
{
formattedCode.addLine(tab + stmtNode.ToString(), stmtNode);
formattedCode.addLine(tab + "do");
statement = (CommonAST)statement.getFirstChild().getNextSibling();
formattedCode = getFormattedSSEQ(statement, formattedCode, tab + " ");
formattedCode.addLine(tab + "od");
}
}
else
{
formattedCode.addLine(tab + stmtNode.ToString(), stmtNode);
}
}
walker = (CommonAST)walker.getNextSibling();
}
return(formattedCode);
}
//This Procedure assumes Procedure is a PROC AST node
private List <SemanticError> CheckProcedure(CommonAST Procedure, List <SemanticError> Errors)
{
List <string> LocalVariables = new List <string>();
CommonAST walker = Procedure;
walker = (CommonAST)walker.getFirstChild();
string ProcedureName = walker.getText();
walker = (CommonAST)walker.getFirstChild();
#region Variables checking
while (walker.Type == BoolParserTokenTypes.ID)
{
string variable = walker.ToString();
if (LocalVariables.Contains(variable))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_NAME_CLASH, variable, ProcedureName));
}
else
{
LocalVariables.Add(variable);
}
walker = (CommonAST)walker.getNextSibling();
}
while ((walker.Type == BoolParserTokenTypes.LITERAL_decl))
{
CommonAST subWalker = (CommonAST)walker.getFirstChild();
while (subWalker != null)
{
string variable = subWalker.ToString();
if (LocalVariables.Contains(variable))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_NAME_CLASH, variable, ProcedureName));
}
else
{
LocalVariables.Add(variable);
}
subWalker = (CommonAST)subWalker.getNextSibling();
}
walker = (CommonAST)walker.getNextSibling();
}
#endregion
Errors = CheckSSEQ(walker, Errors, LocalVariables, ProcedureName);
return(Errors);
}
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();
}
}
private List <SemanticError> CheckExpression(CommonAST EXPR, List <SemanticError> Errors,
List <string> LocalVariables, string ProcOf)
{
CommonAST walker = (CommonAST)EXPR.getFirstChild();
while (walker != null)
{
switch (walker.Type)
{
case (BoolParserTokenTypes.ID):
if (!(LocalVariables.Contains(walker.getText())) &&
!(GlobalVariables.Contains(walker.getText())))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_UNDECLARED,
walker.getText(), ProcOf));
}
break;
case (BoolParserTokenTypes.EXPR):
Errors = CheckExpression(walker, Errors, LocalVariables, ProcOf);
break;
}
walker = (CommonAST)walker.getNextSibling();
}
return(Errors);
}
public static string DeclToString(CommonAST Decl)
{
Debug.Assert(Decl != null);
string output = "decl ";
Decl = (CommonAST)Decl.getFirstChild();
bool first = true;
while (Decl != null)
{
if (!first)
{
output = output + ", ";
}
output = output + Decl.getText();
Decl = (CommonAST)Decl.getNextSibling();
first = false;
}
output = output + ";";
return(output);
}
public static string DeciderToString(CommonAST Decider)
{
Decider = (CommonAST)Decider.getFirstChild();
if (Decider.Type == BoolParserTokenTypes.EXPR)
{
return(HelperFunctions.ExprToString(Decider));
}
else
{
return(Decider.getText());
}
}
private int DrawAST(CommonAST AST, ref Graph g)
{
if (AST != null)
{
int thisNodeIndex = ASTforGLEEIndex++;
ASTorderedByGraphIndex.Add(AST);
Node thisNode = (Node)g.AddNode(thisNodeIndex.ToString());
thisNode.Attr.Label = AST.getText();
CommonAST ChildAST = (CommonAST)AST.getFirstChild();
int previousChildIndex = -1;
for (int i = 0; i < AST.getNumberOfChildren(); i++)
{
int childIndex = DrawAST(ChildAST, ref g);
if (childIndex != -1)
{
g.AddEdge(thisNodeIndex.ToString(), childIndex.ToString());
/* if (previousChildIndex != -1)
* {
* Edge SiblingEdge = (Edge)g.AddEdge(previousChildIndex.ToString(),
* childIndex.ToString());
* SiblingEdge.Attr.Styles = new Style[] { Microsoft.Glee.Drawing.Style.Dashed };
* }
*/
}
previousChildIndex = childIndex;
ChildAST = (CommonAST)ChildAST.getNextSibling();
}
return(thisNodeIndex);
}
else
{
return(-1);
}
}
public override string ToString()
{
CommonAST walker = (CommonAST)NodeASTSubTree.getFirstChild();
string Text = m_Label + walker.getText() + "(";
walker = (CommonAST)walker.getFirstChild();
while (walker != null)
{
Text += HelperFunctions.ExprToString(walker);
if (walker.getNextSibling() != null)
{
Text += ",";
}
walker = (CommonAST)walker.getNextSibling();
}
Text += ");";
return(Text);
}
private formattedCodeView getFormattedProcedure(CommonAST procedure, formattedCodeView formattedCode)
{
CommonAST walker = (CommonAST)procedure.getFirstChild();
string procedureHead = string.Empty;
procedureHead += walker.getText() + "(";
walker = (CommonAST)walker.getFirstChild();
bool first = true;
while (walker.Type == BoolParserTokenTypes.ID)
{
if (!first)
{
procedureHead += ", ";
}
procedureHead += walker.getText();
walker = (CommonAST)walker.getNextSibling();
first = false;
}
procedureHead += ")";
formattedCode.addLine(procedureHead);
formattedCode.addLine("begin");
while (walker.Type == BoolParserTokenTypes.LITERAL_decl)
{
formattedCode.addLine(" " + HelperFunctions.DeclToString(walker));
walker = (CommonAST)walker.getNextSibling();
}
formattedCode = getFormattedSSEQ(walker, formattedCode, " ");
formattedCode.addLine("end");
return(formattedCode);
}
public static string ExprToString(CommonAST Expression)
{
Debug.Assert(Expression != null);
string output = String.Empty;
Expression = (CommonAST)Expression.getFirstChild();
while (Expression != null)
{
if (Expression.Type != BoolParserTokenTypes.EXPR)
{
output += Expression.getText();
}
else
{
output += ExprToString(Expression);
}
Expression = (CommonAST)Expression.getNextSibling();
}
return(output);
}
private List <SemanticError> CheckSSEQ(CommonAST sseqAST, List <SemanticError> Errors,
List <string> LocalVariables, string ProcOf)
{
CommonAST walker = (CommonAST)sseqAST.getFirstChild();
while (walker != null)
{
CommonAST subWalker;
CommonAST stmtWalker = (CommonAST)walker;
if (stmtWalker.Type == BoolParserTokenTypes.LSTMT)
{
stmtWalker = (CommonAST)stmtWalker.getFirstChild().getNextSibling();
}
else
{
stmtWalker = (CommonAST)stmtWalker.getFirstChild();
}
switch (stmtWalker.Type)
{
case (BoolParserTokenTypes.LITERAL_print):
subWalker = (CommonAST)stmtWalker.getFirstChild();
while (subWalker != null)
{
Errors = CheckExpression(subWalker, Errors, LocalVariables, ProcOf);
subWalker = (CommonAST)subWalker.getNextSibling();
}
break;
case (BoolParserTokenTypes.ASSIGNMENT):
subWalker = (CommonAST)stmtWalker.getFirstChild();
while (subWalker != null)
{
switch (subWalker.Type)
{
case (BoolParserTokenTypes.ID):
if (!(LocalVariables.Contains(subWalker.getText())) &&
!(GlobalVariables.Contains(subWalker.getText())))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_UNDECLARED,
subWalker.getText(), ProcOf));
}
break;
case (BoolParserTokenTypes.EXPR):
Errors = CheckExpression(subWalker, Errors, LocalVariables, ProcOf);
break;
}
subWalker = (CommonAST)subWalker.getNextSibling();
}
break;
case (BoolParserTokenTypes.LITERAL_if):
case (BoolParserTokenTypes.LITERAL_while):
subWalker = (CommonAST)stmtWalker.getFirstChild();
if (subWalker.getFirstChild().Type == BoolParserTokenTypes.EXPR)
{
Errors = CheckExpression((CommonAST)subWalker.getFirstChild(),
Errors, LocalVariables, ProcOf);
}
subWalker = (CommonAST)subWalker.getNextSibling();
Errors = CheckSSEQ(subWalker, Errors, LocalVariables, ProcOf);
if (stmtWalker.Type == BoolParserTokenTypes.LITERAL_if)
{
subWalker = (CommonAST)subWalker.getNextSibling();
Errors = CheckSSEQ(subWalker, Errors, LocalVariables, ProcOf);
}
break;
case (BoolParserTokenTypes.LITERAL_assert):
subWalker = (CommonAST)stmtWalker.getFirstChild();
if (subWalker.getFirstChild().Type == BoolParserTokenTypes.EXPR)
{
Errors = CheckExpression((CommonAST)subWalker.getFirstChild(),
Errors, LocalVariables, ProcOf);
}
break;
case (BoolParserTokenTypes.PROCCALL):
subWalker = (CommonAST)stmtWalker.getFirstChild();
if (ProcedureNames.Contains(subWalker.getText()))
{
//Checking for a required skip statement after a Procedure call
CommonAST afterProc = (CommonAST)walker.getNextSibling();
if (afterProc != null)
{
if (afterProc.Type == BoolParserTokenTypes.LSTMT)
{
afterProc = (CommonAST)afterProc.getFirstChild().getNextSibling();
}
else
{
afterProc = (CommonAST)afterProc.getFirstChild();
}
}
if ((afterProc == null) || (afterProc.Type != BoolParserTokenTypes.LITERAL_skip))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.SKIP_EXPECTED,
subWalker.getText(), ProcOf));
}
string ProcCallName = subWalker.getText();
subWalker = (CommonAST)subWalker.getFirstChild();
int numParams = 0;
while (subWalker != null)
{
numParams++;
Errors = CheckExpression(subWalker, Errors, LocalVariables, ProcOf);
subWalker = (CommonAST)subWalker.getNextSibling();
}
int realNumParams;
ProcedureToNumParam.TryGetValue(ProcCallName, out realNumParams);
if (numParams != realNumParams)
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.WRONG_PARAM_NUM,
ProcCallName, ProcOf));
}
}
else
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.PROC_UNDECLARED,
subWalker.getText(), ProcOf));
}
break;
}
walker = (CommonAST)walker.getNextSibling();
}
return(Errors);
}
public List <SemanticError> Check()
{
List <SemanticError> Errors = new List <SemanticError>();
GlobalVariables.Clear();
ProcedureNames.Clear();
ProcedureToNumParam.Clear();
CommonAST walker = BoolProgram;
while ((walker != null) && (walker.Type == BoolParserTokenTypes.LITERAL_decl))
{
CommonAST subWalker = (CommonAST)walker.getFirstChild();
while (subWalker != null)
{
string variable = subWalker.ToString();
if (GlobalVariables.Contains(variable))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.VAR_NAME_CLASH, variable));
}
else
{
GlobalVariables.Add(variable);
}
subWalker = (CommonAST)subWalker.getNextSibling();
}
walker = (CommonAST)walker.getNextSibling();
}
CommonAST procWalker = walker;
while (walker != null)
{
string procName = walker.getFirstChild().getText();
if (ProcedureNames.Contains(procName))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.PROC_NAME_CLASH, procName));
}
else
{
ProcedureNames.Add(procName);
CommonAST subWalker = (CommonAST)walker.getFirstChild().getFirstChild();
int numParameters = 0;
while (subWalker.Type == BoolParserTokenTypes.ID)
{
numParameters++;
subWalker = (CommonAST)subWalker.getNextSibling();
}
ProcedureToNumParam.Add(procName, numParameters);
}
walker = (CommonAST)walker.getNextSibling();
}
while (procWalker != null)
{
Errors = CheckProcedure(procWalker, Errors);
procWalker = (CommonAST)procWalker.getNextSibling();
}
if (!(ProcedureNames.Contains("main")))
{
Errors.Add(new SemanticError(BoolSemanticErrorTypes.MAIN_MISSING, ""));
}
return(Errors);
}
private void BuildSuccesors()
{
foreach (CFGNode node in ListOfCfgNodes)
{
CommonAST nodeAST = node.GetAST();
CFGNode succNode;
#region Succesors for Statements
if (node is CFGNodeStatement)
{
CFGNodeStatement stmtNode = (CFGNodeStatement)node;
switch (nodeAST.Type)
{
case BoolParserTokenTypes.LITERAL_goto:
nodeAST = (CommonAST)nodeAST.getFirstChild();
if (LabelToStatement.TryGetValue(nodeAST.getText(), out succNode))
{
stmtNode.AddSuccesor(succNode);
}
break;
case BoolParserTokenTypes.ASSIGNMENT:
case BoolParserTokenTypes.LITERAL_skip:
case BoolParserTokenTypes.LITERAL_print:
stmtNode.AddSuccesor(stmtNode.Next);
break;
case BoolParserTokenTypes.LITERAL_return:
stmtNode.AddSuccesor(stmtNode.ProcOf);
break;
case BoolParserTokenTypes.LITERAL_if:
nodeAST = (CommonAST)nodeAST.getFirstChild();
nodeAST = (CommonAST)nodeAST.getNextSibling();
if (AstToCfgMapping.TryGetValue(nodeAST.getFirstChild() as CommonAST, out succNode))
{
(stmtNode as CFGNodeStmtIf).TrueSuccesor = succNode;
}
nodeAST = (CommonAST)nodeAST.getNextSibling();
if (AstToCfgMapping.TryGetValue(nodeAST.getFirstChild() as CommonAST, out succNode))
{
(stmtNode as CFGNodeStmtIf).FalseSuccesor = succNode;
}
break;
case BoolParserTokenTypes.LITERAL_while:
nodeAST = (CommonAST)nodeAST.getFirstChild();
nodeAST = (CommonAST)nodeAST.getNextSibling();
nodeAST = (CommonAST)nodeAST.getFirstChild();
if (AstToCfgMapping.TryGetValue(nodeAST, out succNode))
{
(stmtNode as CFGNodeStmtWhile).TrueSuccesor = succNode;
}
(stmtNode as CFGNodeStmtWhile).FalseSuccesor = stmtNode.Next;
break;
case BoolParserTokenTypes.LITERAL_assert:
(stmtNode as CFGNodeStmtAssert).FalseSuccesor = ErrorNode;
(stmtNode as CFGNodeStmtAssert).TrueSuccesor = stmtNode.Next;
break;
case BoolParserTokenTypes.PROCCALL:
nodeAST = (CommonAST)nodeAST.getFirstChild();
CFGNodeProcedure procNode;
if (ProcNameToNode.TryGetValue(nodeAST.getText(), out procNode))
{
stmtNode.AddSuccesor(procNode.FirstStmtOf);
}
//Exit points of procedures need to be filled when processing all procedure calls
procNode.AddSuccesor(stmtNode.Next);
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
}
#endregion
//Succesors for Procedure Exits are built when processing Procedure calls
}
}
private void BuildNextFunction()
{
foreach (CFGNode node in ListOfCfgNodes)
{
if (node is CFGNodeStatement)
{
CFGNodeStatement stmt = (CFGNodeStatement)node;
CFGNode NextNode = null;
CommonAST ASTwalker = stmt.GetAST();
ASTParentByASTNode.TryGetValue(ASTwalker, out ASTwalker);
bool done = false;
while (!done && ASTwalker != null)
{
#region STMT or LSTMT
if (ASTwalker.Type == BoolParserTokenTypes.LITERAL_while)
{
done = true;
ASTParentByASTNode.TryGetValue(ASTwalker, out ASTwalker);
if (AstToCfgMapping.TryGetValue(ASTwalker, out NextNode))
{
stmt.Next = NextNode;
}
else
{
stmt.Next = null;
}
}
else
if ((ASTwalker.Type == BoolParserTokenTypes.STMT ||
ASTwalker.Type == BoolParserTokenTypes.LSTMT) &&
(ASTwalker.getNextSibling() != null))
{
CommonAST ASTwalkerSibling = (CommonAST)ASTwalker.getNextSibling();
if (ASTwalkerSibling.Type == BoolParserTokenTypes.STMT ||
ASTwalkerSibling.Type == BoolParserTokenTypes.LSTMT)
{
done = true;
if (AstToCfgMapping.TryGetValue(ASTwalkerSibling, out NextNode))
{
stmt.Next = NextNode;
}
else
{
stmt.Next = null;
}
}
}
#endregion
#region PROC
if (ASTwalker.Type == BoolParserTokenTypes.PROC)
{
done = true;
if (AstToCfgMapping.TryGetValue(ASTwalker, out NextNode))
{
stmt.Next = NextNode;
}
else
{
stmt.Next = null;
}
}
#endregion
if (!done)
{
ASTParentByASTNode.TryGetValue(ASTwalker, out ASTwalker);
}
}
if (stmt is CFGNodeStmtProcCall)
{
if (NextNode is CFGNodeStmtSkip)
{
(NextNode as CFGNodeStmtSkip).setPreviousProcCall(stmt as CFGNodeStmtProcCall);
}
}
}
else
//We use this pass trough the CFG nodes to build "First Statement Of Procedure" function
if (node is CFGNodeProcedure)
{
CFGNodeProcedure proc = (CFGNodeProcedure)node;
CommonAST ASTwalker = proc.GetAST();
ASTwalker = (CommonAST)ASTwalker.getFirstChild();
while (ASTwalker.Type != BoolParserTokenTypes.SSEQ)
{
ASTwalker = (CommonAST)ASTwalker.getNextSibling();
}
ASTwalker = (CommonAST)ASTwalker.getFirstChild();
CFGNode FirstOf;
if (AstToCfgMapping.TryGetValue(ASTwalker, out FirstOf))
{
proc.FirstStmtOf = FirstOf;
}
}
}
}
private void ExtractCfgNodes(CommonAST SubAst, CommonAST ParentAST, CFGNodeProcedure ProcOf)
{
while (SubAst != null)
{
ASTParentByASTNode.Add(SubAst, ParentAST);
#region AST Nodes of type Statement
if (SubAst.Type == BoolParserTokenTypes.STMT ||
SubAst.Type == BoolParserTokenTypes.LSTMT)
{
if (!AstToCfgMapping.ContainsKey(SubAst))
{
CFGNodeStatement NewStatementNode;
if (SubAst.Type == BoolParserTokenTypes.STMT)
{
NewStatementNode = CFGStatementNodeFactory.Make((CommonAST)SubAst.getFirstChild());
}
else
{
NewStatementNode = CFGStatementNodeFactory.Make(
(CommonAST)SubAst.getFirstChild().getNextSibling());
NewStatementNode.setLabel(SubAst.getFirstChild().getText());
LabelToStatement.Add(SubAst.getFirstChild().getText(), NewStatementNode);
}
NewStatementNode.ProcOf = ProcOf;
ListOfCfgNodes.Add(NewStatementNode);
AstToCfgMapping.Add(SubAst, NewStatementNode);
}
}
#endregion
#region AST Nodes of type Procedure
if (SubAst.Type == BoolParserTokenTypes.PROC)
{
if (!AstToCfgMapping.ContainsKey(SubAst))
{
CFGNodeProcedure NewStatementNode =
new CFGNodeProcedure((CommonAST)SubAst.getFirstChild());
ListOfCfgNodes.Add(NewStatementNode);
AstToCfgMapping.Add(SubAst, NewStatementNode);
ProcNameToNode.Add(SubAst.getFirstChild().getText(), NewStatementNode);
ProcOf = NewStatementNode;
//Inserting the function parameters into the procedure local variables list
CommonAST walker = (CommonAST)SubAst.getFirstChild().getFirstChild();
while (walker.Type == BoolParserTokenTypes.ID)
{
int varID = ProcOf.LocalVariables.AddVar(walker.getText(), m_BddManager, m_BddVariableToName);
ProcOf.FormalParameters.AddVar(walker.getText(), varID);
walker = (CommonAST)walker.getNextSibling();
}
}
}
#endregion
#region AST Nodes of type Variable Declaration
if (SubAst.Type == BoolParserTokenTypes.LITERAL_decl)
{
CommonAST walker = (CommonAST)SubAst.getFirstChild();
while (walker != null)
{
if (ProcOf != null)
{
ProcOf.LocalVariables.AddVar(walker.getText(), m_BddManager, m_BddVariableToName);
}
else
{
m_GlobalVariables.AddVar(walker.getText(), m_BddManager, m_BddVariableToName);
}
walker = (CommonAST)walker.getNextSibling();
}
}
#endregion
ExtractCfgNodes((CommonAST)SubAst.getFirstChild(), SubAst, ProcOf);
SubAst = (CommonAST)SubAst.getNextSibling();
}
}
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 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 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);
}
