Made all visitors consistent in taking an Context object as an argument.

This commit is contained in:
Patrick Lühne 2016-11-24 00:52:28 +01:00
parent 1103f5cbf1
commit 6af3b7b875
Signed by: patrick
GPG Key ID: 05F3611E97A70ABF
7 changed files with 171 additions and 157 deletions

View File

@ -17,35 +17,35 @@ namespace anthem
struct TermPrintVisitor
{
void visit(const Clingo::Symbol &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &)
void visit(const Clingo::Symbol &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“symbol” terms currently unsupported in this context");
throwErrorAtLocation(term.location, "“symbol” terms currently unsupported in this context", context);
}
void visit(const Clingo::AST::Variable &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &)
void visit(const Clingo::AST::Variable &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“variable” terms currently unsupported in this context");
throwErrorAtLocation(term.location, "“variable” terms currently unsupported in this context", context);
}
void visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &)
void visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“unary operation” terms currently unsupported in this context");
throwErrorAtLocation(term.location, "“unary operation” terms currently unsupported in this context", context);
}
void visit(const Clingo::AST::BinaryOperation &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &)
void visit(const Clingo::AST::BinaryOperation &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“binary operation” terms currently unsupported in this context");
throwErrorAtLocation(term.location, "“binary operation” terms currently unsupported in this context", context);
}
void visit(const Clingo::AST::Interval &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &)
void visit(const Clingo::AST::Interval &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“interval” terms currently unsupported in this context");
throwErrorAtLocation(term.location, "“interval” terms currently unsupported in this context", context);
}
void visit(const Clingo::AST::Function &function, const Clingo::AST::Literal &literal, const Clingo::AST::Term &term, Context &context)
{
if (literal.sign == Clingo::AST::Sign::DoubleNegation)
throwErrorAtLocation(literal.location, "double-negated literals currently unsupported");
throwErrorAtLocation(literal.location, "double-negated literals currently unsupported", context);
if (function.arguments.empty())
{
@ -98,9 +98,9 @@ struct TermPrintVisitor
context.auxiliaryBodyLiteralID += function.arguments.size();
}
void visit(const Clingo::AST::Pool &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &)
void visit(const Clingo::AST::Pool &, const Clingo::AST::Literal &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“pool” terms currently unsupported");
throwErrorAtLocation(term.location, "“pool” terms currently unsupported", context);
}
};
@ -108,9 +108,9 @@ struct TermPrintVisitor
struct LiteralPrintVisitor
{
void visit(const Clingo::AST::Boolean &, const Clingo::AST::Literal &literal, Context &)
void visit(const Clingo::AST::Boolean &, const Clingo::AST::Literal &literal, Context &context)
{
throwErrorAtLocation(literal.location, "“boolean” literals currently unsupported in this context");
throwErrorAtLocation(literal.location, "“boolean” literals currently unsupported in this context", context);
}
void visit(const Clingo::AST::Term &term, const Clingo::AST::Literal &literal, Context &context)
@ -164,9 +164,9 @@ struct LiteralPrintVisitor
context.auxiliaryBodyLiteralID += 2;
}
void visit(const Clingo::AST::CSPLiteral &, const Clingo::AST::Literal &literal, Context &)
void visit(const Clingo::AST::CSPLiteral &, const Clingo::AST::Literal &literal, Context &context)
{
throwErrorAtLocation(literal.location, "CSP literals currently unsupported");
throwErrorAtLocation(literal.location, "CSP literals currently unsupported", context);
}
};
@ -179,29 +179,29 @@ struct BodyLiteralPrintVisitor
literal.data.accept(LiteralPrintVisitor(), literal, context);
}
void visit(const Clingo::AST::ConditionalLiteral &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &)
void visit(const Clingo::AST::ConditionalLiteral &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &context)
{
throwErrorAtLocation(bodyLiteral.location, "“conditional literal” body literals currently unsupported");
throwErrorAtLocation(bodyLiteral.location, "“conditional literal” body literals currently unsupported", context);
}
void visit(const Clingo::AST::Aggregate &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &)
void visit(const Clingo::AST::Aggregate &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &context)
{
throwErrorAtLocation(bodyLiteral.location, "“aggregate” body literals currently unsupported");
throwErrorAtLocation(bodyLiteral.location, "“aggregate” body literals currently unsupported", context);
}
void visit(const Clingo::AST::BodyAggregate &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &)
void visit(const Clingo::AST::BodyAggregate &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &context)
{
throwErrorAtLocation(bodyLiteral.location, "“body aggregate” body literals currently unsupported");
throwErrorAtLocation(bodyLiteral.location, "“body aggregate” body literals currently unsupported", context);
}
void visit(const Clingo::AST::TheoryAtom &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &)
void visit(const Clingo::AST::TheoryAtom &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &context)
{
throwErrorAtLocation(bodyLiteral.location, "“theory atom” body literals currently unsupported");
throwErrorAtLocation(bodyLiteral.location, "“theory atom” body literals currently unsupported", context);
}
void visit(const Clingo::AST::Disjoint &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &)
void visit(const Clingo::AST::Disjoint &, const Clingo::AST::BodyLiteral &bodyLiteral, Context &context)
{
throwErrorAtLocation(bodyLiteral.location, "“disjoint” body literals currently unsupported");
throwErrorAtLocation(bodyLiteral.location, "“disjoint” body literals currently unsupported", context);
}
};

View File

@ -1,6 +1,10 @@
#ifndef __ANTHEM__CONTEXT_H
#define __ANTHEM__CONTEXT_H
#include <clingo.hh>
#include <anthem/output/Logger.h>
namespace anthem
{
@ -12,7 +16,10 @@ namespace anthem
struct Context
{
int auxiliaryBodyLiteralID = 0;
output::Logger logger;
std::vector<const Clingo::AST::Term *> headTerms;
size_t auxiliaryBodyLiteralID = 0;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

View File

@ -16,45 +16,45 @@ namespace anthem
struct TermCollectFunctionTermsVisitor
{
void visit(const Clingo::Symbol &symbol, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::Symbol &symbol, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“symbol” terms not allowed, function expected");
throwErrorAtLocation(term.location, "“symbol” terms not allowed, function expected", context);
}
void visit(const Clingo::AST::Variable &, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Variable &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“variable” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“variable” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“unary operation” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“unary operation” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::BinaryOperation &, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::BinaryOperation &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“binary operation” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“binary operation” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::Interval &, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Interval &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“interval” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“interval” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::Function &function, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Function &function, const Clingo::AST::Term &term, Context &context)
{
if (function.external)
throwErrorAtLocation(term.location, "external functions currently unsupported");
throwErrorAtLocation(term.location, "external functions currently unsupported", context);
terms.reserve(terms.size() + function.arguments.size());
context.headTerms.reserve(context.headTerms.size() + function.arguments.size());
for (const auto &argument : function.arguments)
terms.emplace_back(&argument);
context.headTerms.emplace_back(&argument);
}
void visit(const Clingo::AST::Pool &, const Clingo::AST::Term &term, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Pool &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“pool” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“pool” terms currently unsupported, function expected", context);
}
};
@ -62,23 +62,23 @@ struct TermCollectFunctionTermsVisitor
struct LiteralCollectFunctionTermsVisitor
{
void visit(const Clingo::AST::Boolean &, const Clingo::AST::Literal &, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Boolean &, const Clingo::AST::Literal &, Context &context)
{
}
void visit(const Clingo::AST::Term &term, const Clingo::AST::Literal &, std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Term &term, const Clingo::AST::Literal &, Context &context)
{
term.data.accept(TermCollectFunctionTermsVisitor(), term, terms);
term.data.accept(TermCollectFunctionTermsVisitor(), term, context);
}
void visit(const Clingo::AST::Comparison &, const Clingo::AST::Literal &literal, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Comparison &, const Clingo::AST::Literal &literal, Context &context)
{
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals");
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals", context);
}
void visit(const Clingo::AST::CSPLiteral &, const Clingo::AST::Literal &literal, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::CSPLiteral &, const Clingo::AST::Literal &literal, Context &context)
{
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals");
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals", context);
}
};
@ -86,35 +86,35 @@ struct LiteralCollectFunctionTermsVisitor
struct HeadLiteralCollectFunctionTermsVisitor
{
void visit(const Clingo::AST::Literal &literal, const Clingo::AST::HeadLiteral &, std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Literal &literal, const Clingo::AST::HeadLiteral &, Context &context)
{
literal.data.accept(LiteralCollectFunctionTermsVisitor(), literal, terms);
literal.data.accept(LiteralCollectFunctionTermsVisitor(), literal, context);
}
void visit(const Clingo::AST::Disjunction &disjunction, const Clingo::AST::HeadLiteral &headLiteral, std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Disjunction &disjunction, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
for (const auto &conditionLiteral : disjunction.elements)
{
if (!conditionLiteral.condition.empty())
throwErrorAtLocation(headLiteral.location, "conditional head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "conditional head literals currently unsupported", context);
conditionLiteral.literal.data.accept(LiteralCollectFunctionTermsVisitor(), conditionLiteral.literal, terms);
conditionLiteral.literal.data.accept(LiteralCollectFunctionTermsVisitor(), conditionLiteral.literal, context);
}
}
void visit(const Clingo::AST::Aggregate &, const Clingo::AST::HeadLiteral &headLiteral, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Aggregate &, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
throwErrorAtLocation(headLiteral.location, "“aggregate” head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "“aggregate” head literals currently unsupported", context);
}
void visit(const Clingo::AST::HeadAggregate &, const Clingo::AST::HeadLiteral &headLiteral, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::HeadAggregate &, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
throwErrorAtLocation(headLiteral.location, "“head aggregate” head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "“head aggregate” head literals currently unsupported", context);
}
void visit(const Clingo::AST::TheoryAtom &, const Clingo::AST::HeadLiteral &headLiteral, std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::TheoryAtom &, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
throwErrorAtLocation(headLiteral.location, "“theory” head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "“theory” head literals currently unsupported", context);
}
};
@ -122,35 +122,35 @@ struct HeadLiteralCollectFunctionTermsVisitor
struct TermPrintSubstitutedVisitor
{
void visit(const Clingo::Symbol &symbol, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::Symbol &symbol, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“symbol” terms not allowed, function expected");
throwErrorAtLocation(term.location, "“symbol” terms not allowed, function expected", context);
}
void visit(const Clingo::AST::Variable &, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Variable &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“variable” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“variable” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“unary operation” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“unary operation” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::BinaryOperation &, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::BinaryOperation &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“binary operation” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“binary operation” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::Interval &, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Interval &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“interval” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“interval” terms currently unsupported, function expected", context);
}
void visit(const Clingo::AST::Function &function, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Function &function, const Clingo::AST::Term &term, Context &context)
{
if (function.external)
throwErrorAtLocation(term.location, "external functions currently unsupported");
throwErrorAtLocation(term.location, "external functions currently unsupported", context);
std::cout << function.name;
@ -166,19 +166,19 @@ struct TermPrintSubstitutedVisitor
const auto &argument = *i;
const auto matchingTerm = std::find(terms.cbegin(), terms.cend(), &argument);
const auto matchingTerm = std::find(context.headTerms.cbegin(), context.headTerms.cend(), &argument);
assert(matchingTerm != terms.cend());
std::cout << AuxiliaryHeadVariablePrefix << (matchingTerm - terms.cbegin());
std::cout << AuxiliaryHeadVariablePrefix << (matchingTerm - context.headTerms.cbegin());
}
std::cout << ")";
}
void visit(const Clingo::AST::Pool &, const Clingo::AST::Term &term, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Pool &, const Clingo::AST::Term &term, Context &context)
{
throwErrorAtLocation(term.location, "“pool” terms currently unsupported, function expected");
throwErrorAtLocation(term.location, "“pool” terms currently unsupported, function expected", context);
}
};
@ -186,24 +186,24 @@ struct TermPrintSubstitutedVisitor
struct LiteralPrintSubstitutedVisitor
{
void visit(const Clingo::AST::Boolean &boolean, const Clingo::AST::Literal &, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Boolean &boolean, const Clingo::AST::Literal &, Context &context)
{
std::cout << (boolean.value == true ? "true" : "false");
}
void visit(const Clingo::AST::Term &term, const Clingo::AST::Literal &, const std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Term &term, const Clingo::AST::Literal &, Context &context)
{
term.data.accept(TermPrintSubstitutedVisitor(), term, terms);
term.data.accept(TermPrintSubstitutedVisitor(), term, context);
}
void visit(const Clingo::AST::Comparison &, const Clingo::AST::Literal &literal, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Comparison &, const Clingo::AST::Literal &literal, Context &context)
{
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals");
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals", context);
}
void visit(const Clingo::AST::CSPLiteral &, const Clingo::AST::Literal &literal, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::CSPLiteral &, const Clingo::AST::Literal &literal, Context &context)
{
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals");
throwErrorAtLocation(literal.location, "only disjunctions of literals allowed as head literals", context);
}
};
@ -211,45 +211,45 @@ struct LiteralPrintSubstitutedVisitor
struct HeadLiteralPrintSubstitutedVisitor
{
void visit(const Clingo::AST::Literal &literal, const Clingo::AST::HeadLiteral &, const std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Literal &literal, const Clingo::AST::HeadLiteral &, Context &context)
{
if (literal.sign == Clingo::AST::Sign::DoubleNegation)
throwErrorAtLocation(literal.location, "double-negated literals currently unsupported");
throwErrorAtLocation(literal.location, "double-negated literals currently unsupported", context);
else if (literal.sign == Clingo::AST::Sign::Negation)
std::cout << "not ";
literal.data.accept(LiteralPrintSubstitutedVisitor(), literal, terms);
literal.data.accept(LiteralPrintSubstitutedVisitor(), literal, context);
}
void visit(const Clingo::AST::Disjunction &disjunction, const Clingo::AST::HeadLiteral &headLiteral, const std::vector<const Clingo::AST::Term *> &terms)
void visit(const Clingo::AST::Disjunction &disjunction, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
for (auto i = disjunction.elements.cbegin(); i != disjunction.elements.cend(); i++)
{
const auto &conditionLiteral = *i;
if (!conditionLiteral.condition.empty())
throwErrorAtLocation(headLiteral.location, "conditional head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "conditional head literals currently unsupported", context);
if (i != disjunction.elements.cbegin())
std::cout << " or ";
visit(conditionLiteral.literal, headLiteral, terms);
visit(conditionLiteral.literal, headLiteral, context);
}
}
void visit(const Clingo::AST::Aggregate &, const Clingo::AST::HeadLiteral &headLiteral, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::Aggregate &, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
throwErrorAtLocation(headLiteral.location, "“aggregate” head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "“aggregate” head literals currently unsupported", context);
}
void visit(const Clingo::AST::HeadAggregate &, const Clingo::AST::HeadLiteral &headLiteral, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::HeadAggregate &, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
throwErrorAtLocation(headLiteral.location, "“head aggregate” head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "“head aggregate” head literals currently unsupported", context);
}
void visit(const Clingo::AST::TheoryAtom &, const Clingo::AST::HeadLiteral &headLiteral, const std::vector<const Clingo::AST::Term *> &)
void visit(const Clingo::AST::TheoryAtom &, const Clingo::AST::HeadLiteral &headLiteral, Context &context)
{
throwErrorAtLocation(headLiteral.location, "“theory” head literals currently unsupported");
throwErrorAtLocation(headLiteral.location, "“theory” head literals currently unsupported", context);
}
};

View File

@ -14,52 +14,38 @@ namespace anthem
//
////////////////////////////////////////////////////////////////////////////////////////////////////
void throwErrorUnsupportedStatement(const char *statementType, const Clingo::AST::Statement &statement)
{
const auto errorMessage = std::string("") + statementType + "” statements currently unsupported";
throwErrorAtLocation(statement.location, errorMessage.c_str());
throw std::runtime_error(errorMessage);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct StatementVisitor
{
void visit(const Clingo::AST::Program &program, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::Program &program, const Clingo::AST::Statement &statement, Context &context)
{
std::cout << "[program] " << program.name << std::endl;
if (!program.parameters.empty())
throwErrorAtLocation(statement.location, "program parameters currently unsupported");
throwErrorAtLocation(statement.location, "program parameters currently unsupported", context);
}
void visit(const Clingo::AST::Rule &rule, const Clingo::AST::Statement &)
void visit(const Clingo::AST::Rule &rule, const Clingo::AST::Statement &, Context &context)
{
Context context;
// Concatenate all head terms
std::vector<const Clingo::AST::Term *> headTerms;
rule.head.data.accept(HeadLiteralCollectFunctionTermsVisitor(), rule.head, headTerms);
rule.head.data.accept(HeadLiteralCollectFunctionTermsVisitor(), rule.head, context);
// Print auxiliary variables replacing the head atoms arguments
if (!headTerms.empty())
if (!context.headTerms.empty())
{
for (auto i = headTerms.cbegin(); i != headTerms.cend(); i++)
for (auto i = context.headTerms.cbegin(); i != context.headTerms.cend(); i++)
{
const auto &headTerm = **i;
if (i != headTerms.cbegin())
if (i != context.headTerms.cbegin())
std::cout << ", ";
std::cout
<< AuxiliaryHeadVariablePrefix << (i - headTerms.cbegin())
<< AuxiliaryHeadVariablePrefix << (i - context.headTerms.cbegin())
<< " in " << headTerm;
}
}
if (rule.body.empty() && headTerms.empty())
if (rule.body.empty() && context.headTerms.empty())
std::cout << "true";
else
{
@ -68,11 +54,11 @@ struct StatementVisitor
{
const auto &bodyLiteral = *i;
if (!headTerms.empty())
if (!context.headTerms.empty())
std::cout << " and ";
if (bodyLiteral.sign != Clingo::AST::Sign::None)
throwErrorAtLocation(bodyLiteral.location, "only positive literals currently supported");
throwErrorAtLocation(bodyLiteral.location, "only positive literals currently supported", context);
bodyLiteral.data.accept(BodyLiteralPrintVisitor(), bodyLiteral, context);
}
@ -81,62 +67,62 @@ struct StatementVisitor
std::cout << " -> ";
// Print consequent of the implication
rule.head.data.accept(HeadLiteralPrintSubstitutedVisitor(), rule.head, headTerms);
rule.head.data.accept(HeadLiteralPrintSubstitutedVisitor(), rule.head, context);
}
void visit(const Clingo::AST::Definition &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::Definition &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("definition", statement);
throwErrorAtLocation(statement.location, "“definition” statements currently unsupported", context);
}
void visit(const Clingo::AST::ShowSignature &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::ShowSignature &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("show signature", statement);
throwErrorAtLocation(statement.location, "“show signature” statements currently unsupported", context);
}
void visit(const Clingo::AST::ShowTerm &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::ShowTerm &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("show term", statement);
throwErrorAtLocation(statement.location, "“show term” statements currently unsupported", context);
}
void visit(const Clingo::AST::Minimize &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::Minimize &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("minimize", statement);
throwErrorAtLocation(statement.location, "“minimize” statements currently unsupported", context);
}
void visit(const Clingo::AST::Script &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::Script &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("script", statement);
throwErrorAtLocation(statement.location, "“script” statements currently unsupported", context);
}
void visit(const Clingo::AST::External &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::External &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("external", statement);
throwErrorAtLocation(statement.location, "“external” statements currently unsupported", context);
}
void visit(const Clingo::AST::Edge &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::Edge &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("edge", statement);
throwErrorAtLocation(statement.location, "“edge” statements currently unsupported", context);
}
void visit(const Clingo::AST::Heuristic &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::Heuristic &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("heuristic", statement);
throwErrorAtLocation(statement.location, "“heuristic” statements currently unsupported", context);
}
void visit(const Clingo::AST::ProjectAtom &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::ProjectAtom &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("project atom", statement);
throwErrorAtLocation(statement.location, "“project atom” statements currently unsupported", context);
}
void visit(const Clingo::AST::ProjectSignature &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::ProjectSignature &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("project signature", statement);
throwErrorAtLocation(statement.location, "“project signature” statements currently unsupported", context);
}
void visit(const Clingo::AST::TheoryDefinition &, const Clingo::AST::Statement &statement)
void visit(const Clingo::AST::TheoryDefinition &, const Clingo::AST::Statement &statement, Context &context)
{
throwErrorUnsupportedStatement("theory definition", statement);
throwErrorAtLocation(statement.location, "“theory definition” statements currently unsupported", context);
}
};

View File

@ -5,6 +5,9 @@
#include <clingo.hh>
#include <anthem/Context.h>
#include <anthem/input/Location.h>
namespace anthem
{
@ -14,13 +17,26 @@ namespace anthem
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline void throwErrorAtLocation(const Clingo::Location &location, const char *errorMessage)
template<class T1, class T2>
T1 location_cast(const T2 &location);
////////////////////////////////////////////////////////////////////////////////////////////////////
template<>
input::Location location_cast(const Clingo::Location &location)
{
std::cerr
<< location.begin_file() << ":"
<< location.begin_line() << ":" << location.begin_column()
<< ": error: "
<< errorMessage << std::endl;
return {location.begin_file(), location.end_file(), location.begin_line(), location.end_line(),
location.begin_column(), location.end_column()};
}
////////////////////////////////////////////////////////////////////////////////////////////////////
inline void throwErrorAtLocation(const Clingo::Location &clingoLocation, const char *errorMessage,
Context &context)
{
const auto location = location_cast<input::Location>(clingoLocation);
context.logger.log(output::Priority::Error, location, errorMessage);
throw std::runtime_error(errorMessage);
}

View File

@ -1,6 +1,8 @@
#ifndef __ANTHEM__OUTPUT__LOCATION_H
#define __ANTHEM__OUTPUT__LOCATION_H
#include <cstdlib>
namespace anthem
{
namespace input
@ -17,11 +19,11 @@ struct Location
const char *sectionStart = nullptr;
const char *sectionEnd = nullptr;
int rowStart = -1;
int rowEnd = -1;
std::size_t rowStart = -1;
std::size_t rowEnd = -1;
int columnStart = -1;
int columnEnd = -1;
std::size_t columnStart = -1;
std::size_t columnEnd = -1;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

View File

@ -6,6 +6,7 @@
#include <clingo.hh>
#include <anthem/Context.h>
#include <anthem/StatementVisitor.h>
namespace anthem
@ -35,10 +36,12 @@ void translate(const char *fileName, std::istream &stream)
auto fileContent = std::string(std::istreambuf_iterator<char>(stream), {});
Context context;
const auto translateStatement =
[](const Clingo::AST::Statement &statement)
[&context](const Clingo::AST::Statement &statement)
{
statement.data.accept(StatementVisitor(), statement);
statement.data.accept(StatementVisitor(), statement, context);
std::cout << std::endl;
};