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"
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
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))
278#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
279# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
280# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
281 _Pragma ("GCC diagnostic push") \
282 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
284# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
285 _Pragma ("GCC diagnostic push") \
286 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
287 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
289# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
290 _Pragma ("GCC diagnostic pop")
292# define YY_INITIAL_VALUE(Value) Value
294#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
295# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
296# define YY_IGNORE_MAYBE_UNINITIALIZED_END
298#ifndef YY_INITIAL_VALUE
299# define YY_INITIAL_VALUE(Value)
302#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
303# define YY_IGNORE_USELESS_CAST_BEGIN \
304 _Pragma ("GCC diagnostic push") \
305 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
306# define YY_IGNORE_USELESS_CAST_END \
307 _Pragma ("GCC diagnostic pop")
309#ifndef YY_IGNORE_USELESS_CAST_BEGIN
310# define YY_IGNORE_USELESS_CAST_BEGIN
311# define YY_IGNORE_USELESS_CAST_END
316# define YY_CAST(Type, Val) static_cast<Type> (Val)
317# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
319# define YY_CAST(Type, Val) ((Type) (Val))
320# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
324# if defined __cplusplus
325# if 201103L <= __cplusplus
326# define YY_NULLPTR nullptr
331# define YY_NULLPTR ((void*)0)
349#line 350 "parsetl.hh"
360# pragma GCC message "bison: do not #define TLYYSTYPE in C++, use %define api.value.type"
381 template <
typename T>
384 new (yyas_<T> ()) T (YY_MOVE (t));
387#if 201103L <= YY_CPLUSPLUS
398# if 201103L <= YY_CPLUSPLUS
400 template <
typename T,
typename... U>
404 return *
new (yyas_<T> ()) T (std::forward <U>(u)...);
408 template <
typename T>
412 return *
new (yyas_<T> ()) T ();
416 template <
typename T>
420 return *
new (yyas_<T> ()) T (t);
426 template <
typename T>
430 return emplace<T> ();
435 template <
typename T>
439 return emplace<T> (t);
443 template <
typename T>
451 template <
typename T>
453 as () const YY_NOEXCEPT
466 template <
typename T>
470 std::swap (as<T> (), that.as<T> ());
476 template <
typename T>
480# if 201103L <= YY_CPLUSPLUS
481 emplace<T> (std::move (that.
as<T> ()));
489# if 201103L <= YY_CPLUSPLUS
491 template <
typename T>
495 emplace<T> (std::move (that.as<T> ()));
501 template <
typename T>
505 emplace<T> (that.
as<T> ());
509 template <
typename T>
517#if YY_CPLUSPLUS < 201103L
525 template <
typename T>
530 return static_cast<T*
> (yyp);
534 template <
typename T>
536 yyas_ () const YY_NOEXCEPT
539 return static_cast<const T*
> (yyp);
561 char dummy2[
sizeof (
pnode)];
567 char dummy3[
sizeof (std::string)];
572 char dummy4[
sizeof (unsigned)];
576 enum { size =
sizeof (union_type) };
599 : std::runtime_error (m)
604 : std::runtime_error (s.what ())
605 , location (s.location)
630 BRA_BANG_BLOCK = 266,
633 BRACE_BANG_CLOSE = 269,
661 OP_SQBKT_CLOSE = 297,
662 OP_SQBKT_STRONG_CLOSE = 298,
668 OP_UCONCAT_NONO = 304,
669 OP_ECONCAT_NONO = 305,
670 OP_FIRST_MATCH = 306,
712 S_BRA_BANG_BLOCK = 11,
715 S_BRACE_BANG_CLOSE = 14,
740 S_OP_FSTAR_OPEN = 39,
741 S_OP_EQUAL_OPEN = 40,
743 S_OP_SQBKT_CLOSE = 42,
744 S_OP_SQBKT_STRONG_CLOSE = 43,
750 S_OP_UCONCAT_NONO = 49,
751 S_OP_ECONCAT_NONO = 50,
752 S_OP_FIRST_MATCH = 51,
762 S_OP_DELAY_OPEN = 61,
763 S_OP_DELAY_PLUS = 62,
764 S_OP_DELAY_STAR = 63,
785 S_OP_SQBKT_SEP_unbounded = 84,
786 S_OP_SQBKT_SEP_opt = 85,
789 S_sqbracketargs = 88,
800 S_parenthesedsubformula = 99,
819 template <
typename Base>
831#if 201103L <= YY_CPLUSPLUS
834 : Base (std::
move (that))
838 switch (this->kind ())
840 case symbol_kind::S_sqbracketargs:
841 case symbol_kind::S_gotoargs:
842 case symbol_kind::S_starargs:
843 case symbol_kind::S_fstarargs:
844 case symbol_kind::S_equalargs:
845 case symbol_kind::S_delayargs:
849 case symbol_kind::S_atomprop:
850 case symbol_kind::S_booleanatom:
851 case symbol_kind::S_sere:
852 case symbol_kind::S_bracedsere:
853 case symbol_kind::S_parenthesedsubformula:
854 case symbol_kind::S_boolformula:
855 case symbol_kind::S_subformula:
856 case symbol_kind::S_lbtformula:
860 case symbol_kind::S_PAR_BLOCK:
861 case symbol_kind::S_BRA_BLOCK:
862 case symbol_kind::S_BRA_BANG_BLOCK:
863 case symbol_kind::S_ATOMIC_PROP:
864 value.
move< std::string > (std::move (that.value));
867 case symbol_kind::S_OP_SQBKT_NUM:
868 case symbol_kind::S_OP_DELAY_N:
869 case symbol_kind::S_sqbkt_num:
870 value.
move<
unsigned > (std::move (that.value));
884#if 201103L <= YY_CPLUSPLUS
896#if 201103L <= YY_CPLUSPLUS
910#if 201103L <= YY_CPLUSPLUS
924#if 201103L <= YY_CPLUSPLUS
938#if 201103L <= YY_CPLUSPLUS
976 case symbol_kind::S_sqbracketargs:
977 case symbol_kind::S_gotoargs:
978 case symbol_kind::S_starargs:
979 case symbol_kind::S_fstarargs:
980 case symbol_kind::S_equalargs:
981 case symbol_kind::S_delayargs:
982 value.template destroy< minmax_t > ();
985 case symbol_kind::S_atomprop:
986 case symbol_kind::S_booleanatom:
987 case symbol_kind::S_sere:
988 case symbol_kind::S_bracedsere:
989 case symbol_kind::S_parenthesedsubformula:
990 case symbol_kind::S_boolformula:
991 case symbol_kind::S_subformula:
992 case symbol_kind::S_lbtformula:
993 value.template destroy< pnode > ();
996 case symbol_kind::S_PAR_BLOCK:
997 case symbol_kind::S_BRA_BLOCK:
998 case symbol_kind::S_BRA_BANG_BLOCK:
999 case symbol_kind::S_ATOMIC_PROP:
1000 value.template destroy< std::string > ();
1003 case symbol_kind::S_OP_SQBKT_NUM:
1004 case symbol_kind::S_OP_DELAY_N:
1005 case symbol_kind::S_sqbkt_num:
1006 value.template destroy< unsigned > ();
1017 std::string
name () const YY_NOEXCEPT
1038#if YY_CPLUSPLUS < 201103L
1053#if 201103L <= YY_CPLUSPLUS
1097#if 201103L <= YY_CPLUSPLUS
1099 : super_type (token_kind_type (tok), std::
move (l))
1105#if 201103L <= YY_CPLUSPLUS
1107 : super_type (token_kind_type (tok), std::
move (v), std::
move (l))
1110 : super_type (token_kind_type (tok), v, l)
1113#if 201103L <= YY_CPLUSPLUS
1117 symbol_type (int tok, const unsigned& v, const
location_type& l)
1127#if 201103L <= YY_CPLUSPLUS
1169#if 201103L <= YY_CPLUSPLUS
1174 return symbol_type (token::TLYYEOF, std::move (l));
1181 return symbol_type (token::TLYYEOF, l);
1184#if 201103L <= YY_CPLUSPLUS
1189 return symbol_type (token::TLYYerror, std::move (l));
1196 return symbol_type (token::TLYYerror, l);
1199#if 201103L <= YY_CPLUSPLUS
1204 return symbol_type (token::TLYYUNDEF, std::move (l));
1211 return symbol_type (token::TLYYUNDEF, l);
1214#if 201103L <= YY_CPLUSPLUS
1219 return symbol_type (token::START_LTL, std::move (l));
1226 return symbol_type (token::START_LTL, l);
1229#if 201103L <= YY_CPLUSPLUS
1234 return symbol_type (token::START_LBT, std::move (l));
1241 return symbol_type (token::START_LBT, l);
1244#if 201103L <= YY_CPLUSPLUS
1249 return symbol_type (token::START_SERE, std::move (l));
1256 return symbol_type (token::START_SERE, l);
1259#if 201103L <= YY_CPLUSPLUS
1264 return symbol_type (token::START_BOOL, std::move (l));
1271 return symbol_type (token::START_BOOL, l);
1274#if 201103L <= YY_CPLUSPLUS
1279 return symbol_type (token::PAR_OPEN, std::move (l));
1286 return symbol_type (token::PAR_OPEN, l);
1289#if 201103L <= YY_CPLUSPLUS
1294 return symbol_type (token::PAR_CLOSE, std::move (l));
1301 return symbol_type (token::PAR_CLOSE, l);
1304#if 201103L <= YY_CPLUSPLUS
1309 return symbol_type (token::PAR_BLOCK, std::move (v), std::move (l));
1314 make_PAR_BLOCK (
const std::string& v,
const location_type& l)
1316 return symbol_type (token::PAR_BLOCK, v, l);
1319#if 201103L <= YY_CPLUSPLUS
1324 return symbol_type (token::BRA_BLOCK, std::move (v), std::move (l));
1329 make_BRA_BLOCK (
const std::string& v,
const location_type& l)
1331 return symbol_type (token::BRA_BLOCK, v, l);
1334#if 201103L <= YY_CPLUSPLUS
1339 return symbol_type (token::BRA_BANG_BLOCK, std::move (v), std::move (l));
1344 make_BRA_BANG_BLOCK (
const std::string& v,
const location_type& l)
1346 return symbol_type (token::BRA_BANG_BLOCK, v, l);
1349#if 201103L <= YY_CPLUSPLUS
1354 return symbol_type (token::BRACE_OPEN, std::move (l));
1361 return symbol_type (token::BRACE_OPEN, l);
1364#if 201103L <= YY_CPLUSPLUS
1369 return symbol_type (token::BRACE_CLOSE, std::move (l));
1376 return symbol_type (token::BRACE_CLOSE, l);
1379#if 201103L <= YY_CPLUSPLUS
1384 return symbol_type (token::BRACE_BANG_CLOSE, std::move (l));
1391 return symbol_type (token::BRACE_BANG_CLOSE, l);
1394#if 201103L <= YY_CPLUSPLUS
1399 return symbol_type (token::OP_OR, std::move (l));
1406 return symbol_type (token::OP_OR, l);
1409#if 201103L <= YY_CPLUSPLUS
1414 return symbol_type (token::OP_XOR, std::move (l));
1421 return symbol_type (token::OP_XOR, l);
1424#if 201103L <= YY_CPLUSPLUS
1429 return symbol_type (token::OP_AND, std::move (l));
1436 return symbol_type (token::OP_AND, l);
1439#if 201103L <= YY_CPLUSPLUS
1444 return symbol_type (token::OP_SHORT_AND, std::move (l));
1451 return symbol_type (token::OP_SHORT_AND, l);
1454#if 201103L <= YY_CPLUSPLUS
1459 return symbol_type (token::OP_IMPLIES, std::move (l));
1466 return symbol_type (token::OP_IMPLIES, l);
1469#if 201103L <= YY_CPLUSPLUS
1474 return symbol_type (token::OP_EQUIV, std::move (l));
1481 return symbol_type (token::OP_EQUIV, l);
1484#if 201103L <= YY_CPLUSPLUS
1489 return symbol_type (token::OP_U, std::move (l));
1496 return symbol_type (token::OP_U, l);
1499#if 201103L <= YY_CPLUSPLUS
1504 return symbol_type (token::OP_R, std::move (l));
1511 return symbol_type (token::OP_R, l);
1514#if 201103L <= YY_CPLUSPLUS
1519 return symbol_type (token::OP_W, std::move (l));
1526 return symbol_type (token::OP_W, l);
1529#if 201103L <= YY_CPLUSPLUS
1534 return symbol_type (token::OP_M, std::move (l));
1541 return symbol_type (token::OP_M, l);
1544#if 201103L <= YY_CPLUSPLUS
1549 return symbol_type (token::OP_F, std::move (l));
1556 return symbol_type (token::OP_F, l);
1559#if 201103L <= YY_CPLUSPLUS
1564 return symbol_type (token::OP_G, std::move (l));
1571 return symbol_type (token::OP_G, l);
1574#if 201103L <= YY_CPLUSPLUS
1579 return symbol_type (token::OP_X, std::move (l));
1586 return symbol_type (token::OP_X, l);
1589#if 201103L <= YY_CPLUSPLUS
1594 return symbol_type (token::OP_STRONG_X, std::move (l));
1601 return symbol_type (token::OP_STRONG_X, l);
1604#if 201103L <= YY_CPLUSPLUS
1609 return symbol_type (token::OP_NOT, std::move (l));
1616 return symbol_type (token::OP_NOT, l);
1619#if 201103L <= YY_CPLUSPLUS
1624 return symbol_type (token::OP_XREP, std::move (l));
1631 return symbol_type (token::OP_XREP, l);
1634#if 201103L <= YY_CPLUSPLUS
1639 return symbol_type (token::OP_FREP, std::move (l));
1646 return symbol_type (token::OP_FREP, l);
1649#if 201103L <= YY_CPLUSPLUS
1654 return symbol_type (token::OP_GREP, std::move (l));
1661 return symbol_type (token::OP_GREP, l);
1664#if 201103L <= YY_CPLUSPLUS
1669 return symbol_type (token::OP_STAR, std::move (l));
1676 return symbol_type (token::OP_STAR, l);
1679#if 201103L <= YY_CPLUSPLUS
1684 return symbol_type (token::OP_BSTAR, std::move (l));
1691 return symbol_type (token::OP_BSTAR, l);
1694#if 201103L <= YY_CPLUSPLUS
1699 return symbol_type (token::OP_BFSTAR, std::move (l));
1706 return symbol_type (token::OP_BFSTAR, l);
1709#if 201103L <= YY_CPLUSPLUS
1714 return symbol_type (token::OP_PLUS, std::move (l));
1721 return symbol_type (token::OP_PLUS, l);
1724#if 201103L <= YY_CPLUSPLUS
1729 return symbol_type (token::OP_FPLUS, std::move (l));
1736 return symbol_type (token::OP_FPLUS, l);
1739#if 201103L <= YY_CPLUSPLUS
1744 return symbol_type (token::OP_STAR_OPEN, std::move (l));
1751 return symbol_type (token::OP_STAR_OPEN, l);
1754#if 201103L <= YY_CPLUSPLUS
1759 return symbol_type (token::OP_FSTAR_OPEN, std::move (l));
1766 return symbol_type (token::OP_FSTAR_OPEN, l);
1769#if 201103L <= YY_CPLUSPLUS
1774 return symbol_type (token::OP_EQUAL_OPEN, std::move (l));
1781 return symbol_type (token::OP_EQUAL_OPEN, l);
1784#if 201103L <= YY_CPLUSPLUS
1789 return symbol_type (token::OP_GOTO_OPEN, std::move (l));
1796 return symbol_type (token::OP_GOTO_OPEN, l);
1799#if 201103L <= YY_CPLUSPLUS
1804 return symbol_type (token::OP_SQBKT_CLOSE, std::move (l));
1811 return symbol_type (token::OP_SQBKT_CLOSE, l);
1814#if 201103L <= YY_CPLUSPLUS
1819 return symbol_type (token::OP_SQBKT_STRONG_CLOSE, std::move (l));
1826 return symbol_type (token::OP_SQBKT_STRONG_CLOSE, l);
1829#if 201103L <= YY_CPLUSPLUS
1834 return symbol_type (token::OP_SQBKT_NUM, std::move (v), std::move (l));
1839 make_OP_SQBKT_NUM (
const unsigned& v,
const location_type& l)
1841 return symbol_type (token::OP_SQBKT_NUM, v, l);
1844#if 201103L <= YY_CPLUSPLUS
1849 return symbol_type (token::OP_UNBOUNDED, std::move (l));
1856 return symbol_type (token::OP_UNBOUNDED, l);
1859#if 201103L <= YY_CPLUSPLUS
1864 return symbol_type (token::OP_SQBKT_SEP, std::move (l));
1871 return symbol_type (token::OP_SQBKT_SEP, l);
1874#if 201103L <= YY_CPLUSPLUS
1879 return symbol_type (token::OP_UCONCAT, std::move (l));
1886 return symbol_type (token::OP_UCONCAT, l);
1889#if 201103L <= YY_CPLUSPLUS
1894 return symbol_type (token::OP_ECONCAT, std::move (l));
1901 return symbol_type (token::OP_ECONCAT, l);
1904#if 201103L <= YY_CPLUSPLUS
1909 return symbol_type (token::OP_UCONCAT_NONO, std::move (l));
1916 return symbol_type (token::OP_UCONCAT_NONO, l);
1919#if 201103L <= YY_CPLUSPLUS
1924 return symbol_type (token::OP_ECONCAT_NONO, std::move (l));
1931 return symbol_type (token::OP_ECONCAT_NONO, l);
1934#if 201103L <= YY_CPLUSPLUS
1939 return symbol_type (token::OP_FIRST_MATCH, std::move (l));
1946 return symbol_type (token::OP_FIRST_MATCH, l);
1949#if 201103L <= YY_CPLUSPLUS
1954 return symbol_type (token::ATOMIC_PROP, std::move (v), std::move (l));
1959 make_ATOMIC_PROP (
const std::string& v,
const location_type& l)
1961 return symbol_type (token::ATOMIC_PROP, v, l);
1964#if 201103L <= YY_CPLUSPLUS
1969 return symbol_type (token::OP_CONCAT, std::move (l));
1976 return symbol_type (token::OP_CONCAT, l);
1979#if 201103L <= YY_CPLUSPLUS
1984 return symbol_type (token::OP_FUSION, std::move (l));
1991 return symbol_type (token::OP_FUSION, l);
1994#if 201103L <= YY_CPLUSPLUS
1999 return symbol_type (token::CONST_TRUE, std::move (l));
2006 return symbol_type (token::CONST_TRUE, l);
2009#if 201103L <= YY_CPLUSPLUS
2014 return symbol_type (token::CONST_FALSE, std::move (l));
2021 return symbol_type (token::CONST_FALSE, l);
2024#if 201103L <= YY_CPLUSPLUS
2029 return symbol_type (token::END_OF_INPUT, std::move (l));
2036 return symbol_type (token::END_OF_INPUT, l);
2039#if 201103L <= YY_CPLUSPLUS
2044 return symbol_type (token::OP_POST_NEG, std::move (l));
2051 return symbol_type (token::OP_POST_NEG, l);
2054#if 201103L <= YY_CPLUSPLUS
2059 return symbol_type (token::OP_POST_POS, std::move (l));
2066 return symbol_type (token::OP_POST_POS, l);
2069#if 201103L <= YY_CPLUSPLUS
2074 return symbol_type (token::OP_DELAY_N, std::move (v), std::move (l));
2081 return symbol_type (token::OP_DELAY_N, v, l);
2084#if 201103L <= YY_CPLUSPLUS
2089 return symbol_type (token::OP_DELAY_OPEN, std::move (l));
2096 return symbol_type (token::OP_DELAY_OPEN, l);
2099#if 201103L <= YY_CPLUSPLUS
2104 return symbol_type (token::OP_DELAY_PLUS, std::move (l));
2111 return symbol_type (token::OP_DELAY_PLUS, l);
2114#if 201103L <= YY_CPLUSPLUS
2119 return symbol_type (token::OP_DELAY_STAR, std::move (l));
2126 return symbol_type (token::OP_DELAY_STAR, l);
2135 const symbol_type& lookahead ()
const YY_NOEXCEPT {
return yyla_; }
2137 const location_type& location ()
const YY_NOEXCEPT {
return yyla_.location; }
2150#if YY_CPLUSPLUS < 201103L
2159 typedef short state_type;
2162 int yy_syntax_error_arguments_ (
const context& yyctx,
2167 virtual std::string yysyntax_error_ (
const context& yyctx)
const;
2171 static state_type yy_lr_goto_state_ (state_type yystate,
int yysym);
2175 static bool yy_pact_value_is_default_ (
int yyvalue) YY_NOEXCEPT;
2179 static bool yy_table_value_is_error_ (
int yyvalue) YY_NOEXCEPT;
2181 static const signed char yypact_ninf_;
2182 static const signed char yytable_ninf_;
2190 static std::string yytnamerr_ (
const char *yystr);
2193 static const char*
const yytname_[];
2199 static const short yypact_[];
2204 static const unsigned char yydefact_[];
2207 static const short yypgoto_[];
2210 static const unsigned char yydefgoto_[];
2215 static const short yytable_[];
2217 static const short yycheck_[];
2221 static const signed char yystos_[];
2224 static const signed char yyr1_[];
2227 static const signed char yyr2_[];
2232 static const short yyrline_[];
2234 virtual void yy_reduce_print_ (
int r)
const;
2236 virtual void yy_stack_print_ ()
const;
2241 std::ostream* yycdebug_;
2246 template <
typename Base>
2254 template <
typename Base>
2262 by_state () YY_NOEXCEPT;
2271 by_state (const by_state& that) YY_NOEXCEPT;
2274 void clear () YY_NOEXCEPT;
2277 void move (by_state& that);
2285 enum { empty_state = 0 };
2293 struct stack_symbol_type : basic_symbol<by_state>
2296 typedef basic_symbol<by_state> super_type;
2298 stack_symbol_type ();
2300 stack_symbol_type (YY_RVREF (stack_symbol_type) that);
2302 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
2303#if YY_CPLUSPLUS < 201103L
2306 stack_symbol_type& operator= (stack_symbol_type& that);
2310 stack_symbol_type& operator= (
const stack_symbol_type& that);
2315 template <
typename T,
typename S = std::vector<T> >
2320 typedef typename S::iterator iterator;
2321 typedef typename S::const_iterator const_iterator;
2322 typedef typename S::size_type size_type;
2323 typedef typename std::ptrdiff_t index_type;
2325 stack (size_type n = 200) YY_NOEXCEPT
2329#if 201103L <= YY_CPLUSPLUS
2331 stack (
const stack&) =
delete;
2333 stack& operator= (
const stack&) =
delete;
2340 operator[] (index_type i)
const
2342 return seq_[size_type (size () - 1 - i)];
2349 operator[] (index_type i)
2351 return seq_[size_type (size () - 1 - i)];
2358 push (YY_MOVE_REF (T) t)
2360 seq_.push_back (T ());
2361 operator[] (0).move (t);
2366 pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2374 clear () YY_NOEXCEPT
2381 size () const YY_NOEXCEPT
2383 return index_type (seq_.size ());
2388 begin () const YY_NOEXCEPT
2390 return seq_.begin ();
2395 end () const YY_NOEXCEPT
2404 slice (
const stack& stack, index_type range) YY_NOEXCEPT
2410 operator[] (index_type i)
const
2412 return stack_[range_ - i];
2416 const stack& stack_;
2421#if YY_CPLUSPLUS < 201103L
2423 stack (
const stack&);
2425 stack& operator= (
const stack&);
2433 typedef stack<stack_symbol_type> stack_type;
2436 stack_type yystack_;
2443 void yypush_ (
const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2451 void yypush_ (
const char* m, state_type s, YY_MOVE_REF (
symbol_type) sym);
2454 void yypop_ (
int n = 1) YY_NOEXCEPT;
2474#line 2475 "parsetl.hh"
An environment that describes atomic propositions.
Definition: environment.hh:29
Actual storage for formula nodes.
Definition: formula.hh:127
const fnode * clone() const
Clone an fnode.
Definition: formula.hh:133
static const fnode * multop(op o, std::vector< const fnode * > l)
Definition: parsetl.hh:2132
int expected_tokens(symbol_kind_type yyarg[], int yyargn) const
Present a slice of the top of a stack.
Definition: parsetl.hh:2402
Definition: parsetl.hh:370
T & emplace(const T &t)
Instantiate a T in here from t.
Definition: parsetl.hh:418
value_type self_type
Type of *this.
Definition: parsetl.hh:373
T & as()
Accessor to a built T.
Definition: parsetl.hh:445
void move(self_type &that)
Definition: parsetl.hh:478
T & build(const T &t)
Definition: parsetl.hh:437
void destroy()
Destroy the stored T.
Definition: parsetl.hh:511
value_type()
Empty construction.
Definition: parsetl.hh:376
char yyraw_[size]
A buffer large enough to store any of the semantic values.
Definition: parsetl.hh:584
T & build()
Definition: parsetl.hh:428
void swap(self_type &that)
Definition: parsetl.hh:468
long double yyalign_me_
Strongest alignment constraints.
Definition: parsetl.hh:582
const T & as() const
Const accessor to a built T (for printer).
Definition: parsetl.hh:453
void copy(const self_type &that)
Copy the content of that to this.
Definition: parsetl.hh:503
T & emplace()
Instantiate an empty T in here.
Definition: parsetl.hh:410
~value_type()
Destruction, allowed only if empty.
Definition: parsetl.hh:395
value_type(const T &t)
Construct and fill.
Definition: parsetl.hh:382
A Bison parser.
Definition: parsetl.hh:356
parser(spot::parse_error_list &error_list_yyarg, spot::environment &parse_environment_yyarg, spot::formula &result_yyarg)
Build a parser object.
std::ostream & debug_stream() const
The current debugging stream.
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
Definition: parsetl.hh:689
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:811
int debug_level_type
Type for debugging levels.
Definition: parsetl.hh:1149
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition: parsetl.hh:808
value_type semantic_type
Backward compatibility (Bison 3.8).
Definition: parsetl.hh:590
virtual void error(const location_type &loc, const std::string &msg)
void set_debug_stream(std::ostream &)
Set the current debugging stream.
debug_level_type debug_level() const
The current debugging level.
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
Definition: parsetl.hh:692
static std::string symbol_name(symbol_kind_type yysymbol)
spot::location location_type
Symbol locations.
Definition: parsetl.hh:593
void error(const syntax_error &err)
Report a syntax error.
op
Operator types.
Definition: formula.hh:78
std::list< one_parse_error > parse_error_list
A list of parser diagnostics, as filled by parse.
Definition: parse.hh:38
Definition: parsetl.hh:58
Definition: parsetl.hh:70
Definition: parsetl.hh:76
Definition: parsetl.hh:821
basic_symbol(const basic_symbol &that)
Copy constructor.
value_type value
The semantic value.
Definition: parsetl.hh:1032
symbol_kind_type type_get() const
Backward compatibility (Bison 3.6).
void clear()
Destroy contents, and record that is empty.
Definition: parsetl.hh:961
std::string name() const
The user-facing name of this symbol.
Definition: parsetl.hh:1017
location_type location
The location.
Definition: parsetl.hh:1035
bool empty() const
Whether empty.
~basic_symbol()
Destroy the symbol.
Definition: parsetl.hh:953
Base super_type
Alias to Base.
Definition: parsetl.hh:823
void move(basic_symbol &s)
Destructive move, s is emptied into this.
basic_symbol()
Default constructor.
Definition: parsetl.hh:826
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
Definition: parsetl.hh:890
Type access provider for token (enum) based symbols.
Definition: parsetl.hh:1046
symbol_kind_type kind_
Definition: parsetl.hh:1081
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:1048
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:696
symbol_kind_type
Definition: parsetl.hh:698
@ YYNTOKENS
Number of tokens.
Definition: parsetl.hh:699
"External" symbols: returned by the scanner.
Definition: parsetl.hh:1089
symbol_type()
Empty symbol.
Definition: parsetl.hh:1094
basic_symbol< by_kind > super_type
Superclass.
Definition: parsetl.hh:1091
Syntax errors thrown from user actions.
Definition: parsetl.hh:597
Token kinds.
Definition: parsetl.hh:615
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
Definition: parsetl.hh:685