Esempio n. 1
0
        private Method TraverseAccessVars(AssignmentStatementSyntax vnes)
        {
            Method retMethod = new Method();
            if (vnes.Left is IdentifierNameSyntax)
            {
                Variables retVar = new Variables();
                retVar.IsReferenced = true;
                retVar.Name = (vnes.Left as IdentifierNameSyntax).Identifier.ValueText;
                retMethod.AccessedVariables.Add(retVar);
            }
            else if (vnes.Left is MemberAccessExpressionSyntax)
            {
                MemberAccessExpressionSyntax maes = vnes.Left as MemberAccessExpressionSyntax;
                Variables retVar = new Variables();
                retVar.Name = maes.ToString();
                retVar.IsReferenced = true;
                retMethod.AccessedVariables.Add(retVar);
            }
            else
            {
                foreach (SyntaxNode sn in vnes.Left.ChildNodes())
                {
                    if (sn is VariableDeclaratorSyntax)
                    {
                        Variables retVar = new Variables();
                        retVar = TraverseVariableSyntax(sn as VariableDeclaratorSyntax, null, null);
                        retVar.IsReferenced = true;
                        retMethod.AccessedVariables.Add(retVar);
                    }
                    else if (sn is CallStatementSyntax)
                    {
                        retMethod.InvokedMethods.Add(TraverseInvokedMethod(sn as CallStatementSyntax));
                    }
                    else if (sn is MemberAccessExpressionSyntax)
                    {
                        MemberAccessExpressionSyntax maes = sn as MemberAccessExpressionSyntax;
                        Variables retVar = new Variables();
                        retVar.Name = maes.ToString();
                        retVar.IsReferenced = true;
                        retMethod.AccessedVariables.Add(retVar);
                    }
                }
            }
            if (vnes.Right is IdentifierNameSyntax)
            {
                Variables retVar = new Variables();
                retVar.IsReferenced = true;
                retVar.Name = (vnes.Right as IdentifierNameSyntax).Identifier.ValueText;
                retMethod.AccessedVariables.Add(retVar);
            }
            else if (vnes.Right is MemberAccessExpressionSyntax)
            {
                MemberAccessExpressionSyntax maes = vnes.Right as MemberAccessExpressionSyntax;
                Variables retVar = new Variables();
                retVar.Name = maes.ToString();
                retVar.IsReferenced = true;
                retMethod.AccessedVariables.Add(retVar);
            }
            else
            {
                foreach (SyntaxNode sn in vnes.Right.ChildNodes())
                {
                    if (sn is VariableDeclaratorSyntax)
                    {
                        Variables retVar = new Variables();
                        retVar = TraverseVariableSyntax(sn as VariableDeclaratorSyntax, null, null);
                        retVar.IsReferenced = true;
                        retMethod.AccessedVariables.Add(retVar);
                    }
                    else if (sn is CallStatementSyntax)
                    {
                        retMethod.InvokedMethods.Add(TraverseInvokedMethod(sn as CallStatementSyntax));
                    }
                    else if (sn is MemberAccessExpressionSyntax)
                    {
                        MemberAccessExpressionSyntax maes = sn as MemberAccessExpressionSyntax;
                        Variables retVar = new Variables();
                        retVar.Name = maes.ToString();
                        retVar.IsReferenced = true;
                        retMethod.AccessedVariables.Add(retVar);
                    }
                }
            }

            return retMethod;
        }
Esempio n. 2
0
        private Method TraverseVarDecls(LocalDeclarationStatementSyntax ldss)
        {
            Method retMethod = new Method();
            List<Encapsulation> accessability = new List<Encapsulation>();
            List<Qualifiers> qualifiers = new List<Qualifiers>();
            foreach (SyntaxToken st in ldss.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    accessability.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    qualifiers.Add(qual);
                }
            }

            foreach (SyntaxNode ss in ldss.ChildNodes())
            {
                if (ss is VariableDeclaratorSyntax)
                {
                    Variables retVar = new Variables();
                    retVar = TraverseVariableSyntax(ss as VariableDeclaratorSyntax, accessability, qualifiers);
                    retMethod.AccessedVariables.Add(retVar);
                }
                else if (ss is CallStatementSyntax)
                {
                    retMethod.InvokedMethods.Add(TraverseInvokedMethod(ss as CallStatementSyntax));
                }
            }

            return retMethod;
        }
Esempio n. 3
0
        private InvokedMethod TraverseInvokedMethod(CallStatementSyntax css)
        {
            InvokedMethod invokedMethod = new InvokedMethod();

            InvocationExpressionSyntax invokeInfo = css.Invocation as InvocationExpressionSyntax;
            if (invokeInfo.ArgumentList != null)
            {
                foreach (ArgumentSyntax argSyn in invokeInfo.ArgumentList.Arguments)
                {
                    Variables parameter = new Variables();
                    parameter.Name = argSyn.ToString();
                    invokedMethod.Parameters.Add(parameter);
                }
            }
            ExpressionSyntax es = invokeInfo.Expression;
            if (es is IdentifierNameSyntax)
            {
                invokedMethod.Name = (es as IdentifierNameSyntax).Identifier.ValueText;
            }
            else if(es is MemberAccessExpressionSyntax)
            {
                MemberAccessExpressionSyntax maes = es as MemberAccessExpressionSyntax;
                invokedMethod.Name = (maes.Name as SimpleNameSyntax).Identifier.ValueText;
                //TODO: What about the expression? Is it a variable? I think so!?
            }

            return invokedMethod;
        }
Esempio n. 4
0
        private Variables TraverseParameters(ParameterSyntax vds)
        {
            Variables retVar = new Variables();

            retVar.Name = vds.Identifier.ToString();

            retVar.IsReferenced = false;

            //Encapsulation
            foreach (SyntaxToken st in vds.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retVar.Accessibility.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retVar.Qualifiers.Add(qual);
                }
            }

            AsClauseSyntax acs = vds.AsClause;
            TypeSyntax ts = acs.Type();
            Model.Type type = new Model.Type();
            type.Name = ts.ToString();
            type.IsKnownType = SyntaxFacts.IsKeywordKind(ts.VisualBasicKind());
            type.IsNotUserDefined = SyntaxFacts.IsKeywordKind(ts.VisualBasicKind());

            return retVar;
        }
Esempio n. 5
0
        private ForEachStatement TraverseForeachStatement(ForEachStatementSyntax fess, ref int returnCnt, bool nested = false)
        {
            ForEachStatement foreachStm = new ForEachStatement();
            foreachStm.IsNested = nested;
            foreachStm.ConditionCount = 1;
            bool skipId = false;
            int skipIds = 0;
            foreach (SyntaxNode sn in fess.ChildNodes())
            {
                if (sn is BinaryExpressionSyntax)
                {
                    foreachStm.ConditionCount++;
                }
                else if (sn is VariableDeclaratorSyntax)
                {
                    foreachStm.AccessedVars.Add(TraverseVariableSyntax(sn as VariableDeclaratorSyntax, null, null));
                    skipId = true;
                }
                else if (sn is InvocationExpressionSyntax)
                {
                    InvokedMethod invokedMethod = TraverseInvokedMethod(sn as InvocationExpressionSyntax);
                    foreachStm.InvokedMethods.Add(invokedMethod);
                    skipId = true;
                    skipIds = invokedMethod.Parameters.Count;
                }
                else if (sn is IdentifierNameSyntax)
                {
                    if (!skipId)
                    {
                        Variables variable = new Variables();
                        variable.IsReferenced = true;

                        variable.Name = (sn as IdentifierNameSyntax).Identifier.ValueText;
                        foreachStm.AccessedVars.Add(variable);
                    }
                    else if (skipIds == 0)
                    {
                        skipId = false;
                    }
                    else
                    {
                        skipIds--;
                    }
                }

            }

            ForBlockSyntax fbs = fess.Parent as ForBlockSyntax;

            foreach (StatementSyntax ss in fbs.Statements)
            {
                if (ss is AssignmentStatementSyntax)
                {
                    //TODO: need to look at more than just then name!
                    Method tempMethod = TraverseAccessVars(ss as AssignmentStatementSyntax);

                    foreachStm.AccessedVars.AddRange(tempMethod.AccessedVariables);
                    foreachStm.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                }
                else if (ss is LocalDeclarationStatementSyntax)
                {
                    Method tempMethod = TraverseVarDecls(ss as LocalDeclarationStatementSyntax);
                    foreachStm.AccessedVars.AddRange(tempMethod.AccessedVariables);
                    foreachStm.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                }
                else if (ss is SingleLineIfStatementSyntax)
                {
                    Decisions decision = TraverseIfStatement(ss as SingleLineIfStatementSyntax, ref returnCnt, true);
                    foreachStm.Nested.AddRange(decision.IfStatements);
                    foreachStm.Nested.AddRange(decision.ElseStatements);
                }
                else if (ss is MultiLineIfBlockSyntax)
                {
                    Decisions decisions = TraverseMultiIfStatement(ss as MultiLineIfBlockSyntax, ref returnCnt, true);
                    foreachStm.Nested.AddRange(decisions.IfStatements);
                    foreachStm.Nested.AddRange(decisions.ElseStatements);
                }
                else if (ss is ForBlockSyntax)
                {
                    Decisions tempDecision = TraverseForStatement(ss as ForBlockSyntax, ref returnCnt, true);
                    foreachStm.Nested.AddRange(tempDecision.IfStatements);
                    foreachStm.Nested.AddRange(tempDecision.ElseStatements);
                    foreachStm.Nested.AddRange(tempDecision.ForEachStatements);
                    foreachStm.Nested.AddRange(tempDecision.ForStatements);
                    foreachStm.Nested.AddRange(tempDecision.WhileLoops);
                    foreachStm.Nested.AddRange(tempDecision.DoWhileLoops);
                    foreachStm.Nested.AddRange(tempDecision.Catches);
                    foreachStm.Nested.AddRange(tempDecision.SwitchStatements);
                }
                else if (ss is ElseStatementSyntax)
                {
                    foreachStm.Nested.Add(TravsereElseStatement(ss as ElseStatementSyntax, ref returnCnt, true));
                }
                else if (ss is SelectBlockSyntax)
                {
                    foreachStm.Nested.Add(TraverseSwitchStatement(ss as SelectBlockSyntax, ref returnCnt, true));
                }
                else if (ss is DoLoopBlockSyntax)
                {
                    foreachStm.Nested.Add(TraverseDoWhileLoop(ss as DoLoopBlockSyntax, ref returnCnt, true));
                }
                else if (ss is WhileBlockSyntax)
                {
                    foreachStm.Nested.Add(TraverseWhileLoop(ss as WhileBlockSyntax, ref returnCnt, true));
                }
                else if (ss is CallStatementSyntax)
                {
                    foreachStm.InvokedMethods.Add(TraverseInvokedMethod(ss as CallStatementSyntax));
                }
                else if (ss is ReturnStatementSyntax)
                {
                    Method tempMethod = TraverseReturnStatement(ss as ReturnStatementSyntax);
                    foreachStm.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                    foreachStm.AccessedVars.AddRange(tempMethod.AccessedVariables);
                    returnCnt++;
                }
            }
            return foreachStm;
        }
Esempio n. 6
0
        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;
        }
        private Method TraverseVarDeclarators(VariableDeclaratorSyntax vds)
        {
            Method retMethod = new Method();
            Variables retVar = new Variables();

            if (vds.HasLeadingTrivia)
            {
                SetOuterComments(retVar, vds.GetLeadingTrivia().ToFullString());
            }

            if (vds.HasTrailingTrivia)
            {
                SetInnerComments(retVar, vds.GetTrailingTrivia().ToFullString());
            }

            retVar.Name = vds.Identifier.ValueText;
            Model.Type retType = new Model.Type();
            retType.IsKnownType = SyntaxFacts.IsKeywordKind(vds.CSharpKind());
            retType.IsNotUserDefined = SyntaxFacts.IsKeywordKind(vds.CSharpKind());
            retVar.Type = retType;
            retMethod.AccessedVariables.Add(retVar);
            var valueClauses = from aValueClase in vds.ChildNodes().OfType<EqualsValueClauseSyntax>() select aValueClase;
            foreach (EqualsValueClauseSyntax evcs in valueClauses)
            {
                retMethod.AccessedVariables.AddRange(TraverseEqualsClause(evcs).AccessedVariables);
            }
            //TODO
            //Don't know if I need more stuff here
            //or even if i can fetch it from vds
            return retMethod;
        }
        private Variables TransverseVariables(FieldDeclarationSyntax fds, bool isRef = false)
        {
            Variables retVar = new Variables();

            if (fds.HasLeadingTrivia)
            {
                SetOuterComments(retVar, fds.GetLeadingTrivia().ToFullString());
            }

            if (fds.HasTrailingTrivia)
            {
                SetInnerComments(retVar, fds.GetTrailingTrivia().ToFullString());
            }

            retVar.IsReferenced = isRef;
            //Not sure if right
            retVar.Type.IsKnownType = SyntaxFacts.IsKeywordKind(fds.CSharpKind());
            retVar.Type.IsNotUserDefined = SyntaxFacts.IsKeywordKind(fds.CSharpKind());
            //This should pick up the "type" name
            retVar.Type.Name = fds.Declaration.Type.ToString();

            foreach (SyntaxToken st in fds.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retVar.Accessibility.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retVar.Qualifiers.Add(qual);
                }
            }
            //This does return variable name but I don't know if fds can contain a list of
            //variables or if it will always be 1
            retVar.Name = fds.Declaration.Variables.ToString();
            return retVar;
        }
        private Variables TraverseParamaters(ParameterSyntax ps, bool isRef = false)
        {
            Variables retVar = new Variables();

            if (ps.HasLeadingTrivia)
            {
                SetOuterComments(retVar, ps.GetLeadingTrivia().ToFullString());
            }

            if (ps.HasTrailingTrivia)
            {
                SetInnerComments(retVar, ps.GetTrailingTrivia().ToFullString());
            }

            retVar.IsReferenced = isRef;
            TypeSyntax ts = ps.Type;
            //Breakpoint here to test return type!
            Model.Type retType = new Model.Type();
            retType.Name = ts.ToString();
            retType.IsKnownType = SyntaxFacts.IsKeywordKind(ts.CSharpKind());
            retType.IsNotUserDefined = SyntaxFacts.IsKeywordKind(ts.CSharpKind());
            //rettype.generictype
            retVar.Type = retType;

            foreach (SyntaxToken st in ps.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retVar.Accessibility.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retVar.Qualifiers.Add(qual);
                }
                else if (modifier == "Ref")
                {
                    //TODO handle ref
                }
            }
            //need retvar's name
            //TODO check if this actually works
            retVar.Name = ps.Identifier.ValueText;
            return retVar;
        }
Esempio n. 10
0
        private Method TraversePrefixUnaryExpressions(PrefixUnaryExpressionSyntax pues)
        {
            Method retMethod = new Method();

            if (pues.HasLeadingTrivia)
            {
                SetOuterComments(retMethod, pues.GetLeadingTrivia().ToFullString());
            }

            if (pues.HasTrailingTrivia)
            {
                SetInnerComments(retMethod, pues.GetTrailingTrivia().ToFullString());
            }

            var vars = from aVar in pues.ChildNodes().OfType<IdentifierNameSyntax>() select aVar;
            foreach (IdentifierNameSyntax ins in vars)
            {
                Variables tempVar = new Variables();
                tempVar.Name = ins.Identifier.ValueText;
                retMethod.AccessedVariables.Add(tempVar);
            }
            return retMethod;
        }
Esempio n. 11
0
        private Method TraverseInvocationExpression(InvocationExpressionSyntax ies)
        {
            //TODO
            //get method name and accessed variables
            //and attributes and qualifiers
            Method retIm = new Method();

            if (ies.HasLeadingTrivia)
            {
                SetOuterComments(retIm, ies.GetLeadingTrivia().ToFullString());
            }

            if (ies.HasTrailingTrivia)
            {
                SetInnerComments(retIm, ies.GetTrailingTrivia().ToFullString());
            }
            //havent tested this with extra stuff like setting the variable equal to the method call
            //or with variables in the method call
            var methods = from aMethod in ies.ChildNodes().OfType<IdentifierNameSyntax>() select aMethod;
            foreach (IdentifierNameSyntax ins in methods)
            {
                InvokedMethod tempMethod = new InvokedMethod();
                tempMethod.Name = ins.Identifier.ValueText;
                retIm.InvokedMethods.Add(tempMethod);
            }
            //var args = from aArg in ies.ArgumentList.Arguments.OfType<ArgumentSyntax>() select aArg;
            //foreach (ArgumentSyntax asyn in args)
            //{
            //    Variables tempVar = new Variables();

            //}
            var args = from aArg in ies.Expression.ChildNodes().OfType<IdentifierNameSyntax>() select aArg;
            foreach (IdentifierNameSyntax ins in args)
            {
                Variables tempVar = new Variables();
                tempVar.Name = ins.Identifier.ValueText;
                retIm.AccessedVariables.Add(tempVar);
            }
            retIm.Name = ies.Expression.ToString();
            return retIm;
        }
Esempio n. 12
0
        private Method TraverseCastExpressions(CastExpressionSyntax ces)
        {
            Method retMethod = new Method();

            if (ces.HasLeadingTrivia)
            {
                SetOuterComments(retMethod, ces.GetLeadingTrivia().ToFullString());
            }

            if (ces.HasTrailingTrivia)
            {
                SetInnerComments(retMethod, ces.GetTrailingTrivia().ToFullString());
            }

            var variables = from aVariable in ces.ChildNodes().OfType<IdentifierNameSyntax>() select aVariable;
            Model.Type type = new Model.Type();
            type.Name = ces.Type.ToString();
            type.IsKnownType = SyntaxFacts.IsKeywordKind(ces.Type.CSharpKind());
            type.IsNotUserDefined = SyntaxFacts.IsKeywordKind(ces.Type.CSharpKind());
            foreach (IdentifierNameSyntax ins in variables)
            {
                //TODO put a bp here and test if this adds method names (bad) or just var names(good)
                Variables vars = new Variables();
                vars.Name = ins.Identifier.ValueText;
                vars.IsReferenced = true;
                vars.Type = type;
                retMethod.AccessedVariables.Add(vars);
            }
            var binaryExprs = from aBinaryExpr in ces.ChildNodes().OfType<BinaryExpressionSyntax>() select aBinaryExpr;
            foreach (BinaryExpressionSyntax bes in binaryExprs)
            {
                Method retMethod2 = TraverseBinaryExpression(bes);
                retMethod.AccessedVariables.AddRange(retMethod2.AccessedVariables);
                retMethod.InvokedMethods.AddRange(retMethod2.InvokedMethods);
            }
            var invokedMethods = from aInvokedMethod in ces.ChildNodes().OfType<InvocationExpressionSyntax>() select aInvokedMethod;
            foreach (InvocationExpressionSyntax ies in invokedMethods)
            {
                Method tempMethod = TraverseInvocationExpression(ies);
                retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables);
            }
            var castExprs = from aCastExpr in ces.ChildNodes().OfType<CastExpressionSyntax>() select aCastExpr;
            foreach (CastExpressionSyntax ces2 in castExprs)
            {
                Method retMethod3 = TraverseCastExpressions(ces2);
                retMethod.AccessedVariables.AddRange(retMethod3.AccessedVariables);
                retMethod.InvokedMethods.AddRange(retMethod3.InvokedMethods);
            }
            return retMethod;
        }
Esempio n. 13
0
        private Method TraverseBinaryExpression(BinaryExpressionSyntax bes)
        {
            var variables = from aVariable in bes.ChildNodes().OfType<IdentifierNameSyntax>() select aVariable;
            Method retMethod = new Method();

            if (bes.HasLeadingTrivia)
            {
                SetOuterComments(retMethod, bes.GetLeadingTrivia().ToFullString());
            }

            if (bes.HasTrailingTrivia)
            {
                SetInnerComments(retMethod, bes.GetTrailingTrivia().ToFullString());
            }

            //Casting on the back end....ex:
            // abc = def as double ------- def as double is the binary expression
            if (bes.OperatorToken.IsKind(SyntaxKind.AsKeyword))
            {
                if (bes.Left is IdentifierNameSyntax)
                {
                    IdentifierNameSyntax ins = bes.Left as IdentifierNameSyntax;
                    Variables tempVar = new Variables();
                    tempVar.Name = ins.Identifier.ValueText;
                    if (bes.Right is PredefinedTypeSyntax)
                    {
                        PredefinedTypeSyntax pts = bes.Right as PredefinedTypeSyntax;
                        Model.Type tempType = new Model.Type();
                        tempType.Name = pts.ToString();
                        tempType.IsKnownType = true;
                        tempType.IsNotUserDefined = true;
                        tempVar.Type = tempType;
                    }
                    retMethod.AccessedVariables.Add(tempVar);
                }
                else if (bes.Left is MemberAccessExpressionSyntax)
                {
                    MemberAccessExpressionSyntax maes = bes.Left as MemberAccessExpressionSyntax;
                    Variables tempVar = new Variables();
                    tempVar.Name = maes.ToString();
                    tempVar.IsReferenced = true;
                    retMethod.AccessedVariables.Add(tempVar);
                }
            }
            else
            {
                foreach (IdentifierNameSyntax ins in variables)
                {
                    //TODO put a bp here and test if this adds method names (bad) or just var names(good)
                    Variables vars = new Variables();
                    vars.Name = ins.Identifier.ValueText;
                    vars.IsReferenced = true;
                    retMethod.AccessedVariables.Add(vars);
                    //TODO variable types
                }
                var binaryExprs = from aBinaryExpr in bes.ChildNodes().OfType<BinaryExpressionSyntax>() select aBinaryExpr;
                foreach (BinaryExpressionSyntax bes2 in binaryExprs)
                {
                    Method retMethod2 = TraverseBinaryExpression(bes2);
                    retMethod.AccessedVariables.AddRange(retMethod2.AccessedVariables);
                    retMethod.InvokedMethods.AddRange(retMethod2.InvokedMethods);
                }
                var invokedMethods = from aInvokedMethod in bes.ChildNodes().OfType<InvocationExpressionSyntax>() select aInvokedMethod;
                foreach (InvocationExpressionSyntax ies in invokedMethods)
                {
                    Method tempMethod = TraverseInvocationExpression(ies);
                    retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                    retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables);
                }
                var castExprs = from aCastExpr in bes.ChildNodes().OfType<CastExpressionSyntax>() select aCastExpr;
                foreach (CastExpressionSyntax ces in castExprs)
                {
                    Method retMethod3 = TraverseCastExpressions(ces);
                    retMethod.AccessedVariables.AddRange(retMethod3.AccessedVariables);
                    retMethod.InvokedMethods.AddRange(retMethod3.InvokedMethods);
                }
            }
            return retMethod;
        }
Esempio n. 14
0
        private Variables TraverseVariableSyntax(VariableDeclaratorSyntax vds, List<Encapsulation> accessability, List<Qualifiers> qualifiers)
        {
            Variables retVar = new Variables();
            if (accessability != null)
            {
                retVar.Accessibility = accessability;
            }
            if (qualifiers != null)
            {
                retVar.Qualifiers = qualifiers;
            }
            foreach (ModifiedIdentifierSyntax mis in vds.Names)
            {
                retVar.Name = retVar.Name == null ? mis.Identifier.ValueText : retVar.Name + "." + mis.Identifier.ValueText;
            }

            AsClauseSyntax acs = vds.AsClause;
            TypeSyntax ts = acs.Type();
            Model.Type type = new Model.Type();
            type.Name = ts.ToString();
            type.IsKnownType = SyntaxFacts.IsKeywordKind(ts.VisualBasicKind());
            type.IsNotUserDefined = SyntaxFacts.IsKeywordKind(ts.VisualBasicKind());

            return retVar;
        }
Esempio n. 15
0
        private Variables TraverseField(FieldDeclarationSyntax fds)
        {
            Variables retVar = new Variables();

            //Name

            //Encapsulation
            foreach (SyntaxToken st in fds.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retVar.Accessibility.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retVar.Qualifiers.Add(qual);
                }
            }

            return retVar;
        }
Esempio n. 16
0
        private DoWhileLoop TraverseDoWhileLoop(DoLoopBlockSyntax dbs, ref int returnCnt, bool nested = false)
        {
            DoWhileLoop doWhileLoop = new DoWhileLoop();
            DoStatementSyntax dss = dbs.DoStatement;
            doWhileLoop.IsNested = nested;
            foreach (SyntaxNode sn in dss.DescendantNodesAndSelf())
            {
                if (sn is BinaryExpressionSyntax)
                {
                    doWhileLoop.ConditionCount++;
                }
                else if (sn is IdentifierNameSyntax)
                {
                    Variables variable = new Variables();
                    variable.IsReferenced = true;

                    variable.Name = (sn as IdentifierNameSyntax).Identifier.ValueText;
                    doWhileLoop.AccessedVars.Add(variable);
                }
            }

            foreach (StatementSyntax ss in dbs.Statements)
            {
                if (ss is AssignmentStatementSyntax)
                {
                    //TODO: need to look at more than just then name!
                    Method tempMethod = TraverseAccessVars(ss as AssignmentStatementSyntax);

                    doWhileLoop.AccessedVars.AddRange(tempMethod.AccessedVariables);
                    doWhileLoop.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                }
                else if (ss is LocalDeclarationStatementSyntax)
                {
                    Method tempMethod = TraverseVarDecls(ss as LocalDeclarationStatementSyntax);
                    doWhileLoop.AccessedVars.AddRange(tempMethod.AccessedVariables);
                    doWhileLoop.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                }
                else if (ss is SingleLineIfStatementSyntax)
                {
                    Decisions decision = TraverseIfStatement(ss as SingleLineIfStatementSyntax, ref returnCnt, true);
                    doWhileLoop.Nested.AddRange(decision.IfStatements);
                    doWhileLoop.Nested.AddRange(decision.ElseStatements);
                }
                else if (ss is MultiLineIfBlockSyntax)
                {
                    Decisions decisions = TraverseMultiIfStatement(ss as MultiLineIfBlockSyntax, ref returnCnt, true);
                    doWhileLoop.Nested.AddRange(decisions.IfStatements);
                    doWhileLoop.Nested.AddRange(decisions.ElseStatements);
                }
                else if (ss is ElseStatementSyntax)
                {
                    doWhileLoop.Nested.Add(TravsereElseStatement(ss as ElseStatementSyntax, ref returnCnt, true));
                }
                else if (ss is ForBlockSyntax)
                {
                    Decisions tempDecision = TraverseForStatement(ss as ForBlockSyntax, ref returnCnt, true);
                    doWhileLoop.Nested.AddRange(tempDecision.IfStatements);
                    doWhileLoop.Nested.AddRange(tempDecision.ElseStatements);
                    doWhileLoop.Nested.AddRange(tempDecision.ForEachStatements);
                    doWhileLoop.Nested.AddRange(tempDecision.ForStatements);
                    doWhileLoop.Nested.AddRange(tempDecision.WhileLoops);
                    doWhileLoop.Nested.AddRange(tempDecision.DoWhileLoops);
                    doWhileLoop.Nested.AddRange(tempDecision.Catches);
                    doWhileLoop.Nested.AddRange(tempDecision.SwitchStatements);
                }
                else if (ss is SelectBlockSyntax)
                {
                    doWhileLoop.Nested.Add(TraverseSwitchStatement(ss as SelectBlockSyntax, ref returnCnt, true));
                }
                else if (ss is DoLoopBlockSyntax)
                {
                    doWhileLoop.Nested.Add(TraverseDoWhileLoop(ss as DoLoopBlockSyntax, ref returnCnt, true));
                }
                else if (ss is WhileBlockSyntax)
                {
                    doWhileLoop.Nested.Add(TraverseWhileLoop(ss as WhileBlockSyntax, ref returnCnt, true));
                }
                else if (ss is CallStatementSyntax)
                {
                    doWhileLoop.InvokedMethods.Add(TraverseInvokedMethod(ss as CallStatementSyntax));
                }
                else if (ss is ReturnStatementSyntax)
                {
                    Method tempMethod = TraverseReturnStatement(ss as ReturnStatementSyntax);
                    doWhileLoop.InvokedMethods.AddRange(tempMethod.InvokedMethods);
                    doWhileLoop.AccessedVars.AddRange(tempMethod.AccessedVariables);
                    returnCnt++;
                }
            }

            return doWhileLoop;
        }
Esempio n. 17
0
 /// <summary>
 /// Constructor that sets all the Types so no lingering null types exist
 /// </summary>
 public InvokedMethod()
 {
     Attribute = new Variables();
     Parameters = new List<Variables>();
     Qualifiers = new List<Qualifiers>();
 }