Skip to content
Snippets Groups Projects
Commit 3a3c302b authored by Daniel Plagge's avatar Daniel Plagge
Browse files

Removed comparision with old implementation of the translation.

parent f2f95f63
No related branches found
No related tags found
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
Showing
with 3 additions and 1535 deletions
de.prob.core/src/de/prob/eventb/translator/AssignmentVisitor.java deleted 100644 → 0
+ 0
− 129
View file @ f2f95f63
/**
* (c) 2009 Lehrstuhl fuer Softwaretechnik und Programmiersprachen,
* Heinrich Heine Universitaet Duesseldorf
* This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html)
* */
package de.prob.eventb.translator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.eventb.core.ast.BecomesEqualTo;
import org.eventb.core.ast.BecomesMemberOf;
import org.eventb.core.ast.BecomesSuchThat;
import org.eventb.core.ast.Expression;
import org.eventb.core.ast.FreeIdentifier;
import org.eventb.core.ast.ISimpleVisitor;
import org.eventb.core.ast.Predicate;
import de.be4.classicalb.core.parser.node.AAssignSubstitution;
import de.be4.classicalb.core.parser.node.ABecomesElementOfSubstitution;
import de.be4.classicalb.core.parser.node.ABecomesSuchSubstitution;
import de.be4.classicalb.core.parser.node.AIdentifierExpression;
import de.be4.classicalb.core.parser.node.PExpression;
import de.be4.classicalb.core.parser.node.PSubstitution;
import de.be4.classicalb.core.parser.node.TIdentifierLiteral;
import de.prob.eventb.translator.internal.SimpleVisitorAdapter;
import de.prob.eventb.translator.internal.TranslationVisitor;
/**
* @deprecated Use {@link TranslationVisitor} instead
*/
@Deprecated
public class AssignmentVisitor extends SimpleVisitorAdapter implements
ISimpleVisitor {
private PSubstitution sub;
private boolean substitutonSet = false;
public PSubstitution getSubstitution() {
return sub;
}
public void setSub(final PSubstitution sub) {
if (substitutonSet) {
throw new AssertionError("The Visitor must not be used twice!");
}
substitutonSet = true;
this.sub = sub;
}
@Override
public void visitBecomesEqualTo(final BecomesEqualTo assignment) {
final FreeIdentifier[] identifiers = assignment
.getAssignedIdentifiers();
final Expression[] expressions = assignment.getExpressions();
final AAssignSubstitution assignSubstitution = new AAssignSubstitution();
assignSubstitution
.setLhsExpression(createListOfIdentifiers(identifiers));
assignSubstitution
.setRhsExpressions(createListOfExpressions(expressions));
setSub(assignSubstitution);
}
private List<PExpression> createListOfExpressions(
final Expression[] expressions) {
final List<PExpression> list = new ArrayList<PExpression>();
for (Expression e : expressions) {
final ExpressionVisitor visitor = new ExpressionVisitor(
new LinkedList<String>());
e.accept(visitor);
list.add(visitor.getExpression());
}
return list;
}
private List<PExpression> createListOfIdentifiers(
final FreeIdentifier[] identifiers) {
final List<PExpression> res = new ArrayList<PExpression>(
identifiers.length);
for (FreeIdentifier freeIdentifier : identifiers) {
final List<TIdentifierLiteral> list = Arrays
.asList(new TIdentifierLiteral[] { new TIdentifierLiteral(
freeIdentifier.getName()) });
final AIdentifierExpression expression = new AIdentifierExpression();
expression.setIdentifier(list);
res.add(expression);
}
return res;
}
@Override
public void visitBecomesMemberOf(final BecomesMemberOf assignment) {
final ABecomesElementOfSubstitution becomesElementOfSubstitution = new ABecomesElementOfSubstitution();
final FreeIdentifier[] identifiers = assignment
.getAssignedIdentifiers();
final Expression set = assignment.getSet();
final ExpressionVisitor visitor = new ExpressionVisitor(
new LinkedList<String>());
set.accept(visitor);
becomesElementOfSubstitution
.setIdentifiers(createListOfIdentifiers(identifiers));
becomesElementOfSubstitution.setSet(visitor.getExpression());
setSub(becomesElementOfSubstitution);
}
@Override
public void visitBecomesSuchThat(final BecomesSuchThat assignment) {
final FreeIdentifier[] identifiers = assignment
.getAssignedIdentifiers();
LinkedList<String> list = new LinkedList<String>();
for (FreeIdentifier f : identifiers) {
list.addFirst(f.getName() + "'");
}
final Predicate predicate = assignment.getCondition();
final PredicateVisitor visitor = new PredicateVisitor(list);
predicate.accept(visitor);
final ABecomesSuchSubstitution becomesSuchSubstitution = new ABecomesSuchSubstitution();
becomesSuchSubstitution
.setIdentifiers(createListOfIdentifiers(identifiers));
becomesSuchSubstitution.setPredicate(visitor.getPredicate());
setSub(becomesSuchSubstitution);
}
}
de.prob.core/src/de/prob/eventb/translator/ExpressionVisitor.java deleted 100644 → 0
+ 0
− 738
View file @ f2f95f63
This diff is collapsed.
de.prob.core/src/de/prob/eventb/translator/PredicateVisitor.java deleted 100644 → 0
+ 0
− 453
View file @ f2f95f63
/**
* (c) 2009 Lehrstuhl fuer Softwaretechnik und Programmiersprachen, Heinrich
* Heine Universitaet Duesseldorf This software is licenced under EPL 1.0
* (http://www.eclipse.org/org/documents/epl-v10.html)
* */
package de.prob.eventb.translator; // NOPMD
// High number of imports because it depends on AST
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import org.eventb.core.ast.AssociativePredicate;
import org.eventb.core.ast.BinaryPredicate;
import org.eventb.core.ast.BoundIdentDecl;
import org.eventb.core.ast.Expression;
import org.eventb.core.ast.ExtendedPredicate;
import org.eventb.core.ast.Formula;
import org.eventb.core.ast.ISimpleVisitor;
import org.eventb.core.ast.LiteralPredicate;
import org.eventb.core.ast.MultiplePredicate;
import org.eventb.core.ast.Predicate;
import org.eventb.core.ast.QuantifiedPredicate;
import org.eventb.core.ast.RelationalPredicate;
import org.eventb.core.ast.SimplePredicate;
import org.eventb.core.ast.UnaryPredicate;
import org.eventb.core.ast.extension.IPredicateExtension;
import de.be4.classicalb.core.parser.node.AConjunctPredicate;
import de.be4.classicalb.core.parser.node.ADisjunctPredicate;
import de.be4.classicalb.core.parser.node.AEqualPredicate;
import de.be4.classicalb.core.parser.node.AEquivalencePredicate;
import de.be4.classicalb.core.parser.node.AExistsPredicate;
import de.be4.classicalb.core.parser.node.AExtendedPredPredicate;
import de.be4.classicalb.core.parser.node.AFalsityPredicate;
import de.be4.classicalb.core.parser.node.AFinitePredicate;
import de.be4.classicalb.core.parser.node.AForallPredicate;
import de.be4.classicalb.core.parser.node.AGreaterEqualPredicate;
import de.be4.classicalb.core.parser.node.AGreaterPredicate;
import de.be4.classicalb.core.parser.node.AImplicationPredicate;
import de.be4.classicalb.core.parser.node.ALessEqualPredicate;
import de.be4.classicalb.core.parser.node.ALessPredicate;
import de.be4.classicalb.core.parser.node.AMemberPredicate;
import de.be4.classicalb.core.parser.node.ANegationPredicate;
import de.be4.classicalb.core.parser.node.ANotEqualPredicate;
import de.be4.classicalb.core.parser.node.ANotMemberPredicate;
import de.be4.classicalb.core.parser.node.ANotSubsetPredicate;
import de.be4.classicalb.core.parser.node.ANotSubsetStrictPredicate;
import de.be4.classicalb.core.parser.node.APartitionPredicate;
import de.be4.classicalb.core.parser.node.ASubsetPredicate;
import de.be4.classicalb.core.parser.node.ASubsetStrictPredicate;
import de.be4.classicalb.core.parser.node.ATruthPredicate;
import de.be4.classicalb.core.parser.node.PExpression;
import de.be4.classicalb.core.parser.node.PPredicate;
import de.be4.classicalb.core.parser.node.TIdentifierLiteral;
import de.prob.eventb.translator.internal.SimpleVisitorAdapter;
import de.prob.eventb.translator.internal.TranslationVisitor;
/**
* @deprecated Use {@link TranslationVisitor} instead
*/
@Deprecated
public class PredicateVisitor extends SimpleVisitorAdapter implements // NOPMD
ISimpleVisitor {
private static final String UNCOVERED_PREDICATE = "Uncovered Predicate";
private PPredicate p;
private final LinkedList<String> bounds; // NOPMD
// we need properties of linked lists, List is not an option
private boolean predicateSet = false;
public PPredicate getPredicate() {
return p;
}
public void setPredicate(final PPredicate p) {
synchronized (bounds) {
if (predicateSet) {
throw new AssertionError("The Visitor must not be used twice!");
}
predicateSet = true;
this.p = p;
}
// public ClassifiedPragma(String name, Node attachedTo, List<String>
// arguments, List<String> warnings, SourcePosition start,
// SourcePosition end) {
// new ClassifiedPragma("discharged", p, proof, Collections.emptyList(),
// new SourcePosition(-1, -1), new SourcePosition(-1, -1));
}
public PredicateVisitor() {
this(null);
}
public PredicateVisitor(LinkedList<String> bounds) {
super();
if (bounds == null) {
this.bounds = new LinkedList<String>();
} else {
this.bounds = bounds;
}
}
@Override
public void visitQuantifiedPredicate(final QuantifiedPredicate predicate) {
final int tag = predicate.getTag();
// Add quantified identifiers to bound list and recursively create
// subtrees representing the identifiers
final List<ExpressionVisitor> ev = new LinkedList<ExpressionVisitor>();
final BoundIdentDecl[] decls = predicate.getBoundIdentDecls();
for (final BoundIdentDecl boundIdentDecl : decls) {
final ExpressionVisitor visitor = new ExpressionVisitor(bounds);
boundIdentDecl.accept(visitor);
ev.add(visitor);
bounds.addFirst(boundIdentDecl.getName());
}
// Collect Subtrees in a list
final LinkedList<PExpression> list = new LinkedList<PExpression>();
for (final ExpressionVisitor visitor : ev) {
list.add(visitor.getExpression());
}
// Recursively analyze the predicate (important, bounds are already set)
final PredicateVisitor predicateVisitor = new PredicateVisitor(bounds);
predicate.getPredicate().accept(predicateVisitor);
switch (tag) {
case Formula.EXISTS:
final AExistsPredicate existentialQuantificationPredicate = new AExistsPredicate();
existentialQuantificationPredicate.setIdentifiers(list);
existentialQuantificationPredicate.setPredicate(predicateVisitor
.getPredicate());
setPredicate(existentialQuantificationPredicate);
break;
case Formula.FORALL:
final AForallPredicate universalQuantificationPredicate = new AForallPredicate();
universalQuantificationPredicate.setIdentifiers(list);
PPredicate pred = predicateVisitor.getPredicate();
if (!(pred instanceof AImplicationPredicate)) {
pred = new AImplicationPredicate(new ATruthPredicate(), pred);
}
universalQuantificationPredicate.setImplication(pred);
setPredicate(universalQuantificationPredicate);
break;
default:
throw new AssertionError(UNCOVERED_PREDICATE);
}
// remove quantified identifiers from bound list (leaving scope)
for (int i = 0; i < decls.length; i++) {
bounds.removeFirst();
}
}
@Override
public void visitAssociativePredicate(final AssociativePredicate predicate) {
// {LAND, LOR, LEQV}
final int tag = predicate.getTag();
final Predicate[] children = predicate.getChildren();
if (children.length < 2) {
throw new AssertionError(
"Predicate must have at least 2 subpredicates.");
}
final LinkedList<PredicateVisitor> pv = new LinkedList<PredicateVisitor>();
for (final Predicate pr : children) {
final PredicateVisitor p = new PredicateVisitor(bounds);
pv.add(p);
pr.accept(p);
}
switch (tag) {
case Formula.LOR:
setPredicate(recurseOR(pv));
break;
case Formula.LAND:
setPredicate(recurseAND(pv));
break;
case Formula.LEQV:
setPredicate(recurseEQV(pv));
break;
default:
throw new AssertionError(UNCOVERED_PREDICATE);
}
}
private PPredicate recurseOR(final List<PredicateVisitor> list) {
final ADisjunctPredicate r = new ADisjunctPredicate();
if (list.size() == 2) {
r.setLeft(list.get(0).getPredicate());
r.setRight(list.get(1).getPredicate());
} else {
r.setLeft(list.get(0).getPredicate());
r.setRight(recurseOR(list.subList(1, list.size())));
}
return r;
}
private PPredicate recurseAND(final List<PredicateVisitor> list) {
final AConjunctPredicate r = new AConjunctPredicate();
if (list.size() == 2) {
r.setLeft(list.get(0).getPredicate());
r.setRight(list.get(1).getPredicate());
} else {
r.setLeft(list.get(0).getPredicate());
r.setRight(recurseAND(list.subList(1, list.size())));
}
return r;
}
private PPredicate recurseEQV(final List<PredicateVisitor> list) {
final AEquivalencePredicate r = new AEquivalencePredicate();
if (list.size() == 2) {
r.setLeft(list.get(0).getPredicate());
r.setRight(list.get(1).getPredicate());
} else {
r.setLeft(list.get(0).getPredicate());
r.setRight(recurseEQV(list.subList(1, list.size())));
}
return r;
}
@Override
public void visitBinaryPredicate(final BinaryPredicate predicate) {
final int tag = predicate.getTag();
final PredicateVisitor subLeft = new PredicateVisitor(bounds);
predicate.getLeft().accept(subLeft);
final PredicateVisitor subRight = new PredicateVisitor(bounds);
predicate.getRight().accept(subRight);
switch (tag) {
case Formula.LIMP:
final AImplicationPredicate limp = new AImplicationPredicate();
limp.setLeft(subLeft.getPredicate());
limp.setRight(subRight.getPredicate());
setPredicate(limp);
break;
case Formula.LEQV:
final AEquivalencePredicate leqv = new AEquivalencePredicate();
leqv.setLeft(subLeft.getPredicate());
leqv.setRight(subRight.getPredicate());
setPredicate(leqv);
break;
default:
throw new AssertionError(UNCOVERED_PREDICATE);
}
}
@Override
public void visitLiteralPredicate(final LiteralPredicate predicate) {
final int tag = predicate.getTag();
switch (tag) {
case Formula.BTRUE:
setPredicate(new ATruthPredicate());
break;
case Formula.BFALSE:
setPredicate(new AFalsityPredicate());
break;
default:
throw new AssertionError(UNCOVERED_PREDICATE);
}
}
@Override
public void visitRelationalPredicate(final RelationalPredicate predicate) { // NOPMD
// High complexity is ok
// EQUAL, NOTEQUAL, LT, LE, GT, GE, IN, NOTIN, SUBSET,
// NOTSUBSET, SUBSETEQ, NOTSUBSETEQ
final ExpressionVisitor subLeft = new ExpressionVisitor(bounds);
predicate.getLeft().accept(subLeft);
final ExpressionVisitor subRight = new ExpressionVisitor(bounds);
predicate.getRight().accept(subRight);
final int tag = predicate.getTag();
switch (tag) {
case Formula.EQUAL:
final AEqualPredicate equalPredicate = new AEqualPredicate();
equalPredicate.setLeft(subLeft.getExpression());
equalPredicate.setRight(subRight.getExpression());
setPredicate(equalPredicate);
break;
case Formula.NOTEQUAL:
final ANotEqualPredicate unequalPredicate = new ANotEqualPredicate();
unequalPredicate.setLeft(subLeft.getExpression());
unequalPredicate.setRight(subRight.getExpression());
setPredicate(unequalPredicate);
break;
case Formula.LT:
final ALessPredicate ltPredicate = new ALessPredicate();
ltPredicate.setLeft(subLeft.getExpression());
ltPredicate.setRight(subRight.getExpression());
setPredicate(ltPredicate);
break;
case Formula.LE:
final ALessEqualPredicate lePredicate = new ALessEqualPredicate();
lePredicate.setLeft(subLeft.getExpression());
lePredicate.setRight(subRight.getExpression());
setPredicate(lePredicate);
break;
case Formula.GT:
final AGreaterPredicate gtPredicate = new AGreaterPredicate();
gtPredicate.setLeft(subLeft.getExpression());
gtPredicate.setRight(subRight.getExpression());
setPredicate(gtPredicate);
break;
case Formula.GE:
final AGreaterEqualPredicate gePredicate = new AGreaterEqualPredicate();
gePredicate.setLeft(subLeft.getExpression());
gePredicate.setRight(subRight.getExpression());
setPredicate(gePredicate);
break;
case Formula.IN:
final AMemberPredicate inPredicate = new AMemberPredicate();
inPredicate.setLeft(subLeft.getExpression());
inPredicate.setRight(subRight.getExpression());
setPredicate(inPredicate);
break;
case Formula.NOTIN:
final ANotMemberPredicate ninPredicate = new ANotMemberPredicate();
ninPredicate.setLeft(subLeft.getExpression());
ninPredicate.setRight(subRight.getExpression());
setPredicate(ninPredicate);
break;
case Formula.SUBSET:
final ASubsetStrictPredicate strictSubsetPredicate = new ASubsetStrictPredicate();
strictSubsetPredicate.setLeft(subLeft.getExpression());
strictSubsetPredicate.setRight(subRight.getExpression());
setPredicate(strictSubsetPredicate);
break;
case Formula.NOTSUBSET:
final ANotSubsetStrictPredicate notStrictSubsetPredicate = new ANotSubsetStrictPredicate();
notStrictSubsetPredicate.setLeft(subLeft.getExpression());
notStrictSubsetPredicate.setRight(subRight.getExpression());
setPredicate(notStrictSubsetPredicate);
break;
case Formula.SUBSETEQ:
final ASubsetPredicate subsetPredicate = new ASubsetPredicate();
subsetPredicate.setLeft(subLeft.getExpression());
subsetPredicate.setRight(subRight.getExpression());
setPredicate(subsetPredicate);
break;
case Formula.NOTSUBSETEQ:
final ANotSubsetPredicate notSubsetPredicate = new ANotSubsetPredicate();
notSubsetPredicate.setLeft(subLeft.getExpression());
notSubsetPredicate.setRight(subRight.getExpression());
setPredicate(notSubsetPredicate);
break;
default:
throw new AssertionError(UNCOVERED_PREDICATE);
}
}
@Override
public void visitSimplePredicate(final SimplePredicate predicate) {
if (predicate.getTag() != Formula.KFINITE) {
throw new AssertionError(UNCOVERED_PREDICATE);
}
final AFinitePredicate finite = new AFinitePredicate();
final ExpressionVisitor subEx = new ExpressionVisitor(bounds);
predicate.getExpression().accept(subEx);
finite.setSet(subEx.getExpression());
setPredicate(finite);
}
@Override
public void visitUnaryPredicate(final UnaryPredicate predicate) {
if (predicate.getTag() != Formula.NOT) {
throw new AssertionError(UNCOVERED_PREDICATE);
}
final ANegationPredicate negationPredicate = new ANegationPredicate();
final PredicateVisitor sub = new PredicateVisitor(bounds);
predicate.getChild().accept(sub);
negationPredicate.setPredicate(sub.getPredicate());
setPredicate(negationPredicate);
}
@Override
public void visitMultiplePredicate(final MultiplePredicate predicate) {
final Expression[] subs = predicate.getChildren();
final List<PExpression> expressions = new ArrayList<PExpression>(
subs.length);
for (Expression e : subs) {
final ExpressionVisitor sub = new ExpressionVisitor(bounds);
e.accept(sub);
expressions.add(sub.getExpression());
}
final PPredicate result;
if (predicate.getTag() == Formula.KPARTITION) {
if (expressions.size() > 0) {
PExpression set = expressions.remove(0);
result = new APartitionPredicate(set, expressions);
} else {
throw new AssertionError("to few arguments for PARTITION");
}
} else {
throw new AssertionError(UNCOVERED_PREDICATE);
}
setPredicate(result);
}
@Override
public void visitExtendedPredicate(ExtendedPredicate predicate) {
AExtendedPredPredicate p = new AExtendedPredPredicate();
IPredicateExtension extension = predicate.getExtension();
String symbol = extension.getSyntaxSymbol();
// FIXME THEORY-PLUGIN re-enable when the theory plugin was released
// Theories.addOrigin(origin);
p.setIdentifier(new TIdentifierLiteral(symbol));
Expression[] expressions = predicate.getChildExpressions();
List<PExpression> childExprs = new ArrayList<PExpression>();
for (Expression e : expressions) {
ExpressionVisitor v = new ExpressionVisitor(bounds);
e.accept(v);
childExprs.add(v.getExpression());
}
p.setExpressions(childExprs);
Predicate[] childPredicates = predicate.getChildPredicates();
List<PPredicate> childPreds = new ArrayList<PPredicate>();
for (Predicate pd : childPredicates) {
PredicateVisitor v = new PredicateVisitor(bounds);
pd.accept(v);
childPreds.add(v.getPredicate());
}
p.setPredicates(childPreds);
setPredicate(p);
}
}
de.prob.core/src/de/prob/eventb/translator/internal/SimpleVisitorAdapter.java deleted 100644 → 0
+ 0
− 157
View file @ f2f95f63
/**
* (c) 2009 Lehrstuhl fuer Softwaretechnik und Programmiersprachen,
* Heinrich Heine Universitaet Duesseldorf
* This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html)
* */
package de.prob.eventb.translator.internal;
import org.eventb.core.ast.AssociativeExpression;
import org.eventb.core.ast.AssociativePredicate;
import org.eventb.core.ast.AtomicExpression;
import org.eventb.core.ast.BecomesEqualTo;
import org.eventb.core.ast.BecomesMemberOf;
import org.eventb.core.ast.BecomesSuchThat;
import org.eventb.core.ast.BinaryExpression;
import org.eventb.core.ast.BinaryPredicate;
import org.eventb.core.ast.BoolExpression;
import org.eventb.core.ast.BoundIdentDecl;
import org.eventb.core.ast.BoundIdentifier;
import org.eventb.core.ast.ExtendedExpression;
import org.eventb.core.ast.ExtendedPredicate;
import org.eventb.core.ast.FreeIdentifier;
import org.eventb.core.ast.ISimpleVisitor;
import org.eventb.core.ast.IntegerLiteral;
import org.eventb.core.ast.LiteralPredicate;
import org.eventb.core.ast.MultiplePredicate;
import org.eventb.core.ast.QuantifiedExpression;
import org.eventb.core.ast.QuantifiedPredicate;
import org.eventb.core.ast.RelationalPredicate;
import org.eventb.core.ast.SetExtension;
import org.eventb.core.ast.SimplePredicate;
import org.eventb.core.ast.UnaryExpression;
import org.eventb.core.ast.UnaryPredicate;
public class SimpleVisitorAdapter implements ISimpleVisitor {
public void visitAssociativeExpression(
final AssociativeExpression expression) {
// Default implementation does nothing
}
public void visitAssociativePredicate(final AssociativePredicate predicate) {
// Default implementation does nothing
}
public void visitAtomicExpression(final AtomicExpression expression) {
// Default implementation does nothing
}
public void visitBecomesEqualTo(final BecomesEqualTo assignment) {
// Default implementation does nothing
}
public void visitBecomesMemberOf(final BecomesMemberOf assignment) {
// Default implementation does nothing
}
public void visitBecomesSuchThat(final BecomesSuchThat assignment) {
// Default implementation does nothing
}
public void visitBinaryExpression(final BinaryExpression expression) {
// Default implementation does nothing
}
public void visitBinaryPredicate(final BinaryPredicate predicate) {
// Default implementation does nothing
}
public void visitBoolExpression(final BoolExpression expression) {
// Default implementation does nothing
}
public void visitBoundIdentDecl(final BoundIdentDecl boundIdentDecl) {
// Default implementation does nothing
}
public void visitBoundIdentifier(final BoundIdentifier identifierExpression) {
// Default implementation does nothing
}
public void visitFreeIdentifier(final FreeIdentifier identifierExpression) {
// Default implementation does nothing
}
public void visitIntegerLiteral(final IntegerLiteral expression) {
// Default implementation does nothing
}
public void visitLiteralPredicate(final LiteralPredicate predicate) {
// Default implementation does nothing
}
public void visitQuantifiedExpression(final QuantifiedExpression expression) {
// Default implementation does nothing
}
public void visitQuantifiedPredicate(final QuantifiedPredicate predicate) {
// Default implementation does nothing
}
public void visitRelationalPredicate(final RelationalPredicate predicate) {
// Default implementation does nothing
}
public void visitSetExtension(final SetExtension expression) {
// Default implementation does nothing
}
public void visitSimplePredicate(final SimplePredicate predicate) {
// Default implementation does nothing
}
public void visitUnaryExpression(final UnaryExpression expression) {
// Default implementation does nothing
}
public void visitUnaryPredicate(final UnaryPredicate predicate) {
// Default implementation does nothing
}
public void visitMultiplePredicate(final MultiplePredicate predicate) {
// Default implementation does nothing
}
@Override
public void visitExtendedExpression(final ExtendedExpression expression) {
// Default implementation does nothing
}
@Override
public void visitExtendedPredicate(final ExtendedPredicate predicate) {
// Default implementation does nothing
}
}
de.prob.core/src/de/prob/eventb/translator/internal/TranslationVisitor.java
+ 3
− 58
View file @ 3a3c302b
......@@ -722,76 +722,21 @@ public class TranslationVisitor implements ISimpleVisitor {
// Create a visitor and use it to translate the predicate
final TranslationVisitor visitor = new TranslationVisitor();
p.accept(visitor);
final PPredicate newImp = visitor.getPredicate();
// Use the old visitor to check if the implementation of the new visitor
// is correct.
final PredicateVisitor oldVisitor = new PredicateVisitor();
p.accept(oldVisitor);
final PPredicate oldImp = oldVisitor.getPredicate();
// Compare both results. If there are differences, throw an exception
final String expected = oldImp.toString();
final String actual = newImp.toString();
if (!expected.equals(actual)) {
throw new AssertionError("Expected:\n" + expected + "\n but was:\n"
+ actual);
}
// TODO[DP, 13.8.2013]: Remove call to old implementation after a test
// phase
return newImp;
return visitor.getPredicate();
}
public static PExpression translateExpression(Expression e) {
// Create a visitor and use it to translate the predicate
final TranslationVisitor visitor = new TranslationVisitor();
e.accept(visitor);
final PExpression newImp = visitor.getExpression();
// Use the old visitor to check if the implementation of the new visitor
// is correct.
final ExpressionVisitor oldVisitor = new ExpressionVisitor(
new LinkedList<String>());
e.accept(oldVisitor);
final PExpression oldImp = oldVisitor.getExpression();
// Compare both results. If there are differences, throw an exception
final String expected = oldImp.toString();
final String actual = newImp.toString();
if (!expected.equals(actual)) {
throw new AssertionError("Expected:\n" + expected + "\n but was:\n"
+ actual);
}
// TODO[DP, 13.8.2013]: Remove call to old implementation after a test
// phase
return newImp;
return visitor.getExpression();
}
public static PSubstitution translateAssignment(Assignment a) {
// Create a visitor and use it to translate the predicate
final TranslationVisitor visitor = new TranslationVisitor();
a.accept(visitor);
final PSubstitution newImp = visitor.getSubstitution();
// Use the old visitor to check if the implementation of the new visitor
// is correct.
final AssignmentVisitor oldVisitor = new AssignmentVisitor();
a.accept(oldVisitor);
final PSubstitution oldImp = oldVisitor.getSubstitution();
// Compare both results. If there are differences, throw an exception
final String expected = oldImp.toString();
final String actual = newImp.toString();
if (!expected.equals(actual)) {
throw new AssertionError("Expected:\n" + expected + "\n but was:\n"
+ actual);
}
// TODO[DP, 13.8.2013]: Remove call to old implementation after a test
// phase
return newImp;
return visitor.getSubstitution();
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment