Commit d2ded147 authored by Carlos Galindo's avatar Carlos Galindo
Browse files

Organize NodeType enum 

* Added METHOD_EXIT
* Renamed METHOD to METHOD_ENTER
* Split VARIABLE_IN into FORMAL_IN and ACTUAL_IN.
* Split VARIABLE_OUT into FORMAL_OUT and ACTUAL_OUT.
* Removed exitNode from CFG and corresponding methods.
parent af64d37d

src/main/java/tfm/graphs/augmented/ACFG.java

+0 −5
Original line number Diff line number Diff line
@@ -10,11 +10,6 @@ public class ACFG extends CFG { 
        addControlFlowEdge(from, to, new ControlFlowArc.NonExecutable());

    }



    @Override

    protected void setExitNode(GraphNode<?> exitNode) {

        super.setExitNode(exitNode);

    }



    @Override

    protected CFGBuilder newCFGBuilder() {

        return new ACFGBuilder(this);

src/main/java/tfm/graphs/augmented/ACFGBuilder.java

+7 −3
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ package tfm.graphs.augmented; 


import com.github.javaparser.ast.Node;

import com.github.javaparser.ast.body.MethodDeclaration;

import com.github.javaparser.ast.body.Parameter;

import com.github.javaparser.ast.expr.BooleanLiteralExpr;

import com.github.javaparser.ast.expr.Expression;

import com.github.javaparser.ast.stmt.*;
@@ -239,13 +240,16 @@ public class ACFGBuilder extends CFGBuilder { 
        if (!methodDeclaration.getBody().isPresent())

            throw new IllegalStateException("The method must have a body!");



        graph.buildRootNode("ENTER " + methodDeclaration.getNameAsString(), methodDeclaration, TypeNodeFactory.fromType(NodeType.METHOD));

        graph.buildRootNode("ENTER " + methodDeclaration.getNameAsString(), methodDeclaration, TypeNodeFactory.fromType(NodeType.METHOD_ENTER));



        hangingNodes.add(graph.getRootNode().get());

        for (Parameter param : methodDeclaration.getParameters())

            connectTo(addFormalInGraphNode(param));

        methodDeclaration.getBody().get().accept(this, arg);

        returnList.stream().filter(node -> !hangingNodes.contains(node)).forEach(hangingNodes::add);

        for (Parameter param : methodDeclaration.getParameters())

            connectTo(addFormalOutGraphNode(param));

        nonExecHangingNodes.add(graph.getRootNode().get());

        GraphNode<EmptyStmt> exitNode = connectTo(new EmptyStmt(), "Exit");

        ((ACFG) graph).setExitNode(exitNode);

        connectTo(graph.addNode("Exit", new EmptyStmt(), TypeNodeFactory.fromType(NodeType.METHOD_EXIT)));

    }

}

src/main/java/tfm/graphs/cfg/CFG.java

+7 −16
Original line number Diff line number Diff line
@@ -3,9 +3,9 @@ package tfm.graphs.cfg; 
import com.github.javaparser.ast.body.MethodDeclaration;

import tfm.arcs.Arc;

import tfm.arcs.cfg.ControlFlowArc;

import tfm.graphs.Graph;

import tfm.graphs.GraphWithRootNode;

import tfm.nodes.GraphNode;

import tfm.nodes.type.NodeType;

import tfm.utils.NodeNotFoundException;



import java.util.HashSet;
@@ -21,7 +21,6 @@ import java.util.Set; 
 */

public class CFG extends GraphWithRootNode<MethodDeclaration> {

    private boolean built = false;

    protected GraphNode<?> exitNode;



    public CFG() {

        super();
@@ -66,28 +65,20 @@ public class CFG extends GraphWithRootNode<MethodDeclaration> { 


    @Override

    public boolean removeVertex(GraphNode<?> graphNode) {

        if (Objects.equals(graphNode, exitNode))

        // Cannot remove exit node

        // Enter node's removal is checked in super#removeVertex(GraphNode)

        if (graphNode.getNodeType() == NodeType.METHOD_EXIT)

            return false;

        return super.removeVertex(graphNode);

    }



    public GraphNode<?> getExitNode() {

        return exitNode;

    }



    protected void setExitNode(GraphNode<?> exitNode) {

        if (this.exitNode != null)

            throw new IllegalStateException("Exit node already set!");

        this.exitNode = exitNode;

    }



    @Override

    public void build(MethodDeclaration method) {

        method.accept(newCFGBuilder(), null);

        if (exitNode == null)

            throw new IllegalStateException("Exit node missing!");

        if (vertexSet().stream().anyMatch(n -> n.getNodeType() == NodeType.METHOD_EXIT))

            throw new IllegalStateException("There is no exit node after building the graph");

        built = true;

    }

    }/**/



    @Override

    public boolean isBuilt() {

src/main/java/tfm/graphs/cfg/CFGBuilder.java

+35 −51
Original line number Diff line number Diff line
@@ -9,13 +9,15 @@ import com.github.javaparser.ast.stmt.*; 
import com.github.javaparser.ast.visitor.VoidVisitor;

import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

import tfm.nodes.GraphNode;

import tfm.nodes.NodeFactory;

import tfm.nodes.TypeNodeFactory;

import tfm.nodes.type.NodeType;

import tfm.utils.ASTUtils;



import java.util.*;



import static tfm.nodes.type.NodeType.FORMAL_IN;

import static tfm.nodes.type.NodeType.FORMAL_OUT;



/**

 * Populates a {@link CFG}, given one and an AST root node.

 * For now it only accepts {@link MethodDeclaration} as roots, as it disallows
@@ -286,64 +288,46 @@ public class CFGBuilder extends VoidVisitorAdapter<Void> { 


    @Override

    public void visit(MethodDeclaration methodDeclaration, Void arg) {

        // Sanity checks

        if (graph.getRootNode().isPresent())

            throw new IllegalStateException("CFG is only allowed for one method, not multiple!");

        if (!methodDeclaration.getBody().isPresent())

            throw new IllegalStateException("The method must have a body!");



        graph.buildRootNode("ENTER " + methodDeclaration.getNameAsString(), methodDeclaration, TypeNodeFactory.fromType(NodeType.METHOD));



        // Compute variable in and out expressions (necessary to compute data dependence in SDG)

        List<ExpressionStmt> inVariableExpressions = new ArrayList<>();

        List<ExpressionStmt> outVariableExpressions = new ArrayList<>();



        for (Parameter parameter : methodDeclaration.getParameters()) {

            // In expression

            VariableDeclarationExpr inVariableDeclarationExpr = new VariableDeclarationExpr(

                new VariableDeclarator(

                    parameter.getType(),

                    parameter.getNameAsString(),

                    new NameExpr(parameter.getNameAsString() + "_in")

                )

            );



            ExpressionStmt inExprStmt = new ExpressionStmt(inVariableDeclarationExpr);



            inVariableExpressions.add(inExprStmt);



            // Out expression

            VariableDeclarationExpr outVariableDeclarationExpr = new VariableDeclarationExpr(

                    new VariableDeclarator(

                            parameter.getType(),

                            parameter.getNameAsString() + "_out",

                            new NameExpr(parameter.getNameAsString())

                    )

            );



            ExpressionStmt outExprStmt = new ExpressionStmt(outVariableDeclarationExpr);



            outVariableExpressions.add(outExprStmt);

        }

            throw new IllegalStateException("The method must have a body! Abstract methods have no CFG");



        // Create the root node

        graph.buildRootNode(

                "ENTER " + methodDeclaration.getNameAsString(),

                methodDeclaration,

                TypeNodeFactory.fromType(NodeType.METHOD_ENTER));

        hangingNodes.add(graph.getRootNode().get());



        // Add in variable nodes

        for (ExpressionStmt expressionStmt : inVariableExpressions) {

            GraphNode<ExpressionStmt> node = this.graph.addNode(expressionStmt.toString(), expressionStmt, TypeNodeFactory.fromType(NodeType.VARIABLE_IN));

            connectTo(node);

        }



        // Create and connect formal-in nodes sequentially

        for (Parameter param : methodDeclaration.getParameters())

            connectTo(addFormalInGraphNode(param));

        // Visit the body of the method

        methodDeclaration.getBody().get().accept(this, arg);



        // Append all return statements (without repetition)

        returnList.stream().filter(node -> !hangingNodes.contains(node)).forEach(hangingNodes::add);



        // Add out variable nodes

        for (ExpressionStmt expressionStmt : outVariableExpressions) {

            GraphNode<ExpressionStmt> node = this.graph.addNode(expressionStmt.toString(), expressionStmt, TypeNodeFactory.fromType(NodeType.VARIABLE_OUT));

            connectTo(node);

        // Create and connect formal-out nodes sequentially

        for (Parameter param : methodDeclaration.getParameters())

            connectTo(addFormalOutGraphNode(param));

        // Create and connect the exit node

        connectTo(graph.addNode("Exit", new EmptyStmt(), TypeNodeFactory.fromType(NodeType.METHOD_EXIT)));

    }



    protected GraphNode<ExpressionStmt> addFormalInGraphNode(Parameter param) {

        ExpressionStmt exprStmt = new ExpressionStmt(new VariableDeclarationExpr(new VariableDeclarator(

                param.getType(),

                param.getNameAsString(),

                new NameExpr(param.getNameAsString() + "_in"))));

        return graph.addNode(exprStmt.toString(), exprStmt, TypeNodeFactory.fromType(FORMAL_IN));

    }



        GraphNode<EmptyStmt> exitNode = connectTo(new EmptyStmt(), "Exit");

        graph.setExitNode(exitNode);

    protected GraphNode<ExpressionStmt> addFormalOutGraphNode(Parameter param) {

        ExpressionStmt exprStmt = new ExpressionStmt(new VariableDeclarationExpr(new VariableDeclarator(

                param.getType(),

                param.getNameAsString() + "_out",

                new NameExpr(param.getNameAsString()))));

        return graph.addNode(exprStmt.toString(), exprStmt, TypeNodeFactory.fromType(FORMAL_OUT));

    }

}

src/main/java/tfm/graphs/pdg/ControlDependencyBuilder.java

+4 −2
Original line number Diff line number Diff line
@@ -4,8 +4,10 @@ import tfm.arcs.Arc; 
import tfm.graphs.augmented.PPDG;

import tfm.graphs.cfg.CFG;

import tfm.nodes.GraphNode;

import tfm.nodes.type.NodeType;



import java.util.*;

import java.util.HashSet;

import java.util.Set;

import java.util.stream.Collectors;



/**
@@ -41,7 +43,7 @@ class ControlDependencyBuilder { 
        roots.remove(cfg.getRootNode().get());



        Set<GraphNode<?>> cfgNodes = new HashSet<>(cfg.vertexSet());

        cfgNodes.remove(cfg.getExitNode());

        cfgNodes.removeIf(node -> node.getNodeType() == NodeType.METHOD_EXIT);



        for (GraphNode<?> node : cfgNodes)

            registerNode(node);