Started implementing PDDL normalization.

include/plasp/pddl/TranslatorASP.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/ColorStream.h>
 
-#include <pddlparse/ASTForward.h>
+#include <pddlparse/NormalizedASTForward.h>
 #include <pddlparse/Parse.h>
 
 namespace plasp
@@ -20,7 +20,7 @@ namespace pddl
 class TranslatorASP
 {
 	public:
-		explicit TranslatorASP(const ::pddl::ast::Description &description, colorlog::ColorStream &outputStream);
+		explicit TranslatorASP(const ::pddl::normalizedAST::Description &description, colorlog::ColorStream &outputStream);
 
 		void translate() const;
 
@@ -35,7 +35,7 @@ class TranslatorASP
 		void translateGoal() const;
 		void translateConstants(const std::string &heading, const ::pddl::ast::ConstantDeclarations &constants) const;
 
-		const ::pddl::ast::Description &m_description;
+		const ::pddl::normalizedAST::Description &m_description;
 		colorlog::ColorStream &m_outputStream;
 };
 

include/plasp/pddl/translation/Effect.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/Formatting.h>
 
-#include <pddlparse/AST.h>
+#include <pddlparse/NormalizedAST.h>
 
 #include <plasp/TranslatorException.h>
 
@@ -22,7 +22,7 @@ namespace pddl
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<typename PrintObjectName>
-inline void translateEffect(colorlog::ColorStream &outputStream, const ::pddl::ast::Effect &effect, const std::string &objectType, PrintObjectName printObjectName)
+inline void translateEffect(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::Effect &effect, const std::string &objectType, PrintObjectName printObjectName)
 {
 	const auto handleUnsupported =
 		[](const auto &)
@@ -31,7 +31,7 @@ inline void translateEffect(colorlog::ColorStream &outputStream, const ::pddl::a
 		};
 
 	const auto handlePredicate =
-		[&](const ::pddl::ast::PredicatePointer &predicate, bool isPositive = true)
+		[&](const ::pddl::normalizedAST::PredicatePointer &predicate, bool isPositive = true)
 		{
 			outputStream << std::endl << colorlog::Function("postcondition") << "(";
 			printObjectName();
@@ -46,24 +46,24 @@ inline void translateEffect(colorlog::ColorStream &outputStream, const ::pddl::a
 		};
 
 	const auto handleAtomicFormula =
-		[&](const ::pddl::ast::AtomicFormula &atomicFormula)
+		[&](const ::pddl::normalizedAST::AtomicFormula &atomicFormula)
 		{
 			atomicFormula.match(handlePredicate, handleUnsupported);
 		};
 
 	const auto handleNot =
-		[&](const ::pddl::ast::NotPointer<::pddl::ast::Effect> &not_)
+		[&](const ::pddl::normalizedAST::NotPointer<::pddl::normalizedAST::Effect> &not_)
 		{
-			if (!not_->argument.is<::pddl::ast::AtomicFormula>() || !not_->argument.get<::pddl::ast::AtomicFormula>().is<::pddl::ast::PredicatePointer>())
+			if (!not_->argument.is<::pddl::normalizedAST::AtomicFormula>() || !not_->argument.get<::pddl::normalizedAST::AtomicFormula>().is<::pddl::normalizedAST::PredicatePointer>())
 				handleUnsupported(not_);
 
-			const auto &predicate = not_->argument.get<::pddl::ast::AtomicFormula>().get<::pddl::ast::PredicatePointer>();
+			const auto &predicate = not_->argument.get<::pddl::normalizedAST::AtomicFormula>().get<::pddl::normalizedAST::PredicatePointer>();
 
 			handlePredicate(predicate, false);
 		};
 
 	const auto handleAnd =
-		[&](const ::pddl::ast::AndPointer<::pddl::ast::Effect> &and_)
+		[&](const ::pddl::normalizedAST::AndPointer<::pddl::normalizedAST::Effect> &and_)
 		{
 			for (const auto &argument : and_->arguments)
 				translateEffect(outputStream, argument, objectType, printObjectName);

include/plasp/pddl/translation/Goal.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/Formatting.h>
 
-#include <pddlparse/AST.h>
+#include <pddlparse/NormalizedAST.h>
 
 #include <plasp/TranslatorException.h>
 
@@ -21,16 +21,10 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline void translateGoal(colorlog::ColorStream &outputStream, const ::pddl::ast::Goal &goal)
+inline void translateGoal(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::Goal &goal)
 {
-	const auto handleUnsupported =
-		[](const auto &)
-		{
-			throw TranslatorException("only “and” expressions and (negated) predicates supported as goals currently");
-		};
-
 	const auto handlePredicate =
-		[&](const ::pddl::ast::PredicatePointer &predicate, bool isPositive = true)
+		[&](const ::pddl::normalizedAST::PredicatePointer &predicate, bool isPositive = true)
 		{
 			outputStream << std::endl << colorlog::Function("goal") << "(";
 			// TODO: assert that goal is variable-free
@@ -38,31 +32,54 @@ inline void translateGoal(colorlog::ColorStream &outputStream, const ::pddl::ast
 			outputStream << ").";
 		};
 
-	const auto handleAtomicFormula =
-		[&](const ::pddl::ast::AtomicFormula &atomicFormula)
+	const auto handleNegatedPredicate =
+		[&](const ::pddl::normalizedAST::PredicatePointer &predicate)
 		{
-			atomicFormula.match(handlePredicate, handleUnsupported);
-		};
-
-	const auto handleNot =
-		[&](const ::pddl::ast::NotPointer<::pddl::ast::Goal> &not_)
-		{
-			if (!not_->argument.is<::pddl::ast::AtomicFormula>() || !not_->argument.get<::pddl::ast::AtomicFormula>().is<::pddl::ast::PredicatePointer>())
-				handleUnsupported(not_);
-
-			const auto &predicate = not_->argument.get<::pddl::ast::AtomicFormula>().get<::pddl::ast::PredicatePointer>();
-
 			handlePredicate(predicate, false);
 		};
 
-	const auto handleAnd =
-		[&](const ::pddl::ast::AndPointer<::pddl::ast::Goal> &and_)
+	const auto handleDerivedPredicate =
+		[&](const ::pddl::normalizedAST::DerivedPredicatePointer &, bool = true)
 		{
-			for (const auto &argument : and_->arguments)
-				translateGoal(outputStream, argument);
+			outputStream << std::endl << colorlog::Function("goal") << "(";
+			// TODO: assert that goal is variable-free
+			// TODO: implement
+			//translatePredicateToVariable(outputStream, *predicate, isPositive);
+			outputStream << ").";
 		};
 
-	goal.match(handleAtomicFormula, handleNot, handleAnd, handleUnsupported);
+	const auto handleNegatedDerivedPredicate =
+		[&](const ::pddl::normalizedAST::DerivedPredicatePointer &derivedPredicate)
+		{
+			handleDerivedPredicate(derivedPredicate, false);
+		};
+
+	const auto handleAtomicFormula =
+		[&](const ::pddl::normalizedAST::AtomicFormula &atomicFormula)
+		{
+			atomicFormula.match(handlePredicate, handleDerivedPredicate);
+		};
+
+	const auto handleNot =
+		[&](const ::pddl::normalizedAST::NotPointer<::pddl::normalizedAST::AtomicFormula> &not_)
+		{
+			not_->argument.match(handleNegatedPredicate, handleNegatedDerivedPredicate);
+		};
+
+	const auto handleLiteral =
+		[&](const ::pddl::normalizedAST::Literal &literal)
+		{
+			literal.match(handleAtomicFormula, handleNot);
+		};
+
+	const auto handleAnd =
+		[&](const ::pddl::normalizedAST::AndPointer<::pddl::normalizedAST::Literal> &and_)
+		{
+			for (const auto &argument : and_->arguments)
+				handleLiteral(argument);
+		};
+
+	goal.match(handleLiteral, handleAnd);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/pddl/translation/Precondition.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/Formatting.h>
 
-#include <pddlparse/AST.h>
+#include <pddlparse/NormalizedAST.h>
 
 #include <plasp/TranslatorException.h>
 
@@ -22,16 +22,10 @@ namespace pddl
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<typename PrintObjectName>
-inline void translatePrecondition(colorlog::ColorStream &outputStream, const ::pddl::ast::Precondition &precondition, const std::string &objectType, PrintObjectName printObjectName)
+inline void translatePrecondition(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::Precondition &precondition, const std::string &objectType, PrintObjectName printObjectName)
 {
-	const auto handleUnsupported =
-		[](const auto &)
-		{
-			throw TranslatorException("only “and” expressions and (negated) predicates supported as action preconditions currently");
-		};
-
 	const auto handlePredicate =
-		[&](const ::pddl::ast::PredicatePointer &predicate, bool isPositive = true)
+		[&](const ::pddl::normalizedAST::PredicatePointer &predicate, bool isPositive = true)
 		{
 			outputStream << std::endl << colorlog::Function("precondition") << "(";
 			printObjectName();
@@ -42,31 +36,57 @@ inline void translatePrecondition(colorlog::ColorStream &outputStream, const ::p
 			outputStream << ").";
 		};
 
-	const auto handleAtomicFormula =
-		[&](const ::pddl::ast::AtomicFormula &atomicFormula)
+	const auto handleNegatedPredicate =
+		[&](const ::pddl::normalizedAST::PredicatePointer &predicate)
 		{
-			atomicFormula.match(handlePredicate, handleUnsupported);
-		};
-
-	const auto handleNot =
-		[&](const ::pddl::ast::NotPointer<::pddl::ast::Precondition> &not_)
-		{
-			if (!not_->argument.is<::pddl::ast::AtomicFormula>() || !not_->argument.get<::pddl::ast::AtomicFormula>().is<::pddl::ast::PredicatePointer>())
-				handleUnsupported(not_);
-
-			const auto &predicate = not_->argument.get<::pddl::ast::AtomicFormula>().get<::pddl::ast::PredicatePointer>();
-
 			handlePredicate(predicate, false);
 		};
 
-	const auto handleAnd =
-		[&](const ::pddl::ast::AndPointer<::pddl::ast::Precondition> &and_)
+	const auto handleDerivedPredicate =
+		[&](const ::pddl::normalizedAST::DerivedPredicatePointer &, bool = true)
 		{
-			for (const auto &argument : and_->arguments)
-				translatePrecondition(outputStream, argument, objectType, printObjectName);
+			outputStream << std::endl << colorlog::Function("precondition") << "(";
+			printObjectName();
+			outputStream << ", ";
+			// TODO: implement
+			/*translatePredicateToVariable(outputStream, *predicate, isPositive);
+			outputStream << ") :- " << output::Function(objectType.c_str()) << "(";
+			printObjectName();
+			outputStream << ").";*/
 		};
 
-	precondition.match(handleAtomicFormula, handleNot, handleAnd, handleUnsupported);
+	const auto handleNegatedDerivedPredicate =
+		[&](const ::pddl::normalizedAST::DerivedPredicatePointer &derivedPredicate)
+		{
+			handleDerivedPredicate(derivedPredicate, false);
+		};
+
+	const auto handleAtomicFormula =
+		[&](const ::pddl::normalizedAST::AtomicFormula &atomicFormula)
+		{
+			atomicFormula.match(handlePredicate, handleDerivedPredicate);
+		};
+
+	const auto handleNot =
+		[&](const ::pddl::normalizedAST::NotPointer<::pddl::normalizedAST::AtomicFormula> &not_)
+		{
+			not_->argument.match(handleNegatedPredicate, handleNegatedDerivedPredicate);
+		};
+
+	const auto handleLiteral =
+		[&](const ::pddl::normalizedAST::Literal &literal)
+		{
+			literal.match(handleAtomicFormula, handleNot);
+		};
+
+	const auto handleAnd =
+		[&](const ::pddl::normalizedAST::AndPointer<::pddl::normalizedAST::Literal> &and_)
+		{
+			for (const auto &argument : and_->arguments)
+				handleLiteral(argument);
+		};
+
+	precondition.match(handleLiteral, handleAnd);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/pddl/translation/Predicate.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/Formatting.h>
 
-#include <pddlparse/AST.h>
+#include <pddlparse/NormalizedAST.h>
 #include <pddlparse/Parse.h>
 
 #include <plasp/pddl/translation/Primitives.h>
@@ -20,12 +20,12 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate);
-void translatePredicateDeclaration(colorlog::ColorStream &outputStream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration);
+void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::Predicate &predicate);
+void translatePredicateDeclaration(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::PredicateDeclaration &predicateDeclaration);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate)
+inline void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::Predicate &predicate)
 {
 	const auto &arguments = predicate.arguments;
 
@@ -42,13 +42,13 @@ inline void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl
 		outputStream << ", ";
 
 		const auto handleConstant =
-			[&](const ::pddl::ast::ConstantPointer &constant)
+			[&](const ::pddl::normalizedAST::ConstantPointer &constant)
 			{
 				outputStream << colorlog::Keyword("constant") << "(" << *constant << ")";
 			};
 
 		const auto handleVariable =
-			[&](const ::pddl::ast::VariablePointer &variable)
+			[&](const ::pddl::normalizedAST::VariablePointer &variable)
 			{
 				outputStream << *variable;
 			};
@@ -67,7 +67,7 @@ inline void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline void translatePredicateDeclaration(colorlog::ColorStream &outputStream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration)
+inline void translatePredicateDeclaration(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::PredicateDeclaration &predicateDeclaration)
 {
 	outputStream << colorlog::Keyword("variable") << "(";
 
@@ -84,7 +84,7 @@ inline void translatePredicateDeclaration(colorlog::ColorStream &outputStream, c
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void translatePredicateToVariable(colorlog::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate, bool isPositive = true)
+void translatePredicateToVariable(colorlog::ColorStream &outputStream, const ::pddl::normalizedAST::Predicate &predicate, bool isPositive = true)
 {
 	outputStream << colorlog::Keyword("variable") << "(";
 	translatePredicate(outputStream, predicate);

include/plasp/pddl/translation/Primitives.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/Formatting.h>
 
-#include <pddlparse/AST.h>
+#include <pddlparse/NormalizedAST.h>
 
 #include <plasp/TranslatorException.h>
 
@@ -18,7 +18,7 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::ConstantDeclaration &constantDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::ConstantDeclaration &constantDeclaration)
 {
 	assert(!constantDeclaration.name.empty());
 
@@ -27,7 +27,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::Constant &constant)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::Constant &constant)
 {
 	assert(constant.declaration != nullptr);
 
@@ -36,7 +36,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::PrimitiveTypeDeclaration &primitiveTypeDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::PrimitiveTypeDeclaration &primitiveTypeDeclaration)
 {
 	assert(!primitiveTypeDeclaration.name.empty());
 
@@ -45,7 +45,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::PrimitiveType &primitiveType)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::PrimitiveType &primitiveType)
 {
 	assert(primitiveType.declaration != nullptr);
 
@@ -54,7 +54,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::ast::VariableDeclaration &variableDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::normalizedAST::VariableDeclaration &variableDeclaration)
 {
 	assert(!variableDeclaration.name.empty());
 	assert(std::isalpha(variableDeclaration.name[0]));
@@ -70,7 +70,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::ast::Variable &variable)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::normalizedAST::Variable &variable)
 {
 	assert(variable.declaration != nullptr);
 
@@ -80,7 +80,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // TODO: move to appropriate header
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::Action &action)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::Action &action)
 {
 	return (stream << colorlog::String(action.name.c_str()));
 }
@@ -88,7 +88,7 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // TODO: move to appropriate header
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::PredicateDeclaration &predicateDeclaration)
 {
 	return (stream << colorlog::String(predicateDeclaration.name.c_str()));
 }
@@ -96,13 +96,29 @@ inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // TODO: move to appropriate header
-inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::Predicate &predicate)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::Predicate &predicate)
 {
 	return (stream << *predicate.declaration);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+// TODO: move to appropriate header
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::DerivedPredicateDeclaration &derivedPredicateDeclaration)
+{
+	return (stream << colorlog::String(derivedPredicateDeclaration.name.c_str()));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// TODO: move to appropriate header
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::normalizedAST::DerivedPredicate &derivedPredicate)
+{
+	return (stream << *derivedPredicate.declaration);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 

include/plasp/pddl/translation/Variables.h

@@ -3,7 +3,7 @@
 
 #include <colorlog/Formatting.h>
 
-#include <pddlparse/AST.h>
+#include <pddlparse/NormalizedAST.h>
 #include <pddlparse/Parse.h>
 
 #include <plasp/TranslatorException.h>
@@ -53,10 +53,10 @@ inline void translateVariablesForRuleBody(colorlog::ColorStream &outputStream, c
 
 		if (variable->type)
 		{
-			if (!variable->type.value().template is<::pddl::ast::PrimitiveTypePointer>())
+			if (!variable->type.value().template is<::pddl::normalizedAST::PrimitiveTypePointer>())
 				throw TranslatorException("only primitive types supported currently");
 
-			const auto &type = variable->type.value().template get<::pddl::ast::PrimitiveTypePointer>();
+			const auto &type = variable->type.value().template get<::pddl::normalizedAST::PrimitiveTypePointer>();
 
 			outputStream << colorlog::Function("has") << "("
 				<< *variable << ", " << colorlog::Keyword("type") << "(" << *type << "))";