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

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

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/anthem/Body.h
View File

@ -17,35 +17,35 @@ namespace anthem
struct TermPrintVisitor 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) 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) 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()) if (function.arguments.empty())
{ {
@ -98,9 +98,9 @@ struct TermPrintVisitor
context.auxiliaryBodyLiteralID += function.arguments.size(); 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 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) void visit(const Clingo::AST::Term &term, const Clingo::AST::Literal &literal, Context &context)
@ -164,9 +164,9 @@ struct LiteralPrintVisitor
context.auxiliaryBodyLiteralID += 2; 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); 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);
} }
}; };

9
include/anthem/Context.h
View File

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

138
include/anthem/Head.h
View File

@ -16,45 +16,45 @@ namespace anthem
struct TermCollectFunctionTermsVisitor 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) 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) 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 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 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) for (const auto &conditionLiteral : disjunction.elements)
{ {
if (!conditionLiteral.condition.empty()) 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 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) if (function.external)
throwErrorAtLocation(term.location, "external functions currently unsupported"); throwErrorAtLocation(term.location, "external functions currently unsupported", context);
std::cout << function.name; std::cout << function.name;
@ -166,19 +166,19 @@ struct TermPrintSubstitutedVisitor
const auto &argument = *i; 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()); assert(matchingTerm != terms.cend());
std::cout << AuxiliaryHeadVariablePrefix << (matchingTerm - terms.cbegin()); std::cout << AuxiliaryHeadVariablePrefix << (matchingTerm - context.headTerms.cbegin());
} }
std::cout << ")"; 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 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"); 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 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) 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) else if (literal.sign == Clingo::AST::Sign::Negation)
std::cout << "not "; 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++) for (auto i = disjunction.elements.cbegin(); i != disjunction.elements.cend(); i++)
{ {
const auto &conditionLiteral = *i; const auto &conditionLiteral = *i;
if (!conditionLiteral.condition.empty()) 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()) if (i != disjunction.elements.cbegin())
std::cout << " or "; 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);
} }
}; };

82
include/anthem/StatementVisitor.h
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 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; std::cout << "[program] " << program.name << std::endl;
if (!program.parameters.empty()) 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 // Concatenate all head terms
std::vector<const Clingo::AST::Term *> headTerms; rule.head.data.accept(HeadLiteralCollectFunctionTermsVisitor(), rule.head, context);
rule.head.data.accept(HeadLiteralCollectFunctionTermsVisitor(), rule.head, headTerms);
// Print auxiliary variables replacing the head atom’s arguments // Print auxiliary variables replacing the head atom’s 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; const auto &headTerm = **i;
if (i != headTerms.cbegin()) if (i != context.headTerms.cbegin())
std::cout << ", "; std::cout << ", ";
std::cout std::cout
<< AuxiliaryHeadVariablePrefix << (i - headTerms.cbegin()) << AuxiliaryHeadVariablePrefix << (i - context.headTerms.cbegin())
<< " in " << headTerm; << " in " << headTerm;
} }
} }
if (rule.body.empty() && headTerms.empty()) if (rule.body.empty() && context.headTerms.empty())
std::cout << "true"; std::cout << "true";
else else
{ {
@ -68,11 +54,11 @@ struct StatementVisitor
{ {
const auto &bodyLiteral = *i; const auto &bodyLiteral = *i;
if (!headTerms.empty()) if (!context.headTerms.empty())
std::cout << " and "; std::cout << " and ";
if (bodyLiteral.sign != Clingo::AST::Sign::None) 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); bodyLiteral.data.accept(BodyLiteralPrintVisitor(), bodyLiteral, context);
} }
@ -81,62 +67,62 @@ struct StatementVisitor
std::cout << " -> "; std::cout << " -> ";
// Print consequent of the implication // 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);
} }
}; };

28
include/anthem/Utils.h
View File

@ -5,6 +5,9 @@
#include <clingo.hh> #include <clingo.hh>
#include <anthem/Context.h>
#include <anthem/input/Location.h>
namespace anthem 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 return {location.begin_file(), location.end_file(), location.begin_line(), location.end_line(),
<< location.begin_file() << ":" location.begin_column(), location.end_column()};
<< location.begin_line() << ":" << location.begin_column() }
<< ": error: "
<< errorMessage << std::endl; ////////////////////////////////////////////////////////////////////////////////////////////////////
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); throw std::runtime_error(errorMessage);
} }

10
include/anthem/input/Location.h
View File

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

7
src/anthem/Translation.cpp
View File

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