Commit 6481b38d authored by Carlos Galindo's avatar Carlos Galindo
Browse files

fix merge conflicts

parent 76b73488

EDG/src/main/java/edg/EDGFactory.java

+5 −3
Original line number Diff line number Diff line
@@ -15,7 +15,8 @@ import edg.graph.LAST; 
public class EDGFactory {

	private final LAST last;

	private EDG edg;

	private boolean interproceduralGraph = true;

	private boolean interproceduralGraph = true; // CHANGE THIS ONE TO TRUE IN SETB

	private boolean summarisedGraph = false;



	public EDGFactory(LAST last)

	{
@@ -87,6 +88,7 @@ public class EDGFactory { 
			new InterproceduralEdgeGenerator(edg).generate(); // Specially Generated for OOPrograms

		else {

			long initialInputOutput = System.nanoTime();

			if (interproceduralGraph)

				new InterproceduralEdgeGenerator(edg).generateErlang(); //

			long finalInputOutput = System.nanoTime();

			edg.getGenerationTime().setInterproceduralTime((finalInputOutput-initialInputOutput) / 1000000.0);
@@ -99,7 +101,7 @@ public class EDGFactory { 
		edg.getGenerationTime().setFlowTime((finalFlow-initialFlow) / 1000000.0);



		// WE ARE NOT GENERATING SUMMARIES

		if (interproceduralGraph)

		if (summarisedGraph)

			new SummaryEdgeGenerator(edg).generate();

		else

			//new SummaryEdgeGenerator(edg).generateAsExternal();

EDG/src/main/java/edg/constraint/Constraints.java

+20 −0
Original line number Diff line number Diff line
@@ -61,6 +61,8 @@ public class Constraints { 
	}

	public boolean equals(Object object)

	{

		if (!this.nodeConstraints.isEmpty())

			System.out.println("Sergio sabe que aqui no hay nada...");

		if (object == this)

			return true;

		if (!(object instanceof Constraints))
@@ -76,6 +78,24 @@ public class Constraints { 
			return false;

		return this.edgeConstraints.equals(constraints.edgeConstraints);

	}



	public boolean isSuffix(Constraints constraints)

	{

		if (this.edgeConstraints.size() > constraints.edgeConstraints.size())

			return false;

		if (this.edgeConstraints.equals(constraints.edgeConstraints))

			return true;



		Stack<EdgeConstraint> edgeConstraints = constraints.getEdgeConstraints();

		for (int i = 1; i <= this.edgeConstraints.size(); i++) {

			EdgeConstraint thisEC = this.edgeConstraints.get(this.edgeConstraints.size() - i);

			EdgeConstraint constraintsEC = edgeConstraints.get(edgeConstraints.size() - i);

			if (!thisEC.equals(constraintsEC))

				return false;

		}

		return true;

	}



	public int hashCode()

	{

		return this.nodeConstraints.size() + this.edgeConstraints.size();

EDG/src/main/java/edg/edge/InterproceduralEdgeGenerator.java

+4 −4
Original line number Diff line number Diff line
@@ -338,7 +338,7 @@ public class InterproceduralEdgeGenerator extends EdgeGenerator 
			final List<Node> parameterNodes = edg.getChildren(parameters);

			parameterNodes.removeIf(n -> n.getType() == Node.Type.Result);



			this.edg.addEdge(calleeResult, matchingClause,  new Edge(Edge.Type.Input, new PhaseConstraint(Phase.Input)));

			this.edg.addEdge(calleeResult, matchingClause,  new Edge(Edge.Type.Input, new PhaseConstraint(Phase.Input,Phase.OnePhase)));

			for (int argumentIndex = 0; argumentIndex < argumentNodes.size(); argumentIndex++)

			{

				final Node argument = argumentNodes.get(argumentIndex);
@@ -347,9 +347,9 @@ public class InterproceduralEdgeGenerator extends EdgeGenerator 
				final Node parameterResult = edg.getResFromNode(parameter);



				if (argumentResult != null && parameterResult != null)

					this.edg.addEdge(argumentResult, parameterResult, new Edge(Edge.Type.Input, new PhaseConstraint(Phase.Input)));

					this.edg.addEdge(argumentResult, parameterResult, new Edge(Edge.Type.Input, new PhaseConstraint(Phase.Input,Phase.OnePhase)));

			}

			this.edg.addEdge(calleeResult, matchingClause, new Edge(Edge.Type.Call, new PhaseConstraint(Phase.Input)));

			this.edg.addEdge(calleeResult, matchingClause, new Edge(Edge.Type.Call, new PhaseConstraint(Phase.Input,Phase.OnePhase)));

		}

	}

	private List<Node> getPossibleClausesErlang(Node call)
@@ -502,7 +502,7 @@ public class InterproceduralEdgeGenerator extends EdgeGenerator 
			final Node result = edg.getResFromNode(callingFunction);



			if (result != null)

				this.edg.addEdge(result, callResult,  new Edge(Edge.Type.Output, new PhaseConstraint(Phase.Output)));

				this.edg.addEdge(result, callResult,  new Edge(Edge.Type.Output, new PhaseConstraint(Phase.Output,Phase.OnePhase)));

		}

	}

}
 
 No newline at end of file

EDG/src/main/java/edg/slicing/AdaptedStandardAlgorithm.java

+6 −2
Original line number Diff line number Diff line
@@ -20,12 +20,12 @@ public class AdaptedStandardAlgorithm extends StandardAlgorithm{ 
            return slice;



        slice.add(slicingCriterion);

        this.traverse(slicingCriterion, slice);

        this.traverse(Phase.OnePhase,slicingCriterion, slice);



        return slice;

    }



    protected void traverse(Node slicingCriterion, Set<Node> slice, Edge.Type... ignoreEdgeTypes) {

    protected void traverse(Phase phase, Node slicingCriterion, Set<Node> slice, Edge.Type... ignoreEdgeTypes) {

        final Deque<SliceState> pendingNodes = new LinkedList<>();



        for (Node n : slice)
@@ -47,6 +47,10 @@ public class AdaptedStandardAlgorithm extends StandardAlgorithm{ 


            for (Edge nextEdge : nextEdges)

            {

                if(phase == Phase.SummaryGeneration &&

                        (nextEdge.getType() == Edge.Type.Input || nextEdge.getType() == Edge.Type.Output))

                    continue;



                final Node nextNode = sliceDirection == LAST.Direction.Backwards ?

                        edg.getEdgeSource(nextEdge): edg.getEdgeTarget(nextEdge);

                if (!slice.contains(nextNode))

EDG/src/main/java/edg/slicing/AdaptedTwoPassStandardAlgorithm.java

deleted100644 → 0
+0 −112
Original line number Diff line number Diff line 
package edg.slicing;



import edg.graph.EDG;

import edg.graph.Edge;

import edg.graph.LAST;

import edg.graph.Node;



import java.util.*;



public class AdaptedTwoPassStandardAlgorithm extends StandardAlgorithm{



    public AdaptedTwoPassStandardAlgorithm(EDG edg) {

        super(edg);

    }



    public Set<Node> slice(Node slicingCriterion)

    {

        final Set<Node> slice = new HashSet<>();

        if (slicingCriterion == null)

            return slice;



        slice.add(slicingCriterion);

        this.traverse(slicingCriterion, slice, Edge.Type.Output);

        this.traverse(slicingCriterion, slice, Edge.Type.Input);



        return slice;

    }



    protected void traverse(Node slicingCriterion, Set<Node> slice, Edge.Type... ignoreEdgeTypes) {

        final Deque<SliceState> pendingNodes = new LinkedList<>();



        for (Node n : slice)

            pendingNodes.add(new SliceState(n,null));



        final Set<Edge.Type> ignoreEdgeTypesSet = new HashSet<>(Arrays.asList(ignoreEdgeTypes));



        while (!pendingNodes.isEmpty())

        {

            final SliceState pendingNode = pendingNodes.removeFirst();

            final Set<Edge> nextEdges = edg.getEdges(pendingNode.getNode(), sliceDirection);



            nextEdges.removeIf(e -> ignoreEdgeTypesSet.contains(e.getType()));

            nextEdges.removeIf(Edge::isControlFlowEdge);

            nextEdges.removeIf(e -> !e.isTraversable());



            if (pendingNode.getLastEdgeType() != null && pendingNode.getLastEdgeType() == Edge.Type.Structural)

                nextEdges.removeIf(e -> e.getType() != Edge.Type.Structural);



            for (Edge nextEdge : nextEdges)

            {

                final Node nextNode = sliceDirection == LAST.Direction.Backwards ?

                        edg.getEdgeSource(nextEdge): edg.getEdgeTarget(nextEdge);

                if (!slice.contains(nextNode))

                {

                    Node outerStructureNode = this.getOuterCompositeNode(nextNode);

                    if (outerStructureNode != null) {

                        List<Node> nextNodes = edg.getDescendants(outerStructureNode);

                        nextNodes.add(outerStructureNode);



                        if (nextNodes.contains(slicingCriterion))

                            nextNodes.removeIf(n -> n.getType() == Node.Type.Result);

                        nextNodes.add(edg.getResFromNode(nextNode));



                        for (Node next : nextNodes) {

                            pendingNodes.addLast(new SliceState(next,nextEdge.getType()));

                            slice.add(next);

                        }

                    }

                    else {

                        pendingNodes.addLast(new SliceState(nextNode,nextEdge.getType()));

                        slice.add(nextNode);

                    }

                }

            }

        }

    }

    public Node getOuterCompositeNode(Node node) {

        Node lastDataContainerParent = null;

        Node nextParent = edg.getParent(node);

        while (nextParent != null && isPossibleDataContainer(nextParent)){

            if (nextParent.getType() == Node.Type.List || nextParent.getType() == Node.Type.DataConstructor)

                lastDataContainerParent = nextParent;

            nextParent = edg.getParent(nextParent);

        }

        return lastDataContainerParent;

    }



    public boolean isPossibleDataContainer(Node parent) {

        switch (parent.getType()){

            case Equality:

            case Arguments:

            case Call:

            case Operation:

            case List:

            case DataConstructor:

                return true;

            default:

                return false;

        }

    }



    private class SliceState{

        private Node node;

        private Edge.Type lastEdgeType;

        public SliceState(Node n, Edge.Type type){

            node = n;

            lastEdgeType = type;

        }

        public Node getNode() { return node; }

        public Edge.Type getLastEdgeType() { return lastEdgeType; }

    }

}