Implemented At expressions.

src/plasp/pddl/Expression.cpp

@@ -229,5 +229,54 @@ ExpressionPointer parsePredicate(Context &context, ExpressionContext &expression
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer parseLiteral(Context &context, ExpressionContext &expressionContext)
+{
+	ExpressionPointer expression;
+
+	if ((expression = parseAtomicFormula(context, expressionContext))
+		|| (expression = expressions::Not::parse(context, expressionContext, parseAtomicFormula)))
+	{
+		return expression;
+	}
+
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ExpressionPointer parseAtomicFormula(Context &context, ExpressionContext &expressionContext)
+{
+	auto &parser = context.parser;
+
+	ExpressionPointer expression;
+
+	if ((expression = expressions::Predicate::parse(context, expressionContext)))
+		return expression;
+
+	const auto position = parser.position();
+
+	parser.expect<std::string>("(");
+
+	const auto expressionIdentifierPosition = parser.position();
+
+	if (parser.probeIdentifier("=", isIdentifier))
+	{
+		parser.seek(expressionIdentifierPosition);
+		const auto expressionIdentifier = parser.parseIdentifier(isIdentifier);
+
+		parser.seek(position);
+		warnUnsupported(context, expressionIdentifier);
+
+		parser.seek(expressionIdentifierPosition);
+		skipSection(parser);
+
+		return nullptr;
+	}
+
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }

src/plasp/pddl/InitialState.cpp

@@ -1,8 +1,11 @@
 #include <plasp/pddl/InitialState.h>
 
 #include <plasp/pddl/Context.h>
+#include <plasp/pddl/ExpressionContext.h>
 #include <plasp/pddl/Identifier.h>
 #include <plasp/pddl/IO.h>
+#include <plasp/pddl/Problem.h>
+#include <plasp/pddl/expressions/At.h>
 #include <plasp/pddl/expressions/Predicate.h>
 #include <plasp/utils/ParserException.h>
 
@@ -24,7 +27,8 @@ inline void warnUnsupported(Context &context, const std::string &expressionIdent
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<InitialState> InitialState::parseDeclaration(Context &context, const Problem &problem)
+std::unique_ptr<InitialState> InitialState::parseDeclaration(Context &context,
+	ExpressionContext &expressionContext)
 {
 	auto &parser = context.parser;
 
@@ -35,8 +39,12 @@ std::unique_ptr<InitialState> InitialState::parseDeclaration(Context &context, c
 		{
 			ExpressionPointer expression;
 
-			if ((expression = expressions::Predicate::parse(context, problem)))
+			// TODO: do not allow negative initial state literals
+			if ((expression = parseLiteral(context, expressionContext))
+				|| (expression = expressions::At::parse(context, expressionContext, parseLiteral)))
+			{
 				return expression;
+			}
 
 			const auto position = parser.position();
 
@@ -44,9 +52,7 @@ std::unique_ptr<InitialState> InitialState::parseDeclaration(Context &context, c
 
 			const auto expressionIdentifierPosition = parser.position();
 
-			if (parser.probeIdentifier("at", isIdentifier)
-				|| parser.probeIdentifier("=", isIdentifier)
-				|| parser.probeIdentifier("not", isIdentifier))
+			if (parser.probeIdentifier("=", isIdentifier))
 			{
 				parser.seek(expressionIdentifierPosition);
 				const auto expressionIdentifier = parser.parseIdentifier(isIdentifier);

src/plasp/pddl/Problem.cpp

@@ -332,7 +332,11 @@ void Problem::parseInitialStateSection()
 	parser.expect<std::string>(":");
 	parser.expect<std::string>("init");
 
-	m_initialState = InitialState::parseDeclaration(m_context, *this);
+	// TODO: remove workaround
+	expressions::Variables noParameters;
+	ExpressionContext expressionContext(m_domain, this, noParameters);
+
+	m_initialState = InitialState::parseDeclaration(m_context, expressionContext);
 
 	parser.expect<std::string>(")");
 }
@@ -349,7 +353,6 @@ void Problem::parseGoalSection()
 
 	// TODO: remove workaround
 	expressions::Variables noParameters;
-
 	ExpressionContext expressionContext(m_domain, this, noParameters);
 
 	m_goal = parsePreconditionExpression(m_context, expressionContext);

src/plasp/pddl/TranslatorASP.cpp

@@ -84,8 +84,11 @@ void TranslatorASP::checkSupport() const
 					std::for_each(preconditionArguments.cbegin(), preconditionArguments.cend(),
 						[&](const auto &argument)
 						{
-							if (argument->expressionType() != Expression::Type::Predicate)
+							if (argument->expressionType() != Expression::Type::Predicate
+								&& argument->expressionType() != Expression::Type::Not)
+							{
 								throw utils::TranslatorException("Only predicates supported in preconditions currently");
+							}
 						});
 				}
 			}

src/plasp/pddl/expressions/At.cpp

@@ -0,0 +1,48 @@
+#include <plasp/pddl/expressions/At.h>
+
+namespace plasp
+{
+namespace pddl
+{
+namespace expressions
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// At
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+At::At()
+:	m_argument{nullptr}
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void At::setArgument(const Expression *argument)
+{
+	m_argumentStorage = nullptr;
+	m_argument = argument;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void At::setArgument(ExpressionPointer &&argument)
+{
+	m_argumentStorage = std::move(argument);
+	m_argument = m_argumentStorage.get();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const Expression *At::argument() const
+{
+	return m_argument;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+}

src/plasp/utils/Parser.cpp

@@ -528,6 +528,17 @@ void Parser::expect<bool>(const bool &expectedValue)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+bool Parser::probeNumber()
+{
+	while (!std::iswspace(currentCharacter()))
+		if (!std::isdigit(currentCharacter()))
+			return false;
+
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Parser::removeComments(const std::string &startSequence, const std::string &endSequence, bool removeEnd)
 {
 	const auto inPosition = m_stream.tellg();