public CFGNodeProcedure(CommonAST StatementAST)
{
NodeASTSubTree = StatementAST;
m_LocalVariables = new Variables();
m_FormalParameters = new Variables();
m_Succesor = new List <CFGNode>();
}
public formattedCodeView getFormattedProgram()
{
formattedCodeView formattedProgram = new formattedCodeView();
CommonAST walker = BoolProgramAst;
while ((walker != null) && (walker.Type == BoolParserTokenTypes.LITERAL_decl))
{
formattedProgram.addLine(HelperFunctions.DeclToString(walker));
walker = (CommonAST)walker.getNextSibling();
}
formattedProgram.addLine("");
while ((walker != null) && (walker.Type == BoolParserTokenTypes.PROC))
{
formattedProgram = getFormattedProcedure(walker, formattedProgram);
formattedProgram.addLine("");
walker = (CommonAST)walker.getNextSibling();
}
return(formattedProgram);
}
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 Graph GetASTasGLEEGraph()
{
Graph g = new Graph("AST");
g.GraphAttr.NodeAttr.Padding = 3;
CommonAST BoolProgramASTRoot = new CommonAST();
BoolProgramASTRoot.setText("Bool Program");
BoolProgramASTRoot.addChild(BoolProgAST);
ASTforGLEEIndex = 0;
if (ASTorderedByGraphIndex == null)
{
ASTorderedByGraphIndex = new List <CommonAST>();
}
else
{
ASTorderedByGraphIndex.Clear();
}
DrawAST(BoolProgramASTRoot, ref g);
return(g);
}
public override string ToString()
{
CommonAST walker = (CommonAST)NodeASTSubTree.getFirstChild();
string Text = m_Label + walker.getText();
walker = (CommonAST)walker.getNextSibling();
while (walker.Type != BoolParserTokenTypes.ASSIGN)
{
Text += "," + walker.getText();
walker = (CommonAST)walker.getNextSibling();
}
Text += ":=";
walker = (CommonAST)walker.getNextSibling();
while (walker != null)
{
Text += HelperFunctions.ExprToString(walker);
if (walker.getNextSibling() != null)
{
Text += ",";
}
walker = (CommonAST)walker.getNextSibling();
}
Text += ';';
return(Text);
}
public BoolProgramChecker(CommonAST ProgramAST)
{
BoolProgram = ProgramAST;
GlobalVariables = new List <string>();
ProcedureNames = new List <string>();
ProcedureToNumParam = new Dictionary <string, int>();
}
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);
}
override public string ToString()
{
string Text = m_Label + "assert(";
CommonAST walker = (CommonAST)NodeASTSubTree.getFirstChild();
Text += HelperFunctions.DeciderToString(walker);
Text += ");";
return(Text);
}
//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 string DeciderToString(CommonAST Decider)
{
Decider = (CommonAST)Decider.getFirstChild();
if (Decider.Type == BoolParserTokenTypes.EXPR)
{
return(HelperFunctions.ExprToString(Decider));
}
else
{
return(Decider.getText());
}
}
public override string ToString()
{
string Text = m_Label + "print(";
CommonAST walker = (CommonAST)NodeASTSubTree.getFirstChild();
while (walker != null)
{
Text += HelperFunctions.ExprToString(walker);
if (walker.getNextSibling() != null)
{
Text += ",";
}
walker = (CommonAST)walker.getNextSibling();
}
Text += ");";
return(Text);
}
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 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>();
}
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);
}
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 Bdd GetExprBdd(int ASTIndex, out String Description)
{
if (ASTorderedByGraphIndex != null)
{
CommonAST Expression = ASTorderedByGraphIndex[ASTIndex];
if (Expression.Type == BoolParserTokenTypes.EXPR)
{
Description = ControlFlowGraph.HelperFunctions.ExprToString(Expression);
return(ControlFlowGraph.HelperFunctions.ExprToBdd(Expression, m_BddManager,
ProgramCFG.GlobalVariables.VariablesToId, ProgramCFG.GlobalVariables.VariablesToId));
}
else
{
Description = "Not an expression";
return(null);
}
}
else
{
Description = "N/A";
return(null);
}
}
public static CFGNodeStatement Make(CommonAST NodeAST)
{
switch (NodeAST.Type)
{
case BoolParserTokenTypes.LITERAL_skip:
return(new CFGNodeStmtSkip(NodeAST));
case BoolParserTokenTypes.LITERAL_print:
return(new CFGNodeStmtPrint(NodeAST));
case BoolParserTokenTypes.LITERAL_goto:
return(new CFGNodeStmtGoto(NodeAST));
case BoolParserTokenTypes.LITERAL_return:
return(new CFGNodeStmtReturn(NodeAST));
case BoolParserTokenTypes.ASSIGNMENT:
return(new CFGNodeStmtAssignment(NodeAST));
case BoolParserTokenTypes.LITERAL_if:
return(new CFGNodeStmtIf(NodeAST));
case BoolParserTokenTypes.LITERAL_while:
return(new CFGNodeStmtWhile(NodeAST));
case BoolParserTokenTypes.LITERAL_assert:
return(new CFGNodeStmtAssert(NodeAST));
case BoolParserTokenTypes.PROCCALL:
return(new CFGNodeStmtProcCall(NodeAST));
default:
Debug.Assert(false);
return(null);
}
}
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);
}
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();
}
}
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 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);
}
public CFGNodeStmtReturn(CommonAST StatementAST)
: base(StatementAST)
{
}
public CFGNodeStmtConditional(CommonAST StatementAST)
: base(StatementAST)
{
}
public CFGNodeStmtPrint(CommonAST StatementAST)
: base(StatementAST)
{
}
public bool ParseProgram(string BooleanProgram)
{
bool Succesful = true;
try
{
ErrorLog = String.Empty;
Lexer.resetState(new StringReader(BooleanProgram));
Parser.resetState();
StringWriter ErrorLogger = new StringWriter();
Console.SetError(ErrorLogger);
Parser.prog();
ErrorLog = ErrorLogger.ToString();
if (ErrorLog.Equals(String.Empty))
{
ErrorLog += "Syntax validation completed without errors.\n";
BoolProgAST = (CommonAST)Parser.getAST();
}
else
{
Succesful = false;
}
}
catch (TokenStreamException err)
{
ErrorLog += ("exception: " + err.ToString() + "\n");
Succesful = false;
}
catch (RecognitionException err)
{
ErrorLog += ("exception: " + err.ToString() + "\n");
Succesful = false;
}
if (Succesful)
{
BoolSemantics.BoolProgramChecker SemanticChecker =
new BoolSemantics.BoolProgramChecker(BoolProgAST);
List <BoolSemantics.SemanticError> Errors = SemanticChecker.Check();
if (Errors.Count == 0)
{
ErrorLog += "Semantic validation completed without errors.\n";
BuildCFG();
}
else
{
ErrorLog += "\n";
foreach (BoolSemantics.SemanticError Error in Errors)
{
ErrorLog += Error.ToString() + "\n";
}
BoolProgAST = null;
}
}
return(Succesful);
}
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
}
}
