45 #ifndef YY_TLYY_PARSETL_HH_INCLUDED
46 # define YY_TLYY_PARSETL_HH_INCLUDED
54 #include <spot/tl/parse.hh>
56 #include <spot/tl/print.hh>
71 std::vector<const spot::fnode*> children;
80 std::variant<const spot::fnode*, nary> data;
109 pnode& operator=(
const pnode& other) =
delete;
112 : data(std::move(other.data))
119 data = std::move(other.data);
128 if (
auto* n = std::get_if<nary>(&data))
130 for (
auto f: n->children)
135 auto* f = std::get<const spot::fnode*>(data);
150 nary& n = std::get<nary>(data);
152 if (
auto* nleft = std::get_if<nary>(&left.data);
153 nleft && nleft->kind == o)
154 std::swap(n.children, nleft->children);
156 n.children.push_back(left);
157 if (
auto* nright = std::get_if<nary>(&right.data);
158 nright && nright->kind == o)
160 auto& rch = nright->children;
161 n.children.insert(n.children.end(), rch.begin(), rch.end());
166 n.children.push_back(right);
173 if (
auto* n = std::get_if<nary>(&data))
179 return std::get<const spot::fnode*>(data);
188 if (
auto* n = std::get_if<nary>(&data))
190 for (
auto c: n->children)
196 f = std::get<const spot::fnode*>(data);
197 assert(f !=
nullptr);
206 #line 207 "parsetl.hh"
211 # include <stdexcept>
215 #if defined __cplusplus
216 # define YY_CPLUSPLUS __cplusplus
218 # define YY_CPLUSPLUS 199711L
222 #if 201103L <= YY_CPLUSPLUS
223 # define YY_MOVE std::move
224 # define YY_MOVE_OR_COPY move
225 # define YY_MOVE_REF(Type) Type&&
226 # define YY_RVREF(Type) Type&&
227 # define YY_COPY(Type) Type
230 # define YY_MOVE_OR_COPY copy
231 # define YY_MOVE_REF(Type) Type&
232 # define YY_RVREF(Type) const Type&
233 # define YY_COPY(Type) const Type&
237 #if 201103L <= YY_CPLUSPLUS
238 # define YY_NOEXCEPT noexcept
242 # define YY_NOTHROW throw ()
246 #if 201703 <= YY_CPLUSPLUS
247 # define YY_CONSTEXPR constexpr
249 # define YY_CONSTEXPR
254 #ifndef YY_ATTRIBUTE_PURE
255 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
256 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
258 # define YY_ATTRIBUTE_PURE
262 #ifndef YY_ATTRIBUTE_UNUSED
263 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
264 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
266 # define YY_ATTRIBUTE_UNUSED
271 #if ! defined lint || defined __GNUC__
272 # define YY_USE(E) ((void) (E))
277 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
279 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
280 _Pragma ("GCC diagnostic push") \
281 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
282 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
283 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
284 _Pragma ("GCC diagnostic pop")
286 # define YY_INITIAL_VALUE(Value) Value
288 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
289 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
290 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
292 #ifndef YY_INITIAL_VALUE
293 # define YY_INITIAL_VALUE(Value)
296 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
297 # define YY_IGNORE_USELESS_CAST_BEGIN \
298 _Pragma ("GCC diagnostic push") \
299 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
300 # define YY_IGNORE_USELESS_CAST_END \
301 _Pragma ("GCC diagnostic pop")
303 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
304 # define YY_IGNORE_USELESS_CAST_BEGIN
305 # define YY_IGNORE_USELESS_CAST_END
310 # define YY_CAST(Type, Val) static_cast<Type> (Val)
311 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
313 # define YY_CAST(Type, Val) ((Type) (Val))
314 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
318 # if defined __cplusplus
319 # if 201103L <= __cplusplus
320 # define YY_NULLPTR nullptr
322 # define YY_NULLPTR 0
325 # define YY_NULLPTR ((void*)0)
343 #line 344 "parsetl.hh"
370 template <
typename T>
373 new (yyas_<T> ()) T (YY_MOVE (t));
376 #if 201103L <= YY_CPLUSPLUS
387 # if 201103L <= YY_CPLUSPLUS
389 template <
typename T,
typename... U>
393 return *
new (yyas_<T> ()) T (std::forward <U>(u)...);
397 template <
typename T>
401 return *
new (yyas_<T> ()) T ();
405 template <
typename T>
409 return *
new (yyas_<T> ()) T (t);
415 template <
typename T>
419 return emplace<T> ();
424 template <
typename T>
428 return emplace<T> (t);
432 template <
typename T>
440 template <
typename T>
442 as () const YY_NOEXCEPT
455 template <
typename T>
459 std::swap (as<T> (), that.as<T> ());
465 template <
typename T>
469 # if 201103L <= YY_CPLUSPLUS
470 emplace<T> (std::move (that.
as<T> ()));
478 # if 201103L <= YY_CPLUSPLUS
480 template <
typename T>
484 emplace<T> (std::move (that.as<T> ()));
490 template <
typename T>
494 emplace<T> (that.
as<T> ());
498 template <
typename T>
506 #if YY_CPLUSPLUS < 201103L
514 template <
typename T>
518 void *yyp = yybuffer_.yyraw;
519 return static_cast<T*
> (yyp);
523 template <
typename T>
525 yyas_ () const YY_NOEXCEPT
527 const void *yyp = yybuffer_.yyraw;
528 return static_cast<const T*
> (yyp);
550 char dummy2[
sizeof (
pnode)];
556 char dummy3[
sizeof (std::string)];
561 char dummy4[
sizeof (unsigned)];
565 enum { size =
sizeof (union_type) };
578 typedef TLYYSTYPE semantic_type;
587 : std::runtime_error (m)
592 : std::runtime_error (s.what ())
593 , location (s.location)
618 BRA_BANG_BLOCK = 266,
621 BRACE_BANG_CLOSE = 269,
649 OP_SQBKT_CLOSE = 297,
650 OP_SQBKT_STRONG_CLOSE = 298,
656 OP_UCONCAT_NONO = 304,
657 OP_ECONCAT_NONO = 305,
658 OP_FIRST_MATCH = 306,
700 S_BRA_BANG_BLOCK = 11,
703 S_BRACE_BANG_CLOSE = 14,
728 S_OP_FSTAR_OPEN = 39,
729 S_OP_EQUAL_OPEN = 40,
731 S_OP_SQBKT_CLOSE = 42,
732 S_OP_SQBKT_STRONG_CLOSE = 43,
738 S_OP_UCONCAT_NONO = 49,
739 S_OP_ECONCAT_NONO = 50,
740 S_OP_FIRST_MATCH = 51,
750 S_OP_DELAY_OPEN = 61,
751 S_OP_DELAY_PLUS = 62,
752 S_OP_DELAY_STAR = 63,
773 S_OP_SQBKT_SEP_unbounded = 84,
774 S_OP_SQBKT_SEP_opt = 85,
777 S_sqbracketargs = 88,
788 S_parenthesedsubformula = 99,
807 template <
typename Base>
819 #if 201103L <= YY_CPLUSPLUS
822 : Base (std::
move (that))
826 switch (this->kind ())
828 case symbol_kind::S_sqbracketargs:
829 case symbol_kind::S_gotoargs:
830 case symbol_kind::S_starargs:
831 case symbol_kind::S_fstarargs:
832 case symbol_kind::S_equalargs:
833 case symbol_kind::S_delayargs:
837 case symbol_kind::S_atomprop:
838 case symbol_kind::S_booleanatom:
839 case symbol_kind::S_sere:
840 case symbol_kind::S_bracedsere:
841 case symbol_kind::S_parenthesedsubformula:
842 case symbol_kind::S_boolformula:
843 case symbol_kind::S_subformula:
844 case symbol_kind::S_lbtformula:
848 case symbol_kind::S_PAR_BLOCK:
849 case symbol_kind::S_BRA_BLOCK:
850 case symbol_kind::S_BRA_BANG_BLOCK:
851 case symbol_kind::S_ATOMIC_PROP:
852 value.
move< std::string > (std::move (that.value));
855 case symbol_kind::S_OP_SQBKT_NUM:
856 case symbol_kind::S_OP_DELAY_N:
857 case symbol_kind::S_sqbkt_num:
858 value.
move<
unsigned > (std::move (that.value));
872 #if 201103L <= YY_CPLUSPLUS
884 #if 201103L <= YY_CPLUSPLUS
898 #if 201103L <= YY_CPLUSPLUS
912 #if 201103L <= YY_CPLUSPLUS
926 #if 201103L <= YY_CPLUSPLUS
962 case symbol_kind::S_sqbracketargs:
963 case symbol_kind::S_gotoargs:
964 case symbol_kind::S_starargs:
965 case symbol_kind::S_fstarargs:
966 case symbol_kind::S_equalargs:
967 case symbol_kind::S_delayargs:
968 value.template destroy< minmax_t > ();
971 case symbol_kind::S_atomprop:
972 case symbol_kind::S_booleanatom:
973 case symbol_kind::S_sere:
974 case symbol_kind::S_bracedsere:
975 case symbol_kind::S_parenthesedsubformula:
976 case symbol_kind::S_boolformula:
977 case symbol_kind::S_subformula:
978 case symbol_kind::S_lbtformula:
979 value.template destroy< pnode > ();
982 case symbol_kind::S_PAR_BLOCK:
983 case symbol_kind::S_BRA_BLOCK:
984 case symbol_kind::S_BRA_BANG_BLOCK:
985 case symbol_kind::S_ATOMIC_PROP:
986 value.template destroy< std::string > ();
989 case symbol_kind::S_OP_SQBKT_NUM:
990 case symbol_kind::S_OP_DELAY_N:
991 case symbol_kind::S_sqbkt_num:
992 value.template destroy< unsigned > ();
1003 std::string
name () const YY_NOEXCEPT
1024 #if YY_CPLUSPLUS < 201103L
1036 #if 201103L <= YY_CPLUSPLUS
1081 #if 201103L <= YY_CPLUSPLUS
1083 : super_type(token_type (tok), std::
move (l))
1089 #if 201103L <= YY_CPLUSPLUS
1091 : super_type(token_type (tok), std::
move (v), std::
move (l))
1094 : super_type(token_type (tok), v, l)
1097 #if 201103L <= YY_CPLUSPLUS
1101 symbol_type (int tok, const unsigned& v, const
location_type& l)
1111 #if 201103L <= YY_CPLUSPLUS
1153 #if 201103L <= YY_CPLUSPLUS
1158 return symbol_type (token::TLYYEOF, std::move (l));
1165 return symbol_type (token::TLYYEOF, l);
1168 #if 201103L <= YY_CPLUSPLUS
1173 return symbol_type (token::TLYYerror, std::move (l));
1180 return symbol_type (token::TLYYerror, l);
1183 #if 201103L <= YY_CPLUSPLUS
1188 return symbol_type (token::TLYYUNDEF, std::move (l));
1195 return symbol_type (token::TLYYUNDEF, l);
1198 #if 201103L <= YY_CPLUSPLUS
1203 return symbol_type (token::START_LTL, std::move (l));
1210 return symbol_type (token::START_LTL, l);
1213 #if 201103L <= YY_CPLUSPLUS
1218 return symbol_type (token::START_LBT, std::move (l));
1225 return symbol_type (token::START_LBT, l);
1228 #if 201103L <= YY_CPLUSPLUS
1233 return symbol_type (token::START_SERE, std::move (l));
1240 return symbol_type (token::START_SERE, l);
1243 #if 201103L <= YY_CPLUSPLUS
1248 return symbol_type (token::START_BOOL, std::move (l));
1255 return symbol_type (token::START_BOOL, l);
1258 #if 201103L <= YY_CPLUSPLUS
1263 return symbol_type (token::PAR_OPEN, std::move (l));
1270 return symbol_type (token::PAR_OPEN, l);
1273 #if 201103L <= YY_CPLUSPLUS
1278 return symbol_type (token::PAR_CLOSE, std::move (l));
1285 return symbol_type (token::PAR_CLOSE, l);
1288 #if 201103L <= YY_CPLUSPLUS
1293 return symbol_type (token::PAR_BLOCK, std::move (v), std::move (l));
1298 make_PAR_BLOCK (
const std::string& v,
const location_type& l)
1300 return symbol_type (token::PAR_BLOCK, v, l);
1303 #if 201103L <= YY_CPLUSPLUS
1308 return symbol_type (token::BRA_BLOCK, std::move (v), std::move (l));
1313 make_BRA_BLOCK (
const std::string& v,
const location_type& l)
1315 return symbol_type (token::BRA_BLOCK, v, l);
1318 #if 201103L <= YY_CPLUSPLUS
1323 return symbol_type (token::BRA_BANG_BLOCK, std::move (v), std::move (l));
1328 make_BRA_BANG_BLOCK (
const std::string& v,
const location_type& l)
1330 return symbol_type (token::BRA_BANG_BLOCK, v, l);
1333 #if 201103L <= YY_CPLUSPLUS
1338 return symbol_type (token::BRACE_OPEN, std::move (l));
1345 return symbol_type (token::BRACE_OPEN, l);
1348 #if 201103L <= YY_CPLUSPLUS
1353 return symbol_type (token::BRACE_CLOSE, std::move (l));
1360 return symbol_type (token::BRACE_CLOSE, l);
1363 #if 201103L <= YY_CPLUSPLUS
1368 return symbol_type (token::BRACE_BANG_CLOSE, std::move (l));
1375 return symbol_type (token::BRACE_BANG_CLOSE, l);
1378 #if 201103L <= YY_CPLUSPLUS
1383 return symbol_type (token::OP_OR, std::move (l));
1390 return symbol_type (token::OP_OR, l);
1393 #if 201103L <= YY_CPLUSPLUS
1398 return symbol_type (token::OP_XOR, std::move (l));
1405 return symbol_type (token::OP_XOR, l);
1408 #if 201103L <= YY_CPLUSPLUS
1413 return symbol_type (token::OP_AND, std::move (l));
1420 return symbol_type (token::OP_AND, l);
1423 #if 201103L <= YY_CPLUSPLUS
1428 return symbol_type (token::OP_SHORT_AND, std::move (l));
1435 return symbol_type (token::OP_SHORT_AND, l);
1438 #if 201103L <= YY_CPLUSPLUS
1443 return symbol_type (token::OP_IMPLIES, std::move (l));
1450 return symbol_type (token::OP_IMPLIES, l);
1453 #if 201103L <= YY_CPLUSPLUS
1458 return symbol_type (token::OP_EQUIV, std::move (l));
1465 return symbol_type (token::OP_EQUIV, l);
1468 #if 201103L <= YY_CPLUSPLUS
1473 return symbol_type (token::OP_U, std::move (l));
1480 return symbol_type (token::OP_U, l);
1483 #if 201103L <= YY_CPLUSPLUS
1488 return symbol_type (token::OP_R, std::move (l));
1495 return symbol_type (token::OP_R, l);
1498 #if 201103L <= YY_CPLUSPLUS
1503 return symbol_type (token::OP_W, std::move (l));
1510 return symbol_type (token::OP_W, l);
1513 #if 201103L <= YY_CPLUSPLUS
1518 return symbol_type (token::OP_M, std::move (l));
1525 return symbol_type (token::OP_M, l);
1528 #if 201103L <= YY_CPLUSPLUS
1533 return symbol_type (token::OP_F, std::move (l));
1540 return symbol_type (token::OP_F, l);
1543 #if 201103L <= YY_CPLUSPLUS
1548 return symbol_type (token::OP_G, std::move (l));
1555 return symbol_type (token::OP_G, l);
1558 #if 201103L <= YY_CPLUSPLUS
1563 return symbol_type (token::OP_X, std::move (l));
1570 return symbol_type (token::OP_X, l);
1573 #if 201103L <= YY_CPLUSPLUS
1578 return symbol_type (token::OP_STRONG_X, std::move (l));
1585 return symbol_type (token::OP_STRONG_X, l);
1588 #if 201103L <= YY_CPLUSPLUS
1593 return symbol_type (token::OP_NOT, std::move (l));
1600 return symbol_type (token::OP_NOT, l);
1603 #if 201103L <= YY_CPLUSPLUS
1608 return symbol_type (token::OP_XREP, std::move (l));
1615 return symbol_type (token::OP_XREP, l);
1618 #if 201103L <= YY_CPLUSPLUS
1623 return symbol_type (token::OP_FREP, std::move (l));
1630 return symbol_type (token::OP_FREP, l);
1633 #if 201103L <= YY_CPLUSPLUS
1638 return symbol_type (token::OP_GREP, std::move (l));
1645 return symbol_type (token::OP_GREP, l);
1648 #if 201103L <= YY_CPLUSPLUS
1653 return symbol_type (token::OP_STAR, std::move (l));
1660 return symbol_type (token::OP_STAR, l);
1663 #if 201103L <= YY_CPLUSPLUS
1668 return symbol_type (token::OP_BSTAR, std::move (l));
1675 return symbol_type (token::OP_BSTAR, l);
1678 #if 201103L <= YY_CPLUSPLUS
1683 return symbol_type (token::OP_BFSTAR, std::move (l));
1690 return symbol_type (token::OP_BFSTAR, l);
1693 #if 201103L <= YY_CPLUSPLUS
1698 return symbol_type (token::OP_PLUS, std::move (l));
1705 return symbol_type (token::OP_PLUS, l);
1708 #if 201103L <= YY_CPLUSPLUS
1713 return symbol_type (token::OP_FPLUS, std::move (l));
1720 return symbol_type (token::OP_FPLUS, l);
1723 #if 201103L <= YY_CPLUSPLUS
1728 return symbol_type (token::OP_STAR_OPEN, std::move (l));
1735 return symbol_type (token::OP_STAR_OPEN, l);
1738 #if 201103L <= YY_CPLUSPLUS
1743 return symbol_type (token::OP_FSTAR_OPEN, std::move (l));
1750 return symbol_type (token::OP_FSTAR_OPEN, l);
1753 #if 201103L <= YY_CPLUSPLUS
1758 return symbol_type (token::OP_EQUAL_OPEN, std::move (l));
1765 return symbol_type (token::OP_EQUAL_OPEN, l);
1768 #if 201103L <= YY_CPLUSPLUS
1773 return symbol_type (token::OP_GOTO_OPEN, std::move (l));
1780 return symbol_type (token::OP_GOTO_OPEN, l);
1783 #if 201103L <= YY_CPLUSPLUS
1788 return symbol_type (token::OP_SQBKT_CLOSE, std::move (l));
1795 return symbol_type (token::OP_SQBKT_CLOSE, l);
1798 #if 201103L <= YY_CPLUSPLUS
1803 return symbol_type (token::OP_SQBKT_STRONG_CLOSE, std::move (l));
1810 return symbol_type (token::OP_SQBKT_STRONG_CLOSE, l);
1813 #if 201103L <= YY_CPLUSPLUS
1818 return symbol_type (token::OP_SQBKT_NUM, std::move (v), std::move (l));
1823 make_OP_SQBKT_NUM (
const unsigned& v,
const location_type& l)
1825 return symbol_type (token::OP_SQBKT_NUM, v, l);
1828 #if 201103L <= YY_CPLUSPLUS
1833 return symbol_type (token::OP_UNBOUNDED, std::move (l));
1840 return symbol_type (token::OP_UNBOUNDED, l);
1843 #if 201103L <= YY_CPLUSPLUS
1848 return symbol_type (token::OP_SQBKT_SEP, std::move (l));
1855 return symbol_type (token::OP_SQBKT_SEP, l);
1858 #if 201103L <= YY_CPLUSPLUS
1863 return symbol_type (token::OP_UCONCAT, std::move (l));
1870 return symbol_type (token::OP_UCONCAT, l);
1873 #if 201103L <= YY_CPLUSPLUS
1878 return symbol_type (token::OP_ECONCAT, std::move (l));
1885 return symbol_type (token::OP_ECONCAT, l);
1888 #if 201103L <= YY_CPLUSPLUS
1893 return symbol_type (token::OP_UCONCAT_NONO, std::move (l));
1900 return symbol_type (token::OP_UCONCAT_NONO, l);
1903 #if 201103L <= YY_CPLUSPLUS
1908 return symbol_type (token::OP_ECONCAT_NONO, std::move (l));
1915 return symbol_type (token::OP_ECONCAT_NONO, l);
1918 #if 201103L <= YY_CPLUSPLUS
1923 return symbol_type (token::OP_FIRST_MATCH, std::move (l));
1930 return symbol_type (token::OP_FIRST_MATCH, l);
1933 #if 201103L <= YY_CPLUSPLUS
1938 return symbol_type (token::ATOMIC_PROP, std::move (v), std::move (l));
1943 make_ATOMIC_PROP (
const std::string& v,
const location_type& l)
1945 return symbol_type (token::ATOMIC_PROP, v, l);
1948 #if 201103L <= YY_CPLUSPLUS
1953 return symbol_type (token::OP_CONCAT, std::move (l));
1960 return symbol_type (token::OP_CONCAT, l);
1963 #if 201103L <= YY_CPLUSPLUS
1968 return symbol_type (token::OP_FUSION, std::move (l));
1975 return symbol_type (token::OP_FUSION, l);
1978 #if 201103L <= YY_CPLUSPLUS
1983 return symbol_type (token::CONST_TRUE, std::move (l));
1990 return symbol_type (token::CONST_TRUE, l);
1993 #if 201103L <= YY_CPLUSPLUS
1998 return symbol_type (token::CONST_FALSE, std::move (l));
2005 return symbol_type (token::CONST_FALSE, l);
2008 #if 201103L <= YY_CPLUSPLUS
2013 return symbol_type (token::END_OF_INPUT, std::move (l));
2020 return symbol_type (token::END_OF_INPUT, l);
2023 #if 201103L <= YY_CPLUSPLUS
2028 return symbol_type (token::OP_POST_NEG, std::move (l));
2035 return symbol_type (token::OP_POST_NEG, l);
2038 #if 201103L <= YY_CPLUSPLUS
2043 return symbol_type (token::OP_POST_POS, std::move (l));
2050 return symbol_type (token::OP_POST_POS, l);
2053 #if 201103L <= YY_CPLUSPLUS
2058 return symbol_type (token::OP_DELAY_N, std::move (v), std::move (l));
2065 return symbol_type (token::OP_DELAY_N, v, l);
2068 #if 201103L <= YY_CPLUSPLUS
2073 return symbol_type (token::OP_DELAY_OPEN, std::move (l));
2080 return symbol_type (token::OP_DELAY_OPEN, l);
2083 #if 201103L <= YY_CPLUSPLUS
2088 return symbol_type (token::OP_DELAY_PLUS, std::move (l));
2095 return symbol_type (token::OP_DELAY_PLUS, l);
2098 #if 201103L <= YY_CPLUSPLUS
2103 return symbol_type (token::OP_DELAY_STAR, std::move (l));
2110 return symbol_type (token::OP_DELAY_STAR, l);
2119 const symbol_type& lookahead ()
const YY_NOEXCEPT {
return yyla_; }
2121 const location_type& location ()
const YY_NOEXCEPT {
return yyla_.location; }
2134 #if YY_CPLUSPLUS < 201103L
2143 typedef short state_type;
2146 int yy_syntax_error_arguments_ (
const context& yyctx,
2151 virtual std::string yysyntax_error_ (
const context& yyctx)
const;
2155 static state_type yy_lr_goto_state_ (state_type yystate,
int yysym);
2159 static bool yy_pact_value_is_default_ (
int yyvalue);
2163 static bool yy_table_value_is_error_ (
int yyvalue);
2165 static const signed char yypact_ninf_;
2166 static const signed char yytable_ninf_;
2174 static std::string yytnamerr_ (
const char *yystr);
2177 static const char*
const yytname_[];
2183 static const short yypact_[];
2188 static const unsigned char yydefact_[];
2191 static const short yypgoto_[];
2194 static const unsigned char yydefgoto_[];
2199 static const short yytable_[];
2201 static const short yycheck_[];
2205 static const signed char yystos_[];
2208 static const signed char yyr1_[];
2211 static const signed char yyr2_[];
2216 static const short yyrline_[];
2218 virtual void yy_reduce_print_ (
int r)
const;
2220 virtual void yy_stack_print_ ()
const;
2225 std::ostream* yycdebug_;
2230 template <
typename Base>
2238 template <
typename Base>
2246 by_state () YY_NOEXCEPT;
2255 by_state (const by_state& that) YY_NOEXCEPT;
2258 void clear () YY_NOEXCEPT;
2261 void move (by_state& that);
2269 enum { empty_state = 0 };
2277 struct stack_symbol_type : basic_symbol<by_state>
2280 typedef basic_symbol<by_state> super_type;
2282 stack_symbol_type ();
2284 stack_symbol_type (YY_RVREF (stack_symbol_type) that);
2286 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
2287 #if YY_CPLUSPLUS < 201103L
2290 stack_symbol_type& operator= (stack_symbol_type& that);
2294 stack_symbol_type& operator= (
const stack_symbol_type& that);
2299 template <
typename T,
typename S = std::vector<T> >
2304 typedef typename S::iterator iterator;
2305 typedef typename S::const_iterator const_iterator;
2306 typedef typename S::size_type size_type;
2307 typedef typename std::ptrdiff_t index_type;
2309 stack (size_type n = 200)
2313 #if 201103L <= YY_CPLUSPLUS
2315 stack (
const stack&) =
delete;
2317 stack& operator= (
const stack&) =
delete;
2324 operator[] (index_type i)
const
2326 return seq_[size_type (size () - 1 - i)];
2333 operator[] (index_type i)
2335 return seq_[size_type (size () - 1 - i)];
2342 push (YY_MOVE_REF (T) t)
2344 seq_.push_back (T ());
2345 operator[] (0).move (t);
2350 pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2358 clear () YY_NOEXCEPT
2365 size () const YY_NOEXCEPT
2367 return index_type (seq_.size ());
2372 begin () const YY_NOEXCEPT
2374 return seq_.begin ();
2379 end () const YY_NOEXCEPT
2388 slice (
const stack& stack, index_type range)
2394 operator[] (index_type i)
const
2396 return stack_[range_ - i];
2400 const stack& stack_;
2405 #if YY_CPLUSPLUS < 201103L
2407 stack (
const stack&);
2409 stack& operator= (
const stack&);
2417 typedef stack<stack_symbol_type> stack_type;
2420 stack_type yystack_;
2427 void yypush_ (
const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2435 void yypush_ (
const char* m, state_type s, YY_MOVE_REF (
symbol_type) sym);
2438 void yypop_ (
int n = 1);
2458 #line 2459 "parsetl.hh"
An environment that describes atomic propositions.
Definition: environment.hh:33
Actual storage for formula nodes.
Definition: formula.hh:128
static const fnode * multop(op o, std::vector< const fnode * > l)
const fnode * clone() const
Clone an fnode.
Definition: formula.hh:134
Definition: parsetl.hh:2116
int expected_tokens(symbol_kind_type yyarg[], int yyargn) const
Definition: parsetl.hh:359
void copy(const self_type &that)
Copy the content of that to this.
Definition: parsetl.hh:492
T & build(const T &t)
Definition: parsetl.hh:426
semantic_type(const T &t)
Construct and fill.
Definition: parsetl.hh:371
~semantic_type()
Destruction, allowed only if empty.
Definition: parsetl.hh:384
long double yyalign_me
Strongest alignment constraints.
Definition: parsetl.hh:571
char yyraw[size]
A buffer large enough to store any of the semantic values.
Definition: parsetl.hh:573
const T & as() const
Const accessor to a built T (for printer).
Definition: parsetl.hh:442
void move(self_type &that)
Definition: parsetl.hh:467
void destroy()
Destroy the stored T.
Definition: parsetl.hh:500
T & emplace()
Instantiate an empty T in here.
Definition: parsetl.hh:399
T & as()
Accessor to a built T.
Definition: parsetl.hh:434
T & emplace(const T &t)
Instantiate a T in here from t.
Definition: parsetl.hh:407
semantic_type self_type
Type of *this.
Definition: parsetl.hh:362
void swap(self_type &that)
Definition: parsetl.hh:457
T & build()
Definition: parsetl.hh:417
semantic_type()
Empty construction.
Definition: parsetl.hh:365
Present a slice of the top of a stack.
Definition: parsetl.hh:2386
A Bison parser.
Definition: parsetl.hh:350
parser(spot::parse_error_list &error_list_yyarg, spot::environment &parse_environment_yyarg, spot::formula &result_yyarg)
Build a parser object.
void set_debug_level(debug_level_type l)
Set the current debugging level.
static const symbol_kind_type YYNTOKENS
The number of tokens.
Definition: parsetl.hh:799
int debug_level_type
Type for debugging levels.
Definition: parsetl.hh:1133
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition: parsetl.hh:796
virtual void error(const location_type &loc, const std::string &msg)
void set_debug_stream(std::ostream &)
Set the current debugging stream.
token::yytokentype token_kind_type
Token kind, as returned by yylex.
Definition: parsetl.hh:677
debug_level_type debug_level() const
The current debugging level.
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
Definition: parsetl.hh:680
std::ostream & debug_stream() const
The current debugging stream.
static std::string symbol_name(symbol_kind_type yysymbol)
spot::location location_type
Symbol locations.
Definition: parsetl.hh:581
void error(const syntax_error &err)
Report a syntax error.
op
Operator types.
Definition: formula.hh:79
std::list< one_parse_error > parse_error_list
A list of parser diagnostics, as filled by parse.
Definition: parse.hh:42
Definition: parsetl.hh:58
Definition: parsetl.hh:70
Definition: parsetl.hh:76
Definition: parsetl.hh:809
basic_symbol(const basic_symbol &that)
Copy constructor.
semantic_type value
The semantic value.
Definition: parsetl.hh:1018
symbol_kind_type type_get() const
Backward compatibility (Bison 3.6).
void clear()
Destroy contents, and record that is empty.
Definition: parsetl.hh:947
std::string name() const
The user-facing name of this symbol.
Definition: parsetl.hh:1003
location_type location
The location.
Definition: parsetl.hh:1021
bool empty() const
Whether empty.
~basic_symbol()
Destroy the symbol.
Definition: parsetl.hh:941
Base super_type
Alias to Base.
Definition: parsetl.hh:811
void move(basic_symbol &s)
Destructive move, s is emptied into this.
basic_symbol()
Default constructor.
Definition: parsetl.hh:814
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
Definition: parsetl.hh:878
Type access provider for token (enum) based symbols.
Definition: parsetl.hh:1032
symbol_kind_type kind_
Definition: parsetl.hh:1065
void move(by_kind &that)
Steal the symbol kind from that.
symbol_kind_type type_get() const
Backward compatibility (Bison 3.6).
symbol_kind_type kind() const
token_kind_type kind_type
The symbol kind as needed by the constructor.
Definition: parsetl.hh:1045
by_kind(const by_kind &that)
Copy constructor.
by_kind()
Default constructor.
by_kind(kind_type t)
Constructor from (external) token numbers.
void clear()
Record that this symbol is empty.
Symbol kinds.
Definition: parsetl.hh:684
symbol_kind_type
Definition: parsetl.hh:686
@ YYNTOKENS
Number of tokens.
Definition: parsetl.hh:687
"External" symbols: returned by the scanner.
Definition: parsetl.hh:1073
symbol_type()
Empty symbol.
Definition: parsetl.hh:1078
basic_symbol< by_kind > super_type
Superclass.
Definition: parsetl.hh:1075
Syntax errors thrown from user actions.
Definition: parsetl.hh:585
Token kinds.
Definition: parsetl.hh:603
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
Definition: parsetl.hh:673