23#ifndef PLUGINS_PDDL_GRAMMAR_H_
24#define PLUGINS_PDDL_GRAMMAR_H_
27#include "pddl_semantics.h"
29#include <boost/spirit/include/phoenix.hpp>
30#include <boost/spirit/include/qi.hpp>
31#include <boost/spirit/include/qi_expect.hpp>
32#include <boost/spirit/repository/include/qi_iter_pos.hpp>
34namespace px = boost::phoenix;
35namespace qr = boost::spirit::repository::qi;
37namespace pddl_parser {
43template <
typename Iterator>
48 skip = ascii::space | (
';' >> *(qi::char_ - qi::eol));
57template <
typename Iterator,
typename Skipper = pddl_skipper<Iterator>>
67 name_type = lexeme[alnum > *(alnum | char_(
'-') | char_(
'_'))];
69 domain_name = lit(
"define") >
'(' > lit(
"domain") > +(char_ -
')') >
')';
71 requirements =
'(' > lit(
":requirements") > *(
':' > name_type) >
')';
76 >> qi::as<pair_strings_type>()[+name_type
77 > -(
'-' >> (qi::as<std::vector<std::string>>()[name_type]
78 | (
'(' > lit(
"either") > *name_type >
')')))])
79 [_val = type_semantics_(qi::_1, param_transformer_(qi::_1, qi::_2, qi::_r2), qi::_r1)];
81 types =
'(' >> lit(
":types") > +type_pair(qi::_r1, qi::_val) >
')';
83 constant_value_list = +name_type;
86 (qr::iter_pos >> qi::as<pair_multi_const>()[(constant_value_list > -(
'-' > name_type))])
88 constant_semantics_(qi::_1, qi::_2, qi::_r1, px::bind(&domain_parser::warnings,
this))];
90 constants =
'(' >> lit(
":constants") > +constant_multi_pair(qi::_r1) >
')';
95 >> qi::as<pair_strings_type>()[+(
'?' > name_type)
96 > -(
'-' >> (qi::as<std::vector<std::string>>()[name_type]
97 | (
'(' > lit(
"either") > *name_type >
')')))])
98 [_val = param_transformer_(qi::_1, qi::_2, qi::_r1)];
99 param_pairs = +param_pair(qi::_val);
100 pred =
'(' > name_type > -param_pairs >
')';
101 predicates =
'(' > lit(
":predicates") > +pred >
')';
103 function =
'(' >> name_type > -param_pairs >
')' >> -(
"-" > lit(
"number"));
104 functions =
'(' >> lit(
":functions") > *function >
')';
106 atom = +(graph -
'(' -
')');
107 bool_op = qi::string(
"and") | qi::string(
"or") | qi::string(
"not");
109 qi::string(
"<") | qi::string(
">") | qi::string(
"=") | qi::string(
"<=") | qi::string(
">=");
110 numerical_op = qi::string(
"+") | qi::string(
"-") | qi::string(
"/") | qi::string(
"*")
111 | qi::string(
"=") | string(
"increase") | string(
"decrease");
114 value_expression = attr(ExpressionType::VALUE) >> qi::as_string[qi::raw[qi::float_]];
116 attr(ExpressionType::NUMERIC)
117 >> qi::as<Predicate>()[atom >> *(hold[attr(ExpressionType::ATOM) >> atom])];
118 pred_expression = attr(ExpressionType::PREDICATE)
119 >> qi::as<Predicate>()[atom >> *(hold[attr(ExpressionType::ATOM) >> atom])];
120 bool_expression = attr(ExpressionType::BOOL) >> qi::as<Predicate>()[(bool_op >> +expression)];
121 quantified_expression =
122 attr(ExpressionType::QUANTIFIED)
123 >> qi::as<QuantifiedFormula>()[(qi::string(
"exists") | qi::string(
"forall")) >
'('
124 > param_pairs >
')' > expression];
125 cond_effect_expression = attr(ExpressionType::COND_EFFECT)
126 >> qi::as<Predicate>()[qi::string(
"when") > expression > expression];
127 durative_expression = attr(ExpressionType::DURATIVE)
128 >> qi::as<Predicate>()[(qi::string(
"at start") | qi::string(
"at end")
129 | qi::string(
"over all"))
132 attr(ExpressionType::UNKNOWN) >> atom >> *(hold[attr(ExpressionType::ATOM) >> atom]);
133 function_expression = attr(ExpressionType::NUMERIC_COMP)
134 >> qi::as<Predicate>()[qi::as<Atom>()[comparison_op]
135 > (hold[expression >> value_expression]
136 | hold[value_expression >> expression]
137 | hold[expression >> expression]
138 | +(hold[attr(ExpressionType::ATOM) >> atom]))];
139 function_change_expression =
140 attr(ExpressionType::NUMERIC_CHANGE)
141 >> qi::as<Predicate>()[numerical_op > (hold[expression >> value_expression]
142 | hold[value_expression >> expression]
143 | hold[expression >> expression])];
148 >> hold[(hold[bool_expression] | hold[function_expression] | hold[function_change_expression]
149 | hold[durative_expression] | hold[quantified_expression]
150 | hold[cond_effect_expression] | hold[pred_expression] | hold[unknown_expression])]
152 temp_breakup = lit(
":temporal-breakup") > expression;
153 cond_breakup = lit(
":conditional-breakup") > expression;
154 effects = lit(
":effect") > expression;
155 preconditions = (lit(
":precondition") | lit(
":condition")) > expression;
156 duration = lit(
":duration") >
'(' >
'=' > lit(
"?duration")
158 | (
'(' > (hold[function_change_expression] | hold[pred_expression]) >
')'))
160 action_params = lit(
":parameters") >
'(' > *param_pair(qi::_val) >
')';
166 >> qi::as<Action>()[(lit(
":durative-action") | lit(
":action")) > name_type > action_params
167 > -duration > preconditions > effects > -cond_breakup > -temp_breakup
168 >
')'])[_val = action_semantics_(qi::_1, qi::_2, qi::_r1)];
171 actions = +(action(qi::_r1));
173 domain =
'(' > domain_name > requirements > -types(qi::_val) > -constants(qi::_val) > predicates
174 > -functions > actions(qi::_val)
181 px::function<pddl_parser::TypeSemantics> type_semantics_;
183 px::function<pddl_parser::ParamTransformer> param_transformer_;
185 px::function<pddl_parser::ActionSemantics> action_semantics_;
187 px::function<pddl_parser::ConstantSemantics> constant_semantics_;
188 std::vector<std::string> warnings;
190 qi::rule<Iterator, std::string(), Skipper> name_type;
193 qi::rule<Iterator, std::string(), Skipper> domain_name;
196 qi::rule<Iterator, std::vector<std::string>(), Skipper> requirements;
199 qi::rule<Iterator, pairs_type(
const Domain &), Skipper> types;
201 qi::rule<Iterator, pair_type(
const Domain &, string_pairs_type &), Skipper> type_pair;
204 qi::rule<Iterator, type_list(), Skipper> constant_value_list;
206 qi::rule<Iterator, type_list(), Skipper> predicate_params;
208 qi::rule<Iterator, pair_multi_const(
const Domain &), Skipper> constant_multi_pair;
210 qi::rule<Iterator, pairs_multi_consts(
const Domain &), Skipper> constants;
213 qi::rule<Iterator, string_pair_type(string_pairs_type &), Skipper> param_pair;
215 qi::rule<Iterator, string_pairs_type(), Skipper> param_pairs;
217 qi::rule<Iterator, predicate_type(), Skipper> pred;
219 qi::rule<Iterator, std::vector<predicate_type>(), Skipper> predicates;
222 qi::rule<Iterator, Atom()> atom;
224 qi::rule<Iterator, Atom()> bool_op;
226 qi::rule<Iterator, Atom()> comparison_op;
228 qi::rule<Iterator, Atom()> numerical_op;
230 qi::rule<Iterator,
Predicate(), Skipper> predicate;
232 qi::rule<Iterator,
Expression(), Skipper> pred_expression;
234 qi::rule<Iterator,
Expression(), Skipper> value_expression;
236 qi::rule<Iterator,
Expression(), Skipper> numeric_expression;
238 qi::rule<Iterator,
Expression(), Skipper> function_expression;
240 qi::rule<Iterator,
Expression(), Skipper> function_change_expression;
242 qi::rule<Iterator,
Expression(), Skipper> bool_expression;
244 qi::rule<Iterator,
Expression(), Skipper> durative_expression;
246 qi::rule<Iterator,
Expression(), Skipper> quantified_expression;
248 qi::rule<Iterator,
Expression(), Skipper> cond_effect_expression;
250 qi::rule<Iterator,
Expression(), Skipper> unknown_expression;
252 qi::rule<Iterator,
Expression(), Skipper> expression;
254 qi::rule<Iterator,
Expression(), Skipper> preconditions;
256 qi::rule<Iterator,
Expression(), Skipper> effects;
258 qi::rule<Iterator,
Expression(), Skipper> temp_breakup;
260 qi::rule<Iterator,
Expression(), Skipper> cond_breakup;
262 qi::rule<Iterator,
Expression(), Skipper> duration;
264 qi::rule<Iterator, string_pairs_type(), Skipper> action_params;
266 qi::rule<Iterator,
Action(
const Domain &), Skipper> action;
268 qi::rule<Iterator,
Function(), Skipper> function;
270 qi::rule<Iterator, std::vector<Function>(), Skipper> functions;
272 qi::rule<Iterator, std::vector<Action>(
const Domain &), Skipper> actions;
275 qi::rule<Iterator,
Domain(), Skipper> domain;
281template <
typename Iterator,
typename Skipper = pddl_skipper<Iterator>>
291 name_type = lexeme[alnum > *(alnum | char_(
'-') | char_(
'_'))];
301 atom = +(graph -
'(' -
')');
326 qi::rule<Iterator, pairs_multi_consts(), Skipper>
objects;
329 qi::rule<Iterator, Atom()>
atom;
337 qi::rule<Iterator, std::vector<Expression>(), Skipper>
init;
A structured representation of a PDDL action.
A structured representation of a PDDL domain.
A structured representation of a PDDL function.
A PDDL formula (either part of a precondition or an effect(.
A structured representation of a PDDL problem.
A Boost QI parser for a PDDL domain.
A skipper for PDDL files.
qi::rule< Iterator > skip
The actual skipping rule.
A Boost QI parser for a PDDL problem.
qi::rule< Iterator, type_list(), Skipper > constant_value_list
Named placeholder for parsing a list of constant values.
qi::rule< Iterator, std::string(), Skipper > name_type
Named placeholder for parsing a name.
qi::rule< Iterator, std::string(), Skipper > domain_name
Named placeholder for parsing a domain name.
qi::rule< Iterator, std::vector< Expression >(), Skipper > init
Named placeholder for parsing the initial state.
qi::rule< Iterator, Problem(), Skipper > problem
Named placeholder for parsing a PDDL problem.
qi::rule< Iterator, Expression(), Skipper > goal
Named placeholder for parsing a PDDL goal.
qi::rule< Iterator, std::string(), Skipper > problem_name
Named placeholder for parsing a problem name.
qi::rule< Iterator, Expression(), Skipper > expression
Named placeholder for parsing a PDDL expression.
qi::rule< Iterator, Predicate(), Skipper > predicate
Named placeholder for parsing a predicate.
qi::rule< Iterator, pair_multi_const(), Skipper > constant_multi_pair
Named placeholder for parsing a list of typed constants.
qi::rule< Iterator, Atom()> atom
Named placeholder for parsing an atom.
qi::rule< Iterator, pairs_multi_consts(), Skipper > objects
Named placeholder for parsing a list of domain objects.
qi::rule< Iterator, type_list(), Skipper > predicate_params
Named placeholder for parsing a list of predicate parameters.