public BoundIfPart(IfPartSyntax syntax, BaseBoundExpression condition, BoundStatementBlock body)
{
Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null.");
Debug.Assert(!condition.IsDefault(), "'condition' must not be null.");
Debug.Assert(!body.IsDefault(), "'body' must not be null.");
this.Syntax = syntax;
this.Condition = condition;
this.Body = body;
}
private IfStatementSyntax ParseIfStatement()
{
var ifToken = this.Eat(TokenKind.If);
var expression = this.ParseBaseExpression();
var thenToken = this.Eat(TokenKind.Then);
this.RunToEndOfLine();
var statements = this.ParseStatementsExcept(TokenKind.ElseIf, TokenKind.Else, TokenKind.EndIf);
var ifPart = new IfPartSyntax(ifToken, expression, thenToken, statements);
var elseIfParts = new List <ElseIfPartSyntax>();
while (this.index < this.tokens.Count && this.Peek() == TokenKind.ElseIf)
{
var elseIfToken = this.Eat(TokenKind.ElseIf);
expression = this.ParseBaseExpression();
thenToken = this.Eat(TokenKind.Then);
this.RunToEndOfLine();
statements = this.ParseStatementsExcept(TokenKind.ElseIf, TokenKind.Else, TokenKind.EndIf);
elseIfParts.Add(new ElseIfPartSyntax(elseIfToken, expression, thenToken, statements));
}
ElsePartSyntax elsePartOpt = null;
if (this.index < this.tokens.Count && this.Peek() == TokenKind.Else)
{
var elseToken = this.Eat(TokenKind.Else);
this.RunToEndOfLine();
statements = this.ParseStatementsExcept(TokenKind.ElseIf, TokenKind.Else, TokenKind.EndIf);
elsePartOpt = new ElsePartSyntax(elseToken, statements);
}
var endIfToken = this.Eat(TokenKind.EndIf);
this.RunToEndOfLine();
return(new IfStatementSyntax(ifPart, elseIfParts, elsePartOpt, endIfToken));
}
private IfStatement TraverseIfStatement(IfPartSyntax slips, ref int returnCnt, bool nested = false)
{
IfStatement ifStm = new IfStatement();
ifStm.IsNested = nested;
IfStatementSyntax iss = slips.Begin;
BinaryExpressionSyntax bes = iss.Condition as BinaryExpressionSyntax;
if (bes != null)
{
foreach (SyntaxNode sn in bes.DescendantNodesAndSelf())
{
if (sn is BinaryExpressionSyntax)
{
ifStm.ConditionCount++;
}
else if (sn is IdentifierNameSyntax)
{
Variables variable = new Variables();
variable.IsReferenced = true;
variable.Name = (sn as IdentifierNameSyntax).Identifier.ValueText;
ifStm.AccessedVars.Add(variable);
}
}
}
foreach (StatementSyntax ss in slips.Statements)
{
if (ss is AssignmentStatementSyntax)
{
//TODO: need to look at more than just then name!
Method tempMethod = TraverseAccessVars(ss as AssignmentStatementSyntax);
ifStm.AccessedVars.AddRange(tempMethod.AccessedVariables);
ifStm.InvokedMethods.AddRange(tempMethod.InvokedMethods);
}
else if (ss is LocalDeclarationStatementSyntax)
{
Method tempMethod = TraverseVarDecls(ss as LocalDeclarationStatementSyntax);
ifStm.AccessedVars.AddRange(tempMethod.AccessedVariables);
ifStm.InvokedMethods.AddRange(tempMethod.InvokedMethods);
}
else if (ss is SingleLineIfStatementSyntax)
{
Decisions decision = TraverseIfStatement(ss as SingleLineIfStatementSyntax, ref returnCnt, true);
ifStm.Nested.AddRange(decision.IfStatements);
ifStm.Nested.AddRange(decision.ElseStatements);
}
else if (ss is MultiLineIfBlockSyntax)
{
Decisions decisions = TraverseMultiIfStatement(ss as MultiLineIfBlockSyntax, ref returnCnt, true);
ifStm.Nested.AddRange(decisions.IfStatements);
ifStm.Nested.AddRange(decisions.ElseStatements);
}
else if (ss is ForBlockSyntax)
{
Decisions tempDecision = TraverseForStatement(ss as ForBlockSyntax, ref returnCnt, true);
ifStm.Nested.AddRange(tempDecision.IfStatements);
ifStm.Nested.AddRange(tempDecision.ElseStatements);
ifStm.Nested.AddRange(tempDecision.ForEachStatements);
ifStm.Nested.AddRange(tempDecision.ForStatements);
ifStm.Nested.AddRange(tempDecision.WhileLoops);
ifStm.Nested.AddRange(tempDecision.DoWhileLoops);
ifStm.Nested.AddRange(tempDecision.Catches);
ifStm.Nested.AddRange(tempDecision.SwitchStatements);
}
else if (ss is ElseStatementSyntax)
{
ifStm.Nested.Add(TravsereElseStatement(ss as ElseStatementSyntax, ref returnCnt, true));
}
else if (ss is SelectBlockSyntax)
{
ifStm.Nested.Add(TraverseSwitchStatement(ss as SelectBlockSyntax, ref returnCnt, true));
}
else if (ss is DoLoopBlockSyntax)
{
ifStm.Nested.Add(TraverseDoWhileLoop(ss as DoLoopBlockSyntax, ref returnCnt, true));
}
else if (ss is WhileBlockSyntax)
{
ifStm.Nested.Add(TraverseWhileLoop(ss as WhileBlockSyntax, ref returnCnt, true));
}
else if (ss is CallStatementSyntax)
{
ifStm.InvokedMethods.Add(TraverseInvokedMethod(ss as CallStatementSyntax));
}
else if (ss is ReturnStatementSyntax)
{
Method tempMethod = TraverseReturnStatement(ss as ReturnStatementSyntax);
ifStm.InvokedMethods.AddRange(tempMethod.InvokedMethods);
ifStm.AccessedVars.AddRange(tempMethod.AccessedVariables);
returnCnt++;
}
}
//!!!!!!!!!!!!!!!!!!Start Here!!!!!!!!!!!!!!!!!!!!!!!
return ifStm;
}
