001: /*
002: * Spoon - http://spoon.gforge.inria.fr/
003: * Copyright (C) 2006 INRIA Futurs <renaud.pawlak@inria.fr>
004: *
005: * This software is governed by the CeCILL-C License under French law and
006: * abiding by the rules of distribution of free software. You can use, modify
007: * and/or redistribute the software under the terms of the CeCILL-C license as
008: * circulated by CEA, CNRS and INRIA at http://www.cecill.info.
009: *
010: * This program is distributed in the hope that it will be useful, but WITHOUT
011: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
012: * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details.
013: *
014: * The fact that you are presently reading this means that you have had
015: * knowledge of the CeCILL-C license and that you accept its terms.
016: */
017:
018: package spoon.reflect.eval;
019:
020: import java.util.List;
021:
022: import spoon.reflect.code.CtExpression;
023: import spoon.reflect.declaration.CtElement;
024: import spoon.reflect.declaration.CtExecutable;
025: import spoon.reflect.reference.CtTypeReference;
026:
027: /**
028: * This interface defines a symbolic evaluator for the Spoon meta-model.
029: */
030: public interface SymbolicEvaluator {
031:
032: /**
033: * Returns the list of external classes that should be handled as statefull
034: * beans.
035: */
036: List<CtTypeReference<?>> getStatefullExternals();
037:
038: /**
039: * Resets the state of this symbolic evaluator.
040: */
041: void reset();
042:
043: /**
044: * Starts a symbolic evaluation by invoking a given static executable. Note
045: * that symbolic evaluation may have several paths and thus several results.
046: * In order to access the evaluation information, you need to use
047: * {@link #addObserver(SymbolicEvaluatorObserver)}.
048: *
049: * @param executable
050: * to be invoked symbolically
051: * @param args
052: * the arguments of the call (as symbolic instances)
053: */
054: void invoke(CtExecutable<?> executable, SymbolicInstance<?>... args);
055:
056: /**
057: * Starts a symbolic evaluation by invoking a given executable. Note that
058: * symbolic evaluation may have several paths and thus several results. In
059: * order to access the evaluation information, you need to use
060: * {@link #addObserver(SymbolicEvaluatorObserver)}.
061: *
062: * @param target
063: * the target instance
064: * @param executable
065: * to be invoked
066: * @param args
067: * the arguments of the call (as symbolic instances)
068: */
069: void invoke(SymbolicInstance<?> target, CtExecutable<?> executable,
070: List<SymbolicInstance<?>> args);
071:
072: /**
073: * Starts a symbolic evaluation by invoking a given executable and
074: * constructs default symbolic instances for the parameters and the target
075: * when needed. Note that symbolic evaluation may have several paths and
076: * thus several results. In order to access the evaluation information, you
077: * need to use {@link #addObserver(SymbolicEvaluatorObserver)}.
078: *
079: * @param executable
080: * to be invoked
081: */
082: void invoke(CtExecutable<?> executable);
083:
084: /**
085: * Gets the heap of the current symbolic evaluation step.
086: */
087: SymbolicHeap getHeap();
088:
089: /**
090: * Gets the stack of the symbolic abstract evaluation step.
091: */
092: SymbolicEvaluationStack getStack();
093:
094: /**
095: * Evaluates the given meta-model element in the current context of the
096: * evaluator.
097: */
098: SymbolicInstance<?> evaluate(CtElement element);
099:
100: /**
101: * Evaluates the given meta-model expression in the current context of the
102: * evaluator.
103: */
104: <T> SymbolicInstance<T> evaluate(CtExpression<T> expresion);
105:
106: /**
107: * Adds an evaluation observer.
108: *
109: * @param observer
110: * the observer to be notified from evaluation events
111: */
112: void addObserver(SymbolicEvaluatorObserver observer);
113:
114: /**
115: * Adds some evaluation observers.
116: *
117: * @param evaluatorObservers
118: * the observers to be notified from evaluation events
119: */
120: void addObservers(List<SymbolicEvaluatorObserver> evaluatorObservers);
121:
122: }
|