Fawkes API  Fawkes Development Version
pddl_grammar.h
1 
2 /***************************************************************************
3  * grammar.h
4  *
5  * Created: Fri 19 May 2017 14:07:29 CEST
6  * Copyright 2017 Matthias Loebach
7  * Till Hofmann
8  ****************************************************************************/
9 
10 /* This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Library General Public License for more details.
19  *
20  * Read the full text in the LICENSE.GPL file in the doc directory.
21  */
22 
23 #ifndef PLUGINS_PDDL_GRAMMAR_H_
24 #define PLUGINS_PDDL_GRAMMAR_H_
25 
26 #include "pddl_ast.h"
27 
28 namespace pddl_parser {
29 namespace grammar {
30 /** @class pddl_skipper
31  * A skipper for PDDL files.
32  * This skipper skips spaces and comments starting with ';'
33  */
34 template <typename Iterator>
35 struct pddl_skipper : public qi::grammar<Iterator>
36 {
37  pddl_skipper() : pddl_skipper::base_type(skip, "PDDL")
38  {
39  skip = ascii::space | (';' >> *(qi::char_ - qi::eol));
40  }
41  /** The actual skipping rule. */
42  qi::rule<Iterator> skip;
43 };
44 
45 /** @class domain_parser
46  * A Boost QI parser for a PDDL domain.
47  */
48 template <typename Iterator, typename Skipper = pddl_skipper<Iterator>>
49 struct domain_parser : qi::grammar<Iterator, Domain(), Skipper>
50 {
51  domain_parser() : domain_parser::base_type(domain)
52  {
53  using namespace qi;
54  using ascii::alnum;
55  using ascii::blank;
56  using ascii::char_;
57 
58  name_type = lexeme[alnum >> *(alnum | char_('-') | char_('_'))];
59 
60  domain_name = lit("define") >> '(' >> lit("domain") >> +(char_ - ')') >> ')';
61 
62  requirements = '(' >> lit(":requirements") >> *(':' >> lexeme[*qi::alnum]) >> ')';
63 
64  type_pair = name_type >> -('-' >> name_type);
65  types = '(' >> lit(":types") >> +type_pair >> ')';
66 
69  constants = '(' >> lit(":constants") >> +constant_multi_pair >> ')';
70 
71  param_pair = '?' >> name_type >> '-' >> name_type;
73  pred = '(' >> name_type >> -param_pairs >> ')';
74  predicates = '(' >> lit(":predicates") >> +pred >> ')';
75 
76  atom = +(graph - '(' - ')');
77  predicate = '(' >> atom >> *expression >> ')';
79  temp_breakup = lit(":temporal-breakup") >> expression;
80  cond_breakup = lit(":conditional-breakup") >> expression;
81  effects = lit(":effect") >> expression;
82  preconditions = lit(":precondition") >> expression;
83  duration = lit(":duration") >> '(' >> '=' >> lit("?duration") >> uint_ >> ')';
84  action_params = lit(":parameters") >> '(' >> +param_pair >> ')';
85  action = '(' >> (lit(":durative-action") | lit(":action")) >> name_type >> action_params
86  >> -duration >> preconditions >> effects >> -cond_breakup >> -temp_breakup >> ')';
87  actions = +action;
88 
90  // make closing parenthesis optional to stay backwards compatible
91  >> -lit(")");
92  }
93 
94  /** Named placeholder for parsing a name. */
95  qi::rule<Iterator, std::string(), Skipper> name_type;
96 
97  /** Named placeholder for parsing a domain name. */
98  qi::rule<Iterator, std::string(), Skipper> domain_name;
99 
100  /** Named placeholder for parsing requirements. */
101  qi::rule<Iterator, std::vector<std::string>(), Skipper> requirements;
102 
103  /** Named placeholder for parsing types. */
104  qi::rule<Iterator, pairs_type(), Skipper> types;
105  /** Named placeholder for parsing type pairs. */
106  qi::rule<Iterator, pair_type(), Skipper> type_pair;
107 
108  /** Named placeholder for parsing a list of constant values. */
109  qi::rule<Iterator, type_list(), Skipper> constant_value_list;
110  /** Named placeholder for parsing a list of predicate parameters. */
111  qi::rule<Iterator, type_list(), Skipper> predicate_params;
112  /** Named placeholder for parsing a list of typed constants. */
113  qi::rule<Iterator, pair_multi_const(), Skipper> constant_multi_pair;
114  /** Named placeholder for parsing a list of constants. */
115  qi::rule<Iterator, pairs_multi_consts(), Skipper> constants;
116 
117  /** Named placeholder for parsing a parameter pair. */
118  qi::rule<Iterator, string_pair_type(), Skipper> param_pair;
119  /** Named placeholder for parsing a list of parameter pairs. */
120  qi::rule<Iterator, string_pairs_type(), Skipper> param_pairs;
121  /** Named placeholder for parsing a predicate type. */
122  qi::rule<Iterator, predicate_type(), Skipper> pred;
123  /** Named placeholder for parsing a list of predicate types. */
124  qi::rule<Iterator, std::vector<predicate_type>(), Skipper> predicates;
125 
126  /** Named placeholder for parsing an atom. */
127  qi::rule<Iterator, Atom()> atom;
128  /** Named placeholder for parsing a predicate. */
129  qi::rule<Iterator, Predicate(), Skipper> predicate;
130  /** Named placeholder for parsing a PDDL expression. */
131  qi::rule<Iterator, Expression(), Skipper> expression;
132  /** Named placeholder for parsing a PDDL precondition. */
133  qi::rule<Iterator, Expression(), Skipper> preconditions;
134  /** Named placeholder for parsing a PDDL effect. */
135  qi::rule<Iterator, Expression(), Skipper> effects;
136  /** Named placeholder for parsing a temporal breakup. */
137  qi::rule<Iterator, Expression(), Skipper> temp_breakup;
138  /** Named placeholder for parsing a conditional breakup. */
139  qi::rule<Iterator, Expression(), Skipper> cond_breakup;
140  /** Named placeholder for parsing an action duration. */
141  qi::rule<Iterator, int(), Skipper> duration;
142  /** Named placeholder for parsing action parameters. */
143  qi::rule<Iterator, string_pairs_type(), Skipper> action_params;
144  /** Named placeholder for parsing an action. */
145  qi::rule<Iterator, Action(), Skipper> action;
146  /** Named placeholder for parsing a list of actions. */
147  qi::rule<Iterator, std::vector<Action>(), Skipper> actions;
148 
149  /** Named placeholder for parsing a domain. */
150  qi::rule<Iterator, Domain(), Skipper> domain;
151 };
152 
153 /** @class problem_parser
154  * A Boost QI parser for a PDDL problem.
155  */
156 template <typename Iterator, typename Skipper = pddl_skipper<Iterator>>
157 struct problem_parser : qi::grammar<Iterator, Problem(), Skipper>
158 {
159  problem_parser() : problem_parser::base_type(problem)
160  {
161  using namespace qi;
162  using ascii::alnum;
163  using ascii::blank;
164  using ascii::char_;
165 
166  name_type = lexeme[alnum >> *(alnum | char_('-') | char_('_'))];
167 
168  problem_name = '(' >> lit("define") >> '(' >> lit("problem") >> name_type >> ')';
169 
170  domain_name = '(' >> lit(":domain") >> name_type >> ')';
171 
174  objects = '(' >> lit(":objects") >> +constant_multi_pair >> ')';
175 
176  atom = +(graph - '(' - ')');
177  predicate = '(' >> atom >> *expression >> ')';
179  init = '(' >> lit(":init") >> +expression >> ')';
180 
181  goal = '(' >> lit(":goal") >> +expression >> ')';
182 
183  problem = problem_name >> domain_name >> objects >> init >> goal;
184  }
185 
186  /** Named placeholder for parsing a name. */
187  qi::rule<Iterator, std::string(), Skipper> name_type;
188 
189  /** Named placeholder for parsing a problem name. */
190  qi::rule<Iterator, std::string(), Skipper> problem_name;
191  /** Named placeholder for parsing a domain name. */
192  qi::rule<Iterator, std::string(), Skipper> domain_name;
193 
194  /** Named placeholder for parsing a list of constant values. */
195  qi::rule<Iterator, type_list(), Skipper> constant_value_list;
196  /** Named placeholder for parsing a list of predicate parameters. */
197  qi::rule<Iterator, type_list(), Skipper> predicate_params;
198  /** Named placeholder for parsing a list of typed constants. */
199  qi::rule<Iterator, pair_multi_const(), Skipper> constant_multi_pair;
200  /** Named placeholder for parsing a list of domain objects. */
201  qi::rule<Iterator, pairs_multi_consts(), Skipper> objects;
202 
203  /** Named placeholder for parsing an atom. */
204  qi::rule<Iterator, Atom()> atom;
205  /** Named placeholder for parsing a predicate. */
206  qi::rule<Iterator, Predicate(), Skipper> predicate;
207  /** Named placeholder for parsing a PDDL expression. */
208  qi::rule<Iterator, Expression(), Skipper> expression;
209  /** Named placeholder for parsing a PDDL goal. */
210  qi::rule<Iterator, Expression(), Skipper> goal;
211  /** Named placeholder for parsing the initial state. */
212  qi::rule<Iterator, std::vector<Expression>(), Skipper> init;
213 
214  /** Named placeholder for parsing a PDDL problem. */
215  qi::rule<Iterator, Problem(), Skipper> problem;
216 };
217 
218 } // namespace grammar
219 } // namespace pddl_parser
220 
221 #endif
qi::rule< Iterator, pair_multi_const(), Skipper > constant_multi_pair
Named placeholder for parsing a list of typed constants.
Definition: pddl_grammar.h:113
qi::rule< Iterator, type_list(), Skipper > constant_value_list
Named placeholder for parsing a list of constant values.
Definition: pddl_grammar.h:109
qi::rule< Iterator > skip
The actual skipping rule.
Definition: pddl_grammar.h:42
qi::rule< Iterator, Expression(), Skipper > expression
Named placeholder for parsing a PDDL expression.
Definition: pddl_grammar.h:131
qi::rule< Iterator, Domain(), Skipper > domain
Named placeholder for parsing a domain.
Definition: pddl_grammar.h:150
qi::rule< Iterator, Predicate(), Skipper > predicate
Named placeholder for parsing a predicate.
Definition: pddl_grammar.h:206
qi::rule< Iterator, type_list(), Skipper > predicate_params
Named placeholder for parsing a list of predicate parameters.
Definition: pddl_grammar.h:111
qi::rule< Iterator, std::vector< Expression >), Skipper > init
Named placeholder for parsing the initial state.
Definition: pddl_grammar.h:212
qi::rule< Iterator, pairs_multi_consts(), Skipper > objects
Named placeholder for parsing a list of domain objects.
Definition: pddl_grammar.h:201
qi::rule< Iterator, Atom()> atom
Named placeholder for parsing an atom.
Definition: pddl_grammar.h:127
qi::rule< Iterator, std::string(), Skipper > name_type
Named placeholder for parsing a name.
Definition: pddl_grammar.h:95
qi::rule< Iterator, string_pairs_type(), Skipper > param_pairs
Named placeholder for parsing a list of parameter pairs.
Definition: pddl_grammar.h:120
qi::rule< Iterator, std::string(), Skipper > domain_name
Named placeholder for parsing a domain name.
Definition: pddl_grammar.h:98
qi::rule< Iterator, string_pair_type(), Skipper > param_pair
Named placeholder for parsing a parameter pair.
Definition: pddl_grammar.h:118
qi::rule< Iterator, Expression(), Skipper > effects
Named placeholder for parsing a PDDL effect.
Definition: pddl_grammar.h:135
A PDDL formula (either part of a precondition or an effect(.
Definition: pddl_ast.h:59
qi::rule< Iterator, pairs_multi_consts(), Skipper > constants
Named placeholder for parsing a list of constants.
Definition: pddl_grammar.h:115
qi::rule< Iterator, std::string(), Skipper > domain_name
Named placeholder for parsing a domain name.
Definition: pddl_grammar.h:192
qi::rule< Iterator, Expression(), Skipper > expression
Named placeholder for parsing a PDDL expression.
Definition: pddl_grammar.h:208
qi::rule< Iterator, std::vector< Action >), Skipper > actions
Named placeholder for parsing a list of actions.
Definition: pddl_grammar.h:147
qi::rule< Iterator, std::string(), Skipper > name_type
Named placeholder for parsing a name.
Definition: pddl_grammar.h:187
A structured representation of a PDDL action.
Definition: pddl_ast.h:74
qi::rule< Iterator, Predicate(), Skipper > predicate
Named placeholder for parsing a predicate.
Definition: pddl_grammar.h:129
qi::rule< Iterator, pair_multi_const(), Skipper > constant_multi_pair
Named placeholder for parsing a list of typed constants.
Definition: pddl_grammar.h:199
qi::rule< Iterator, predicate_type(), Skipper > pred
Named placeholder for parsing a predicate type.
Definition: pddl_grammar.h:122
qi::rule< Iterator, type_list(), Skipper > constant_value_list
Named placeholder for parsing a list of constant values.
Definition: pddl_grammar.h:195
qi::rule< Iterator, Expression(), Skipper > cond_breakup
Named placeholder for parsing a conditional breakup.
Definition: pddl_grammar.h:139
qi::rule< Iterator, pairs_type(), Skipper > types
Named placeholder for parsing types.
Definition: pddl_grammar.h:104
qi::rule< Iterator, int(), Skipper > duration
Named placeholder for parsing an action duration.
Definition: pddl_grammar.h:141
qi::rule< Iterator, Expression(), Skipper > goal
Named placeholder for parsing a PDDL goal.
Definition: pddl_grammar.h:210
qi::rule< Iterator, std::vector< predicate_type >), Skipper > predicates
Named placeholder for parsing a list of predicate types.
Definition: pddl_grammar.h:124
qi::rule< Iterator, string_pairs_type(), Skipper > action_params
Named placeholder for parsing action parameters.
Definition: pddl_grammar.h:143
qi::rule< Iterator, Atom()> atom
Named placeholder for parsing an atom.
Definition: pddl_grammar.h:204
qi::rule< Iterator, type_list(), Skipper > predicate_params
Named placeholder for parsing a list of predicate parameters.
Definition: pddl_grammar.h:197
qi::rule< Iterator, pair_type(), Skipper > type_pair
Named placeholder for parsing type pairs.
Definition: pddl_grammar.h:106
qi::rule< Iterator, Problem(), Skipper > problem
Named placeholder for parsing a PDDL problem.
Definition: pddl_grammar.h:215
qi::rule< Iterator, std::vector< std::string >), Skipper > requirements
Named placeholder for parsing requirements.
Definition: pddl_grammar.h:101
A Boost QI parser for a PDDL problem.
Definition: pddl_grammar.h:157
qi::rule< Iterator, Expression(), Skipper > preconditions
Named placeholder for parsing a PDDL precondition.
Definition: pddl_grammar.h:133
A skipper for PDDL files.
Definition: pddl_grammar.h:35
A Boost QI parser for a PDDL domain.
Definition: pddl_grammar.h:49
qi::rule< Iterator, Expression(), Skipper > temp_breakup
Named placeholder for parsing a temporal breakup.
Definition: pddl_grammar.h:137
A structured representation of a PDDL problem.
Definition: pddl_ast.h:119
qi::rule< Iterator, Action(), Skipper > action
Named placeholder for parsing an action.
Definition: pddl_grammar.h:145
A structured representation of a PDDL domain.
Definition: pddl_ast.h:98
qi::rule< Iterator, std::string(), Skipper > problem_name
Named placeholder for parsing a problem name.
Definition: pddl_grammar.h:190