patrick/plasp
Archived
1
0
Fork 0
Code Issues 12 Releases 8 Activity

Refactoring to use cleaner output implementation.

Browse Source
This commit is contained in:
Patrick Lühne 2016-11-29 06:03:05 +01:00
parent 9b49b8ebe7
commit c4e19dddae
Signed by: patrick
GPG Key ID: 05F3611E97A70ABF
77 changed files with 1661 additions and 1467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
app/main.cpp
View File

@ -5,12 +5,12 @@
#include <boost/program_options.hpp>
#include <plasp/LanguageDetection.h>
#include <plasp/output/ColorStream.h>
#include <plasp/output/TranslatorException.h>
#include <plasp/pddl/Description.h>
#include <plasp/pddl/TranslatorASP.h>
#include <plasp/sas/Description.h>
#include <plasp/sas/TranslatorASP.h>
#include <plasp/utils/LogStream.h>
#include <plasp/utils/TranslatorException.h>
int main(int argc, char **argv)
{
@ -39,7 +39,7 @@ int main(int argc, char **argv)
std::cout << description;
};
plasp::utils::Logger logger;
plasp::output::Logger logger;
try
{
@ -52,7 +52,7 @@ int main(int argc, char **argv)
}
catch (const po::error &e)
{
logger.logError(e.what());
logger.log(plasp::output::Priority::Error, e.what());
std::cout << std::endl;
printHelp();
return EXIT_FAILURE;
@ -72,31 +72,32 @@ int main(int argc, char **argv)
const auto warningLevel = variablesMap["warning-level"].as<std::string>();
if (warningLevel == "error")
logger.setWarningLevel(plasp::utils::Logger::WarningLevel::Error);
// TODO: reimplement
/*if (warningLevel == "error")
logger.setWarningLevel(plasp::output::Logger::WarningLevel::Error);
else if (warningLevel == "ignore")
logger.setWarningLevel(plasp::utils::Logger::WarningLevel::Ignore);
logger.setWarningLevel(plasp::output::Logger::WarningLevel::Ignore);
else if (warningLevel == "show")
logger.setWarningLevel(plasp::utils::Logger::WarningLevel::Show);
logger.setWarningLevel(plasp::output::Logger::WarningLevel::Show);
else
{
logger.logError("unknown warning level “" + warningLevel + "”");
logger.log(plasp::output::Priority::Error, "unknown warning level “" + warningLevel + "”");
std::cout << std::endl;
printHelp();
return EXIT_FAILURE;
}
}*/
const auto colorPolicy = variablesMap["color"].as<std::string>();
if (colorPolicy == "auto")
logger.setColorPolicy(plasp::utils::LogStream::ColorPolicy::Auto);
logger.setColorPolicy(plasp::output::ColorStream::ColorPolicy::Auto);
else if (colorPolicy == "never")
logger.setColorPolicy(plasp::utils::LogStream::ColorPolicy::Never);
logger.setColorPolicy(plasp::output::ColorStream::ColorPolicy::Never);
else if (colorPolicy == "always")
logger.setColorPolicy(plasp::utils::LogStream::ColorPolicy::Always);
logger.setColorPolicy(plasp::output::ColorStream::ColorPolicy::Always);
else
{
logger.logError("unknown color policy “" + colorPolicy + "”");
logger.log(plasp::output::Priority::Error, "unknown color policy “" + colorPolicy + "”");
std::cout << std::endl;
printHelp();
return EXIT_FAILURE;
@ -104,7 +105,7 @@ int main(int argc, char **argv)
try
{
plasp::utils::Parser<plasp::utils::CaseInsensitiveParserPolicy> parser;
plasp::input::Parser<plasp::input::CaseInsensitiveParserPolicy> parser;
if (variablesMap.count("input"))
{
@ -135,7 +136,7 @@ int main(int argc, char **argv)
if (language == plasp::Language::Type::Unknown)
{
logger.logError("unknown input language");
logger.log(plasp::output::Priority::Error, "unknown input language");
std::cout << std::endl;
printHelp();
return EXIT_FAILURE;
@ -143,10 +144,9 @@ int main(int argc, char **argv)
if (language == plasp::Language::Type::PDDL)
{
auto pddlLogger = logger;
auto context = plasp::pddl::Context(std::move(parser), std::move(pddlLogger));
auto description = plasp::pddl::Description::fromContext(std::move(context));
const auto translator = plasp::pddl::TranslatorASP(description, description.context().logger.outputStream());
auto context = plasp::pddl::Context(std::move(parser), logger);
auto description = plasp::pddl::Description::fromContext(context);
const auto translator = plasp::pddl::TranslatorASP(description, logger.outputStream());
translator.translate();
}
else if (language == plasp::Language::Type::SAS)
@ -156,19 +156,19 @@ int main(int argc, char **argv)
translator.translate();
}
}
catch (const plasp::utils::ParserException &e)
catch (const plasp::input::ParserException &e)
{
logger.logError(e.coordinate(), e.message());
logger.log(plasp::output::Priority::Error, e.location(), e.message().c_str());
return EXIT_FAILURE;
}
catch (const plasp::utils::TranslatorException &e)
catch (const plasp::output::TranslatorException &e)
{
logger.logError(e.what());
logger.log(plasp::output::Priority::Error, e.what());
return EXIT_FAILURE;
}
catch (const std::exception &e)
{
logger.logError(e.what());
logger.log(plasp::output::Priority::Error, e.what());
return EXIT_FAILURE;
}

2
include/plasp/Language.h
View File

@ -1,7 +1,7 @@
#ifndef __PLASP__LANGUAGE_H
#define __PLASP__LANGUAGE_H
#include <plasp/utils/Parser.h>
#include <string>
namespace plasp
{

4
include/plasp/LanguageDetection.h
View File

@ -2,7 +2,7 @@
#define __PLASP__LANGUAGE_DETECTION_H
#include <plasp/Language.h>
#include <plasp/utils/Parser.h>
#include <plasp/input/Parser.h>
namespace plasp
{
@ -13,7 +13,7 @@ namespace plasp
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Language::Type detectLanguage(utils::Parser<utils::CaseInsensitiveParserPolicy> &parser)
Language::Type detectLanguage(input::Parser<input::CaseInsensitiveParserPolicy> &parser)
{
parser.skipWhiteSpace();

23
include/plasp/utils/StreamCoordinate.h → include/plasp/input/Location.h
View File

@ -1,24 +1,29 @@
#ifndef __PLASP__UTILS__STREAM_COORDINATE_H
#define __PLASP__UTILS__STREAM_COORDINATE_H
#ifndef __PLASP__INPUT__LOCATION_H
#define __PLASP__INPUT__LOCATION_H
#include <string>
#include <cstdlib>
namespace plasp
{
namespace utils
namespace input
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// StreamCoordinate
// Location
//
////////////////////////////////////////////////////////////////////////////////////////////////////
struct StreamCoordinate
struct Location
{
std::string sectionName;
size_t row;
size_t column;
const char *sectionStart = nullptr;
const char *sectionEnd = nullptr;
std::size_t rowStart = -1;
std::size_t rowEnd = -1;
std::size_t columnStart = -1;
std::size_t columnEnd = -1;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

23
include/plasp/utils/Parser.h → include/plasp/input/Parser.h
View File

@ -1,5 +1,5 @@
#ifndef __PLASP__UTILS__PARSER_H
#define __PLASP__UTILS__PARSER_H
#ifndef __PLASP__INPUT__PARSER_H
#define __PLASP__INPUT__PARSER_H
#include <iostream>
#include <iterator>
@ -8,14 +8,13 @@
#include <boost/filesystem.hpp>
#include <plasp/utils/ParserException.h>
#include <plasp/utils/ParserPolicy.h>
#include <plasp/utils/Stream.h>
#include <plasp/utils/StreamCoordinate.h>
#include <plasp/input/ParserException.h>
#include <plasp/input/ParserPolicy.h>
#include <plasp/input/Stream.h>
namespace plasp
{
namespace utils
namespace input
{
template<typename Type>
@ -30,7 +29,7 @@ struct Tag
////////////////////////////////////////////////////////////////////////////////////////////////////
template<class ParserPolicy = CaseSensitiveParserPolicy>
class Parser: public Stream, public ParserPolicy
class Parser: public input::Stream, public ParserPolicy
{
template<class OtherParserPolicy>
friend class Parser;
@ -199,7 +198,7 @@ void Parser<ParserPolicy>::expect(const Type &expectedValue)
std::stringstream message;
message << "unexpected value, expected “" << expectedValue << "”";
throw ParserException(coordinate(), message.str());
throw ParserException(location(), message.str());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -402,7 +401,7 @@ uint64_t Parser<ParserPolicy>::parseIntegerBody()
check();
if (!std::isdigit(currentCharacter()))
throw ParserException(coordinate(), "could not parse integer value");
throw ParserException(location(), "could not parse integer value");
uint64_t value = 0;
@ -444,7 +443,7 @@ uint64_t Parser<ParserPolicy>::parseImpl(Tag<uint64_t>)
skipWhiteSpace();
if (currentCharacter() == '-')
throw ParserException(coordinate(), "expected unsigned integer, got signed one");
throw ParserException(location(), "expected unsigned integer, got signed one");
return parseIntegerBody();
}
@ -478,7 +477,7 @@ bool Parser<ParserPolicy>::parseImpl(Tag<bool>)
if (testAndSkip<char>('1'))
return true;
throw ParserException(coordinate(), "could not parse Boolean value");
throw ParserException(location(), "could not parse Boolean value");
}
////////////////////////////////////////////////////////////////////////////////////////////////////

72
include/plasp/input/ParserException.h Normal file
View File

@ -0,0 +1,72 @@
#ifndef __PLASP__INPUT__PARSER_EXCEPTION_H
#define __PLASP__INPUT__PARSER_EXCEPTION_H
#include <exception>
#include <string>
#include <plasp/input/Location.h>
namespace plasp
{
namespace input
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ParserException
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class ParserException: public std::exception
{
public:
explicit ParserException(const input::Location &location)
: ParserException(location, "unspecified parser error")
{
}
explicit ParserException(const input::Location &location, const char *message)
: ParserException(location, static_cast<std::string>(message))
{
}
explicit ParserException(const input::Location &location, const std::string &message)
: m_location{location},
m_message{message},
// TODO: refactor
m_plainMessage{std::string(m_location.sectionStart) + ":" + std::to_string(m_location.rowStart)
+ ":" + std::to_string(m_location.columnStart) + " " + m_message}
{
}
~ParserException() throw()
{
}
const char *what() const throw()
{
return m_plainMessage.c_str();
}
const input::Location &location() const
{
return m_location;
}
const std::string &message() const
{
return m_message;
}
private:
input::Location m_location;
std::string m_message;
std::string m_plainMessage;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

6
include/plasp/utils/ParserPolicy.h → include/plasp/input/ParserPolicy.h
View File

@ -1,11 +1,11 @@
#ifndef __PLASP__UTILS__PARSER_POLICY_H
#define __PLASP__UTILS__PARSER_POLICY_H
#ifndef __PLASP__INPUT__PARSER_POLICY_H
#define __PLASP__INPUT__PARSER_POLICY_H
#include <iostream>
namespace plasp
{
namespace utils
namespace input
{
////////////////////////////////////////////////////////////////////////////////////////////////////

11
include/plasp/utils/Stream.h → include/plasp/input/Stream.h
View File

@ -1,5 +1,5 @@
#ifndef __PLASP__UTILS__STREAM_H
#define __PLASP__UTILS__STREAM_H
#ifndef __PLASP__INPUT__STREAM_H
#define __PLASP__INPUT__STREAM_H
#include <iostream>
#include <iterator>
@ -8,12 +8,11 @@
#include <boost/filesystem.hpp>
#include <plasp/utils/ParserException.h>
#include <plasp/utils/StreamCoordinate.h>
#include <plasp/input/Location.h>
namespace plasp
{
namespace utils
namespace input
{
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -62,7 +61,7 @@ class Stream
void reset();
void seek(Position position);
Position position() const;
StreamCoordinate coordinate() const;
Location location() const;
char currentCharacter() const;
void advance();

294
include/plasp/output/ColorStream.h Normal file
View File

@ -0,0 +1,294 @@
#ifndef __PLASP__OUTPUT__COLOR_STREAM_H
#define __PLASP__OUTPUT__COLOR_STREAM_H
#include <iostream>
#include <unistd.h>
namespace plasp
{
namespace output
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ColorStream
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class ColorStream
{
public:
enum class ColorPolicy
{
Never,
Auto,
Always
};
private:
using CharacterType = std::ostream::char_type;
using TraitsType = std::ostream::traits_type;
public:
ColorStream(std::ostream &stream)
: m_stream{stream},
m_colorPolicy{ColorPolicy::Auto}
{
}
void setColorPolicy(ColorPolicy colorPolicy)
{
m_colorPolicy = colorPolicy;
}
bool supportsColor() const
{
if (m_colorPolicy == ColorPolicy::Never)
return false;
if (m_colorPolicy == ColorPolicy::Always)
return true;
if (&m_stream == &std::cout)
return isatty(fileno(stdout));
if (&m_stream == &std::cerr)
return isatty(fileno(stderr));
return false;
}
std::ostream &stream()
{
return m_stream;
}
inline ColorStream &operator<<(short value);
inline ColorStream &operator<<(unsigned short value);
inline ColorStream &operator<<(int value);
inline ColorStream &operator<<(unsigned int value);
inline ColorStream &operator<<(long value);
inline ColorStream &operator<<(unsigned long value);
inline ColorStream &operator<<(long long value);
inline ColorStream &operator<<(unsigned long long value);
inline ColorStream &operator<<(float value);
inline ColorStream &operator<<(double value);
inline ColorStream &operator<<(long double value);
inline ColorStream &operator<<(bool value);
inline ColorStream &operator<<(const void *value);
inline ColorStream &operator<<(const char *value);
inline ColorStream &operator<<(const signed char *value);
inline ColorStream &operator<<(const unsigned char *value);
inline ColorStream &operator<<(std::basic_streambuf<CharacterType, TraitsType> *sb);
inline ColorStream &operator<<(std::ios_base &(*func)(std::ios_base &));
inline ColorStream &operator<<(std::basic_ios<CharacterType, TraitsType> &(*func)(std::basic_ios<CharacterType, TraitsType> &));
inline ColorStream &operator<<(std::basic_ostream<CharacterType, TraitsType> &(*func)(std::basic_ostream<CharacterType, TraitsType> &));
inline ColorStream &operator<<(char value);
inline ColorStream &operator<<(signed char value);
inline ColorStream &operator<<(unsigned char value);
private:
std::ostream &m_stream;
ColorPolicy m_colorPolicy;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(short value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(unsigned short value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(int value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(unsigned int value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(long value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(unsigned long value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(long long value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(unsigned long long value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(float value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(double value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(long double value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(bool value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(const void *value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(const char *value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(const signed char *value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(const unsigned char *value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(std::basic_streambuf<CharacterType, TraitsType>* sb)
{
m_stream << sb;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(std::ios_base &(*func)(std::ios_base &))
{
m_stream << func;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(std::basic_ios<CharacterType, TraitsType> &(*func)(std::basic_ios<CharacterType, TraitsType> &))
{
m_stream << func;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(std::basic_ostream<CharacterType, TraitsType> &(*func)(std::basic_ostream<CharacterType, TraitsType> &))
{
m_stream << func;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
template<class CharacterType, class Traits, class Allocator>
inline ColorStream &operator<<(ColorStream &colorStream, const std::basic_string<CharacterType, Traits, Allocator> &string)
{
colorStream.stream() << string;
return colorStream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(char value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(signed char value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &ColorStream::operator<<(unsigned char value)
{
m_stream << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

267
include/plasp/utils/Formatting.h → include/plasp/output/Formatting.h
View File

@ -1,13 +1,13 @@
#ifndef __PLASP__UTILS__FORMATTING_H
#define __PLASP__UTILS__FORMATTING_H
#ifndef __PLASP__OUTPUT__FORMATTING_H
#define __PLASP__OUTPUT__FORMATTING_H
#include <iostream>
#include <plasp/utils/LogStream.h>
#include <plasp/output/ColorStream.h>
namespace plasp
{
namespace utils
namespace output
{
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -18,21 +18,30 @@ namespace utils
enum class Color
{
Black = 0,
Red = 1,
Green = 2,
Yellow = 3,
Blue = 4,
Magenta = 5,
Cyan = 6,
White = 7
Default = 39,
Black = 30,
Red = 31,
Green = 32,
Yellow = 33,
Blue = 34,
Magenta = 35,
Cyan = 36,
LightGray = 37,
DarkGray = 90,
LightRed = 91,
LightGreen = 92,
LightYellow = 93,
LightBlue = 94,
LightMagenta = 95,
LightCyan = 96,
White = 97
};
////////////////////////////////////////////////////////////////////////////////////////////////////
enum class FontWeight
{
Normal = 0,
Normal = 21,
Bold = 1
};
@ -40,25 +49,19 @@ enum class FontWeight
struct Format
{
Format(Color color, FontWeight fontWeight = FontWeight::Normal)
: m_color{color},
m_fontWeight{fontWeight}
{
}
Color m_color;
FontWeight m_fontWeight;
Color color = Color::Default;
FontWeight fontWeight = FontWeight::Normal;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Format &format)
inline ColorStream &operator<<(ColorStream &stream, const Format &format)
{
if (!stream.supportsColor())
return stream;
const auto fontWeightCode = static_cast<size_t>(format.m_fontWeight);
const auto colorCode = 30 + static_cast<size_t>(format.m_color);
const auto fontWeightCode = static_cast<int>(format.fontWeight);
const auto colorCode = static_cast<int>(format.color);
return (stream << "\033[" << fontWeightCode << ";" << colorCode << "m");
}
@ -71,7 +74,7 @@ struct ResetFormat
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const ResetFormat &)
inline ColorStream &operator<<(ColorStream &stream, const ResetFormat &)
{
if (!stream.supportsColor())
return stream;
@ -81,196 +84,224 @@ inline LogStream &operator<<(LogStream &stream, const ResetFormat &)
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Token
struct Function
{
Token(const std::string &name)
: name(name)
Function(const char *name)
: name{name}
{
}
};
const std::string &name;
const char *name;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
struct RuleName: public Token
{
RuleName(const std::string &name)
: Token(name)
{
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const RuleName &keyword)
inline ColorStream &operator<<(ColorStream &stream, const Function &function)
{
return (stream
<< utils::Format(utils::Color::White, utils::FontWeight::Bold)
<< Format({Color::White, FontWeight::Normal})
<< function.name
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Keyword
{
Keyword(const char *name)
: name{name}
{
};
const char *name;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline ColorStream &operator<<(ColorStream &stream, const Keyword &keyword)
{
return (stream
<< Format({Color::Blue, FontWeight::Normal})
<< keyword.name
<< utils::ResetFormat());
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Keyword: public Token
struct Operator
{
Keyword(const std::string &name)
: Token(name)
Operator(const char *name)
: name{name}
{
}
};
const char *name;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Keyword &keyword)
inline ColorStream &operator<<(ColorStream &stream, const Operator &operator_)
{
return (stream
<< utils::Format(utils::Color::Blue, utils::FontWeight::Normal)
<< keyword.name
<< utils::ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Number: public Token
{
Number(const std::string &name)
: Token(name)
{
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Number &number)
{
return (stream
<< utils::Format(utils::Color::Yellow, utils::FontWeight::Normal)
<< number.name
<< utils::ResetFormat());
return (stream << operator_.name);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Variable: public Token
template<typename T>
struct Number
{
Variable(const std::string &name)
: Token(name)
Number(T value)
: value{value}
{
}
};
T value;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Variable &variable)
template<typename T>
inline ColorStream &operator<<(ColorStream &stream, const Number<T> &number)
{
return (stream
<< utils::Format(utils::Color::Green, utils::FontWeight::Bold)
<< Format({Color::Yellow, FontWeight::Normal})
<< number.value
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Variable
{
Variable(const char *name)
: name{name}
{
};
const char *name;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline ColorStream &operator<<(ColorStream &stream, const Variable &variable)
{
return (stream
<< Format({Color::Green, FontWeight::Bold})
<< variable.name
<< utils::ResetFormat());
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct String: public Token
struct String
{
String(const std::string &name)
: Token(name)
String(const char *content)
: content{content}
{
}
};
const char *content;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const String &string)
inline ColorStream &operator<<(ColorStream &stream, const String &string)
{
return (stream
<< utils::Format(utils::Color::Green, utils::FontWeight::Normal)
<< "\"" << string.name << "\""
<< utils::ResetFormat());
<< Format({Color::Green, FontWeight::Normal})
<< "\"" << string.content << "\""
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Boolean: public Token
struct Boolean
{
Boolean(const std::string &name)
: Token(name)
Boolean(const char *value)
: value{value}
{
}
};
const char *value;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Boolean &string)
inline ColorStream &operator<<(ColorStream &stream, const Boolean &boolean)
{
return (stream
<< utils::Format(utils::Color::Red, utils::FontWeight::Normal)
<< string.name
<< utils::ResetFormat());
<< Format({Color::Red, FontWeight::Normal})
<< boolean.value
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Reserved: public Token
struct Reserved
{
Reserved(const std::string &name)
: Token(name)
Reserved(const char *name)
: name{name}
{
}
};
const char *name;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Reserved &string)
inline ColorStream &operator<<(ColorStream &stream, const Reserved &reserved)
{
return (stream
<< utils::Format(utils::Color::White, utils::FontWeight::Normal)
<< string.name
<< utils::ResetFormat());
<< Format({Color::White, FontWeight::Normal})
<< reserved.name
<< ResetFormat());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Heading1: public Token
struct Heading1
{
Heading1(const std::string &name)
: Token(name)
Heading1(const char *content)
: content{content}
{
}
};
const char *content;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Heading1 &heading1)
inline ColorStream &operator<<(ColorStream &stream, const Heading1 &heading1)
{
return (stream
<< utils::Format(utils::Color::Blue, utils::FontWeight::Bold)
<< Format({Color::Blue, FontWeight::Bold})
<< "%---------------------------------------" << std::endl
<< "% " << heading1.name << std::endl
<< "% " << heading1.content << std::endl
<< "%---------------------------------------"
<< utils::ResetFormat()
<< ResetFormat()
<< std::endl);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Heading2: public Token
struct Heading2
{
Heading2(const std::string &name)
: Token(name)
Heading2(const char *content)
: content{content}
{
}
};
const char *content;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline LogStream &operator<<(LogStream &stream, const Heading2 &heading2)
inline ColorStream &operator<<(ColorStream &stream, const Heading2 &heading2)
{
return (stream
<< utils::Format(utils::Color::Blue, utils::FontWeight::Bold)
<< "% " << heading2.name
<< utils::ResetFormat());
<< Format({Color::Blue, FontWeight::Bold})
<< "% " << heading2.content
<< ResetFormat());
}

54
include/plasp/output/Logger.h Normal file
View File

@ -0,0 +1,54 @@
#ifndef __PLASP__OUTPUT__LOGGER_H
#define __PLASP__OUTPUT__LOGGER_H
#include <string>
#include <plasp/input/Location.h>
#include <plasp/output/ColorStream.h>
#include <plasp/output/Priority.h>
namespace plasp
{
namespace output
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Logger
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class Logger
{
public:
explicit Logger();
explicit Logger(ColorStream &&outputStream);
explicit Logger(ColorStream &&outputStream, ColorStream &&errorStream);
Logger(Logger &&other);
Logger &operator=(Logger &&other);
ColorStream &outputStream();
ColorStream &errorStream();
// The level from which on messages should be printed
void setLogPriority(Priority logPriority);
void setColorPolicy(ColorStream::ColorPolicy colorPolicy);
void log(Priority priority, const char *message);
void log(Priority priority, const std::string &message);
void log(Priority priority, const input::Location &location, const char *message);
void log(Priority priority, const input::Location &location, const std::string &message);
private:
ColorStream m_outputStream;
ColorStream m_errorStream;
Priority m_logPriority;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

66
include/plasp/output/Priority.h Normal file
View File

@ -0,0 +1,66 @@
#ifndef __PLASP__OUTPUT__PRIORITY_H
#define __PLASP__OUTPUT__PRIORITY_H
#include <cstring>
#include <exception>
namespace plasp
{
namespace output
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Priority
//
////////////////////////////////////////////////////////////////////////////////////////////////////
enum class Priority
{
Debug,
Info,
Warning,
Error
};
////////////////////////////////////////////////////////////////////////////////////////////////////
inline constexpr const char *priorityName(Priority priority)
{
switch (priority)
{
case Priority::Debug:
return "debug";
case Priority::Info:
return "info";
case Priority::Warning:
return "warning";
case Priority::Error:
return "error";
}
return "unknown";
}
////////////////////////////////////////////////////////////////////////////////////////////////////
inline Priority priorityFromName(const char *priorityName)
{
if (std::strcmp(priorityName, "debug") == 0)
return Priority::Debug;
if (std::strcmp(priorityName, "info") == 0)
return Priority::Info;
if (std::strcmp(priorityName, "warning") == 0)
return Priority::Warning;
if (std::strcmp(priorityName, "error") == 0)
return Priority::Error;
throw std::runtime_error("unknown log priority");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

6
include/plasp/utils/TranslatorException.h → include/plasp/output/TranslatorException.h
View File

@ -1,12 +1,12 @@
#ifndef __PLASP__UTILS__TRANSLATOR_EXCEPTION_H
#define __PLASP__UTILS__TRANSLATOR_EXCEPTION_H
#ifndef __PLASP__OUTPUT__TRANSLATOR_EXCEPTION_H
#define __PLASP__OUTPUT__TRANSLATOR_EXCEPTION_H
#include <exception>
#include <string>
namespace plasp
{
namespace utils
namespace output
{
////////////////////////////////////////////////////////////////////////////////////////////////////

2
include/plasp/pddl/Action.h
View File

@ -3,9 +3,9 @@
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{

28
include/plasp/pddl/Context.h
View File

@ -5,8 +5,8 @@
#include <unordered_map>
#include <vector>
#include <plasp/output/Logger.h>
#include <plasp/pddl/Parser.h>
#include <plasp/utils/Logger.h>
namespace plasp
{
@ -25,19 +25,9 @@ class Context
Context() = default;
~Context() = default;
explicit Context(Parser &&otherParser)
: parser{std::move(otherParser)}
{
}
explicit Context(utils::Logger &&otherLogger)
: logger{std::move(otherLogger)}
{
}
explicit Context(Parser &&otherParser, utils::Logger &&otherLogger)
explicit Context(Parser &&otherParser, output::Logger &otherLogger)
: parser{std::move(otherParser)},
logger{std::move(otherLogger)}
logger(otherLogger)
{
}
@ -46,17 +36,11 @@ class Context
Context(Context &&other)
: parser(std::move(other.parser)),
logger(std::move(other.logger))
logger(other.logger)
{
}
Context &operator=(Context &&other)
{
parser = std::move(other.parser);
logger = std::move(other.logger);
return *this;
}
Context &operator=(Context &&other) = delete;
constexpr static const char *auxiliaryPrefix()
{
@ -64,7 +48,7 @@ class Context
}
Parser parser;
utils::Logger logger;
output::Logger &logger;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/plasp/pddl/Description.h
View File

@ -5,7 +5,7 @@
#include <plasp/pddl/Domain.h>
#include <plasp/pddl/Problem.h>
#include <plasp/utils/Parser.h>
#include <plasp/input/Parser.h>
namespace plasp
{
@ -21,10 +21,10 @@ namespace pddl
class Description
{
public:
static Description fromContext(Context &&context);
static Description fromStream(std::istream &istream);
static Description fromFile(const std::string &path);
static Description fromFiles(const std::vector<std::string> &paths);
static Description fromContext(Context &context);
static Description fromStream(std::istream &istream, Context &context);
static Description fromFile(const std::string &path, Context &context);
static Description fromFiles(const std::vector<std::string> &paths, Context &context);
public:
Context &context();
@ -38,18 +38,18 @@ class Description
void normalize();
private:
Description();
Description(Context &context);
void parse();
void findSections();
void checkConsistency();
Context m_context;
Context &m_context;
utils::Stream::Position m_domainPosition;
input::Stream::Position m_domainPosition;
std::unique_ptr<Domain> m_domain;
utils::Stream::Position m_problemPosition;
input::Stream::Position m_problemPosition;
std::unique_ptr<Problem> m_problem;
};

10
include/plasp/pddl/Domain.h
View File

@ -71,19 +71,19 @@ class Domain
std::string m_name;
utils::Stream::Position m_requirementsPosition;
input::Stream::Position m_requirementsPosition;
Requirements m_requirements;
utils::Stream::Position m_typesPosition;
input::Stream::Position m_typesPosition;
expressions::PrimitiveTypes m_types;
utils::Stream::Position m_constantsPosition;
input::Stream::Position m_constantsPosition;
expressions::Constants m_constants;
utils::Stream::Position m_predicatesPosition;
input::Stream::Position m_predicatesPosition;
expressions::PredicateDeclarations m_predicates;
std::vector<utils::Stream::Position> m_actionPositions;
std::vector<input::Stream::Position> m_actionPositions;
std::vector<std::unique_ptr<Action>> m_actions;
};

2
include/plasp/pddl/Expression.h
View File

@ -5,7 +5,7 @@
#include <boost/intrusive_ptr.hpp>
#include <plasp/utils/Parser.h>
#include <plasp/input/Parser.h>
namespace plasp
{

4
include/plasp/pddl/Parser.h
View File

@ -1,7 +1,7 @@
#ifndef __PLASP__PDDL__PARSER_H
#define __PLASP__PDDL__PARSER_H
#include <plasp/utils/Parser.h>
#include <plasp/input/Parser.h>
namespace plasp
{
@ -44,7 +44,7 @@ class PDDLParserPolicy
////////////////////////////////////////////////////////////////////////////////////////////////////
using Parser = utils::Parser<PDDLParserPolicy>;
using Parser = input::Parser<PDDLParserPolicy>;
////////////////////////////////////////////////////////////////////////////////////////////////////

10
include/plasp/pddl/Problem.h
View File

@ -64,18 +64,18 @@ class Problem
std::string m_name;
utils::Stream::Position m_domainPosition;
input::Stream::Position m_domainPosition;
utils::Stream::Position m_requirementsPosition;
input::Stream::Position m_requirementsPosition;
Requirements m_requirements;
utils::Stream::Position m_objectsPosition;
input::Stream::Position m_objectsPosition;
expressions::Constants m_objects;
utils::Stream::Position m_initialStatePosition;
input::Stream::Position m_initialStatePosition;
std::unique_ptr<InitialState> m_initialState;
utils::Stream::Position m_goalPosition;
input::Stream::Position m_goalPosition;
ExpressionPointer m_goal;
};

4
include/plasp/pddl/TranslatorASP.h
View File

@ -19,7 +19,7 @@ namespace pddl
class TranslatorASP
{
public:
explicit TranslatorASP(Description &description, utils::LogStream &outputStream);
explicit TranslatorASP(Description &description, output::ColorStream &outputStream);
void translate() const;
@ -40,7 +40,7 @@ class TranslatorASP
void translatePredicate(const expressions::Predicate &predicate) const;
Description &m_description;
utils::LogStream &m_outputStream;
output::ColorStream &m_outputStream;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

2
include/plasp/pddl/expressions/Constant.h
View File

@ -2,8 +2,6 @@
#define __PLASP__PDDL__EXPRESSIONS__CONSTANT_H
#include <plasp/pddl/Expression.h>
#include <plasp/utils/Parser.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{

2
include/plasp/pddl/expressions/NAry.h
View File

@ -75,7 +75,7 @@ boost::intrusive_ptr<Derived> NAry<Derived>::parse(Context &context,
}
if (expression->m_arguments.empty())
context.logger.logWarning(parser.coordinate(), "“" + Derived::Identifier + "” expressions should not be empty");
context.logger.log(output::Priority::Warning, parser.location(), "“" + Derived::Identifier + "” expressions should not be empty");
parser.expect<std::string>(")");

1
include/plasp/pddl/expressions/PrimitiveType.h
View File

@ -3,7 +3,6 @@
#include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/Expression.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{

6
include/plasp/sas/AssignedVariable.h
View File

@ -4,9 +4,9 @@
#include <iosfwd>
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/sas/Value.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -27,8 +27,8 @@ using AssignedVariables = std::vector<AssignedVariable>;
class AssignedVariable
{
public:
static AssignedVariable fromSAS(utils::Parser<> &parser, const Variables &variables);
static AssignedVariable fromSAS(utils::Parser<> &parser, const Variable &variable);
static AssignedVariable fromSAS(input::Parser<> &parser, const Variables &variables);
static AssignedVariable fromSAS(input::Parser<> &parser, const Variable &variable);
public:
explicit AssignedVariable(const Variable &variable, const Value &value);

4
include/plasp/sas/AxiomRule.h
View File

@ -3,9 +3,9 @@
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/sas/AssignedVariable.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -29,7 +29,7 @@ class AxiomRule
using Condition = AssignedVariable;
using Conditions = AssignedVariables;
static AxiomRule fromSAS(utils::Parser<> &parser, const Variables &variables);
static AxiomRule fromSAS(input::Parser<> &parser, const Variables &variables);
public:
const Conditions &conditions() const;

2
include/plasp/sas/Debugging.h
View File

@ -16,7 +16,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
utils::LogStream &operator<<(utils::LogStream &ostream, const Description &description);
output::ColorStream &operator<<(output::ColorStream &ostream, const Description &description);
////////////////////////////////////////////////////////////////////////////////////////////////////

22
include/plasp/sas/Description.h
View File

@ -7,13 +7,13 @@
#include <boost/filesystem/path.hpp>
#include <plasp/input/Parser.h>
#include <plasp/sas/AxiomRule.h>
#include <plasp/sas/Goal.h>
#include <plasp/sas/InitialState.h>
#include <plasp/sas/MutexGroup.h>
#include <plasp/sas/Operator.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -29,7 +29,7 @@ namespace sas
class Description
{
public:
static Description fromParser(utils::Parser<> &&parser);
static Description fromParser(input::Parser<> &&parser);
static Description fromStream(std::istream &istream);
static Description fromFile(const boost::filesystem::path &path);
@ -50,16 +50,16 @@ class Description
private:
Description();
void parseContent(utils::Parser<> &parser);
void parseContent(input::Parser<> &parser);
void parseVersionSection(utils::Parser<> &parser) const;
void parseMetricSection(utils::Parser<> &parser);
void parseVariablesSection(utils::Parser<> &parser);
void parseMutexSection(utils::Parser<> &parser);
void parseInitialStateSection(utils::Parser<> &parser);
void parseGoalSection(utils::Parser<> &parser);
void parseOperatorSection(utils::Parser<> &parser);
void parseAxiomSection(utils::Parser<> &parser);
void parseVersionSection(input::Parser<> &parser) const;
void parseMetricSection(input::Parser<> &parser);
void parseVariablesSection(input::Parser<> &parser);
void parseMutexSection(input::Parser<> &parser);
void parseInitialStateSection(input::Parser<> &parser);
void parseGoalSection(input::Parser<> &parser);
void parseOperatorSection(input::Parser<> &parser);
void parseAxiomSection(input::Parser<> &parser);
bool m_usesActionCosts;

4
include/plasp/sas/Effect.h
View File

@ -3,9 +3,9 @@
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/sas/AssignedVariable.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -29,7 +29,7 @@ class Effect
using Condition = AssignedVariable;
using Conditions = AssignedVariables;
static Effect fromSAS(utils::Parser<> &parser, const Variables &variables, Conditions &preconditions);
static Effect fromSAS(input::Parser<> &parser, const Variables &variables, Conditions &preconditions);
public:
const Conditions &conditions() const;

4
include/plasp/sas/Goal.h
View File

@ -1,8 +1,8 @@
#ifndef __PLASP__SAS__GOAL_H
#define __PLASP__SAS__GOAL_H
#include <plasp/input/Parser.h>
#include <plasp/sas/AssignedVariable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -21,7 +21,7 @@ class Goal
using Fact = AssignedVariable;
using Facts = AssignedVariables;
static Goal fromSAS(utils::Parser<> &parser, const Variables &variables);
static Goal fromSAS(input::Parser<> &parser, const Variables &variables);
public:
const Facts &facts() const;

4
include/plasp/sas/InitialState.h
View File

@ -1,8 +1,8 @@
#ifndef __PLASP__SAS__INITIAL_STATE_H
#define __PLASP__SAS__INITIAL_STATE_H
#include <plasp/input/Parser.h>
#include <plasp/sas/AssignedVariable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -21,7 +21,7 @@ class InitialState
using Fact = AssignedVariable;
using Facts = AssignedVariables;
static InitialState fromSAS(utils::Parser<> &parser, const Variables &variables);
static InitialState fromSAS(input::Parser<> &parser, const Variables &variables);
public:
const Facts &facts() const;

4
include/plasp/sas/MutexGroup.h
View File

@ -3,8 +3,8 @@
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/sas/AssignedVariable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -28,7 +28,7 @@ class MutexGroup
using Fact = AssignedVariable;
using Facts = AssignedVariables;
static MutexGroup fromSAS(utils::Parser<> &parser, const Variables &variables);
static MutexGroup fromSAS(input::Parser<> &parser, const Variables &variables);
public:
const Facts &facts() const;

8
include/plasp/sas/Operator.h
View File

@ -4,12 +4,12 @@
#include <string>
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/output/ColorStream.h>
#include <plasp/sas/AssignedVariable.h>
#include <plasp/sas/Effect.h>
#include <plasp/sas/Predicate.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/LogStream.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -33,10 +33,10 @@ class Operator
using Condition = AssignedVariable;
using Conditions = AssignedVariables;
static Operator fromSAS(utils::Parser<> &parser, const Variables &variables);
static Operator fromSAS(input::Parser<> &parser, const Variables &variables);
public:
void printPredicateAsASP(utils::LogStream &ostream) const;
void printPredicateAsASP(output::ColorStream &stream) const;
const Predicate &predicate() const;
const Conditions &preconditions() const;

10
include/plasp/sas/Predicate.h
View File

@ -5,8 +5,8 @@
#include <string>
#include <vector>
#include <plasp/utils/LogStream.h>
#include <plasp/utils/Parser.h>
#include <plasp/input/Parser.h>
#include <plasp/output/ColorStream.h>
namespace plasp
{
@ -22,13 +22,13 @@ namespace sas
class Predicate
{
public:
static Predicate fromSAS(utils::Parser<> &parser);
static Predicate fromSAS(input::Parser<> &parser);
using Arguments = std::vector<std::string>;
public:
void printAsSAS(utils::LogStream &outputStream) const;
void printAsASP(utils::LogStream &outputStream) const;
void printAsSAS(output::ColorStream &stream) const;
void printAsASP(output::ColorStream &stream) const;
const std::string &name() const;
const Arguments &arguments() const;

6
include/plasp/sas/TranslatorASP.h
View File

@ -1,8 +1,8 @@
#ifndef __PLASP__SAS__TRANSLATOR_ASP_H
#define __PLASP__SAS__TRANSLATOR_ASP_H
#include <plasp/output/ColorStream.h>
#include <plasp/sas/Description.h>
#include <plasp/utils/LogStream.h>
#include <iosfwd>
@ -20,7 +20,7 @@ namespace sas
class TranslatorASP
{
public:
explicit TranslatorASP(const Description &description, utils::LogStream &outputStream);
explicit TranslatorASP(const Description &description, output::ColorStream &outputStream);
void translate() const;
@ -34,7 +34,7 @@ class TranslatorASP
void translateAxiomRules() const;
const Description &m_description;
utils::LogStream &m_outputStream;
output::ColorStream &m_outputStream;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

12
include/plasp/sas/Value.h
View File

@ -5,8 +5,8 @@
#include <string>
#include <vector>
#include <plasp/utils/LogStream.h>
#include <plasp/utils/Parser.h>
#include <plasp/input/Parser.h>
#include <plasp/output/ColorStream.h>
namespace plasp
{
@ -39,14 +39,14 @@ struct Value
static const Value Any;
static const Value None;
static Value fromSAS(utils::Parser<> &parser);
static const Value &referenceFromSAS(utils::Parser<> &parser, const Variable &variable);
static Value fromSAS(input::Parser<> &parser);
static const Value &referenceFromSAS(input::Parser<> &parser, const Variable &variable);
public:
Value negated() const;
void printAsSAS(utils::LogStream &outputStream) const;
void printAsASPPredicate(utils::LogStream &outputStream) const;
void printAsSAS(output::ColorStream &stream) const;
void printAsASPPredicate(output::ColorStream &stream) const;
Sign sign() const;
const std::string &name() const;

10
include/plasp/sas/Variable.h
View File

@ -5,9 +5,9 @@
#include <string>
#include <vector>
#include <plasp/input/Parser.h>
#include <plasp/output/ColorStream.h>
#include <plasp/sas/Value.h>
#include <plasp/utils/LogStream.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -28,11 +28,11 @@ using Variables = std::vector<Variable>;
class Variable
{
public:
static Variable fromSAS(utils::Parser<> &parser);
static const Variable &referenceFromSAS(utils::Parser<> &parser, const Variables &variables);
static Variable fromSAS(input::Parser<> &parser);
static const Variable &referenceFromSAS(input::Parser<> &parser, const Variables &variables);
public:
void printNameAsASPPredicate(utils::LogStream &outputStream) const;
void printNameAsASPPredicate(output::ColorStream &outputStream) const;
const std::string &name() const;
int axiomLayer() const;

4
include/plasp/sas/VariableTransition.h
View File

@ -3,9 +3,9 @@
#include <iosfwd>
#include <plasp/input/Parser.h>
#include <plasp/sas/Value.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@ -26,7 +26,7 @@ using VariableTransitions = std::vector<VariableTransition>;
class VariableTransition
{
public:
static VariableTransition fromSAS(utils::Parser<> &parser, const Variables &variables);
static VariableTransition fromSAS(input::Parser<> &parser, const Variables &variables);
public:
const Variable &variable() const;

335
include/plasp/utils/LogStream.h
View File

@ -1,335 +0,0 @@
#ifndef __PLASP__UTILS__LOG_STREAM_H
#define __PLASP__UTILS__LOG_STREAM_H
#include <iostream>
#include <unistd.h>
namespace plasp
{
namespace utils
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// LogStream
//
////////////////////////////////////////////////////////////////////////////////////////////////////
enum class StandardStream
{
Out,
Err
};
////////////////////////////////////////////////////////////////////////////////////////////////////
class LogStream
{
public:
enum class ColorPolicy
{
Never,
Auto,
Always
};
private:
using CharacterType = std::ostream::char_type;
using TraitsType = std::ostream::traits_type;
public:
LogStream(StandardStream standardStream)
: m_standardStream{standardStream},
m_colorPolicy{ColorPolicy::Auto}
{
}
LogStream(const LogStream &other)
: m_standardStream{other.m_standardStream},
m_colorPolicy{other.m_colorPolicy}
{
}
LogStream &operator=(const LogStream &other)
{
m_standardStream = other.m_standardStream;
m_colorPolicy = other.m_colorPolicy;
return *this;
}
LogStream(LogStream &&other)
: m_standardStream{other.m_standardStream},
m_colorPolicy{other.m_colorPolicy}
{
other.m_colorPolicy = ColorPolicy::Auto;
}
LogStream &operator=(LogStream &&other)
{
m_standardStream = other.m_standardStream;
m_colorPolicy = other.m_colorPolicy;
other.m_colorPolicy = ColorPolicy::Auto;
return *this;
}
void setColorPolicy(ColorPolicy colorPolicy)
{
m_colorPolicy = colorPolicy;
}
bool supportsColor() const
{
if (m_colorPolicy == ColorPolicy::Never)
return false;
if (m_colorPolicy == ColorPolicy::Always)
return true;
// Autodetect by checking whether output goes to a terminal
const auto fileDescriptor =
(m_standardStream == utils::StandardStream::Out)
? STDOUT_FILENO
: STDERR_FILENO;
return isatty(fileDescriptor);
}
std::ostream &ostream()
{
return (m_standardStream == utils::StandardStream::Out)
? std::cout
: std::cerr;
}
inline LogStream &operator<<(short value);
inline LogStream &operator<<(unsigned short value);
inline LogStream &operator<<(int value);
inline LogStream &operator<<(unsigned int value);
inline LogStream &operator<<(long value);
inline LogStream &operator<<(unsigned long value);
inline LogStream &operator<<(long long value);
inline LogStream &operator<<(unsigned long long value);
inline LogStream &operator<<(float value);
inline LogStream &operator<<(double value);
inline LogStream &operator<<(long double value);
inline LogStream &operator<<(bool value);
inline LogStream &operator<<(const void *value);
inline LogStream &operator<<(const char *value);
inline LogStream &operator<<(const signed char *value);
inline LogStream &operator<<(const unsigned char *value);
inline LogStream &operator<<(std::basic_streambuf<CharacterType, TraitsType> *sb);
inline LogStream &operator<<(std::ios_base &(*func)(std::ios_base &));
inline LogStream &operator<<(std::basic_ios<CharacterType, TraitsType> &(*func)(std::basic_ios<CharacterType, TraitsType> &));
inline LogStream &operator<<(std::basic_ostream<CharacterType, TraitsType> &(*func)(std::basic_ostream<CharacterType, TraitsType> &));
inline LogStream &operator<<(char value);
inline LogStream &operator<<(signed char value);
inline LogStream &operator<<(unsigned char value);
private:
StandardStream m_standardStream;
ColorPolicy m_colorPolicy;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(short value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(unsigned short value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(int value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(unsigned int value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(long value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(unsigned long value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(long long value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(unsigned long long value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(float value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(double value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(long double value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(bool value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(const void *value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(const char *value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(const signed char *value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(const unsigned char *value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(std::basic_streambuf<CharacterType, TraitsType>* sb)
{
ostream() << sb;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(std::ios_base &(*func)(std::ios_base &))
{
ostream() << func;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(std::basic_ios<CharacterType, TraitsType> &(*func)(std::basic_ios<CharacterType, TraitsType> &))
{
ostream() << func;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(std::basic_ostream<CharacterType, TraitsType> &(*func)(std::basic_ostream<CharacterType, TraitsType> &))
{
ostream() << func;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
template<class CharacterType, class Traits, class Allocator>
inline LogStream &operator<<(LogStream &stream, const std::basic_string<CharacterType, Traits, Allocator> &string)
{
stream.ostream() << string;
return stream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(char value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(signed char value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &LogStream::operator<<(unsigned char value)
{
ostream() << value;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

62
include/plasp/utils/Logger.h
View File

@ -1,62 +0,0 @@
#ifndef __PLASP__UTILS__LOGGER_H
#define __PLASP__UTILS__LOGGER_H
#include <string>
#include <plasp/utils/LogStream.h>
#include <plasp/utils/ParserException.h>
#include <plasp/utils/StreamCoordinate.h>
namespace plasp
{
namespace utils
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Logger
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class Logger
{
public:
enum class WarningLevel
{
Show,
Error,
Ignore
};
public:
Logger();
Logger(const Logger &other);
Logger &operator=(const Logger &other);
Logger(Logger &&other);
Logger &operator=(Logger &&other);
LogStream &outputStream();
LogStream &errorStream();
void setWarningLevel(WarningLevel warningLevel);
void setColorPolicy(LogStream::ColorPolicy colorPolicy);
void logError(const std::string &message);
void logError(const StreamCoordinate &coordinate, const std::string &message);
void logWarning(const StreamCoordinate &parserCoordinate, const std::string &message);
private:
LogStream m_outputStream;
LogStream m_errorStream;
WarningLevel m_warningLevel;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

71
include/plasp/utils/ParserException.h
View File

@ -1,71 +0,0 @@
#ifndef __PLASP__UTILS__PARSER_EXCEPTION_H
#define __PLASP__UTILS__PARSER_EXCEPTION_H
#include <exception>
#include <string>
#include <plasp/utils/StreamCoordinate.h>
namespace plasp
{
namespace utils
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ParserException
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class ParserException: public std::exception
{
public:
explicit ParserException(const StreamCoordinate &coordinate)
: ParserException(coordinate, "unspecified parser error")
{
}
explicit ParserException(const StreamCoordinate &coordinate, const char *message)
: ParserException(coordinate, static_cast<std::string>(message))
{
}
explicit ParserException(const StreamCoordinate &coordinate, const std::string &message)
: m_coordinate{coordinate},
m_message{message},
m_plainMessage{m_coordinate.sectionName + ":" + std::to_string(m_coordinate.row)
+ ":" + std::to_string(m_coordinate.column) + " " + m_message}
{
}
~ParserException() throw()
{
}
const char *what() const throw()
{
return m_plainMessage.c_str();
}
const StreamCoordinate &coordinate() const
{
return m_coordinate;
}
const std::string &message() const
{
return m_message;
}
private:
StreamCoordinate m_coordinate;
std::string m_message;
std::string m_plainMessage;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

14
src/CMakeLists.txt
View File

@ -12,8 +12,11 @@ file(GLOB pddl_expressions_headers "../include/plasp/pddl/expressions/*.h")
file(GLOB sas_sources "plasp/sas/*.cpp")
file(GLOB sas_headers "../include/plasp/sas/*.h")
file(GLOB utils_sources "plasp/utils/*.cpp")
file(GLOB utils_headers "../include/plasp/utils/*.h")
file(GLOB input_sources "plasp/input/*.cpp")
file(GLOB input_headers "../include/plasp/input/*.h")
file(GLOB output_sources "plasp/output/*.cpp")
file(GLOB output_headers "../include/plasp/output/*.h")
include_directories(
${Boost_INCLUDE_DIRS}
@ -36,8 +39,11 @@ set(sources
${sas_sources}
${sas_headers}
${utils_sources}
${utils_headers}
${input_sources}
${input_headers}
${output_sources}
${output_headers}
)
set(libraries

16
src/plasp/utils/Stream.cpp → src/plasp/input/Stream.cpp
View File

@ -1,10 +1,12 @@
#include <plasp/utils/Stream.h>
#include <plasp/input/Stream.h>
#include <fstream>
#include <plasp/input/ParserException.h>
namespace plasp
{
namespace utils
namespace input
{
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -77,7 +79,7 @@ typename Stream::Position Stream::position() const
////////////////////////////////////////////////////////////////////////////////////////////////////
StreamCoordinate Stream::coordinate() const
Location Stream::location() const
{
const auto currentPosition = position();
@ -99,7 +101,7 @@ StreamCoordinate Stream::coordinate() const
size_t row = 1;
size_t column = 1;
// Compute the coordinate character by character
// Compute the location character by character
while (true)
{
if (currentPosition == -1 && atEnd())
@ -120,7 +122,7 @@ StreamCoordinate Stream::coordinate() const
m_stream.ignore(1);
}
return {currentFile->sectionName, row, column};
return {currentFile->sectionName.c_str(), currentFile->sectionName.c_str(), row, row, column, column};
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -142,10 +144,10 @@ bool Stream::atEnd() const
void Stream::check() const
{
if (atEnd())
throw ParserException(coordinate(), "reading past end of file");
throw ParserException(location(), "reading past end of file");
if (m_stream.fail())
throw ParserException(coordinate());
throw ParserException(location());
}
////////////////////////////////////////////////////////////////////////////////////////////////////

163
src/plasp/output/Logger.cpp Normal file
View File

@ -0,0 +1,163 @@
#include <plasp/output/Logger.h>
#include <plasp/output/Formatting.h>
namespace plasp
{
namespace output
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Logger
//
////////////////////////////////////////////////////////////////////////////////////////////////////
constexpr Format priorityFormat(Priority priority)
{
switch (priority)
{
case Priority::Debug:
return {Color::Green, FontWeight::Bold};
case Priority::Info:
return {Color::Blue, FontWeight::Bold};
case Priority::Warning:
return {Color::Magenta, FontWeight::Bold};
case Priority::Error:
return {Color::Red, FontWeight::Bold};
}
return {Color::White, FontWeight::Bold};
}
////////////////////////////////////////////////////////////////////////////////////////////////////
constexpr const Format MessageBodyFormat = {Color::White, FontWeight::Bold};
////////////////////////////////////////////////////////////////////////////////////////////////////
constexpr const Format LocationFormat = {Color::White, FontWeight::Bold};
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger()
: Logger(std::cout, std::cerr)
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger(ColorStream &&outputStream)
: Logger(std::forward<ColorStream &&>(outputStream), std::cerr)
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger(ColorStream &&outputStream, ColorStream &&errorStream)
: m_outputStream{outputStream},
m_errorStream{errorStream},
m_logPriority{Priority::Warning}
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger(Logger &&other)
: m_outputStream{std::move(other.m_outputStream)},
m_errorStream{std::move(other.m_errorStream)},
m_logPriority{other.m_logPriority}
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger &Logger::operator=(Logger &&other)
{
*this = std::move(other);
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &Logger::outputStream()
{
return m_outputStream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ColorStream &Logger::errorStream()
{
return m_errorStream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::setLogPriority(Priority logPriority)
{
m_logPriority = logPriority;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::setColorPolicy(ColorStream::ColorPolicy colorPolicy)
{
m_outputStream.setColorPolicy(colorPolicy);
m_errorStream.setColorPolicy(colorPolicy);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::log(Priority priority, const char *message)
{
const auto priorityID = static_cast<int>(priority);
if (priorityID < static_cast<int>(m_logPriority))
return;
m_errorStream
<< priorityFormat(priority) << priorityName(priority) << ":"
<< ResetFormat() << " "
<< MessageBodyFormat << message
<< ResetFormat() << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::log(Priority priority, const std::string &message)
{
log(priority, message.c_str());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::log(Priority priority, const input::Location &location, const char *message)
{
const auto priorityID = static_cast<int>(priority);
if (priorityID < static_cast<int>(m_logPriority))
return;
m_errorStream
<< LocationFormat
<< location.sectionStart << ":" << location.rowStart << ":" << location.columnStart << ":"
<< ResetFormat() << " "
<< priorityFormat(priority) << priorityName(priority) << ":"
<< ResetFormat() << " "
<< MessageBodyFormat << message
<< ResetFormat() << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::log(Priority priority, const input::Location &location, const std::string &message)
{
log(priority, location, message.c_str());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}

32
src/plasp/pddl/Description.cpp
View File

@ -5,8 +5,8 @@
#include <boost/filesystem.hpp>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/IO.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -19,8 +19,9 @@ namespace pddl
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Description::Description()
: m_domainPosition{-1},
Description::Description(Context &context)
: m_context(context),
m_domainPosition{-1},
m_domain{std::make_unique<Domain>(Domain(m_context))},
m_problemPosition{-1}
{
@ -28,11 +29,10 @@ Description::Description()
////////////////////////////////////////////////////////////////////////////////////////////////////
Description Description::fromContext(Context &&context)
Description Description::fromContext(Context &context)
{
Description description;
Description description(context);
description.m_context = std::move(context);
description.parse();
return description;
@ -40,9 +40,9 @@ Description Description::fromContext(Context &&context)
////////////////////////////////////////////////////////////////////////////////////////////////////
Description Description::fromStream(std::istream &istream)
Description Description::fromStream(std::istream &istream, Context &context)
{
Description description;
Description description(context);
description.m_context.parser.read("std::cin", istream);
description.parse();
@ -52,9 +52,9 @@ Description Description::fromStream(std::istream &istream)
////////////////////////////////////////////////////////////////////////////////////////////////////
Description Description::fromFile(const std::string &path)
Description Description::fromFile(const std::string &path, Context &context)
{
Description description;
Description description(context);
description.m_context.parser.read(path);
description.parse();
@ -64,11 +64,13 @@ Description Description::fromFile(const std::string &path)
////////////////////////////////////////////////////////////////////////////////////////////////////
Description Description::fromFiles(const std::vector<std::string> &paths)
Description Description::fromFiles(const std::vector<std::string> &paths, Context &context)
{
BOOST_ASSERT(!paths.empty());
Description description;
// TODO: handle dirty context objects (for instance, reused context objects in unit tests)
Description description(context);
std::for_each(paths.cbegin(), paths.cend(),
[&](const auto &path)
@ -165,7 +167,7 @@ void Description::findSections()
if (parser.testAndSkip<std::string>("domain"))
{
if (m_domainPosition != -1)
throw utils::ParserException(parser.coordinate(), "PDDL description may not contain two domains");
throw input::ParserException(parser.location(), "PDDL description may not contain two domains");
m_domainPosition = position;
@ -175,7 +177,7 @@ void Description::findSections()
else if (m_context.parser.testAndSkip<std::string>("problem"))
{
if (m_problemPosition != -1)
throw utils::ParserException(parser.coordinate(), "PDDL description may currently not contain two problems");
throw input::ParserException(parser.location(), "PDDL description may currently not contain two problems");
m_problem = std::make_unique<Problem>(Problem(m_context, *m_domain));
@ -187,7 +189,7 @@ void Description::findSections()
else
{
const auto sectionIdentifier = parser.parse<std::string>();
throw utils::ParserException(parser.coordinate(), "unknown PDDL section “" + sectionIdentifier + "”");
throw input::ParserException(parser.location(), "unknown PDDL section “" + sectionIdentifier + "”");
}
m_context.parser.skipWhiteSpace();

12
src/plasp/pddl/Domain.cpp
View File

@ -2,13 +2,13 @@
#include <algorithm>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/IO.h>
#include <plasp/pddl/expressions/Constant.h>
#include <plasp/pddl/expressions/PredicateDeclaration.h>
#include <plasp/pddl/expressions/PrimitiveType.h>
#include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -51,7 +51,7 @@ void Domain::findSections()
if (unique && sectionPosition != -1)
{
parser.seek(value);
throw utils::ParserException(parser.coordinate(), "only one “:" + sectionName + "” section allowed");
throw input::ParserException(parser.location(), "only one “:" + sectionName + "” section allowed");
}
sectionPosition = value;
@ -92,7 +92,7 @@ void Domain::findSections()
const auto sectionIdentifier = parser.parseIdentifier();
m_context.logger.logWarning(parser.coordinate(), "section type “" + sectionIdentifier + "” currently unsupported");
m_context.logger.log(output::Priority::Warning, parser.location(), "section type “" + sectionIdentifier + "” currently unsupported");
parser.seek(sectionIdentifierPosition);
}
@ -101,7 +101,7 @@ void Domain::findSections()
const auto sectionIdentifier = parser.parseIdentifier();
parser.seek(position);
throw utils::ParserException(parser.coordinate(), "unknown domain section “" + sectionIdentifier + "”");
throw input::ParserException(parser.location(), "unknown domain section “" + sectionIdentifier + "”");
}
// Skip section for now and parse it later
@ -277,7 +277,7 @@ void Domain::checkRequirement(Requirement::Type requirementType)
if (hasRequirement(requirementType))
return;
m_context.logger.logWarning(m_context.parser.coordinate(), "requirement “" + Requirement(requirementType).toPDDL() + "” used but never declared");
m_context.logger.log(output::Priority::Warning, m_context.parser.location(), "requirement “" + Requirement(requirementType).toPDDL() + "” used but never declared");
m_requirements.push_back(requirementType);
}
@ -340,7 +340,7 @@ void Domain::parseTypeSection()
while (parser.currentCharacter() != ')')
{
if (parser.currentCharacter() == '(')
throw utils::ParserException(parser.coordinate(), "only primitive types are allowed in type section");
throw input::ParserException(parser.location(), "only primitive types are allowed in type section");
expressions::PrimitiveType::parseTypedDeclaration(m_context, *this);

8
src/plasp/pddl/Expression.cpp
View File

@ -1,5 +1,6 @@
#include <plasp/pddl/Expression.h>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Domain.h>
#include <plasp/pddl/ExpressionContext.h>
@ -11,7 +12,6 @@
#include <plasp/pddl/expressions/Predicate.h>
#include <plasp/pddl/expressions/PredicateDeclaration.h>
#include <plasp/pddl/expressions/Unsupported.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -157,7 +157,7 @@ ExpressionPointer parseExpression(Context &context, ExpressionContext &expressio
const auto expressionIdentifier = parser.parseIdentifier();
parser.seek(position);
throw utils::ParserException(parser.coordinate(), "expression type “" + expressionIdentifier + "” unknown or not allowed in this context");
throw input::ParserException(parser.location(), "expression type “" + expressionIdentifier + "” unknown or not allowed in this context");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -229,7 +229,7 @@ ExpressionPointer parseEffectBodyExpression(Context &context, ExpressionContext
const auto expressionIdentifier = parser.parseIdentifier();
parser.seek(position);
throw utils::ParserException(parser.coordinate(), "expression type “" + expressionIdentifier + "” unknown or not allowed in this context");
throw input::ParserException(parser.location(), "expression type “" + expressionIdentifier + "” unknown or not allowed in this context");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -243,7 +243,7 @@ ExpressionPointer parsePredicate(Context &context, ExpressionContext &expression
if ((expression = expressions::Predicate::parse(context, expressionContext)))
return expression;
throw utils::ParserException(parser.coordinate(), "expected predicate");
throw input::ParserException(parser.location(), "expected predicate");
}
////////////////////////////////////////////////////////////////////////////////////////////////////

4
src/plasp/pddl/InitialState.cpp
View File

@ -1,5 +1,6 @@
#include <plasp/pddl/InitialState.h>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/ExpressionContext.h>
#include <plasp/pddl/IO.h>
@ -7,7 +8,6 @@
#include <plasp/pddl/expressions/At.h>
#include <plasp/pddl/expressions/Predicate.h>
#include <plasp/pddl/expressions/Unsupported.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -58,7 +58,7 @@ std::unique_ptr<InitialState> InitialState::parseDeclaration(Context &context,
const auto expressionIdentifier = parser.parseIdentifier();
parser.seek(position);
throw utils::ParserException(parser.coordinate(), "expression type “" + expressionIdentifier + "” unknown or not allowed in this context");
throw input::ParserException(parser.location(), "expression type “" + expressionIdentifier + "” unknown or not allowed in this context");
};
parser.skipWhiteSpace();

12
src/plasp/pddl/Problem.cpp
View File

@ -2,11 +2,11 @@
#include <algorithm>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/Domain.h>
#include <plasp/pddl/ExpressionContext.h>
#include <plasp/pddl/IO.h>
#include <plasp/pddl/expressions/Constant.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -51,7 +51,7 @@ void Problem::findSections()
if (unique && sectionPosition != -1)
{
parser.seek(value);
throw utils::ParserException(parser.coordinate(), "only one “:" + sectionName + "” section allowed");
throw input::ParserException(parser.location(), "only one “:" + sectionName + "” section allowed");
}
sectionPosition = value;
@ -87,7 +87,7 @@ void Problem::findSections()
const auto sectionIdentifier = parser.parseIdentifier();
m_context.logger.logWarning(parser.coordinate(), "section type “" + sectionIdentifier + "” currently unsupported");
m_context.logger.log(output::Priority::Warning, parser.location(), "section type “" + sectionIdentifier + "” currently unsupported");
parser.seek(sectionIdentifierPosition);
}
@ -96,7 +96,7 @@ void Problem::findSections()
const auto sectionIdentifier = parser.parseIdentifier();
parser.seek(position);
throw utils::ParserException(parser.coordinate(), "unknown problem section “" + sectionIdentifier + "”");
throw input::ParserException(parser.location(), "unknown problem section “" + sectionIdentifier + "”");
}
// Skip section for now and parse it later
@ -202,7 +202,7 @@ void Problem::parseDomainSection()
const auto domainName = parser.parseIdentifier();
if (m_domain.name() != domainName)
throw utils::ParserException(parser.coordinate(), "domains do not match (“" + m_domain.name() + "” and “" + domainName + "”)");
throw input::ParserException(parser.location(), "domains do not match (“" + m_domain.name() + "” and “" + domainName + "”)");
parser.expect<std::string>(")");
}
@ -259,7 +259,7 @@ void Problem::checkRequirement(Requirement::Type requirementType)
if (hasRequirement(requirementType))
return;
m_context.logger.logWarning(m_context.parser.coordinate(), "requirement “" + Requirement(requirementType).toPDDL() + "” used but never declared");
m_context.logger.log(output::Priority::Warning, m_context.parser.location(), "requirement “" + Requirement(requirementType).toPDDL() + "” used but never declared");
m_requirements.push_back(requirementType);
}

6
src/plasp/pddl/Requirement.cpp
View File

@ -4,7 +4,7 @@
#include <boost/assign.hpp>
#include <boost/bimap.hpp>
#include <plasp/utils/ParserException.h>
#include <plasp/input/ParserException.h>
namespace plasp
{
@ -89,12 +89,12 @@ Requirement Requirement::parse(Context &context)
const auto match = requirementTypesToPDDL.right.find(requirementName);
if (match == requirementTypesToPDDL.right.end())
throw utils::ParserException(parser.coordinate(), "unknown PDDL requirement “" + requirementName + "”");
throw input::ParserException(parser.location(), "unknown PDDL requirement “" + requirementName + "”");
const auto requirementType = match->second;
if (requirementType == Requirement::Type::GoalUtilities)
context.logger.logWarning(parser.coordinate(), "requirement “goal-utilities” is not part of the PDDL 3.1 specification");
context.logger.log(output::Priority::Warning, parser.location(), "requirement “goal-utilities” is not part of the PDDL 3.1 specification");
return Requirement(match->second);
}

190
src/plasp/pddl/TranslatorASP.cpp
View File

@ -2,11 +2,11 @@
#include <boost/assert.hpp>
#include <plasp/output/Formatting.h>
#include <plasp/output/TranslatorException.h>
#include <plasp/pddl/expressions/And.h>
#include <plasp/pddl/expressions/Not.h>
#include <plasp/pddl/expressions/Predicate.h>
#include <plasp/utils/Formatting.h>
#include <plasp/utils/TranslatorException.h>
namespace plasp
{
@ -19,7 +19,7 @@ namespace pddl
//
////////////////////////////////////////////////////////////////////////////////////////////////////
TranslatorASP::TranslatorASP(Description &description, utils::LogStream &outputStream)
TranslatorASP::TranslatorASP(Description &description, output::ColorStream &outputStream)
: m_description(description),
m_outputStream(outputStream)
{
@ -43,7 +43,7 @@ void TranslatorASP::translate() const
void TranslatorASP::translateDomain() const
{
m_outputStream << utils::Heading1("domain");
m_outputStream << output::Heading1("domain");
const auto &domain = m_description.domain();
@ -77,7 +77,7 @@ void TranslatorASP::translateDomain() const
void TranslatorASP::translateTypes() const
{
m_outputStream << utils::Heading2("types");
m_outputStream << output::Heading2("types");
m_outputStream << std::endl;
@ -86,8 +86,8 @@ void TranslatorASP::translateTypes() const
if (types.empty())
{
m_outputStream
<< utils::RuleName("type") << "("
<< utils::Keyword("type") << "(" << utils::String("object") << "))." << std::endl;
<< output::Function("type") << "("
<< output::Keyword("type") << "(" << output::String("object") << "))." << std::endl;
return;
}
@ -96,9 +96,9 @@ void TranslatorASP::translateTypes() const
[&](const auto &type)
{
m_outputStream
<< utils::RuleName("type") << "("
<< utils::Keyword("type") << "("
<< utils::String(type->name())
<< output::Function("type") << "("
<< output::Keyword("type") << "("
<< output::String(type->name().c_str())
<< "))." << std::endl;
const auto &parentTypes = type->parentTypes();
@ -107,23 +107,23 @@ void TranslatorASP::translateTypes() const
[&](const auto &parentType)
{
m_outputStream
<< utils::RuleName("inherits") << "(" << utils::Keyword("type")
<< "(" << utils::String(type->name()) << "), " << utils::Keyword("type")
<< "(" << utils::String(parentType->name()) << "))." << std::endl;
<< output::Function("inherits") << "(" << output::Keyword("type")
<< "(" << output::String(type->name().c_str()) << "), " << output::Keyword("type")
<< "(" << output::String(parentType->name().c_str()) << "))." << std::endl;
});
});
m_outputStream
<< std::endl
<< utils::RuleName("has") << "("
<< utils::Variable("X") << ", "
<< utils::Keyword("type") << "(" << utils::Variable("T2") << ")) :- "
<< utils::RuleName("has") << "("
<< utils::Variable("X") << ", "
<< utils::Keyword("type") << "(" << utils::Variable("T1") << ")), "
<< utils::RuleName("inherits") << "("
<< utils::Keyword("type") << "(" << utils::Variable("T1") << "), "
<< utils::Keyword("type") << "(" << utils::Variable("T2") << "))."
<< output::Function("has") << "("
<< output::Variable("X") << ", "
<< output::Keyword("type") << "(" << output::Variable("T2") << ")) :- "
<< output::Function("has") << "("
<< output::Variable("X") << ", "
<< output::Keyword("type") << "(" << output::Variable("T1") << ")), "
<< output::Function("inherits") << "("
<< output::Keyword("type") << "(" << output::Variable("T1") << "), "
<< output::Keyword("type") << "(" << output::Variable("T2") << "))."
<< std::endl;
}
@ -131,7 +131,7 @@ void TranslatorASP::translateTypes() const
void TranslatorASP::translatePredicates() const
{
m_outputStream << utils::Heading2("variables");
m_outputStream << output::Heading2("variables");
const auto &predicates = m_description.domain().predicates();
@ -140,12 +140,12 @@ void TranslatorASP::translatePredicates() const
{
if (predicate->arguments().empty())
{
m_outputStream << utils::String(predicate->name());
m_outputStream << output::String(predicate->name().c_str());
return;
}
m_outputStream << "(" << utils::String(predicate->name());
m_outputStream << "(" << output::String(predicate->name().c_str());
this->translateVariablesHead(predicate->arguments());
m_outputStream << ")";
};
@ -155,8 +155,8 @@ void TranslatorASP::translatePredicates() const
{
m_outputStream
<< std::endl
<< utils::RuleName("variable") << "("
<< utils::Keyword("variable") << "(";
<< output::Function("variable") << "("
<< output::Keyword("variable") << "(";
printPredicateName(predicate);
@ -169,14 +169,14 @@ void TranslatorASP::translatePredicates() const
m_outputStream
<< std::endl << std::endl
<< utils::RuleName("boolean") << "(" << utils::Boolean("true") << ")." << std::endl
<< utils::RuleName("boolean") << "(" << utils::Boolean("false") << ")." << std::endl
<< output::Function("boolean") << "(" << output::Boolean("true") << ")." << std::endl
<< output::Function("boolean") << "(" << output::Boolean("false") << ")." << std::endl
<< std::endl
<< utils::RuleName("contains") << "("
<< utils::Keyword("variable") << "(" << utils::Variable("X") << "), "
<< utils::Keyword("value") << "(" << utils::Variable("X") << ", " << utils::Variable("B") << ")) :- "
<< utils::RuleName("variable") << "(" << utils::Keyword("variable") << "(" << utils::Variable("X") << ")), "
<< utils::RuleName("boolean") << "(" << utils::Variable("B") << ")."
<< output::Function("contains") << "("
<< output::Keyword("variable") << "(" << output::Variable("X") << "), "
<< output::Keyword("value") << "(" << output::Variable("X") << ", " << output::Variable("B") << ")) :- "
<< output::Function("variable") << "(" << output::Keyword("variable") << "(" << output::Variable("X") << ")), "
<< output::Function("boolean") << "(" << output::Variable("B") << ")."
<< std::endl;
}
@ -184,23 +184,23 @@ void TranslatorASP::translatePredicates() const
void TranslatorASP::translateActions() const
{
m_outputStream << utils::Heading2("actions");
m_outputStream << output::Heading2("actions");
const auto &actions = m_description.domain().actions();
const auto printActionName =
[&](const auto &action)
{
m_outputStream << utils::Keyword("action") << "(";
m_outputStream << output::Keyword("action") << "(";
if (action.parameters().empty())
{
m_outputStream << utils::String(action.name()) << ")";
m_outputStream << output::String(action.name().c_str()) << ")";
return;
}
m_outputStream << "(" << utils::String(action.name());
m_outputStream << "(" << output::String(action.name().c_str());
this->translateVariablesHead(action.parameters());
m_outputStream << "))";
};
@ -212,19 +212,19 @@ void TranslatorASP::translateActions() const
const auto translateLiteral =
[&](const auto &ruleHead, const auto &literal, bool enumerateEffects = false)
{
m_outputStream << std::endl << utils::RuleName(ruleHead) << "(";
m_outputStream << std::endl << output::Function(ruleHead) << "(";
printActionName(*action);
// TODO: implement conditional effects
if (enumerateEffects)
m_outputStream << ", " << utils::Keyword("effect") << "(" << utils::Reserved("unconditional") << ")";
m_outputStream << ", " << output::Keyword("effect") << "(" << output::Reserved("unconditional") << ")";
m_outputStream << ", ";
this->translateLiteral(literal);
m_outputStream << ") :- " << utils::RuleName("action") << "(";
m_outputStream << ") :- " << output::Function("action") << "(";
printActionName(*action);
@ -234,7 +234,7 @@ void TranslatorASP::translateActions() const
m_outputStream << std::endl;
// Name
m_outputStream << utils::RuleName("action") << "(";
m_outputStream << output::Function("action") << "(";
printActionName(*action);
m_outputStream << ")";
@ -256,7 +256,7 @@ void TranslatorASP::translateActions() const
else
{
if (precondition.expressionType() != Expression::Type::And)
throw utils::TranslatorException("only “and” expressions and (negated) predicates supported as action preconditions currently");
throw output::TranslatorException("only “and” expressions and (negated) predicates supported as action preconditions currently");
const auto &andExpression = dynamic_cast<const expressions::And &>(precondition);
@ -282,7 +282,7 @@ void TranslatorASP::translateActions() const
else
{
if (effect.expressionType() != Expression::Type::And)
throw utils::TranslatorException("only “and” expressions and (negated) predicates supported as action effects currently");
throw output::TranslatorException("only “and” expressions and (negated) predicates supported as action effects currently");
const auto &andExpression = dynamic_cast<const expressions::And &>(effect);
@ -302,30 +302,30 @@ void TranslatorASP::translateActions() const
void TranslatorASP::translateConstants(const std::string &heading, const expressions::Constants &constants) const
{
m_outputStream << utils::Heading2(heading);
m_outputStream << output::Heading2(heading.c_str());
std::for_each(constants.cbegin(), constants.cend(),
[&](const auto &constant)
{
m_outputStream << std::endl
<< utils::RuleName("constant") << "("
<< utils::Keyword("constant") << "("
<< utils::String(constant->name())
<< output::Function("constant") << "("
<< output::Keyword("constant") << "("
<< output::String(constant->name().c_str())
<< "))." << std::endl;
const auto type = constant->type();
if (type != nullptr)
{
m_outputStream << utils::RuleName("has") << "("
<< utils::Keyword("constant") << "(" << utils::String(constant->name()) << "), "
<< utils::Keyword("type") << "(" << utils::String(type->name()) << "))." << std::endl;
m_outputStream << output::Function("has") << "("
<< output::Keyword("constant") << "(" << output::String(constant->name().c_str()) << "), "
<< output::Keyword("type") << "(" << output::String(type->name().c_str()) << "))." << std::endl;
}
else
{
m_outputStream << utils::RuleName("has") << "("
<< utils::Keyword("constant") << "(" << utils::String(constant->name()) << "), "
<< utils::Keyword("type") << "(" << utils::String("object") << "))." << std::endl;
m_outputStream << output::Function("has") << "("
<< output::Keyword("constant") << "(" << output::String(constant->name().c_str()) << "), "
<< output::Keyword("type") << "(" << output::String("object") << "))." << std::endl;
}
});
}
@ -341,7 +341,7 @@ void TranslatorASP::translateVariablesHead(const expressions::Variables &variabl
{
const auto &variable = **i;
m_outputStream << ", " << utils::Variable(variable.name());
m_outputStream << ", " << output::Variable(variable.name().c_str());
}
}
@ -364,19 +364,19 @@ void TranslatorASP::translateVariablesBody(const expressions::Variables &variabl
if (variable.type() != nullptr)
{
if (variable.type()->expressionType() != Expression::Type::PrimitiveType)
throw utils::TranslatorException("only primitive types supported currently");
throw output::TranslatorException("only primitive types supported currently");
const auto &type = dynamic_cast<const expressions::PrimitiveType &>(*variable.type());
m_outputStream << utils::RuleName("has") << "("
<< utils::Variable(variable.name()) << ", "
<< utils::Keyword("type") << "(" << utils::String(type.name()) << "))";
m_outputStream << output::Function("has") << "("
<< output::Variable(variable.name().c_str()) << ", "
<< output::Keyword("type") << "(" << output::String(type.name().c_str()) << "))";
}
else
{
m_outputStream << utils::RuleName("has") << "("
<< utils::Variable(variable.name()) << ", "
<< utils::Keyword("type") << "(" << utils::String("object") << "))";
m_outputStream << output::Function("has") << "("
<< output::Variable(variable.name().c_str()) << ", "
<< output::Keyword("type") << "(" << output::String("object") << "))";
}
}
}
@ -390,11 +390,11 @@ void TranslatorASP::translateLiteral(const Expression &literal) const
{
const auto &predicate = dynamic_cast<const expressions::Predicate &>(literal);
m_outputStream << utils::Keyword("variable") << "(";
m_outputStream << output::Keyword("variable") << "(";
this->translatePredicate(predicate);
m_outputStream << "), " << utils::Keyword("value") << "(";
m_outputStream << "), " << output::Keyword("value") << "(";
this->translatePredicate(predicate);
m_outputStream << ", " << utils::Boolean("true") << ")";
m_outputStream << ", " << output::Boolean("true") << ")";
}
// Assuming that "not" expression may only contain a predicate
else if (literal.expressionType() == Expression::Type::Not)
@ -402,18 +402,18 @@ void TranslatorASP::translateLiteral(const Expression &literal) const
const auto &notExpression = dynamic_cast<const expressions::Not &>(literal);
if (notExpression.argument()->expressionType() != Expression::Type::Predicate)
throw utils::TranslatorException("only negations of primitive predicates supported as literals currently");
throw output::TranslatorException("only negations of primitive predicates supported as literals currently");
const auto &predicate = dynamic_cast<const expressions::Predicate &>(*notExpression.argument());
m_outputStream << utils::Keyword("variable") << "(";
m_outputStream << output::Keyword("variable") << "(";
this->translatePredicate(predicate);
m_outputStream << "), " << utils::Keyword("value") << "(";
m_outputStream << "), " << output::Keyword("value") << "(";
this->translatePredicate(predicate);
m_outputStream << ", " << utils::Boolean("false") << ")";
m_outputStream << ", " << output::Boolean("false") << ")";
}
else
throw utils::TranslatorException("only primitive predicates and their negations supported as literals currently");
throw output::TranslatorException("only primitive predicates and their negations supported as literals currently");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -424,12 +424,12 @@ void TranslatorASP::translatePredicate(const expressions::Predicate &predicate)
if (arguments.empty())
{
m_outputStream << utils::String(predicate.name());
m_outputStream << output::String(predicate.name().c_str());
return;
}
m_outputStream << "(" << utils::String(predicate.name());
m_outputStream << "(" << output::String(predicate.name().c_str());
for (auto i = arguments.cbegin(); i != arguments.cend(); i++)
{
@ -439,16 +439,16 @@ void TranslatorASP::translatePredicate(const expressions::Predicate &predicate)
{
const auto &constant = dynamic_cast<const expressions::Constant &>(**i);
m_outputStream << utils::Keyword("constant") << "(" << utils::String(constant.name()) << ")";
m_outputStream << output::Keyword("constant") << "(" << output::String(constant.name().c_str()) << ")";
}
else if ((*i)->expressionType() == Expression::Type::Variable)
{
const auto &variable = dynamic_cast<const expressions::Variable &>(**i);
m_outputStream << utils::Variable(variable.name());
m_outputStream << output::Variable(variable.name().c_str());
}
else
throw utils::TranslatorException("only variables and constants supported in predicates currently");
throw output::TranslatorException("only variables and constants supported in predicates currently");
}
m_outputStream << ")";
@ -460,7 +460,7 @@ void TranslatorASP::translateProblem() const
{
BOOST_ASSERT(m_description.containsProblem());
m_outputStream << utils::Heading1("problem");
m_outputStream << output::Heading1("problem");
const auto &problem = m_description.problem();
@ -486,25 +486,25 @@ void TranslatorASP::translateInitialState() const
{
BOOST_ASSERT(m_description.containsProblem());
m_outputStream << utils::Heading2("initial state");
m_outputStream << output::Heading2("initial state");
const auto &initialStateFacts = m_description.problem().initialState().facts();
std::for_each(initialStateFacts.cbegin(), initialStateFacts.cend(),
[&](const auto &fact)
{
m_outputStream << std::endl << utils::RuleName("initialState") << "(";
m_outputStream << std::endl << output::Function("initialState") << "(";
// Translate single predicate
if (fact->expressionType() == Expression::Type::Predicate)
{
const auto &predicate = dynamic_cast<const expressions::Predicate &>(*fact);
m_outputStream << utils::Keyword("variable") << "(";
m_outputStream << output::Keyword("variable") << "(";
this->translatePredicate(predicate);
m_outputStream << "), " << utils::Keyword("value") << "(";
m_outputStream << "), " << output::Keyword("value") << "(";
this->translatePredicate(predicate);
m_outputStream << ", " << utils::Boolean("true") << ")";
m_outputStream << ", " << output::Boolean("true") << ")";
}
// Assuming that "not" expression may only contain a predicate
else if (fact->expressionType() == Expression::Type::Not)
@ -512,24 +512,24 @@ void TranslatorASP::translateInitialState() const
const auto &notExpression = dynamic_cast<const expressions::Not &>(*fact);
if (notExpression.argument()->expressionType() != Expression::Type::Predicate)
throw utils::TranslatorException("only negations of simple predicates supported in initial state currently");
throw output::TranslatorException("only negations of simple predicates supported in initial state currently");
}
else
throw utils::TranslatorException("only predicates and their negations supported in initial state currently");
throw output::TranslatorException("only predicates and their negations supported in initial state currently");
m_outputStream << ").";
});
m_outputStream
<< std::endl << std::endl
<< utils::RuleName("initialState") << "("
<< utils::Keyword("variable") << "(" << utils::Variable("X") << "), "
<< utils::Keyword("value") << "(" << utils::Variable("X") << ", " << utils::Boolean("false") << ")) :- "
<< utils::RuleName("variable") << "(" << utils::Keyword("variable") << "(" << utils::Variable("X") << ")), "
<< utils::Keyword("not") << " "
<< utils::RuleName("initialState") << "("
<< utils::Keyword("variable") << "(" << utils::Variable("X") << "), "
<< utils::Keyword("value") << "(" << utils::Variable("X") << ", " << utils::Boolean("true") << "))."
<< output::Function("initialState") << "("
<< output::Keyword("variable") << "(" << output::Variable("X") << "), "
<< output::Keyword("value") << "(" << output::Variable("X") << ", " << output::Boolean("false") << ")) :- "
<< output::Function("variable") << "(" << output::Keyword("variable") << "(" << output::Variable("X") << ")), "
<< output::Keyword("not") << " "
<< output::Function("initialState") << "("
<< output::Keyword("variable") << "(" << output::Variable("X") << "), "
<< output::Keyword("value") << "(" << output::Variable("X") << ", " << output::Boolean("true") << "))."
<< std::endl;
}
@ -539,14 +539,14 @@ void TranslatorASP::translateGoal() const
{
BOOST_ASSERT(m_description.containsProblem());
m_outputStream << utils::Heading2("goal");
m_outputStream << output::Heading2("goal");
const auto &goal = m_description.problem().goal();
if (goal.expressionType() == Expression::Type::Predicate
|| goal.expressionType() == Expression::Type::Not)
{
m_outputStream << std::endl << utils::RuleName("goal") << "(";
m_outputStream << std::endl << output::Function("goal") << "(";
translateLiteral(goal);
@ -559,7 +559,7 @@ void TranslatorASP::translateGoal() const
std::for_each(andExpression.arguments().cbegin(), andExpression.arguments().cend(),
[&](const auto argument)
{
m_outputStream << std::endl << utils::RuleName("goal") << "(";
m_outputStream << std::endl << output::Function("goal") << "(";
this->translateLiteral(*argument);
@ -567,7 +567,7 @@ void TranslatorASP::translateGoal() const
});
}
else
throw utils::TranslatorException("only single predicates, their negations, and conjunctions are currently supported in the goal");
throw output::TranslatorException("only single predicates, their negations, and conjunctions are currently supported in the goal");
m_outputStream << std::endl;
}

4
src/plasp/pddl/expressions/At.cpp
View File

@ -1,6 +1,6 @@
#include <plasp/pddl/expressions/At.h>
#include <plasp/utils/TranslatorException.h>
#include <plasp/output/TranslatorException.h>
namespace plasp
{
@ -38,7 +38,7 @@ ExpressionPointer At::argument() const
ExpressionPointer At::reduced()
{
throw utils::TranslatorException("reducing “at” predicates currently not supported");
throw output::TranslatorException("reducing “at” predicates currently not supported");
}
////////////////////////////////////////////////////////////////////////////////////////////////////

9
src/plasp/pddl/expressions/Constant.cpp
View File

@ -4,6 +4,7 @@
#include <boost/assert.hpp>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Domain.h>
#include <plasp/pddl/ExpressionContext.h>
@ -113,7 +114,7 @@ void Constant::parseTypedDeclarations(Context &context, Domain &domain)
domain.checkRequirement(Requirement::Type::Typing);
// If no types are given, check that typing is not a requirement
else if (domain.hasRequirement(Requirement::Type::Typing))
throw utils::ParserException(parser.coordinate(), "constant has undeclared type");
throw input::ParserException(parser.location(), "constant has undeclared type");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -140,7 +141,7 @@ void Constant::parseTypedDeclarations(Context &context, Problem &problem)
problem.checkRequirement(Requirement::Type::Typing);
// If no types are given, check that typing is not a requirement
else if (problem.hasRequirement(Requirement::Type::Typing))
throw utils::ParserException(parser.coordinate(), "constant has undeclared type");
throw input::ParserException(parser.location(), "constant has undeclared type");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -158,7 +159,7 @@ ConstantPointer Constant::parseAndFind(Context &context, const Domain &domain)
if (constant != nullptr)
return constant;
throw utils::ParserException(parser.coordinate(), "constant “" + constantName + "” used but never declared");
throw input::ParserException(parser.location(), "constant “" + constantName + "” used but never declared");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -181,7 +182,7 @@ ConstantPointer Constant::parseAndFind(Context &context, const Problem &problem)
if (constant)
return constant;
throw utils::ParserException(parser.coordinate(), "constant “" + constantName + "” used but never declared");
throw input::ParserException(parser.location(), "constant “" + constantName + "” used but never declared");
}
////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/plasp/pddl/expressions/Predicate.cpp
View File

@ -126,7 +126,7 @@ PredicatePointer Predicate::parse(Context &context, const Problem &problem)
while (parser.currentCharacter() != ')')
{
if (parser.currentCharacter() == '?')
throw utils::ParserException(parser.coordinate(), "variables not allowed in this context");
throw input::ParserException(parser.location(), "variables not allowed in this context");
// Parse objects and constants
const auto constant = Constant::parseAndFind(context, problem);

7
src/plasp/pddl/expressions/PrimitiveType.cpp
View File

@ -4,6 +4,7 @@
#include <boost/assert.hpp>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Domain.h>
#include <plasp/pddl/ExpressionContext.h>
@ -111,7 +112,7 @@ PrimitiveTypePointer PrimitiveType::parseAndFind(Context &context, Domain &domai
const auto typeName = parser.parseIdentifier();
if (typeName.empty())
throw utils::ParserException(parser.coordinate(), "no type supplied");
throw input::ParserException(parser.location(), "no type supplied");
const auto match = std::find_if(types.cbegin(), types.cend(),
[&](const auto &primitiveType)
@ -124,11 +125,11 @@ PrimitiveTypePointer PrimitiveType::parseAndFind(Context &context, Domain &domai
// Only "object" is allowed as an implicit type
if (typeName == "object" || typeName == "objects")
{
context.logger.logWarning(parser.coordinate(), "primitive type “" + typeName + "” should be declared");
context.logger.log(output::Priority::Warning, parser.location(), "primitive type “" + typeName + "” should be declared");
types.emplace_back(PrimitiveTypePointer(new PrimitiveType(typeName)));
}
else
throw utils::ParserException(parser.coordinate(), "type “" + typeName + "” used but never declared");
throw input::ParserException(parser.location(), "type “" + typeName + "” used but never declared");
return types.back().get();
}

2
src/plasp/pddl/expressions/Unsupported.cpp
View File

@ -25,7 +25,7 @@ UnsupportedPointer Unsupported::parse(Context &context)
expression->m_type = parser.parseIdentifier();
context.logger.logWarning(parser.coordinate(), "expression type “" + expression->m_type + "” currently unsupported in this context");
context.logger.log(output::Priority::Warning, parser.location(), "expression type “" + expression->m_type + "” currently unsupported in this context");
skipSection(parser);

8
src/plasp/pddl/expressions/Variable.cpp
View File

@ -4,13 +4,13 @@
#include <boost/assert.hpp>
#include <plasp/input/ParserException.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Domain.h>
#include <plasp/pddl/ExpressionContext.h>
#include <plasp/pddl/expressions/Either.h>
#include <plasp/pddl/expressions/PrimitiveType.h>
#include <plasp/pddl/expressions/Type.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -53,7 +53,7 @@ void Variable::parseDeclaration(Context &context, Variables &parameters)
});
if (match != parameters.cend())
throw utils::ParserException(parser.coordinate(), "variable “" + variable->m_name + "” already declared in this scope");
throw input::ParserException(parser.location(), "variable “" + variable->m_name + "” already declared in this scope");
// Flag variable for potentially upcoming type declaration
variable->setDirty();
@ -130,7 +130,7 @@ void Variable::parseTypedDeclarations(Context &context, ExpressionContext &expre
expressionContext.checkRequirement(Requirement::Type::Typing);
// If no types are given, check that typing is not a requirement
else if (expressionContext.hasRequirement(Requirement::Type::Typing))
throw utils::ParserException(parser.coordinate(), "variable has undeclared type");
throw input::ParserException(parser.location(), "variable has undeclared type");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -154,7 +154,7 @@ VariablePointer Variable::parseAndFind(Context &context, const ExpressionContext
});
if (match == variables.cend())
throw utils::ParserException(parser.coordinate(), "parameter “" + variableName + "” used but never declared");
throw input::ParserException(parser.location(), "parameter “" + variableName + "” used but never declared");
return match->get();
}

4
src/plasp/sas/AssignedVariable.cpp
View File

@ -31,7 +31,7 @@ AssignedVariable::AssignedVariable(const Variable &variable, const Value &value)
////////////////////////////////////////////////////////////////////////////////////////////////////
AssignedVariable AssignedVariable::fromSAS(utils::Parser<> &parser, const Variables &variables)
AssignedVariable AssignedVariable::fromSAS(input::Parser<> &parser, const Variables &variables)
{
AssignedVariable assignedVariable;
@ -43,7 +43,7 @@ AssignedVariable AssignedVariable::fromSAS(utils::Parser<> &parser, const Variab
////////////////////////////////////////////////////////////////////////////////////////////////////
AssignedVariable AssignedVariable::fromSAS(utils::Parser<> &parser, const Variable &variable)
AssignedVariable AssignedVariable::fromSAS(input::Parser<> &parser, const Variable &variable)
{
AssignedVariable assignedVariable;

2
src/plasp/sas/AxiomRule.cpp
View File

@ -23,7 +23,7 @@ AxiomRule::AxiomRule(AxiomRule::Conditions conditions, AxiomRule::Condition post
////////////////////////////////////////////////////////////////////////////////////////////////////
AxiomRule AxiomRule::fromSAS(utils::Parser<> &parser, const Variables &variables)
AxiomRule AxiomRule::fromSAS(input::Parser<> &parser, const Variables &variables)
{
parser.expect<std::string>("begin_rule");

102
src/plasp/sas/Debugging.cpp
View File

@ -13,163 +13,163 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
utils::LogStream &operator<<(utils::LogStream &ostream, const Description &description)
output::ColorStream &operator<<(output::ColorStream &stream, const Description &description)
{
// Metric section
ostream << "uses action costs: " << (description.usesActionCosts() ? "yes" : "no") << std::endl;
stream << "uses action costs: " << (description.usesActionCosts() ? "yes" : "no") << std::endl;
// Variable section
const auto &variables = description.variables();
ostream << "variables: " << variables.size() << std::endl;
stream << "variables: " << variables.size() << std::endl;
std::for_each(variables.cbegin(), variables.cend(),
[&](const auto &variable)
{
const auto &values = variable.values();
ostream << "\t" << variable.name() << ":" << std::endl;
ostream << "\t\tvalues: " << values.size() << std::endl;
stream << "\t" << variable.name() << ":" << std::endl;
stream << "\t\tvalues: " << values.size() << std::endl;
std::for_each(values.cbegin(), values.cend(),
[&](const auto &value)
{
ostream << "\t\t\t";
value.printAsSAS(ostream);
ostream << std::endl;
stream << "\t\t\t";
value.printAsSAS(stream);
stream << std::endl;
});
ostream << "\t\taxiom layer: " << variable.axiomLayer() << std::endl;
stream << "\t\taxiom layer: " << variable.axiomLayer() << std::endl;
});
// Mutex section
const auto &mutexGroups = description.mutexGroups();
ostream << "mutex groups: " << mutexGroups.size() << std::endl;
stream << "mutex groups: " << mutexGroups.size() << std::endl;
std::for_each(mutexGroups.cbegin(), mutexGroups.cend(),
[&](const auto &mutexGroup)
{
ostream << "\tmutex group:" << std::endl;
stream << "\tmutex group:" << std::endl;
std::for_each(mutexGroup.facts().cbegin(), mutexGroup.facts().cend(),
[&](const auto &fact)
{
ostream << "\t\t" << fact.variable().name() << " = ";
fact.value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t\t" << fact.variable().name() << " = ";
fact.value().printAsSAS(stream);
stream << std::endl;
});
});
// Initial state section
const auto &initialState = description.initialState();
ostream << "initial state:" << std::endl;
stream << "initial state:" << std::endl;
std::for_each(initialState.facts().cbegin(), initialState.facts().cend(),
[&](const auto &fact)
{
ostream << "\t" << fact.variable().name() << " = ";
fact.value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t" << fact.variable().name() << " = ";
fact.value().printAsSAS(stream);
stream << std::endl;
});
// Goal section
const auto &goal = description.goal();
ostream << "goal:" << std::endl;
stream << "goal:" << std::endl;
std::for_each(goal.facts().cbegin(), goal.facts().cend(),
[&](const auto &fact)
{
ostream << "\t" << fact.variable().name() << " = ";
fact.value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t" << fact.variable().name() << " = ";
fact.value().printAsSAS(stream);
stream << std::endl;
});
// Operator section
const auto &operators = description.operators();
ostream << "operators: " << operators.size() << std::endl;
stream << "operators: " << operators.size() << std::endl;
std::for_each(operators.cbegin(), operators.cend(),
[&](const auto &operator_)
{
ostream << "\t";
operator_.predicate().printAsSAS(ostream);
ostream << ":" << std::endl;
stream << "\t";
operator_.predicate().printAsSAS(stream);
stream << ":" << std::endl;
const auto &preconditions = operator_.preconditions();
ostream << "\t\tpreconditions: " << preconditions.size() << std::endl;
stream << "\t\tpreconditions: " << preconditions.size() << std::endl;
std::for_each(preconditions.cbegin(), preconditions.cend(),
[&](const auto &precondition)
{
std::cout << "\t\t\t" << precondition.variable().name() << " = ";
precondition.value().printAsSAS(ostream);
ostream << std::endl;
precondition.value().printAsSAS(stream);
stream << std::endl;
});
const auto &effects = operator_.effects();
ostream << "\t\teffects: " << effects.size() << std::endl;
stream << "\t\teffects: " << effects.size() << std::endl;
std::for_each(effects.cbegin(), effects.cend(),
[&](const auto &effect)
{
ostream << "\t\t\teffect:" << std::endl;
stream << "\t\t\teffect:" << std::endl;
const auto &conditions = effect.conditions();
ostream << "\t\t\t\tconditions: " << conditions.size() << std::endl;
stream << "\t\t\t\tconditions: " << conditions.size() << std::endl;
std::for_each(conditions.cbegin(), conditions.cend(),
[&](const auto &condition)
{
ostream << "\t\t\t\t\t" << condition.variable().name() << " = ";
condition.value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t\t\t\t\t" << condition.variable().name() << " = ";
condition.value().printAsSAS(stream);
stream << std::endl;
});
ostream << "\t\t\t\tpostcondition:" << std::endl;
ostream << "\t\t\t\t\t" << effect.postcondition().variable().name() << " = ";
effect.postcondition().value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t\t\t\tpostcondition:" << std::endl;
stream << "\t\t\t\t\t" << effect.postcondition().variable().name() << " = ";
effect.postcondition().value().printAsSAS(stream);
stream << std::endl;
});
ostream << "\t\tcosts: " << operator_.costs() << std::endl;
stream << "\t\tcosts: " << operator_.costs() << std::endl;
});
// Axiom section
const auto &axiomRules = description.axiomRules();
ostream << "axiom rules: " << axiomRules.size() << std::endl;
stream << "axiom rules: " << axiomRules.size() << std::endl;
std::for_each(axiomRules.cbegin(), axiomRules.cend(),
[&](const auto &axiomRule)
{
ostream << "\taxiom rule:" << std::endl;
stream << "\taxiom rule:" << std::endl;
const auto conditions = axiomRule.conditions();
ostream << "\t\tconditions: " << conditions.size() << std::endl;
stream << "\t\tconditions: " << conditions.size() << std::endl;
std::for_each(conditions.cbegin(), conditions.cend(),
[&](const auto &condition)
{
ostream << "\t\t\t" << condition.variable().name() << " = ";
condition.value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t\t\t" << condition.variable().name() << " = ";
condition.value().printAsSAS(stream);
stream << std::endl;
});
ostream << "\t\tpostcondition:" << std::endl;
ostream << "\t\t\t" << axiomRule.postcondition().variable().name() << " = ";
axiomRule.postcondition().value().printAsSAS(ostream);
ostream << std::endl;
stream << "\t\tpostcondition:" << std::endl;
stream << "\t\t\t" << axiomRule.postcondition().variable().name() << " = ";
axiomRule.postcondition().value().printAsSAS(stream);
stream << std::endl;
});
return ostream;
return stream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////

30
src/plasp/sas/Description.cpp
View File

@ -7,7 +7,7 @@
#include <boost/filesystem.hpp>
#include <plasp/utils/ParserException.h>
#include <plasp/input/ParserException.h>
#include <plasp/sas/VariableTransition.h>
namespace plasp
@ -28,7 +28,7 @@ Description::Description()
////////////////////////////////////////////////////////////////////////////////////////////////////
Description Description::fromParser(utils::Parser<> &&parser)
Description Description::fromParser(input::Parser<> &&parser)
{
Description description;
description.parseContent(parser);
@ -40,7 +40,7 @@ Description Description::fromParser(utils::Parser<> &&parser)
Description Description::fromStream(std::istream &istream)
{
utils::Parser<> parser;
input::Parser<> parser;
parser.read("std::cin", istream);
Description description;
@ -56,7 +56,7 @@ Description Description::fromFile(const boost::filesystem::path &path)
if (!boost::filesystem::is_regular_file(path))
throw std::runtime_error("File does not exist: “" + path.string() + "”");
utils::Parser<> parser;
input::Parser<> parser;
parser.read(path);
Description description;
@ -160,7 +160,7 @@ bool Description::hasRequirements() const
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseContent(utils::Parser<> &parser)
void Description::parseContent(input::Parser<> &parser)
{
parseVersionSection(parser);
parseMetricSection(parser);
@ -174,26 +174,26 @@ void Description::parseContent(utils::Parser<> &parser)
parser.skipWhiteSpace();
if (!parser.atEnd())
throw utils::ParserException(parser.coordinate(), "expected end of SAS description (perhaps, input contains two SAS descriptions?)");
throw input::ParserException(parser.location(), "expected end of SAS description (perhaps, input contains two SAS descriptions?)");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseVersionSection(utils::Parser<> &parser) const
void Description::parseVersionSection(input::Parser<> &parser) const
{
parser.expect<std::string>("begin_version");
const auto formatVersion = parser.parse<size_t>();
if (formatVersion != 3)
throw utils::ParserException(parser.coordinate(), "unsupported SAS format version (" + std::to_string(formatVersion) + ")");
throw input::ParserException(parser.location(), "unsupported SAS format version (" + std::to_string(formatVersion) + ")");
parser.expect<std::string>("end_version");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseMetricSection(utils::Parser<> &parser)
void Description::parseMetricSection(input::Parser<> &parser)
{
parser.expect<std::string>("begin_metric");
@ -204,7 +204,7 @@ void Description::parseMetricSection(utils::Parser<> &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseVariablesSection(utils::Parser<> &parser)
void Description::parseVariablesSection(input::Parser<> &parser)
{
const auto numberOfVariables = parser.parse<size_t>();
m_variables.reserve(numberOfVariables);
@ -215,7 +215,7 @@ void Description::parseVariablesSection(utils::Parser<> &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseMutexSection(utils::Parser<> &parser)
void Description::parseMutexSection(input::Parser<> &parser)
{
const auto numberOfMutexGroups = parser.parse<size_t>();
m_mutexGroups.reserve(numberOfMutexGroups);
@ -226,21 +226,21 @@ void Description::parseMutexSection(utils::Parser<> &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseInitialStateSection(utils::Parser<> &parser)
void Description::parseInitialStateSection(input::Parser<> &parser)
{
m_initialState = std::make_unique<InitialState>(InitialState::fromSAS(parser, m_variables));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseGoalSection(utils::Parser<> &parser)
void Description::parseGoalSection(input::Parser<> &parser)
{
m_goal = std::make_unique<Goal>(Goal::fromSAS(parser, m_variables));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseOperatorSection(utils::Parser<> &parser)
void Description::parseOperatorSection(input::Parser<> &parser)
{
const auto numberOfOperators = parser.parse<size_t>();
m_operators.reserve(numberOfOperators);
@ -251,7 +251,7 @@ void Description::parseOperatorSection(utils::Parser<> &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Description::parseAxiomSection(utils::Parser<> &parser)
void Description::parseAxiomSection(input::Parser<> &parser)
{
const auto numberOfAxiomRules = parser.parse<size_t>();
m_axiomRules.reserve(numberOfAxiomRules);

2
src/plasp/sas/Effect.cpp
View File

@ -23,7 +23,7 @@ Effect::Effect(Conditions conditions, Condition postcondition)
////////////////////////////////////////////////////////////////////////////////////////////////////
Effect Effect::fromSAS(utils::Parser<> &parser, const Variables &variables, Conditions &preconditions)
Effect Effect::fromSAS(input::Parser<> &parser, const Variables &variables, Conditions &preconditions)
{
Effect::Conditions conditions;

2
src/plasp/sas/Goal.cpp
View File

@ -13,7 +13,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Goal Goal::fromSAS(utils::Parser<> &parser, const Variables &variables)
Goal Goal::fromSAS(input::Parser<> &parser, const Variables &variables)
{
Goal goal;

2
src/plasp/sas/InitialState.cpp
View File

@ -11,7 +11,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
InitialState InitialState::fromSAS(utils::Parser<> &parser, const Variables &variables)
InitialState InitialState::fromSAS(input::Parser<> &parser, const Variables &variables)
{
InitialState initialState;

6
src/plasp/sas/MutexGroup.cpp
View File

@ -2,7 +2,7 @@
#include <iostream>
#include <plasp/utils/ParserException.h>
#include <plasp/input/ParserException.h>
namespace plasp
{
@ -15,7 +15,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
MutexGroup MutexGroup::fromSAS(utils::Parser<> &parser, const Variables &variables)
MutexGroup MutexGroup::fromSAS(input::Parser<> &parser, const Variables &variables)
{
MutexGroup mutexGroup;
@ -29,7 +29,7 @@ MutexGroup MutexGroup::fromSAS(utils::Parser<> &parser, const Variables &variabl
mutexGroup.m_facts.emplace_back(Fact::fromSAS(parser, variables));
if (mutexGroup.m_facts[j].value() == Value::None)
throw utils::ParserException(parser.coordinate(), "mutex groups must not contain <none of those> values");
throw input::ParserException(parser.location(), "mutex groups must not contain <none of those> values");
}
parser.expect<std::string>("end_mutex_group");

12
src/plasp/sas/Operator.cpp
View File

@ -3,8 +3,8 @@
#include <iostream>
#include <limits>
#include <plasp/output/Formatting.h>
#include <plasp/sas/VariableTransition.h>
#include <plasp/utils/Formatting.h>
namespace plasp
{
@ -17,7 +17,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Operator Operator::fromSAS(utils::Parser<> &parser, const Variables &variables)
Operator Operator::fromSAS(input::Parser<> &parser, const Variables &variables)
{
Operator operator_;
@ -46,11 +46,11 @@ Operator Operator::fromSAS(utils::Parser<> &parser, const Variables &variables)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Operator::printPredicateAsASP(utils::LogStream &outputStream) const
void Operator::printPredicateAsASP(output::ColorStream &stream) const
{
outputStream << utils::Keyword("action") << "(";
m_predicate.printAsASP(outputStream);
outputStream << ")";
stream << output::Keyword("action") << "(";
m_predicate.printAsASP(stream);
stream << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////

26
src/plasp/sas/Predicate.cpp
View File

@ -4,8 +4,8 @@
#include <limits>
#include <sstream>
#include <plasp/utils/Formatting.h>
#include <plasp/utils/ParserException.h>
#include <plasp/input/ParserException.h>
#include <plasp/output/Formatting.h>
namespace plasp
{
@ -18,7 +18,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Predicate Predicate::fromSAS(utils::Parser<> &parser)
Predicate Predicate::fromSAS(input::Parser<> &parser)
{
Predicate predicate;
@ -43,7 +43,7 @@ Predicate Predicate::fromSAS(utils::Parser<> &parser)
}
catch (const std::exception &e)
{
throw utils::ParserException(parser.coordinate(), "could not parse operator predicate");
throw input::ParserException(parser.location(), "could not parse operator predicate");
}
return predicate;
@ -65,38 +65,38 @@ const Predicate::Arguments &Predicate::arguments() const
////////////////////////////////////////////////////////////////////////////////////////////////////
void Predicate::printAsSAS(utils::LogStream &outputStream) const
void Predicate::printAsSAS(output::ColorStream &stream) const
{
if (m_arguments.empty())
{
outputStream << m_name;
stream << m_name;
return;
}
for (size_t i = 0; i < m_arguments.size(); i++)
{
if (i > 0)
outputStream << " ";
stream << " ";
outputStream << m_arguments[i];
stream << m_arguments[i];
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Predicate::printAsASP(utils::LogStream &outputStream) const
void Predicate::printAsASP(output::ColorStream &stream) const
{
if (m_arguments.empty())
{
outputStream << utils::String(m_name);
stream << output::String(m_name.c_str());
return;
}
outputStream << "(" << utils::String(m_name);
stream << "(" << output::String(m_name.c_str());
for (size_t i = 0; i < m_arguments.size(); i++)
outputStream << ", " << utils::String(m_arguments[i]);
stream << ", " << output::String(m_arguments[i].c_str());
outputStream << ")";
stream << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////

76
src/plasp/sas/TranslatorASP.cpp
View File

@ -1,6 +1,6 @@
#include <plasp/sas/TranslatorASP.h>
#include <plasp/utils/Formatting.h>
#include <plasp/output/Formatting.h>
namespace plasp
{
@ -13,9 +13,9 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
TranslatorASP::TranslatorASP(const Description &description, utils::LogStream &ostream)
TranslatorASP::TranslatorASP(const Description &description, output::ColorStream &outputStream)
: m_description(description),
m_outputStream(ostream)
m_outputStream(outputStream)
{
}
@ -56,30 +56,30 @@ void TranslatorASP::translate() const
void TranslatorASP::translateRequirements() const
{
m_outputStream << utils::Heading2("feature requirements") << std::endl;
m_outputStream << output::Heading2("feature requirements") << std::endl;
if (m_description.usesActionCosts())
m_outputStream << utils::RuleName("requires") << "(" << utils::Keyword("feature") << "(" << utils::Reserved("actionCosts") << "))." << std::endl;
m_outputStream << output::Function("requires") << "(" << output::Keyword("feature") << "(" << output::Reserved("actionCosts") << "))." << std::endl;
if (m_description.usesAxiomRules())
m_outputStream << utils::RuleName("requires") << "(" << utils::Keyword("feature") << "(" << utils::Reserved("axiomRules") << "))." << std::endl;
m_outputStream << output::Function("requires") << "(" << output::Keyword("feature") << "(" << output::Reserved("axiomRules") << "))." << std::endl;
if (m_description.usesConditionalEffects())
m_outputStream << utils::RuleName("requires") << "(" << utils::Keyword("feature") << "(" << utils::Reserved("conditionalEffects") << "))." << std::endl;
m_outputStream << output::Function("requires") << "(" << output::Keyword("feature") << "(" << output::Reserved("conditionalEffects") << "))." << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void TranslatorASP::translateInitialState() const
{
m_outputStream << utils::Heading2("initial state") << std::endl;
m_outputStream << output::Heading2("initial state") << std::endl;
const auto &initialStateFacts = m_description.initialState().facts();
std::for_each(initialStateFacts.cbegin(), initialStateFacts.cend(),
[&](const auto &fact)
{
m_outputStream << utils::RuleName("initialState") << "(";
m_outputStream << output::Function("initialState") << "(";
fact.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
fact.value().printAsASPPredicate(m_outputStream);
@ -91,14 +91,14 @@ void TranslatorASP::translateInitialState() const
void TranslatorASP::translateGoal() const
{
m_outputStream << utils::Heading2("goal") << std::endl;
m_outputStream << output::Heading2("goal") << std::endl;
const auto &goalFacts = m_description.goal().facts();
std::for_each(goalFacts.cbegin(), goalFacts.cend(),
[&](const auto &fact)
{
m_outputStream << utils::RuleName("goal") << "(";
m_outputStream << output::Function("goal") << "(";
fact.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
fact.value().printAsASPPredicate(m_outputStream);
@ -110,7 +110,7 @@ void TranslatorASP::translateGoal() const
void TranslatorASP::translateVariables() const
{
m_outputStream << utils::Heading2("variables");
m_outputStream << output::Heading2("variables");
const auto &variables = m_description.variables();
@ -121,14 +121,14 @@ void TranslatorASP::translateVariables() const
BOOST_ASSERT(!values.empty());
m_outputStream << std::endl << utils::RuleName("variable") << "(";
m_outputStream << std::endl << output::Function("variable") << "(";
variable.printNameAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
std::for_each(values.cbegin(), values.cend(),
[&](const auto &value)
{
m_outputStream << utils::RuleName("contains") << "(";
m_outputStream << output::Function("contains") << "(";
variable.printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
value.printAsASPPredicate(m_outputStream);
@ -141,7 +141,7 @@ void TranslatorASP::translateVariables() const
void TranslatorASP::translateActions() const
{
m_outputStream << utils::Heading2("actions");
m_outputStream << output::Heading2("actions");
const auto &operators = m_description.operators();
@ -150,7 +150,7 @@ void TranslatorASP::translateActions() const
std::for_each(operators.cbegin(), operators.cend(),
[&](const auto &operator_)
{
m_outputStream << std::endl << utils::RuleName("action") << "(";
m_outputStream << std::endl << output::Function("action") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ")." << std::endl;
@ -159,7 +159,7 @@ void TranslatorASP::translateActions() const
std::for_each(preconditions.cbegin(), preconditions.cend(),
[&](const auto &precondition)
{
m_outputStream << utils::RuleName("precondition") << "(";
m_outputStream << output::Function("precondition") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ", ";
precondition.variable().printNameAsASPPredicate(m_outputStream);
@ -175,13 +175,13 @@ void TranslatorASP::translateActions() const
{
const auto &conditions = effect.conditions();
m_outputStream << utils::RuleName("postcondition") << "(";
m_outputStream << output::Function("postcondition") << "(";
operator_.printPredicateAsASP(m_outputStream);
if (conditions.empty())
m_outputStream << ", " << utils::Keyword("effect") << "(" << utils::Reserved("unconditional") << "), ";
m_outputStream << ", " << output::Keyword("effect") << "(" << output::Reserved("unconditional") << "), ";
else
m_outputStream << ", " << utils::Keyword("effect") << "(" << utils::Number(std::to_string(currentEffectID)) << "), ";
m_outputStream << ", " << output::Keyword("effect") << "(" << output::Number<decltype(currentEffectID)>(currentEffectID) << "), ";
effect.postcondition().variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
@ -193,8 +193,8 @@ void TranslatorASP::translateActions() const
{
// Conditions of conditional effects
m_outputStream
<< utils::RuleName("precondition") << "("
<< utils::Keyword("effect") << "(" << utils::Number(std::to_string(currentEffectID)) << "), ";
<< output::Function("precondition") << "("
<< output::Keyword("effect") << "(" << output::Number<decltype(currentEffectID)>(currentEffectID) << "), ";
condition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
condition.value().printAsASPPredicate(m_outputStream);
@ -205,9 +205,9 @@ void TranslatorASP::translateActions() const
currentEffectID++;
});
m_outputStream << utils::RuleName("costs") << "(";
m_outputStream << output::Function("costs") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ", " << utils::Number(std::to_string(operator_.costs())) << ")." << std::endl;
m_outputStream << ", " << output::Number<decltype(operator_.costs())>(operator_.costs()) << ")." << std::endl;
});
}
@ -215,7 +215,7 @@ void TranslatorASP::translateActions() const
void TranslatorASP::translateMutexes() const
{
m_outputStream << utils::Heading2("mutex groups");
m_outputStream << output::Heading2("mutex groups");
const auto &mutexGroups = m_description.mutexGroups();
@ -229,9 +229,9 @@ void TranslatorASP::translateMutexes() const
m_outputStream
<< std::endl
<< utils::RuleName("mutexGroup") << "("
<< utils::Keyword("mutexGroup") << "("
<< utils::Number(mutexGroupID)
<< output::Function("mutexGroup") << "("
<< output::Keyword("mutexGroup") << "("
<< output::Number<decltype(mutexGroupID)>(mutexGroupID)
<< "))." << std::endl;
const auto &facts = mutexGroup.facts();
@ -239,7 +239,7 @@ void TranslatorASP::translateMutexes() const
std::for_each(facts.cbegin(), facts.cend(),
[&](const auto &fact)
{
m_outputStream << utils::RuleName("contains") << "(" << utils::Keyword("mutexGroup") << "(" << utils::Number(mutexGroupID) << "), ";
m_outputStream << output::Function("contains") << "(" << output::Keyword("mutexGroup") << "(" << output::Number<decltype(mutexGroupID)>(mutexGroupID) << "), ";
fact.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
fact.value().printAsASPPredicate(m_outputStream);
@ -252,7 +252,7 @@ void TranslatorASP::translateMutexes() const
void TranslatorASP::translateAxiomRules() const
{
m_outputStream << utils::Heading2("axiom rules");
m_outputStream << output::Heading2("axiom rules");
const auto &axiomRules = m_description.axiomRules();
@ -266,9 +266,9 @@ void TranslatorASP::translateAxiomRules() const
m_outputStream
<< std::endl
<< utils::RuleName("axiomRule") << "("
<< utils::Keyword("axiomRule") << "("
<< utils::Number(axiomRuleID)
<< output::Function("axiomRule") << "("
<< output::Keyword("axiomRule") << "("
<< output::Number<decltype(axiomRuleID)>(axiomRuleID)
<< "))." << std::endl;
const auto &conditions = axiomRule.conditions();
@ -277,8 +277,8 @@ void TranslatorASP::translateAxiomRules() const
[&](const auto &condition)
{
m_outputStream
<< utils::RuleName("precondition") << "("
<< utils::Keyword("axiomRule") << "(" << utils::Number(axiomRuleID) << "), ";
<< output::Function("precondition") << "("
<< output::Keyword("axiomRule") << "(" << output::Number<decltype(axiomRuleID)>(axiomRuleID) << "), ";
condition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
condition.value().printAsASPPredicate(m_outputStream);
@ -288,9 +288,9 @@ void TranslatorASP::translateAxiomRules() const
const auto &postcondition = axiomRule.postcondition();
m_outputStream
<< utils::RuleName("postcondition") << "("
<< utils::Keyword("axiomRule") << "(" << utils::Number(axiomRuleID) << "), "
<< utils::Keyword("effect") << "(" << utils::Reserved("unconditional") << "), ";
<< output::Function("postcondition") << "("
<< output::Keyword("axiomRule") << "(" << output::Number<decltype(axiomRuleID)>(axiomRuleID) << "), "
<< output::Keyword("effect") << "(" << output::Reserved("unconditional") << "), ";
postcondition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
postcondition.value().printAsASPPredicate(m_outputStream);

32
src/plasp/sas/Value.cpp
View File

@ -2,9 +2,9 @@
#include <iostream>
#include <plasp/input/ParserException.h>
#include <plasp/output/Formatting.h>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Formatting.h>
#include <plasp/utils/ParserException.h>
namespace plasp
{
@ -54,7 +54,7 @@ Value Value::negated() const
////////////////////////////////////////////////////////////////////////////////////////////////////
Value Value::fromSAS(utils::Parser<> &parser)
Value Value::fromSAS(input::Parser<> &parser)
{
const auto sasSign = parser.parse<std::string>();
@ -74,7 +74,7 @@ Value Value::fromSAS(utils::Parser<> &parser)
else if (sasSign == "NegatedAtom")
value.m_sign = Value::Sign::Negative;
else
throw utils::ParserException(parser.coordinate(), "invalid value sign “" + sasSign + "”");
throw input::ParserException(parser.location(), "invalid value sign “" + sasSign + "”");
try
{
@ -90,7 +90,7 @@ Value Value::fromSAS(utils::Parser<> &parser)
}
catch (const std::exception &e)
{
throw utils::ParserException(parser.coordinate(), std::string("could not parse variable value (") + e.what() + ")");
throw input::ParserException(parser.location(), std::string("could not parse variable value (") + e.what() + ")");
}
return value;
@ -98,7 +98,7 @@ Value Value::fromSAS(utils::Parser<> &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
const Value &Value::referenceFromSAS(utils::Parser<> &parser, const Variable &variable)
const Value &Value::referenceFromSAS(input::Parser<> &parser, const Variable &variable)
{
const auto valueID = parser.parse<int>();
@ -106,7 +106,7 @@ const Value &Value::referenceFromSAS(utils::Parser<> &parser, const Variable &va
return Value::Any;
if (valueID < 0 || static_cast<size_t>(valueID) >= variable.values().size())
throw utils::ParserException(parser.coordinate(), "value index out of range (variable " + variable.name() + ", index " + std::to_string(valueID) + ")");
throw input::ParserException(parser.location(), "value index out of range (variable " + variable.name() + ", index " + std::to_string(valueID) + ")");
return variable.values()[valueID];
}
@ -127,32 +127,32 @@ const std::string &Value::name() const
////////////////////////////////////////////////////////////////////////////////////////////////////
void Value::printAsASPPredicate(utils::LogStream &outputStream) const
void Value::printAsASPPredicate(output::ColorStream &stream) const
{
// TODO: do not compare by value
if (*this == Value::None)
{
outputStream << utils::Keyword("value") << "(" << utils::Reserved("none") << ")";
stream << output::Keyword("value") << "(" << output::Reserved("none") << ")";
return;
}
outputStream << utils::Keyword("value") << "(" << utils::String(m_name) << ", "
<< (m_sign == Sign::Positive ? utils::Boolean("true") : utils::Boolean("false")) << ")";
stream << output::Keyword("value") << "(" << output::String(m_name.c_str()) << ", "
<< (m_sign == Sign::Positive ? output::Boolean("true") : output::Boolean("false")) << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Value::printAsSAS(utils::LogStream &outputStream) const
void Value::printAsSAS(output::ColorStream &stream) const
{
if (m_sign == Value::Sign::Positive)
outputStream << "Atom ";
stream << "Atom ";
else
outputStream << "NegatedAtom ";
stream << "NegatedAtom ";
outputStream << m_name;
stream << m_name;
if (!m_hasArguments)
outputStream << "()";
stream << "()";
}
////////////////////////////////////////////////////////////////////////////////////////////////////

16
src/plasp/sas/Variable.cpp
View File

@ -2,8 +2,8 @@
#include <iostream>
#include <plasp/utils/Formatting.h>
#include <plasp/utils/ParserException.h>
#include <plasp/input/ParserException.h>
#include <plasp/output/Formatting.h>
namespace plasp
{
@ -23,7 +23,7 @@ Variable::Variable()
////////////////////////////////////////////////////////////////////////////////////////////////////
Variable Variable::fromSAS(utils::Parser<> &parser)
Variable Variable::fromSAS(input::Parser<> &parser)
{
Variable variable;
@ -42,7 +42,7 @@ Variable Variable::fromSAS(utils::Parser<> &parser)
// <none of those> values are only allowed at the end
if (j < numberOfValues - 1 && variable.m_values[j] == Value::None)
throw utils::ParserException(parser.coordinate(), "<none of those> value must be the last value of a variable");
throw input::ParserException(parser.location(), "<none of those> value must be the last value of a variable");
}
parser.expect<std::string>("end_variable");
@ -52,20 +52,20 @@ Variable Variable::fromSAS(utils::Parser<> &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Variable::printNameAsASPPredicate(utils::LogStream &outputStream) const
void Variable::printNameAsASPPredicate(output::ColorStream &stream) const
{
// TODO: assert that name is a number indeed
outputStream << utils::Keyword("variable") << "(" << utils::Number(m_name) << ")";
stream << output::Keyword("variable") << "(" << output::Number<std::string>(m_name) << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////
const Variable &Variable::referenceFromSAS(utils::Parser<> &parser, const Variables &variables)
const Variable &Variable::referenceFromSAS(input::Parser<> &parser, const Variables &variables)
{
const auto variableID = parser.parse<size_t>();
if (variableID >= variables.size())
throw utils::ParserException(parser.coordinate(), "variable index out of range (index " + std::to_string(variableID) + ")");
throw input::ParserException(parser.location(), "variable index out of range (index " + std::to_string(variableID) + ")");
return variables[variableID];
}

2
src/plasp/sas/VariableTransition.cpp
View File

@ -24,7 +24,7 @@ VariableTransition::VariableTransition()
////////////////////////////////////////////////////////////////////////////////////////////////////
VariableTransition VariableTransition::fromSAS(utils::Parser<> &parser, const Variables &variables)
VariableTransition VariableTransition::fromSAS(input::Parser<> &parser, const Variables &variables)
{
VariableTransition variableTransition;

143
src/plasp/utils/Logger.cpp
View File

@ -1,143 +0,0 @@
#include <plasp/utils/Logger.h>
#include <plasp/utils/Formatting.h>
namespace plasp
{
namespace utils
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Logger
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger()
: m_outputStream(StandardStream::Out),
m_errorStream(StandardStream::Err),
m_warningLevel{Logger::WarningLevel::Show}
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger(const Logger &other)
: m_outputStream{other.m_outputStream},
m_errorStream{other.m_errorStream},
m_warningLevel{other.m_warningLevel}
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger &Logger::operator=(const Logger &other)
{
m_outputStream = other.m_outputStream;
m_errorStream = other.m_errorStream;
m_warningLevel = other.m_warningLevel;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger::Logger(Logger &&other)
: m_outputStream{std::move(other.m_outputStream)},
m_errorStream{std::move(other.m_errorStream)},
m_warningLevel{other.m_warningLevel}
{
other.m_warningLevel = WarningLevel::Show;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Logger &Logger::operator=(Logger &&other)
{
m_outputStream = std::move(other.m_outputStream);
m_errorStream = std::move(other.m_errorStream);
m_warningLevel = other.m_warningLevel;
other.m_warningLevel = WarningLevel::Show;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &Logger::outputStream()
{
return m_outputStream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
LogStream &Logger::errorStream()
{
return m_errorStream;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::setWarningLevel(WarningLevel warningLevel)
{
m_warningLevel = warningLevel;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::setColorPolicy(LogStream::ColorPolicy colorPolicy)
{
m_outputStream.setColorPolicy(colorPolicy);
m_errorStream.setColorPolicy(colorPolicy);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::logError(const std::string &message)
{
m_errorStream
<< Format(Color::Red, FontWeight::Bold) << "error:"
<< ResetFormat() << " "
<< Format(Color::White, FontWeight::Bold) << message
<< ResetFormat() << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::logError(const StreamCoordinate &coordinate, const std::string &message)
{
m_errorStream
<< Format(Color::White, FontWeight::Bold) << coordinate.sectionName << ":"
<< std::to_string(coordinate.row) + ":" + std::to_string(coordinate.column) << ":"
<< ResetFormat() << " "
<< Format(Color::Red, FontWeight::Bold) << "error:"
<< ResetFormat() << " "
<< Format(Color::White, FontWeight::Bold) << message
<< ResetFormat() << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Logger::logWarning(const StreamCoordinate &coordinate, const std::string &message)
{
if (m_warningLevel == WarningLevel::Ignore)
return;
if (m_warningLevel == WarningLevel::Error)
throw ParserException(coordinate, message);
m_errorStream
<< Format(Color::White, FontWeight::Bold) << coordinate.sectionName << ":"
<< std::to_string(coordinate.row) + ":" + std::to_string(coordinate.column) << ":"
<< ResetFormat() << " "
<< Format(Color::Magenta, FontWeight::Bold) << "warning:"
<< ResetFormat() << " "
<< Format(Color::White, FontWeight::Bold) << message
<< ResetFormat() << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}

14
tests/TestPDDLNormalization.cpp
View File

@ -33,7 +33,7 @@ TEST_CASE("[PDDL normalization] PDDL expressions are correctly reduced", "[PDDL
std::stringstream output;
n1->reduced()->print(output);
REQUIRE(output.str() == "(not (not (and (or (or (not (a)) (b)) (c)) (d))))");
CHECK(output.str() == "(not (not (and (or (or (not (a)) (b)) (c)) (d))))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -63,7 +63,7 @@ TEST_CASE("[PDDL normalization] PDDL expressions are correctly simplified", "[PD
std::stringstream output;
a1->simplified()->print(output);
REQUIRE(output.str() == "(and (a) (b) (c) (d) (or (e) (f) (g) (h)))");
CHECK(output.str() == "(and (a) (b) (c) (d) (or (e) (f) (g) (h)))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -78,7 +78,7 @@ TEST_CASE("[PDDL normalization] Implications are correctly replaced", "[PDDL nor
std::stringstream output;
i->normalized()->print(output);
REQUIRE(output.str() == "(or (not (a)) (b))");
CHECK(output.str() == "(or (not (a)) (b))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -94,7 +94,7 @@ TEST_CASE("[PDDL normalization] Double negations are correctly replaced", "[PDDL
std::stringstream output;
n1->normalized()->print(output);
REQUIRE(output.str() == "(a)");
CHECK(output.str() == "(a)");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -112,7 +112,7 @@ TEST_CASE("[PDDL normalization] De Morgan’s rule is correctly applied to negat
std::stringstream output;
n->normalized()->print(output);
REQUIRE(output.str() == "(or (not (a)) (not (b)) (not (c)))");
CHECK(output.str() == "(or (not (a)) (not (b)) (not (c)))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -130,7 +130,7 @@ TEST_CASE("[PDDL normalization] De Morgan’s rule is correctly applied to negat
std::stringstream output;
n->normalized()->print(output);
REQUIRE(output.str() == "(and (not (a)) (not (b)) (not (c)))");
CHECK(output.str() == "(and (not (a)) (not (b)) (not (c)))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -153,5 +153,5 @@ TEST_CASE("[PDDL normalization] Expressions inside double negations are also nor
std::stringstream output;
n1->normalized()->print(output);
REQUIRE(output.str() == "(or (not (a)) (not (b)) (not (c)))");
CHECK(output.str() == "(or (not (a)) (not (b)) (not (c)))");
}

378
tests/TestPDDLParser.cpp
View File

@ -18,26 +18,29 @@ using namespace plasp::pddl;
TEST_CASE("[PDDL parser] The Blocks World domain is parsed correctly", "[PDDL parser]")
{
const auto description = Description::fromFile("data/blocksworld-domain.pddl");
plasp::output::Logger logger;
Context context(Parser(), logger);
const auto description = Description::fromFile("data/blocksworld-domain.pddl", context);
REQUIRE_NOTHROW(description.domain());
const auto &domain = description.domain();
// Name
REQUIRE(domain.name() == "blocks");
CHECK(domain.name() == "blocks");
// Requirements
REQUIRE(domain.requirements().size() == 2u);
REQUIRE(domain.requirements()[0].type() == Requirement::Type::STRIPS);
REQUIRE(domain.requirements()[1].type() == Requirement::Type::Typing);
CHECK(domain.requirements()[0].type() == Requirement::Type::STRIPS);
CHECK(domain.requirements()[1].type() == Requirement::Type::Typing);
// Types
REQUIRE(domain.types().size() == 1u);
const auto &block = *domain.types()[0];
REQUIRE(block.name() == "block");
CHECK(block.name() == "block");
REQUIRE(block.parentTypes().size() == 0u);
// Predicates
@ -45,67 +48,70 @@ TEST_CASE("[PDDL parser] The Blocks World domain is parsed correctly", "[PDDL pa
const auto &on = *domain.predicates()[0];
REQUIRE(on.name() == "on");
CHECK(on.name() == "on");
REQUIRE(on.arguments().size() == 2u);
REQUIRE(on.arguments()[0]->name() == "x");
CHECK(on.arguments()[0]->name() == "x");
const auto &onArgument0Type = dynamic_cast<const expressions::PrimitiveType &>(*on.arguments()[0]->type());
REQUIRE(&onArgument0Type == &block);
REQUIRE(on.arguments()[1]->name() == "y");
CHECK(&onArgument0Type == &block);
CHECK(on.arguments()[1]->name() == "y");
const auto &onArgument1Type = dynamic_cast<const expressions::PrimitiveType &>(*on.arguments()[1]->type());
REQUIRE(&onArgument1Type == &block);
CHECK(&onArgument1Type == &block);
const auto &handempty = *domain.predicates()[3];
REQUIRE(handempty.name() == "handempty");
REQUIRE(handempty.arguments().empty());
CHECK(handempty.name() == "handempty");
CHECK(handempty.arguments().empty());
// Actions
REQUIRE(domain.actions().size() == 4u);
const auto &pickUp = *domain.actions()[0];
REQUIRE(pickUp.name() == "pick-up");
CHECK(pickUp.name() == "pick-up");
REQUIRE(pickUp.parameters().size() == 1u);
REQUIRE(pickUp.parameters()[0]->name() == "x");
REQUIRE(pickUp.parameters()[0]->type() == &block);
CHECK(pickUp.parameters()[0]->name() == "x");
CHECK(pickUp.parameters()[0]->type() == &block);
const auto &pickUpPre = dynamic_cast<const expressions::And &>(*pickUp.precondition());
REQUIRE(pickUpPre.arguments().size() == 3u);
const auto &pickUpPre0 = dynamic_cast<const expressions::Predicate &>(*pickUpPre.arguments()[0]);
REQUIRE(pickUpPre0.name() == "clear");
CHECK(pickUpPre0.name() == "clear");
REQUIRE(pickUpPre0.arguments().size() == 1u);
const auto &pickUpPre00 = dynamic_cast<const expressions::Variable &>(*pickUpPre0.arguments()[0]);
REQUIRE(pickUpPre00.name() == "x");
REQUIRE(pickUpPre00.type() == &block);
REQUIRE(&pickUpPre00 == pickUp.parameters()[0].get());
CHECK(pickUpPre00.name() == "x");
CHECK(pickUpPre00.type() == &block);
CHECK(&pickUpPre00 == pickUp.parameters()[0].get());
const auto &pickUpPre2 = dynamic_cast<const expressions::Predicate &>(*pickUpPre.arguments()[2]);
REQUIRE(pickUpPre2.name() == "handempty");
REQUIRE(pickUpPre2.arguments().size() == 0u);
CHECK(pickUpPre2.name() == "handempty");
CHECK(pickUpPre2.arguments().empty());
const auto &pickUpEff = dynamic_cast<const expressions::And &>(*pickUp.effect());
REQUIRE(pickUpEff.arguments().size() == 4u);
const auto &pickUpEff0 = dynamic_cast<const expressions::Not &>(*pickUpEff.arguments()[0]);
const auto &pickUpEff00 = dynamic_cast<const expressions::Predicate &>(*pickUpEff0.argument());
REQUIRE(pickUpEff00.name() == "ontable");
CHECK(pickUpEff00.name() == "ontable");
REQUIRE(pickUpEff00.arguments().size() == 1u);
const auto &pickUpEff000 = dynamic_cast<const expressions::Variable &>(*pickUpEff00.arguments()[0]);
REQUIRE(pickUpEff000.name() == "x");
REQUIRE(pickUpEff000.type() == &block);
CHECK(pickUpEff000.name() == "x");
CHECK(pickUpEff000.type() == &block);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] A Blocks World problem is parsed correctly", "[PDDL parser]")
{
const auto description = Description::fromFiles({"data/blocksworld-domain.pddl", "data/blocksworld-problem.pddl"});
plasp::output::Logger logger;
Context context(Parser(), logger);
const auto description = Description::fromFiles({"data/blocksworld-domain.pddl", "data/blocksworld-problem.pddl"}, context);
REQUIRE_NOTHROW(description.problem());
const auto &problem = description.problem();
// Name
REQUIRE(problem.name() == "blocks-4-0");
REQUIRE(problem.domain().name() == "blocks");
CHECK(problem.name() == "blocks-4-0");
CHECK(problem.domain().name() == "blocks");
// Requirements
// TODO: compute domain vs. problem requirements correctly and check them
@ -113,26 +119,26 @@ TEST_CASE("[PDDL parser] A Blocks World problem is parsed correctly", "[PDDL par
// Objects
REQUIRE(problem.objects().size() == 4u);
REQUIRE(problem.objects()[0]->name() == "d");
CHECK(problem.objects()[0]->name() == "d");
REQUIRE(problem.objects()[0]->type() != nullptr);
REQUIRE(problem.objects()[0]->type()->name() == "block");
REQUIRE(problem.objects()[3]->name() == "c");
CHECK(problem.objects()[0]->type()->name() == "block");
CHECK(problem.objects()[3]->name() == "c");
REQUIRE(problem.objects()[3]->type() != nullptr);
REQUIRE(problem.objects()[3]->type()->name() == "block");
CHECK(problem.objects()[3]->type()->name() == "block");
// Initial State
const auto &facts = problem.initialState().facts();
REQUIRE(facts.size() == 9u);
const auto &fact0 = dynamic_cast<const expressions::Predicate &>(*facts[0].get());
REQUIRE(fact0.name() == "clear");
CHECK(fact0.name() == "clear");
REQUIRE(fact0.arguments().size() == 1u);
const auto &fact00 = dynamic_cast<const expressions::Constant &>(*fact0.arguments()[0]);
REQUIRE(fact00.name() == "c");
CHECK(fact00.name() == "c");
REQUIRE(fact00.type() != nullptr);
REQUIRE(fact00.type()->name() == "block");
CHECK(fact00.type()->name() == "block");
const auto &fact8 = dynamic_cast<const expressions::Predicate &>(*facts[8].get());
REQUIRE(fact8.name() == "handempty");
CHECK(fact8.name() == "handempty");
REQUIRE(fact8.arguments().size() == 0u);
// Goal
@ -140,37 +146,40 @@ TEST_CASE("[PDDL parser] A Blocks World problem is parsed correctly", "[PDDL par
REQUIRE(goal.arguments().size() == 3u);
const auto &goal0 = dynamic_cast<const expressions::Predicate &>(*goal.arguments()[0]);
REQUIRE(goal0.name() == "on");
CHECK(goal0.name() == "on");
REQUIRE(goal0.arguments().size() == 2u);
const auto &goal00 = dynamic_cast<const expressions::Constant &>(*goal0.arguments()[0]);
REQUIRE(goal00.name() == "d");
CHECK(goal00.name() == "d");
const auto &goal01 = dynamic_cast<const expressions::Constant &>(*goal0.arguments()[1]);
REQUIRE(goal01.name() == "c");
CHECK(goal01.name() == "c");
const auto &goal2 = dynamic_cast<const expressions::Predicate &>(*goal.arguments()[2]);
REQUIRE(goal2.name() == "on");
CHECK(goal2.name() == "on");
REQUIRE(goal2.arguments().size() == 2u);
const auto &goal20 = dynamic_cast<const expressions::Constant &>(*goal2.arguments()[0]);
REQUIRE(goal20.name() == "b");
CHECK(goal20.name() == "b");
const auto &goal21 = dynamic_cast<const expressions::Constant &>(*goal2.arguments()[1]);
REQUIRE(goal21.name() == "a");
CHECK(goal21.name() == "a");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] The Storage domain is parsed correctly", "[PDDL parser]")
{
const auto description = plasp::pddl::Description::fromFile("data/storage-domain.pddl");
plasp::output::Logger logger;
Context context(Parser(), logger);
const auto description = plasp::pddl::Description::fromFile("data/storage-domain.pddl", context);
REQUIRE_NOTHROW(description.domain());
const auto &domain = description.domain();
// Name
REQUIRE(domain.name() == "storage-propositional");
CHECK(domain.name() == "storage-propositional");
// Requirements
REQUIRE(domain.requirements().size() == 1u);
REQUIRE(domain.requirements()[0].type() == Requirement::Type::Typing);
CHECK(domain.requirements()[0].type() == Requirement::Type::Typing);
// Types
REQUIRE(domain.types().size() == 10u);
@ -184,81 +193,84 @@ TEST_CASE("[PDDL parser] The Storage domain is parsed correctly", "[PDDL parser]
const auto &hoistParents = hoist.parentTypes();
REQUIRE(hoistParents.size() == 1u);
REQUIRE(std::find(hoistParents.cbegin(), hoistParents.cend(), &object) != hoistParents.cend());
CHECK(std::find(hoistParents.cbegin(), hoistParents.cend(), &object) != hoistParents.cend());
const auto &areaParents = area.parentTypes();
REQUIRE(areaParents.size() == 2u);
REQUIRE(std::find(areaParents.cbegin(), areaParents.cend(), &object) != areaParents.cend());
REQUIRE(std::find(areaParents.cbegin(), areaParents.cend(), &surface) != areaParents.cend());
CHECK(std::find(areaParents.cbegin(), areaParents.cend(), &object) != areaParents.cend());
CHECK(std::find(areaParents.cbegin(), areaParents.cend(), &surface) != areaParents.cend());
// Predicates
REQUIRE(domain.predicates().size() == 8u);
const auto &on = *domain.predicates()[5];
REQUIRE(on.name() == "on");
CHECK(on.name() == "on");
REQUIRE(on.arguments().size() == 2u);
REQUIRE(on.arguments()[0]->name() == "c");
CHECK(on.arguments()[0]->name() == "c");
const auto &onArgument0Type = dynamic_cast<const expressions::PrimitiveType &>(*on.arguments()[0]->type());
REQUIRE(&onArgument0Type == &crate);
REQUIRE(on.arguments()[1]->name() == "s");
CHECK(&onArgument0Type == &crate);
CHECK(on.arguments()[1]->name() == "s");
const auto &onArgument1Type = dynamic_cast<const expressions::PrimitiveType &>(*on.arguments()[1]->type());
REQUIRE(&onArgument1Type == &storearea);
CHECK(&onArgument1Type == &storearea);
const auto &in = *domain.predicates()[1];
REQUIRE(in.name() == "in");
CHECK(in.name() == "in");
REQUIRE(in.arguments().size() == 2u);
REQUIRE(in.arguments()[0]->name() == "x");
CHECK(in.arguments()[0]->name() == "x");
const auto &inArgument0Type = dynamic_cast<const expressions::Either &>(*in.arguments()[0]->type());
REQUIRE(inArgument0Type.arguments().size() == 2u);
const auto &inArgument0Type0 = dynamic_cast<const expressions::PrimitiveType &>(*inArgument0Type.arguments()[0]);
REQUIRE(&inArgument0Type0 == &storearea);
CHECK(&inArgument0Type0 == &storearea);
const auto &inArgument0Type1 = dynamic_cast<const expressions::PrimitiveType &>(*inArgument0Type.arguments()[1]);
REQUIRE(&inArgument0Type1 == &crate);
CHECK(&inArgument0Type1 == &crate);
// Actions
REQUIRE(domain.actions().size() == 5u);
const auto &drop = *domain.actions()[1];
REQUIRE(drop.name() == "drop");
CHECK(drop.name() == "drop");
REQUIRE(drop.parameters().size() == 5u);
REQUIRE(drop.parameters()[3]->name() == "a2");
REQUIRE(drop.parameters()[3]->type() == &area);
CHECK(drop.parameters()[3]->name() == "a2");
CHECK(drop.parameters()[3]->type() == &area);
const auto &dropPre = dynamic_cast<const expressions::And &>(*drop.precondition());
REQUIRE(dropPre.arguments().size() == 5u);
const auto &dropPre2 = dynamic_cast<const expressions::Predicate &>(*dropPre.arguments()[2]);
REQUIRE(dropPre2.name() == "lifting");
CHECK(dropPre2.name() == "lifting");
REQUIRE(dropPre2.arguments().size() == 2u);
const auto &dropPre21 = dynamic_cast<const expressions::Variable &>(*dropPre2.arguments()[1]);
REQUIRE(dropPre21.name() == "c");
REQUIRE(dropPre21.type() == &crate);
CHECK(dropPre21.name() == "c");
CHECK(dropPre21.type() == &crate);
const auto &dropEff = dynamic_cast<const expressions::And &>(*drop.effect());
REQUIRE(dropEff.arguments().size() == 5u);
const auto &dropEff2 = dynamic_cast<const expressions::Not &>(*dropEff.arguments()[2]);
const auto &dropEff20 = dynamic_cast<const expressions::Predicate &>(*dropEff2.argument());
REQUIRE(dropEff20.name() == "clear");
CHECK(dropEff20.name() == "clear");
REQUIRE(dropEff20.arguments().size() == 1u);
const auto &dropEff200 = dynamic_cast<const expressions::Variable &>(*dropEff20.arguments()[0]);
REQUIRE(dropEff200.name() == "a1");
REQUIRE(dropEff200.type() == &storearea);
CHECK(dropEff200.name() == "a1");
CHECK(dropEff200.type() == &storearea);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] A Storage problem is parsed correctly", "[PDDL parser]")
{
const auto description = Description::fromFiles({"data/storage-domain.pddl", "data/storage-problem.pddl"});
plasp::output::Logger logger;
Context context(Parser(), logger);
const auto description = Description::fromFiles({"data/storage-domain.pddl", "data/storage-problem.pddl"}, context);
REQUIRE_NOTHROW(description.problem());
const auto &problem = description.problem();
// Name
REQUIRE(problem.name() == "storage-1");
REQUIRE(problem.domain().name() == "storage-propositional");
CHECK(problem.name() == "storage-1");
CHECK(problem.domain().name() == "storage-propositional");
// Requirements
// TODO: compute domain vs. problem requirements correctly and check them
@ -266,57 +278,60 @@ TEST_CASE("[PDDL parser] A Storage problem is parsed correctly", "[PDDL parser]"
// Objects
REQUIRE(problem.objects().size() == 7u);
REQUIRE(problem.objects()[0]->name() == "depot0-1-1");
CHECK(problem.objects()[0]->name() == "depot0-1-1");
REQUIRE(problem.objects()[0]->type() != nullptr);
REQUIRE(problem.objects()[0]->type()->name() == "storearea");
REQUIRE(problem.objects()[6]->name() == "loadarea");
CHECK(problem.objects()[0]->type()->name() == "storearea");
CHECK(problem.objects()[6]->name() == "loadarea");
REQUIRE(problem.objects()[6]->type() != nullptr);
REQUIRE(problem.objects()[6]->type()->name() == "transitarea");
CHECK(problem.objects()[6]->type()->name() == "transitarea");
// Initial State
const auto &facts = problem.initialState().facts();
REQUIRE(facts.size() == 10u);
const auto &fact0 = dynamic_cast<const expressions::Predicate &>(*facts[0].get());
REQUIRE(fact0.name() == "in");
CHECK(fact0.name() == "in");
REQUIRE(fact0.arguments().size() == 2u);
const auto &fact01 = dynamic_cast<const expressions::Constant &>(*fact0.arguments()[1]);
REQUIRE(fact01.name() == "depot0");
CHECK(fact01.name() == "depot0");
REQUIRE(fact01.type() != nullptr);
REQUIRE(fact01.type()->name() == "depot");
CHECK(fact01.type()->name() == "depot");
const auto &fact9 = dynamic_cast<const expressions::Predicate &>(*facts[9].get());
REQUIRE(fact9.name() == "available");
CHECK(fact9.name() == "available");
REQUIRE(fact9.arguments().size() == 1u);
const auto &fact90 = dynamic_cast<const expressions::Constant &>(*fact9.arguments()[0]);
REQUIRE(fact90.name() == "hoist0");
CHECK(fact90.name() == "hoist0");
REQUIRE(fact90.type() != nullptr);
REQUIRE(fact90.type()->name() == "hoist");
CHECK(fact90.type()->name() == "hoist");
// Goal
const auto &goal = dynamic_cast<const expressions::And &>(problem.goal());
REQUIRE(goal.arguments().size() == 1u);
const auto &goal0 = dynamic_cast<const expressions::Predicate &>(*goal.arguments()[0]);
REQUIRE(goal0.name() == "in");
CHECK(goal0.name() == "in");
REQUIRE(goal0.arguments().size() == 2u);
const auto &goal00 = dynamic_cast<const expressions::Constant &>(*goal0.arguments()[0]);
REQUIRE(goal00.name() == "crate0");
CHECK(goal00.name() == "crate0");
const auto &goal01 = dynamic_cast<const expressions::Constant &>(*goal0.arguments()[1]);
REQUIRE(goal01.name() == "depot0");
CHECK(goal01.name() == "depot0");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] Constants are parsed correctly", "[PDDL parser]")
{
const auto description = Description::fromFile("data/woodworking-domain.pddl");
plasp::output::Logger logger;
Context context(Parser(), logger);
const auto description = Description::fromFile("data/woodworking-domain.pddl", context);
REQUIRE_NOTHROW(description.domain());
const auto &domain = description.domain();
// Name
REQUIRE(domain.name() == "woodworking");
CHECK(domain.name() == "woodworking");
// Types
const auto &acolour = *domain.types()[0];
@ -325,11 +340,11 @@ TEST_CASE("[PDDL parser] Constants are parsed correctly", "[PDDL parser]")
// Constants
REQUIRE(domain.constants().size() == 8u);
REQUIRE(domain.constants()[0]->type() == &surface);
REQUIRE(domain.constants()[2]->type() == &surface);
REQUIRE(domain.constants()[3]->type() == &treatmentstatus);
REQUIRE(domain.constants()[6]->type() == &treatmentstatus);
REQUIRE(domain.constants()[7]->type() == &acolour);
CHECK(domain.constants()[0]->type() == &surface);
CHECK(domain.constants()[2]->type() == &surface);
CHECK(domain.constants()[3]->type() == &treatmentstatus);
CHECK(domain.constants()[6]->type() == &treatmentstatus);
CHECK(domain.constants()[7]->type() == &acolour);
// TODO: add test with constants in predicates
}
@ -338,68 +353,179 @@ TEST_CASE("[PDDL parser] Constants are parsed correctly", "[PDDL parser]")
TEST_CASE("[PDDL parser] White spaces are ignored", "[PDDL parser]")
{
REQUIRE_NOTHROW(Description::fromFile("data/white-space-test.pddl"));
plasp::output::Logger logger;
Context context(Parser(), logger);
CHECK_NOTHROW(Description::fromFile("data/white-space-test.pddl", context));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] Missing or unmatching domain descriptions are detected", "[PDDL parser]")
{
REQUIRE_THROWS_AS(Description::fromFile("data/blocksworld-problem.pddl"), ConsistencyException);
REQUIRE_THROWS_AS(Description::fromFiles({"data/blocksworld-problem.pddl", "data/storage-domain.pddl"}), plasp::utils::ParserException);
plasp::output::Logger logger;
Context context(Parser(), logger);
SECTION("")
{
CHECK_THROWS_AS(Description::fromFile("data/blocksworld-problem.pddl", context), ConsistencyException);
}
SECTION("")
{
CHECK_THROWS_AS(Description::fromFiles({"data/blocksworld-problem.pddl", "data/storage-domain.pddl"}, context), plasp::input::ParserException);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] Common PDDL syntax errors are detected", "[PDDL parser]")
{
REQUIRE_NOTHROW(Description::fromFile("data/pddl-syntax/domain-valid.pddl"));
plasp::output::Logger logger;
Context context(Parser(), logger);
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-expressions-1.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-expressions-2.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-expressions-3.pddl"));
SECTION("")
{
CHECK_NOTHROW(Description::fromFile("data/pddl-syntax/domain-valid.pddl", context));
}
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-expression-name-1.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-expression-name-2.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-expression-name-3.pddl"));
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-expressions-1.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-expressions-2.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-expressions-3.pddl", context));
}
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-1.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-2.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-3.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-4.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-5.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-6.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-7.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-8.pddl"));
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-expression-name-1.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-expression-name-2.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-expression-name-3.pddl", context));
}
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-1.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-2.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-3.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-4.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-5.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-6.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-7.pddl"));
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-1.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-2.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-3.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-4.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-5.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-6.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-7.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-parentheses-8.pddl", context));
}
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-types-1.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-types-2.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-types-3.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-types-4.pddl"));
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-1.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-2.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-3.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-4.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-5.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-6.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-section-name-7.pddl", context));
}
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-variables-1.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-variables-2.pddl"));
REQUIRE_THROWS(Description::fromFile("data/pddl-syntax/domain-variables-3.pddl"));
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-types-1.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-types-2.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-types-3.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-types-4.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-variables-1.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-variables-2.pddl", context));
}
SECTION("")
{
CHECK_THROWS(Description::fromFile("data/pddl-syntax/domain-variables-3.pddl", context));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL parser] Former issues are fixed", "[PDDL parser]")
{
// Check white space issues with constants and parsing unsupported sections
REQUIRE_NOTHROW(Description::fromFile("data/issues/issue-1.pddl"));
plasp::output::Logger logger;
Context context(Parser(), logger);
// Check white space issues with empty n-ary predicates
REQUIRE_NOTHROW(Description::fromFile("data/issues/issue-2.pddl"));
SECTION("white space issues with constants and parsing unsupported sections")
{
CHECK_NOTHROW(Description::fromFile("data/issues/issue-1.pddl", context));
}
// Check that comments are correctly ignored
REQUIRE_NOTHROW(Description::fromFile("data/issues/issue-3.pddl"));
SECTION("white space issues with empty n-ary predicates")
{
CHECK_NOTHROW(Description::fromFile("data/issues/issue-2.pddl", context));
}
SECTION("comments are correctly ignored")
{
CHECK_NOTHROW(Description::fromFile("data/issues/issue-3.pddl", context));
}
}

15
tests/TestPDDLTranslation.cpp
View File

@ -14,17 +14,20 @@ boost::iostreams::stream<boost::iostreams::null_sink> nullStream((boost::iostrea
TEST_CASE("[PDDL translation] Former issues are fixed", "[PDDL translation]")
{
// Check that translating domains without typing information works
plasp::output::Logger logger;
Context context(Parser(), logger);
SECTION("translating domains without typing information works")
{
auto description = Description::fromFile("data/issues/issue-4.pddl");
auto description = Description::fromFile("data/issues/issue-4.pddl", context);
const auto translator = TranslatorASP(description, description.context().logger.outputStream());
REQUIRE_NOTHROW(translator.translate());
CHECK_NOTHROW(translator.translate());
}
// Check that translating the simple blocks world domain works
SECTION("translating the simple blocks world domain works")
{
auto description = Description::fromFile("data/issues/issue-5.pddl");
auto description = Description::fromFile("data/issues/issue-5.pddl", context);
const auto translator = TranslatorASP(description, description.context().logger.outputStream());
REQUIRE_NOTHROW(translator.translate());
CHECK_NOTHROW(translator.translate());
}
}

92
tests/TestSASParser.cpp
View File

@ -48,64 +48,64 @@ TEST_CASE_METHOD(SASParserTestsFixture, "[SAS parser] A valid SAS file is parsed
{
const auto description = plasp::sas::Description::fromStream(m_philosophersTestFile);
REQUIRE_FALSE(description.usesActionCosts());
CHECK_FALSE(description.usesActionCosts());
REQUIRE(description.variables().size() == 37u);
REQUIRE(description.variables()[0].axiomLayer() == -1);
REQUIRE(description.variables()[0].values()[0].sign() == plasp::sas::Value::Sign::Positive);
REQUIRE(description.variables()[0].values()[0].name() == "activate(philosopher-0, forks--pid-rfork)");
REQUIRE(description.variables()[36].axiomLayer() == -1);
REQUIRE(description.variables()[36].values()[1].sign() == plasp::sas::Value::Sign::Negative);
REQUIRE(description.variables()[36].values()[1].name() == "queue-tail-msg(forks-1-, fork)");
CHECK(description.variables()[0].axiomLayer() == -1);
CHECK(description.variables()[0].values()[0].sign() == plasp::sas::Value::Sign::Positive);
CHECK(description.variables()[0].values()[0].name() == "activate(philosopher-0, forks--pid-rfork)");
CHECK(description.variables()[36].axiomLayer() == -1);
CHECK(description.variables()[36].values()[1].sign() == plasp::sas::Value::Sign::Negative);
CHECK(description.variables()[36].values()[1].name() == "queue-tail-msg(forks-1-, fork)");
REQUIRE(description.mutexGroups().size() == 8u);
REQUIRE(description.mutexGroups()[0].facts().size() == 9u);
REQUIRE(&description.mutexGroups()[0].facts()[0].value() == &description.variables()[0].values()[0]);
CHECK(&description.mutexGroups()[0].facts()[0].value() == &description.variables()[0].values()[0]);
REQUIRE(description.mutexGroups()[7].facts().size() == 2u);
REQUIRE(&description.mutexGroups()[7].facts()[1].value() == &description.variables()[34].values()[1]);
CHECK(&description.mutexGroups()[7].facts()[1].value() == &description.variables()[34].values()[1]);
REQUIRE(description.initialState().facts().size() == 37u);
REQUIRE(&description.initialState().facts()[0].value() == &description.variables()[0].values()[8]);
REQUIRE(&description.initialState().facts()[36].value() == &description.variables()[36].values()[1]);
CHECK(&description.initialState().facts()[0].value() == &description.variables()[0].values()[8]);
CHECK(&description.initialState().facts()[36].value() == &description.variables()[36].values()[1]);
REQUIRE(description.goal().facts().size() == 2u);
REQUIRE(&description.goal().facts()[0].value() == &description.variables()[6].values()[0]);
REQUIRE(&description.goal().facts()[1].value() == &description.variables()[7].values()[0]);
CHECK(&description.goal().facts()[0].value() == &description.variables()[6].values()[0]);
CHECK(&description.goal().facts()[1].value() == &description.variables()[7].values()[0]);
REQUIRE(description.operators().size() == 34u);
REQUIRE(description.operators()[0].predicate().name() == "activate-trans");
CHECK(description.operators()[0].predicate().name() == "activate-trans");
REQUIRE(description.operators()[0].predicate().arguments().size() == 5u);
REQUIRE(description.operators()[0].predicate().arguments()[0] == "philosopher-0");
REQUIRE(description.operators()[0].predicate().arguments()[4] == "state-3");
CHECK(description.operators()[0].predicate().arguments()[0] == "philosopher-0");
CHECK(description.operators()[0].predicate().arguments()[4] == "state-3");
REQUIRE(description.operators()[0].preconditions().size() == 3u);
REQUIRE(&description.operators()[0].preconditions()[0].value() == &description.variables()[4].values()[4]);
REQUIRE(&description.operators()[0].preconditions()[1].value() == &description.variables()[16].values()[1]);
REQUIRE(&description.operators()[0].preconditions()[2].value() == &description.variables()[0].values()[8]);
CHECK(&description.operators()[0].preconditions()[0].value() == &description.variables()[4].values()[4]);
CHECK(&description.operators()[0].preconditions()[1].value() == &description.variables()[16].values()[1]);
CHECK(&description.operators()[0].preconditions()[2].value() == &description.variables()[0].values()[8]);
REQUIRE(description.operators()[0].effects().size() == 1u);
REQUIRE(description.operators()[0].effects()[0].conditions().size() == 0u);
REQUIRE(&description.operators()[0].effects()[0].postcondition().value() == &description.variables()[0].values()[0]);
REQUIRE(description.operators()[33].predicate().name() == "queue-write");
CHECK(&description.operators()[0].effects()[0].postcondition().value() == &description.variables()[0].values()[0]);
CHECK(description.operators()[33].predicate().name() == "queue-write");
REQUIRE(description.operators()[33].predicate().arguments().size() == 4u);
REQUIRE(description.operators()[33].predicate().arguments()[0] == "philosopher-1");
REQUIRE(description.operators()[33].predicate().arguments()[3] == "fork");
CHECK(description.operators()[33].predicate().arguments()[0] == "philosopher-1");
CHECK(description.operators()[33].predicate().arguments()[3] == "fork");
REQUIRE(description.operators()[33].preconditions().size() == 2u);
REQUIRE(&description.operators()[33].preconditions()[0].value() == &description.variables()[1].values()[3]);
REQUIRE(&description.operators()[33].preconditions()[1].value() == &description.variables()[2].values()[2]);
CHECK(&description.operators()[33].preconditions()[0].value() == &description.variables()[1].values()[3]);
CHECK(&description.operators()[33].preconditions()[1].value() == &description.variables()[2].values()[2]);
REQUIRE(description.operators()[33].effects().size() == 3u);
REQUIRE(description.operators()[33].effects()[0].conditions().size() == 0u);
REQUIRE(&description.operators()[33].effects()[0].postcondition().value() == &description.variables()[1].values()[7]);
REQUIRE(&description.operators()[33].effects()[2].postcondition().value() == &description.variables()[35].values()[0]);
CHECK(&description.operators()[33].effects()[0].postcondition().value() == &description.variables()[1].values()[7]);
CHECK(&description.operators()[33].effects()[2].postcondition().value() == &description.variables()[35].values()[0]);
REQUIRE(description.axiomRules().size() == 33u);
REQUIRE(description.axiomRules()[0].conditions().size() == 4u);
REQUIRE(&description.axiomRules()[0].conditions()[0].value() == &description.variables()[0].values()[0]);
REQUIRE(&description.axiomRules()[0].conditions()[2].value() == &description.variables()[27].values()[0]);
REQUIRE(&description.axiomRules()[0].conditions()[3].value() == &description.variables()[8].values()[1]);
REQUIRE(&description.axiomRules()[0].postcondition().value() == &description.variables()[8].values()[0]);
CHECK(&description.axiomRules()[0].conditions()[0].value() == &description.variables()[0].values()[0]);
CHECK(&description.axiomRules()[0].conditions()[2].value() == &description.variables()[27].values()[0]);
CHECK(&description.axiomRules()[0].conditions()[3].value() == &description.variables()[8].values()[1]);
CHECK(&description.axiomRules()[0].postcondition().value() == &description.variables()[8].values()[0]);
REQUIRE(description.axiomRules()[32].conditions().size() == 2u);
REQUIRE(&description.axiomRules()[32].conditions()[0].value() == &description.variables()[15].values()[0]);
REQUIRE(&description.axiomRules()[32].conditions()[1].value() == &description.variables()[25].values()[0]);
REQUIRE(&description.axiomRules()[32].postcondition().value() == &description.variables()[25].values()[1]);
CHECK(&description.axiomRules()[32].conditions()[0].value() == &description.variables()[15].values()[0]);
CHECK(&description.axiomRules()[32].conditions()[1].value() == &description.variables()[25].values()[0]);
CHECK(&description.axiomRules()[32].postcondition().value() == &description.variables()[25].values()[1]);
}
catch (const std::exception &e)
{
@ -123,8 +123,8 @@ TEST_CASE_METHOD(SASParserTestsFixture, "[SAS parser] Trailing empty parentheses
{
const auto description = plasp::sas::Description::fromStream(m_blocksworldTestFile);
REQUIRE(description.variables()[4].values()[0].name() == "handempty");
REQUIRE(description.variables()[5].values()[0].name() == "holding(a)");
CHECK(description.variables()[4].values()[0].name() == "handempty");
CHECK(description.variables()[5].values()[0].name() == "holding(a)");
}
catch (const std::exception &e)
{
@ -141,8 +141,8 @@ TEST_CASE_METHOD(SASParserTestsFixture, "[SAS parser] “none” values are corr
const auto description = plasp::sas::Description::fromStream(m_freecellTestFile);
// TODO: compare by identity, not value
REQUIRE(description.variables()[0].values()[3] == plasp::sas::Value::None);
REQUIRE(description.variables()[5].values()[6] == plasp::sas::Value::None);
CHECK(description.variables()[0].values()[3] == plasp::sas::Value::None);
CHECK(description.variables()[5].values()[6] == plasp::sas::Value::None);
}
catch (const std::exception &e)
{
@ -158,19 +158,19 @@ TEST_CASE_METHOD(SASParserTestsFixture, "[SAS parser] SAS requirements are parse
{
const auto description = plasp::sas::Description::fromStream(m_cavedivingTestFile);
REQUIRE(description.usesActionCosts());
REQUIRE(description.usesConditionalEffects());
REQUIRE_FALSE(description.usesAxiomRules());
CHECK(description.usesActionCosts());
CHECK(description.usesConditionalEffects());
CHECK_FALSE(description.usesAxiomRules());
REQUIRE(description.operators().size() == 496u);
REQUIRE(description.operators()[0].costs() == 1u);
REQUIRE(description.operators()[172].costs() == 10u);
REQUIRE(description.operators()[173].costs() == 63u);
CHECK(description.operators()[0].costs() == 1u);
CHECK(description.operators()[172].costs() == 10u);
CHECK(description.operators()[173].costs() == 63u);
REQUIRE(description.operators()[172].effects().size() == 3u);
REQUIRE(description.operators()[172].effects()[1].conditions().size() == 1u);
REQUIRE(&description.operators()[172].effects()[1].conditions()[0].value() == &description.variables()[1].values()[4]);
CHECK(&description.operators()[172].effects()[1].conditions()[0].value() == &description.variables()[1].values()[4]);
}
catch (const std::exception &e)
{
@ -183,5 +183,5 @@ TEST_CASE_METHOD(SASParserTestsFixture, "[SAS parser] SAS requirements are parse
TEST_CASE("[SAS parser] Former issues are fixed", "[SAS parser]")
{
// Check issue where unexpected whitespaces in SAS files led to a parsing error
REQUIRE_NOTHROW(plasp::sas::Description::fromFile("data/issues/issue-6.sas"));
CHECK_NOTHROW(plasp::sas::Description::fromFile("data/issues/issue-6.sas"));
}

154
tests/TestUtils.cpp
View File

@ -1,14 +1,14 @@
#include <catch.hpp>
#include <plasp/utils/Parser.h>
#include <plasp/utils/ParserException.h>
#include <plasp/input/Parser.h>
#include <plasp/input/ParserException.h>
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[parser] Simple strings are parsed correctly", "[parser]")
{
std::stringstream s(" identifier 5 \n-51\t 0 1 100 200 -300 -400");
plasp::utils::Parser<> p("input", s);
plasp::input::Parser<> p("input", s);
REQUIRE(p.parse<std::string>() == "identifier");
REQUIRE(p.parse<size_t>() == 5u);
@ -19,7 +19,7 @@ TEST_CASE("[parser] Simple strings are parsed correctly", "[parser]")
REQUIRE(p.parse<int>() == 100);
REQUIRE(p.parse<size_t>() == 200u);
REQUIRE(p.parse<int>() == -300);
REQUIRE_THROWS_AS(p.parse<size_t>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.parse<size_t>(), plasp::input::ParserException);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -27,7 +27,7 @@ TEST_CASE("[parser] Simple strings are parsed correctly", "[parser]")
TEST_CASE("[parser] Parsing exceptions are correctly reported", "[parser]")
{
std::stringstream s(" identifier 5 \n-51\t 0 1 100 200 -300 -400");
plasp::utils::Parser<> p("input", s);
plasp::input::Parser<> p("input", s);
REQUIRE_NOTHROW(p.expect<std::string>("identifier"));
REQUIRE_NOTHROW(p.expect<size_t>(5u));
@ -38,31 +38,31 @@ TEST_CASE("[parser] Parsing exceptions are correctly reported", "[parser]")
REQUIRE_NOTHROW(p.expect<int>(100));
REQUIRE_NOTHROW(p.expect<size_t>(200u));
REQUIRE_NOTHROW(p.expect<int>(-300));
REQUIRE_THROWS_AS(p.expect<size_t>(-400), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<size_t>(-400), plasp::input::ParserException);
p.seek(0);
REQUIRE_THROWS_AS(p.expect<std::string>("error"), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<std::string>("error"), plasp::input::ParserException);
p.seek(14);
REQUIRE_THROWS_AS(p.expect<size_t>(6u), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<size_t>(6u), plasp::input::ParserException);
p.seek(17);
REQUIRE_THROWS_AS(p.expect<int>(-50), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<int>(-50), plasp::input::ParserException);
p.seek(24);
REQUIRE_THROWS_AS(p.expect<bool>(true), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<bool>(true), plasp::input::ParserException);
p.seek(26);
REQUIRE_THROWS_AS(p.expect<bool>(false), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<bool>(false), plasp::input::ParserException);
p.seek(28);
REQUIRE_THROWS_AS(p.expect<int>(101), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<int>(101), plasp::input::ParserException);
p.seek(31);
REQUIRE_THROWS_AS(p.expect<size_t>(201), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<size_t>(201), plasp::input::ParserException);
p.seek(34);
REQUIRE_THROWS_AS(p.expect<int>(-299), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p.expect<int>(-299), plasp::input::ParserException);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -70,9 +70,9 @@ TEST_CASE("[parser] Parsing exceptions are correctly reported", "[parser]")
TEST_CASE("[parser] While parsing, the cursor position is as expected", "[parser]")
{
std::stringstream s(" identifier 5 \n-51\t 0 1");
plasp::utils::Parser<> p("input", s);
plasp::input::Parser<> p("input", s);
plasp::utils::Parser<>::Position pos;
plasp::input::Parser<>::Position pos;
pos = p.position();
REQUIRE(p.testAndReturn<std::string>("error") == false);
@ -130,136 +130,136 @@ TEST_CASE("[parser] While parsing, the cursor position is as expected", "[parser
TEST_CASE("[parser] The end of the input stream is correctly handled", "[parser]")
{
std::stringstream s1("test");
plasp::utils::Parser<> p1("input", s1);
plasp::input::Parser<> p1("input", s1);
REQUIRE_NOTHROW(p1.expect<std::string>("test"));
REQUIRE_THROWS_AS(p1.parse<std::string>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p1.parse<std::string>(), plasp::input::ParserException);
std::stringstream s2("test1 test2 test3");
plasp::utils::Parser<> p2("input", s2);
plasp::input::Parser<> p2("input", s2);
REQUIRE_NOTHROW(p2.expect<std::string>("test1"));
REQUIRE_NOTHROW(p2.expect<std::string>("test2"));
REQUIRE_NOTHROW(p2.expect<std::string>("test3"));
REQUIRE_THROWS_AS(p2.parse<std::string>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p2.parse<std::string>(), plasp::input::ParserException);
std::stringstream s3("-127");
plasp::utils::Parser<> p3("input", s3);
plasp::input::Parser<> p3("input", s3);
p3.expect<int>(-127);
REQUIRE_THROWS_AS(p3.parse<int>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p3.parse<int>(), plasp::input::ParserException);
std::stringstream s4("128 -1023 -4095");
plasp::utils::Parser<> p4("input", s4);
plasp::input::Parser<> p4("input", s4);
REQUIRE_NOTHROW(p4.expect<size_t>(128));
REQUIRE_NOTHROW(p4.expect<int>(-1023));
REQUIRE_NOTHROW(p4.expect<int>(-4095));
REQUIRE_THROWS_AS(p4.parse<int>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p4.parse<int>(), plasp::input::ParserException);
std::stringstream s5("0");
plasp::utils::Parser<> p5("input", s5);
plasp::input::Parser<> p5("input", s5);
p5.expect<bool>(false);
REQUIRE_THROWS_AS(p5.parse<bool>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p5.parse<bool>(), plasp::input::ParserException);
std::stringstream s6("0 1 0");
plasp::utils::Parser<> p6("input", s6);
plasp::input::Parser<> p6("input", s6);
REQUIRE_NOTHROW(p6.expect<bool>(false));
REQUIRE_NOTHROW(p6.expect<bool>(true));
REQUIRE_NOTHROW(p6.expect<bool>(false));
REQUIRE_THROWS_AS(p6.parse<bool>(), plasp::utils::ParserException);
REQUIRE_THROWS_AS(p6.parse<bool>(), plasp::input::ParserException);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[parser] While parsing, the cursor coordinate is as expcected", "[parser]")
TEST_CASE("[parser] While parsing, the cursor location is as expcected", "[parser]")
{
std::stringstream s("123 \n4\ntest1\n test2\ntest3 \ntest4\n\n\n\n");
plasp::utils::Parser<> p("input", s);
plasp::input::Parser<> p("input", s);
const auto startPosition = p.position();
plasp::utils::StreamCoordinate c;
plasp::input::Location l;
c = p.coordinate();
REQUIRE(c.row == 1u);
REQUIRE(c.column == 1u);
l = p.location();
REQUIRE(l.rowStart == 1u);
REQUIRE(l.columnStart == 1u);
REQUIRE(p.currentCharacter() == '1');
REQUIRE_NOTHROW(p.advance());
c = p.coordinate();
REQUIRE(c.row == 1u);
REQUIRE(c.column == 2u);
l = p.location();
REQUIRE(l.rowStart == 1u);
REQUIRE(l.columnStart == 2u);
REQUIRE(p.currentCharacter() == '2');
REQUIRE_NOTHROW(p.advance());
c = p.coordinate();
REQUIRE(c.row == 1u);
REQUIRE(c.column == 3u);
l = p.location();
REQUIRE(l.rowStart == 1u);
REQUIRE(l.columnStart == 3u);
REQUIRE(p.currentCharacter() == '3');
REQUIRE_NOTHROW(p.advance());
c = p.coordinate();
REQUIRE(c.row == 1u);
REQUIRE(c.column == 4u);
l = p.location();
REQUIRE(l.rowStart == 1u);
REQUIRE(l.columnStart == 4u);
REQUIRE(p.currentCharacter() == ' ');
REQUIRE_NOTHROW(p.advance());
c = p.coordinate();
REQUIRE(c.row == 1u);
REQUIRE(c.column == 5u);
l = p.location();
REQUIRE(l.rowStart == 1u);
REQUIRE(l.columnStart == 5u);
REQUIRE(p.currentCharacter() == '\n');
REQUIRE_NOTHROW(p.advance());
c = p.coordinate();
REQUIRE(c.row == 2u);
REQUIRE(c.column == 1u);
l = p.location();
REQUIRE(l.rowStart == 2u);
REQUIRE(l.columnStart == 1u);
REQUIRE(p.currentCharacter() == '4');
REQUIRE_NOTHROW(p.advance());
REQUIRE_NOTHROW(p.expect<std::string>("test1"));
c = p.coordinate();
REQUIRE(c.row == 3u);
REQUIRE(c.column == 6u);
l = p.location();
REQUIRE(l.rowStart == 3u);
REQUIRE(l.columnStart == 6u);
REQUIRE_NOTHROW(p.expect<std::string>("test2"));
c = p.coordinate();
REQUIRE(c.row == 4u);
REQUIRE(c.column == 7u);
l = p.location();
REQUIRE(l.rowStart == 4u);
REQUIRE(l.columnStart == 7u);
REQUIRE_NOTHROW(p.expect<std::string>("test3"));
c = p.coordinate();
REQUIRE(c.row == 5u);
REQUIRE(c.column == 6u);
l = p.location();
REQUIRE(l.rowStart == 5u);
REQUIRE(l.columnStart == 6u);
REQUIRE_NOTHROW(p.skipLine());
c = p.coordinate();
REQUIRE(c.row == 6u);
REQUIRE(c.column == 1u);
l = p.location();
REQUIRE(l.rowStart == 6u);
REQUIRE(l.columnStart == 1u);
REQUIRE_NOTHROW(p.skipLine());
c = p.coordinate();
REQUIRE(c.row == 7u);
REQUIRE(c.column == 1u);
l = p.location();
REQUIRE(l.rowStart == 7u);
REQUIRE(l.columnStart == 1u);
REQUIRE_NOTHROW(p.skipWhiteSpace());
c = p.coordinate();
REQUIRE(c.row == 10u);
REQUIRE(c.column == 1u);
l = p.location();
REQUIRE(l.rowStart == 10u);
REQUIRE(l.columnStart == 1u);
REQUIRE(p.atEnd());
p.reset();
@ -285,30 +285,30 @@ TEST_CASE("[parser] While parsing, the cursor coordinate is as expcected", "[par
TEST_CASE("[parser] Comments are correctly removed", "[parser]")
{
std::stringstream s1("; comment at beginning\ntest1; comment in between\ntest2; comment at end");
plasp::utils::Parser<> p1("input", s1);
plasp::input::Parser<> p1("input", s1);
p1.removeComments(";", "\n", false);
plasp::utils::StreamCoordinate c;
plasp::input::Location l;
REQUIRE_NOTHROW(p1.expect<std::string>("test1"));
c = p1.coordinate();
REQUIRE(c.row == 2u);
REQUIRE(c.column == 6u);
l = p1.location();
REQUIRE(l.rowStart == 2u);
REQUIRE(l.columnStart == 6u);
REQUIRE_NOTHROW(p1.expect<std::string>("test2"));
c = p1.coordinate();
REQUIRE(c.row == 3u);
REQUIRE(c.column == 6u);
l = p1.location();
REQUIRE(l.rowStart == 3u);
REQUIRE(l.columnStart == 6u);
p1.skipWhiteSpace();
REQUIRE(p1.atEnd());
std::stringstream s2("test;");
plasp::utils::Parser<> p2("input", s2);
plasp::input::Parser<> p2("input", s2);
p2.removeComments(";", "\n", false);
@ -319,7 +319,7 @@ TEST_CASE("[parser] Comments are correctly removed", "[parser]")
REQUIRE(p2.atEnd());
std::stringstream s3("/* comment at start */ test1 /* comment in between */ test2 /*");
plasp::utils::Parser<> p3("input", s3);
plasp::input::Parser<> p3("input", s3);
p3.removeComments("/*", "*/", true);