private void RecursiveDecisions(List<BaseDecisions> nested, ref Decisions decisions) { foreach (BaseDecisions bd in nested) { decisions.Add(bd); RecursiveDecisions(bd.Nested, ref decisions); } }
/// <summary> /// Constructor that sets all the Types so no lingering null types exist /// </summary> public Method() { Preprocessors = new List<Preprocessor>(); Encapsulation = new List<Encapsulation>(); Base = new List<InvokedMethod>(); ReturnType = new Type(); Qualifiers = new List<Qualifiers>(); Parameters = new List<Variables>(); Decisions = new Decisions(); AccessedVariables = new List<Variables>(); LabelStatements = new List<LabelStatement>(); GoToStatements = new List<GoTo>(); InvokedMethods = new List<InvokedMethod>(); }
private Decisions AllDecisions(Decisions decisions) { Decisions retDecisions = new Decisions(); foreach (IfStatement bd in decisions.IfStatements) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (ElseStatement bd in decisions.ElseStatements) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (ForStatement bd in decisions.ForStatements) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (ForEachStatement bd in decisions.ForEachStatements) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (WhileLoop bd in decisions.WhileLoops) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (DoWhileLoop bd in decisions.DoWhileLoops) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (SwitchStatement bd in decisions.SwitchStatements) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } foreach (CatchStatements bd in decisions.Catches) { retDecisions.Add(bd); RecursiveDecisions(bd.Nested, ref retDecisions); } return retDecisions; }
private Decisions TraverseMultiIfStatement(MultiLineIfBlockSyntax mlib, ref int returnCnt, bool nested = false) { Decisions retDecisions = new Decisions(); foreach (SyntaxNode sn in mlib.ChildNodes()) { if (sn is IfPartSyntax) { retDecisions.IfStatements.Add(TraverseIfStatement(sn as IfPartSyntax, ref returnCnt, nested)); } else if (sn is ElsePartSyntax) { retDecisions.ElseStatements.Add(TraverseElseStatement(sn as ElsePartSyntax, ref returnCnt, nested)); } } return retDecisions; }
//TODO: Make sure we recursively go through each decision private Decisions TraverseIfStatement(SingleLineIfStatementSyntax sliss, ref int returnCnt, bool nested = false) { Decisions retDecision = new Decisions(); IfStatement ifStm = new IfStatement(); ifStm.IsNested = nested; //!!!!!!!!!!!!!!!!!!!!Start Here!!!!!!!!!!!!!!!!!!! SingleLineIfPartSyntax ifPart = sliss.IfPart; IfStatementSyntax iss = ifPart.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 ifPart.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 ElseStatementSyntax) { ifStm.Nested.Add(TravsereElseStatement(ss as ElseStatementSyntax, ref returnCnt, true)); } 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 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++; } } retDecision.IfStatements.Add(ifStm); if (sliss.ElsePart != null) { SingleLineElsePartSyntax sleps = sliss.ElsePart; ElseStatement elseStm = new ElseStatement(); foreach (StatementSyntax ss in sleps.Statements) { if (ss is AssignmentStatementSyntax) { //TODO: need to look at more than just then name! Method tempMethod = TraverseAccessVars(ss as AssignmentStatementSyntax); elseStm.AccessedVars.AddRange(tempMethod.AccessedVariables); elseStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } else if (ss is LocalDeclarationStatementSyntax) { Method tempMethod = TraverseVarDecls(ss as LocalDeclarationStatementSyntax); elseStm.AccessedVars.AddRange(tempMethod.AccessedVariables); elseStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } else if (ss is SingleLineIfStatementSyntax) { Decisions decision = TraverseIfStatement(ss as SingleLineIfStatementSyntax, ref returnCnt, true); elseStm.Nested.AddRange(decision.IfStatements); elseStm.Nested.AddRange(decision.ElseStatements); } else if (ss is MultiLineIfBlockSyntax) { Decisions decisions = TraverseMultiIfStatement(ss as MultiLineIfBlockSyntax, ref returnCnt, true); elseStm.Nested.AddRange(decisions.IfStatements); elseStm.Nested.AddRange(decisions.ElseStatements); } else if (ss is ElseStatementSyntax) { elseStm.Nested.Add(TravsereElseStatement(ss as ElseStatementSyntax, ref returnCnt, true)); } 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 SelectBlockSyntax) { elseStm.Nested.Add(TraverseSwitchStatement(ss as SelectBlockSyntax, ref returnCnt, true)); } else if (ss is DoLoopBlockSyntax) { elseStm.Nested.Add(TraverseDoWhileLoop(ss as DoLoopBlockSyntax, ref returnCnt, true)); } else if (ss is WhileBlockSyntax) { elseStm.Nested.Add(TraverseWhileLoop(ss as WhileBlockSyntax, ref returnCnt, true)); } else if (ss is CallStatementSyntax) { elseStm.InvokedMethods.Add(TraverseInvokedMethod(ss as CallStatementSyntax)); } else if (ss is ReturnStatementSyntax) { Method tempMethod = TraverseReturnStatement(ss as ReturnStatementSyntax); elseStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); elseStm.AccessedVars.AddRange(tempMethod.AccessedVariables); returnCnt++; } } retDecision.Add(elseStm); } return retDecision; }
private Decisions TraverseWhileLoops(WhileStatementSyntax wss, ref int exitPoints, bool nested = false) { //TODO //get accessed vars, invoked methods, nested Decisions retDecision = new Decisions(); WhileLoop whileStm = new WhileLoop(); if (wss.HasLeadingTrivia) { SetOuterComments(whileStm, wss.GetLeadingTrivia().ToFullString()); } if (wss.HasTrailingTrivia) { SetInnerComments(whileStm, wss.GetTrailingTrivia().ToFullString()); } ExpressionSyntax es = wss.Condition; //var binaryExpressions = from aBinaryExpression in wss.Condition.DescendantNodesAndSelf().OfType<BinaryExpressionSyntax>() select aBinaryExpression; var binaryExpressions = from abinaryExpression in wss.ChildNodes().OfType<BinaryExpressionSyntax>() select abinaryExpression; whileStm.ConditionCount = binaryExpressions.Count(); if (wss.Condition is BinaryExpressionSyntax) { //this next line doesn't ever fire //binaryExpressions = from aBinaryExpression in wss.Condition.DescendantNodes().OfType<BinaryExpressionSyntax>() select aBinaryExpression; foreach (BinaryExpressionSyntax bes in binaryExpressions) { Method tempMethod = TraverseBinaryExpression(bes); whileStm.AccessedVars.AddRange(tempMethod.AccessedVariables); whileStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } } var catches = from aCatch in wss.ChildNodes().OfType<CatchClauseSyntax>() select aCatch; foreach (CatchClauseSyntax ccs in catches) { Decisions tempCatch = TraverseCatchClauses(ccs, ref exitPoints, true); whileStm.Nested.AddRange(tempCatch.Catches); } var statements = from aStatement in wss.Statement.ChildNodes().OfType<StatementSyntax>() select aStatement; List<BaseDecisions> retBd = new List<BaseDecisions>(); List<InvokedMethod> retIm = new List<InvokedMethod>(); #region Nested and Invoked Methods and accessed vars foreach (StatementSyntax ss in statements) { //if (ss is BreakStatementSyntax) //{ //} //else if (ss is CheckedStatementSyntax) //{ //} //else if (ss is ContinueStatementSyntax) //{ //} if (ss is DoStatementSyntax) { Decisions dwl = TraverseDoStatements(ss as DoStatementSyntax, ref exitPoints, true); whileStm.Nested.AddRange(dwl.DoWhileLoops); //dwl.IsNested = true; //whileStm.Nested.Add(dwl); } //else if (ss is EmptyStatementSyntax) //{ //} else if (ss is ExpressionStatementSyntax) { Method tempMethod = TraverseExpressionStatementSyntax(ss as ExpressionStatementSyntax); whileStm.AccessedVars.AddRange(tempMethod.AccessedVariables); whileStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } //else if (ss is FixedStatementSyntax) //{ //} else if (ss is ForEachStatementSyntax) { Decisions fes = TraverseForEachStatements(ss as ForEachStatementSyntax, ref exitPoints, true); whileStm.Nested.AddRange(fes.ForEachStatements); //fes.IsNested = true; //whileStm.Nested.Add(fes); } else if (ss is ForStatementSyntax) { Decisions fs = TraverseForStatements(ss as ForStatementSyntax, ref exitPoints, true); whileStm.Nested.AddRange(fs.WhileLoops); //fs.IsNested = true; //whileStm.Nested.Add(fs); } //else if (ss is GotoStatementSyntax) //{ //} else if (ss is IfStatementSyntax) { Decisions decision = TraverseIfStatements(ss as IfStatementSyntax, ref exitPoints, true); whileStm.Nested.AddRange(decision.IfStatements); } //else if (ss is LabeledStatementSyntax) //{ // BaseDecisions bd = new BaseDecisions(); // bd.IsNested = true; // bd.Nested.Add(TraverseLabelStatements(ss as LabeledStatementSyntax)); // retIf.Nested.Add(bd); //} else if (ss is LocalDeclarationStatementSyntax) { Method tempMethod = TransverseAccessVars(ss as LocalDeclarationStatementSyntax); whileStm.AccessedVars.AddRange(tempMethod.AccessedVariables); whileStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } //else if (ss is LockStatementSyntax) //{ //} //else if (ss is ReturnStatementSyntax) //{ //} else if (ss is SwitchStatementSyntax) { Decisions switchStm = TraverseSwitchStatements(ss as SwitchStatementSyntax, ref exitPoints, true); whileStm.Nested.AddRange(switchStm.SwitchStatements); //switchStm.IsNested = true; //whileStm.Nested.Add(switchStm); } //else if (ss is ThrowStatementSyntax) //{ //} //else if (ss is TryStatementSyntax) //{ //} //else if (ss is UnsafeStatementSyntax) //{ //} //else if (ss is UsingStatementSyntax) //{ // //using list? //} else if (ss is WhileStatementSyntax) { Decisions wl = TraverseWhileLoops(ss as WhileStatementSyntax, ref exitPoints, true); whileStm.Nested.AddRange(wl.WhileLoops); //wl.IsNested = true; //whileStm.Nested.Add(wl); } //else if (ss is YieldStatementSyntax) //{ //} } #endregion retDecision.WhileLoops.Add(whileStm); return retDecision; }
private Decisions TraverseSwitchStatements(SwitchStatementSyntax sss, ref int exitPoints, bool nested = false) { Decisions retDecision = new Decisions(); SwitchStatement retSwitch = new SwitchStatement(); if (sss.HasLeadingTrivia) { SetOuterComments(retSwitch, sss.GetLeadingTrivia().ToFullString()); } if (sss.HasTrailingTrivia) { SetInnerComments(retSwitch, sss.GetTrailingTrivia().ToFullString()); } ExpressionSyntax es = sss.Expression; var binaryExprs = from aBinaryExpr in sss.ChildNodes().OfType<BinaryExpressionSyntax>() select aBinaryExpr; foreach (BinaryExpressionSyntax bes in binaryExprs) { Method tempMethod = TraverseBinaryExpression(bes); retSwitch.AccessedVars.AddRange(tempMethod.AccessedVariables); retSwitch.InvokedMethods.AddRange(tempMethod.InvokedMethods); } var catches = from aCatch in sss.ChildNodes().OfType<CatchClauseSyntax>() select aCatch; foreach (CatchClauseSyntax ccs in catches) { Decisions tempCatch = TraverseCatchClauses(ccs, ref exitPoints, true); retSwitch.Nested.AddRange(tempCatch.Catches); } var statements = from aStatement in sss.ChildNodes().OfType<StatementSyntax>() select aStatement; List<BaseDecisions> retBd = new List<BaseDecisions>(); List<InvokedMethod> retIm = new List<InvokedMethod>(); #region Nested and Invoked Methods and accessed vars foreach (StatementSyntax ss in statements) { //if (ss is BreakStatementSyntax) //{ //} //else if (ss is CheckedStatementSyntax) //{ //} //else if (ss is ContinueStatementSyntax) //{ //} if (ss is DoStatementSyntax) { Decisions dwl = TraverseDoStatements(ss as DoStatementSyntax, ref exitPoints, true); retSwitch.Nested.AddRange(dwl.DoWhileLoops); //dwl.Nested.Add(TraverseDoStatements(ss as DoStatementSyntax)); //retSwitch.Nested.Add(dwl); } //else if (ss is EmptyStatementSyntax) //{ //} else if (ss is ExpressionStatementSyntax) { var vars = from aVar in ss.ChildNodes().OfType<BinaryExpressionSyntax>() select aVar; foreach (BinaryExpressionSyntax bes in vars) { Method tempMethod = TraverseBinaryExpression(bes); retSwitch.AccessedVars.AddRange(tempMethod.AccessedVariables); retSwitch.InvokedMethods.AddRange(tempMethod.InvokedMethods); } var invokedMethods = from aInvokedMethod in ss.ChildNodes().OfType<InvocationExpressionSyntax>() select aInvokedMethod; foreach (InvocationExpressionSyntax ies in invokedMethods) { Method tempMethod = TraverseInvocationExpression(ies); retSwitch.InvokedMethods.AddRange(tempMethod.InvokedMethods); retSwitch.AccessedVars.AddRange(tempMethod.AccessedVariables); } } //else if (ss is FixedStatementSyntax) //{ //} else if (ss is ForEachStatementSyntax) { Decisions fes = TraverseForEachStatements(ss as ForEachStatementSyntax, ref exitPoints, true); retSwitch.Nested.AddRange(fes.ForEachStatements); //fes.IsNested = true; //retSwitch.Nested.Add(fes); } else if (ss is ForStatementSyntax) { Decisions fs = TraverseForStatements(ss as ForStatementSyntax, ref exitPoints, true); retSwitch.Nested.AddRange(fs.ForStatements); //fs.IsNested = true; //retSwitch.Nested.Add(fs); } //else if (ss is GotoStatementSyntax) //{ //} else if (ss is IfStatementSyntax) { Decisions ifstm = TraverseIfStatements(ss as IfStatementSyntax, ref exitPoints, true); retSwitch.Nested.AddRange(ifstm.IfStatements); //ifstm.IsNested = true; //retSwitch.Nested.Add(ifstm); } //else if (ss is LabeledStatementSyntax) //{ // BaseDecisions bd = new BaseDecisions(); // bd.IsNested = true; // bd.Nested.Add(TraverseLabelStatements(ss as LabeledStatementSyntax)); // retIf.Nested.Add(bd); //} else if (ss is LocalDeclarationStatementSyntax) { Method tempMethod = TransverseAccessVars(ss as LocalDeclarationStatementSyntax); retSwitch.AccessedVars.AddRange(tempMethod.AccessedVariables); retSwitch.InvokedMethods.AddRange(tempMethod.InvokedMethods); } //else if (ss is LockStatementSyntax) //{ //} //else if (ss is ReturnStatementSyntax) //{ //} else if (ss is SwitchStatementSyntax) { Decisions switchStm = TraverseSwitchStatements(ss as SwitchStatementSyntax, ref exitPoints, true); retSwitch.Nested.AddRange(switchStm.SwitchStatements); //switchStm.IsNested = true; //retSwitch.Nested.Add(switchStm); } //else if (ss is ThrowStatementSyntax) //{ //} //else if (ss is TryStatementSyntax) //{ //} //else if (ss is UnsafeStatementSyntax) //{ //} //else if (ss is UsingStatementSyntax) //{ // //using list? //} else if (ss is WhileStatementSyntax) { Decisions wl = TraverseWhileLoops(ss as WhileStatementSyntax, ref exitPoints, true); retSwitch.Nested.AddRange(wl.WhileLoops); //wl.IsNested = true; //retSwitch.Nested.Add(wl); } //else if (ss is YieldStatementSyntax) //{ //} } #endregion retDecision.SwitchStatements.Add(retSwitch); return retDecision; }
private Decisions TraverseIfStatements(IfStatementSyntax iss, ref int exitPoints, bool nested = false) { Decisions retDecision = new Decisions(); IfStatement ifStm = new IfStatement(); if (iss.HasLeadingTrivia) { SetOuterComments(ifStm, iss.GetLeadingTrivia().ToFullString()); } if (iss.HasTrailingTrivia) { SetInnerComments(ifStm, iss.GetTrailingTrivia().ToFullString()); } ifStm.IsNested = nested; //public int ExpressionListEndLn { get; set; } //public int ExpressionListStartLn { get; set; } //public bool IsNested { get; set; } ExpressionSyntax es = iss.Condition; var binaryExpressions = from aBinaryExpression in iss.Condition.DescendantNodesAndSelf().OfType<BinaryExpressionSyntax>() select aBinaryExpression; ifStm.ConditionCount = binaryExpressions.Count(); //This area is for the conditions i.e. the stuff in the () of if () foreach (BinaryExpressionSyntax bes in binaryExpressions) { Method tempMethod = TraverseBinaryExpression(bes); ifStm.AccessedVars.AddRange(tempMethod.AccessedVariables); ifStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } //TODO handle catches (if there are even catches inside if statements) var catches = from aCatch in iss.ChildNodes().OfType<CatchClauseSyntax>() select aCatch; foreach (CatchClauseSyntax ccs in catches) { Decisions tempCatch = TraverseCatchClauses(ccs, ref exitPoints, true); ifStm.Nested.AddRange(tempCatch.Catches); } //TODO need to handle else clauses var elses = from aElse in iss.ChildNodes().OfType<ElseClauseSyntax>() select aElse; foreach (ElseClauseSyntax ecs in elses) { //TODO //Traverse ElseClauseSyntax Decisions tempElse = TraverseElseClauses(ecs, ref exitPoints, true); ifStm.Nested.AddRange(tempElse.ElseStatements); #region old code with method return //ifStm.InvokedMethods.AddRange(tempElse.InvokedMethods); //ifStm.AccessedVars.AddRange(tempElse.AccessedVars); //ifStm.Nested.Add(tempElse); //foreach (BaseDecisions bd in ifStm.Nested) //{ // bd.IsNested = true; //} #endregion } //TODO need to find a way to return both nested //and invoked methods / accessedvars to the parent method var statements = from aStatement in iss.Statement.ChildNodes().OfType<StatementSyntax>() select aStatement; List<BaseDecisions> retBd = new List<BaseDecisions>(); List<InvokedMethod> retIm = new List<InvokedMethod>(); #region Nested and Invoked Methods and accessed vars foreach (StatementSyntax ss in statements) { //if (ss is BreakStatementSyntax) //{ //} //else if (ss is CheckedStatementSyntax) //{ //} //else if (ss is ContinueStatementSyntax) //{ //} if (ss is DoStatementSyntax) { Decisions dwl = TraverseDoStatements(ss as DoStatementSyntax, ref exitPoints, true); ifStm.Nested.AddRange(dwl.DoWhileLoops); //dwl.IsNested = true; //ifStm.Nested.Add(dwl); } //else if (ss is EmptyStatementSyntax) //{ //} else if (ss is ExpressionStatementSyntax) { Method tempMethod = TraverseExpressionStatementSyntax(ss as ExpressionStatementSyntax); ifStm.AccessedVars.AddRange(tempMethod.AccessedVariables); ifStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } //else if (ss is FixedStatementSyntax) //{ //} else if (ss is ForEachStatementSyntax) { Decisions fes = TraverseForEachStatements(ss as ForEachStatementSyntax, ref exitPoints, true); ifStm.Nested.AddRange(fes.ForEachStatements); //fes.IsNested = true; //ifStm.Nested.Add(fes); } else if (ss is ForStatementSyntax) { Decisions fs = TraverseForStatements(ss as ForStatementSyntax, ref exitPoints, true); ifStm.Nested.AddRange(fs.ForStatements); //fs.IsNested = true; //ifStm.Nested.Add(fs); } //else if (ss is GotoStatementSyntax) //{ //} else if (ss is IfStatementSyntax) { Decisions decision = TraverseIfStatements(ss as IfStatementSyntax, ref exitPoints, true); ifStm.Nested.AddRange(decision.IfStatements); } //else if (ss is LabeledStatementSyntax) //{ // BaseDecisions bd = new BaseDecisions(); // bd.IsNested = true; // bd.Nested.Add(TraverseLabelStatements(ss as LabeledStatementSyntax)); // retIf.Nested.Add(bd); //} else if (ss is LocalDeclarationStatementSyntax) { Model.Type tempType = new Model.Type(); LocalDeclarationStatementSyntax ldss = ss as LocalDeclarationStatementSyntax; if (ldss.Declaration != null) { VariableDeclarationSyntax vds = ldss.Declaration; tempType.Name = vds.Type.ToString(); tempType.IsKnownType = true; tempType.IsNotUserDefined = true; } Method tempMethod = TransverseAccessVars(ss as LocalDeclarationStatementSyntax); //NOT SURE if this will work but here goes tempMethod.AccessedVariables[0].Type = tempType; ifStm.AccessedVars.AddRange(tempMethod.AccessedVariables); ifStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } //else if (ss is LockStatementSyntax) //{ //} else if (ss is ReturnStatementSyntax) { exitPoints++; } else if (ss is SwitchStatementSyntax) { Decisions switchStm = TraverseSwitchStatements(ss as SwitchStatementSyntax, ref exitPoints, true); ifStm.Nested.AddRange(switchStm.SwitchStatements); //switchStm.IsNested = true; //ifStm.Nested.Add(switchStm); } //else if (ss is ThrowStatementSyntax) //{ //} //else if (ss is TryStatementSyntax) //{ //} //else if (ss is UnsafeStatementSyntax) //{ //} //else if (ss is UsingStatementSyntax) //{ // //using list? //} else if (ss is WhileStatementSyntax) { Decisions wl = TraverseWhileLoops(ss as WhileStatementSyntax, ref exitPoints, true); ifStm.Nested.AddRange(wl.WhileLoops); //wl.IsNested = true; //ifStm.Nested.Add(wl); } //else if (ss is YieldStatementSyntax) //{ //} } #endregion retDecision.IfStatements.Add(ifStm); return retDecision; }
private Decisions TraverseElseClauses(ElseClauseSyntax ecs, ref int exitPoints, bool nested = false) { Decisions retDecision = new Decisions(); ElseStatement elseStm = new ElseStatement(); if (ecs.HasLeadingTrivia) { SetOuterComments(elseStm, ecs.GetLeadingTrivia().ToFullString()); } if (ecs.HasTrailingTrivia) { SetInnerComments(elseStm, ecs.GetTrailingTrivia().ToFullString()); } elseStm.IsNested = nested; var binaryExpressions = from aBinaryExpression in ecs.ChildNodes().OfType<BinaryExpressionSyntax>() select aBinaryExpression; foreach (BinaryExpressionSyntax bes in binaryExpressions) { Method tempMethod = TraverseBinaryExpression(bes); elseStm.AccessedVars.AddRange(tempMethod.AccessedVariables); elseStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } var catches = from aCatch in ecs.ChildNodes().OfType<CatchClauseSyntax>() select aCatch; foreach (CatchClauseSyntax ccs in catches) { Decisions tempCatch = TraverseCatchClauses(ccs, ref exitPoints, true); elseStm.Nested.AddRange(tempCatch.Catches); } var elses = from aElse in ecs.ChildNodes().OfType<ElseClauseSyntax>() select aElse; foreach (ElseClauseSyntax ecs2 in elses) { Decisions tempElse = TraverseElseClauses(ecs2, ref exitPoints, true); elseStm.Nested.AddRange(tempElse.ElseStatements); } #region nested stuff var statements = from aStatement in ecs.ChildNodes().OfType<StatementSyntax>() select aStatement; foreach (StatementSyntax ss in statements) { if (ss is DoStatementSyntax) { Decisions dwl = TraverseDoStatements(ss as DoStatementSyntax, ref exitPoints, true); elseStm.Nested.AddRange(dwl.DoWhileLoops); } else if (ss is ExpressionStatementSyntax) { Method tempMethod = TraverseExpressionStatementSyntax(ss as ExpressionStatementSyntax); elseStm.AccessedVars.AddRange(tempMethod.AccessedVariables); elseStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } else if (ss is ForEachStatementSyntax) { Decisions fes = TraverseForEachStatements(ss as ForEachStatementSyntax, ref exitPoints, true); elseStm.Nested.AddRange(fes.ForEachStatements); } else if (ss is ForStatementSyntax) { Decisions fs = TraverseForStatements(ss as ForStatementSyntax, ref exitPoints, true); elseStm.Nested.AddRange(fs.ForStatements); } else if (ss is IfStatementSyntax) { Decisions decision = TraverseIfStatements(ss as IfStatementSyntax, ref exitPoints, true); elseStm.Nested.AddRange(decision.IfStatements); } else if (ss is LocalDeclarationStatementSyntax) { Model.Type tempType = new Model.Type(); LocalDeclarationStatementSyntax ldss = ss as LocalDeclarationStatementSyntax; if (ldss.Declaration != null) { VariableDeclarationSyntax vds = ldss.Declaration; tempType.Name = vds.Type.ToString(); tempType.IsKnownType = true; tempType.IsNotUserDefined = true; } Method tempMethod = TransverseAccessVars(ss as LocalDeclarationStatementSyntax); //NOT SURE if this will work but here goes tempMethod.AccessedVariables[0].Type = tempType; elseStm.AccessedVars.AddRange(tempMethod.AccessedVariables); elseStm.InvokedMethods.AddRange(tempMethod.InvokedMethods); } else if (ss is ReturnStatementSyntax) { exitPoints++; } else if (ss is SwitchStatementSyntax) { Decisions switchStm = TraverseSwitchStatements(ss as SwitchStatementSyntax, ref exitPoints, true); elseStm.Nested.AddRange(switchStm.SwitchStatements); } else if (ss is WhileStatementSyntax) { Decisions wl = TraverseWhileLoops(ss as WhileStatementSyntax, ref exitPoints, true); elseStm.Nested.AddRange(wl.WhileLoops); } } #endregion retDecision.ElseStatements.Add(elseStm); return retDecision; }