patrick/anthem
1
0
Fork 0
Code Issues 15 Releases 21 Activity

Removed unnecessary namespace identifiers.

Browse Source
This commit is contained in:
Patrick Lühne
2017-05-30 18:13:31 +02:00
parent 664a57ec68
commit 1de0486989
4 changed files with 67 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/anthem/ASTCopy.cpp
View File

@@ -21,9 +21,9 @@ namespace ast
////////////////////////////////////////////////////////////////////////////////////////////////////
// Replaces all occurrences of a variable in a given term with another term
struct ReplaceVariableInTermVisitor : public ast::RecursiveTermVisitor<ReplaceVariableInTermVisitor>
struct ReplaceVariableInTermVisitor : public RecursiveTermVisitor<ReplaceVariableInTermVisitor>
{
static void accept(ast::Variable &variable, ast::Term &, const ast::VariableDeclaration *original, ast::VariableDeclaration *replacement)
static void accept(Variable &variable, Term &, const VariableDeclaration *original, VariableDeclaration *replacement)
{
if (variable.declaration == original)
variable.declaration = replacement;
@@ -31,7 +31,7 @@ struct ReplaceVariableInTermVisitor : public ast::RecursiveTermVisitor<ReplaceVa
// Ignore all other types of expressions
template<class T>
static void accept(T &, ast::Term &, const ast::VariableDeclaration *, ast::VariableDeclaration *)
static void accept(T &, Term &, const VariableDeclaration *, VariableDeclaration *)
{
}
};
@@ -39,21 +39,21 @@ struct ReplaceVariableInTermVisitor : public ast::RecursiveTermVisitor<ReplaceVa
////////////////////////////////////////////////////////////////////////////////////////////////////
// Replaces all occurrences of a variable in a given formula with a term
struct ReplaceVariableInFormulaVisitor : public ast::RecursiveFormulaVisitor<ReplaceVariableInFormulaVisitor>
struct ReplaceVariableInFormulaVisitor : public RecursiveFormulaVisitor<ReplaceVariableInFormulaVisitor>
{
static void accept(ast::Comparison &comparison, ast::Formula &, const ast::VariableDeclaration *original, ast::VariableDeclaration *replacement)
static void accept(Comparison &comparison, Formula &, const VariableDeclaration *original, VariableDeclaration *replacement)
{
comparison.left.accept(ReplaceVariableInTermVisitor(), comparison.left, original, replacement);
comparison.right.accept(ReplaceVariableInTermVisitor(), comparison.right, original, replacement);
}
static void accept(ast::In &in, ast::Formula &, const ast::VariableDeclaration *original, ast::VariableDeclaration *replacement)
static void accept(In &in, Formula &, const VariableDeclaration *original, VariableDeclaration *replacement)
{
in.element.accept(ReplaceVariableInTermVisitor(), in.element, original, replacement);
in.set.accept(ReplaceVariableInTermVisitor(), in.set, original, replacement);
}
static void accept(ast::Predicate &predicate, ast::Formula &, const ast::VariableDeclaration *original, ast::VariableDeclaration *replacement)
static void accept(Predicate &predicate, Formula &, const VariableDeclaration *original, VariableDeclaration *replacement)
{
for (auto &argument : predicate.arguments)
argument.accept(ReplaceVariableInTermVisitor(), argument, original, replacement);
@@ -61,7 +61,7 @@ struct ReplaceVariableInFormulaVisitor : public ast::RecursiveFormulaVisitor<Rep
// Ignore all other types of expressions
template<class T>
static void accept(T &, ast::Formula &, const ast::VariableDeclaration *, ast::VariableDeclaration *)
static void accept(T &, Formula &, const VariableDeclaration *, VariableDeclaration *)
{
}
};

60
src/anthem/ASTUtils.cpp
View File

@@ -27,7 +27,7 @@ void VariableStack::pop()
////////////////////////////////////////////////////////////////////////////////////////////////////
std::experimental::optional<ast::VariableDeclaration *> VariableStack::findUserVariableDeclaration(const char *variableName) const
std::experimental::optional<VariableDeclaration *> VariableStack::findUserVariableDeclaration(const char *variableName) const
{
const auto variableDeclarationMatches =
[&variableName](const auto &variableDeclaration)
@@ -50,7 +50,7 @@ std::experimental::optional<ast::VariableDeclaration *> VariableStack::findUserV
////////////////////////////////////////////////////////////////////////////////////////////////////
bool VariableStack::contains(const ast::VariableDeclaration &variableDeclaration) const
bool VariableStack::contains(const VariableDeclaration &variableDeclaration) const
{
const auto variableDeclarationMatches =
[&variableDeclaration](const auto &other)
@@ -75,66 +75,66 @@ struct CollectFreeVariablesVisitor
// Formulas
////////////////////////////////////////////////////////////////////////////////////////////////
void visit(ast::And &and_, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(And &and_, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
for (auto &argument : and_.arguments)
argument.accept(*this, variableStack, freeVariables);
}
void visit(ast::Biconditional &biconditional, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Biconditional &biconditional, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
biconditional.left.accept(*this, variableStack, freeVariables);
biconditional.right.accept(*this, variableStack, freeVariables);
}
void visit(ast::Boolean &, VariableStack &, std::vector<ast::VariableDeclaration *> &)
void visit(Boolean &, VariableStack &, std::vector<VariableDeclaration *> &)
{
}
void visit(ast::Comparison &comparison, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Comparison &comparison, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
comparison.left.accept(*this, variableStack, freeVariables);
comparison.right.accept(*this, variableStack, freeVariables);
}
void visit(ast::Exists &exists, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Exists &exists, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
variableStack.push(&exists.variables);
exists.argument.accept(*this, variableStack, freeVariables);
variableStack.pop();
}
void visit(ast::ForAll &forAll, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(ForAll &forAll, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
variableStack.push(&forAll.variables);
forAll.argument.accept(*this, variableStack, freeVariables);
variableStack.pop();
}
void visit(ast::Implies &implies, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Implies &implies, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
implies.antecedent.accept(*this, variableStack, freeVariables);
implies.consequent.accept(*this, variableStack, freeVariables);
}
void visit(ast::In &in, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(In &in, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
in.element.accept(*this, variableStack, freeVariables);
in.set.accept(*this, variableStack, freeVariables);
}
void visit(ast::Not &not_, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Not &not_, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
not_.argument.accept(*this, variableStack, freeVariables);
}
void visit(ast::Or &or_, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Or &or_, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
for (auto &argument : or_.arguments)
argument.accept(*this, variableStack, freeVariables);
}
void visit(ast::Predicate &predicate, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Predicate &predicate, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
for (auto &argument : predicate.arguments)
argument.accept(*this, variableStack, freeVariables);
@@ -144,41 +144,41 @@ struct CollectFreeVariablesVisitor
// Terms
////////////////////////////////////////////////////////////////////////////////////////////////
void visit(ast::BinaryOperation &binaryOperation, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(BinaryOperation &binaryOperation, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
binaryOperation.left.accept(*this, variableStack, freeVariables);
binaryOperation.right.accept(*this, variableStack, freeVariables);
}
void visit(ast::Constant &, VariableStack &, std::vector<ast::VariableDeclaration *> &)
void visit(Constant &, VariableStack &, std::vector<VariableDeclaration *> &)
{
}
void visit(ast::Function &function, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Function &function, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
for (auto &argument : function.arguments)
argument.accept(*this, variableStack, freeVariables);
}
void visit(ast::Integer &, VariableStack &, std::vector<ast::VariableDeclaration *> &)
void visit(Integer &, VariableStack &, std::vector<VariableDeclaration *> &)
{
}
void visit(ast::Interval &interval, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Interval &interval, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
interval.from.accept(*this, variableStack, freeVariables);
interval.to.accept(*this, variableStack, freeVariables);
}
void visit(ast::SpecialInteger &, VariableStack &, std::vector<ast::VariableDeclaration *> &)
void visit(SpecialInteger &, VariableStack &, std::vector<VariableDeclaration *> &)
{
}
void visit(ast::String &, VariableStack &, std::vector<ast::VariableDeclaration *> &)
void visit(String &, VariableStack &, std::vector<VariableDeclaration *> &)
{
}
void visit(ast::Variable &variable, VariableStack &variableStack, std::vector<ast::VariableDeclaration *> &freeVariables)
void visit(Variable &variable, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
{
if (variableStack.contains(*variable.declaration))
return;
@@ -192,17 +192,17 @@ struct CollectFreeVariablesVisitor
////////////////////////////////////////////////////////////////////////////////////////////////////
std::vector<ast::VariableDeclaration *> collectFreeVariables(ast::Formula &formula)
std::vector<VariableDeclaration *> collectFreeVariables(Formula &formula)
{
ast::VariableStack variableStack;
VariableStack variableStack;
return collectFreeVariables(formula, variableStack);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
std::vector<ast::VariableDeclaration *> collectFreeVariables(ast::Formula &formula, ast::VariableStack &variableStack)
std::vector<VariableDeclaration *> collectFreeVariables(Formula &formula, VariableStack &variableStack)
{
std::vector<ast::VariableDeclaration *> freeVariables;
std::vector<VariableDeclaration *> freeVariables;
formula.accept(CollectFreeVariablesVisitor(), variableStack, freeVariables);
@@ -213,7 +213,7 @@ std::vector<ast::VariableDeclaration *> collectFreeVariables(ast::Formula &formu
struct CollectPredicatesVisitor : public RecursiveFormulaVisitor<CollectPredicatesVisitor>
{
static void accept(const ast::Predicate &predicate, const ast::Formula &, std::vector<const ast::Predicate *> &predicates)
static void accept(const Predicate &predicate, const Formula &, std::vector<const Predicate *> &predicates)
{
const auto predicateMatches =
[&predicate](const auto *otherPredicate)
@@ -227,14 +227,14 @@ struct CollectPredicatesVisitor : public RecursiveFormulaVisitor<CollectPredicat
// Ignore all other types of expressions
template<class T>
static void accept(const T &, const ast::Formula &, std::vector<const ast::Predicate *> &)
static void accept(const T &, const Formula &, std::vector<const Predicate *> &)
{
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////
bool matches(const ast::Predicate &lhs, const ast::Predicate &rhs)
bool matches(const Predicate &lhs, const Predicate &rhs)
{
return (lhs.name == rhs.name && lhs.arity() == rhs.arity());
}
@@ -242,9 +242,9 @@ bool matches(const ast::Predicate &lhs, const ast::Predicate &rhs)
////////////////////////////////////////////////////////////////////////////////////////////////////
// TODO: remove const_cast
void collectPredicates(const ast::Formula &formula, std::vector<const ast::Predicate *> &predicates)
void collectPredicates(const Formula &formula, std::vector<const Predicate *> &predicates)
{
auto &formulaMutable = const_cast<ast::Formula &>(formula);
auto &formulaMutable = const_cast<Formula &>(formula);
formulaMutable.accept(CollectPredicatesVisitor(), formulaMutable, predicates);
}