spot  2.11.6
parsetl.hh
Go to the documentation of this file.
1 // A Bison parser, made by GNU Bison 3.7.5.
2 
3 // Skeleton interface for Bison LALR(1) parsers in C++
4 
5 // Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
6 
7 // This program is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11 
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 
17 // You should have received a copy of the GNU General Public License
18 // along with this program. If not, see <http://www.gnu.org/licenses/>.
19 
20 // As a special exception, you may create a larger work that contains
21 // part or all of the Bison parser skeleton and distribute that work
22 // under terms of your choice, so long as that work isn't itself a
23 // parser generator using the skeleton or a modified version thereof
24 // as a parser skeleton. Alternatively, if you modify or redistribute
25 // the parser skeleton itself, you may (at your option) remove this
26 // special exception, which will cause the skeleton and the resulting
27 // Bison output files to be licensed under the GNU General Public
28 // License without this special exception.
29 
30 // This special exception was added by the Free Software Foundation in
31 // version 2.2 of Bison.
32 
33 
39 // C++ LALR(1) parser skeleton written by Akim Demaille.
40 
41 // DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
42 // especially those whose name start with YY_ or yy_. They are
43 // private implementation details that can be changed or removed.
44 
45 #ifndef YY_TLYY_PARSETL_HH_INCLUDED
46 # define YY_TLYY_PARSETL_HH_INCLUDED
47 // "%code requires" blocks.
48 #line 37 "parsetl.yy"
49 
50 #include "config.h"
51 #include <string>
52 #include <sstream>
53 #include <variant>
54 #include <spot/tl/parse.hh>
55 #include <spot/tl/formula.hh>
56 #include <spot/tl/print.hh>
57 
58  struct minmax_t { unsigned min, max; };
59 
60  // pnode (parsing node) is simular to fnode (formula node) except
61  // that n-ary operators will delay their construction until all
62  // children are known; this is a hack to speedup the parsing,
63  // because n-ary operator usually do a lot of work on construction
64  // (sorting all children if the operator is commutative, removing
65  // duplicates if applicable, etc.). Building n-ary nodes by
66  // repeatedly calling the binary constructor as we did in the past
67  // has a prohibitive cost. See issue #500.
68 
69  struct nary
70  {
71  std::vector<const spot::fnode*> children;
72  spot::op kind;
73  };
74 
75  struct pnode
76  {
77  // Hold either a constructed formula, or an n-ary operator that we
78  // will construct only when it is combined with a different
79  // operator.
80  std::variant<const spot::fnode*, nary> data;
81  // Record whether this pnode has been transformed into a fnode( or
82  // moved to another pnode). If that occurred, the ownership of
83  // any fnode we store has been transfered to the constructed fnode
84  // (or to the other pnode), and our destructor has nothing to do.
85  // This is the usual case while parsing a formula without error.
86  // However during error recovering, the parser may have to discard
87  // unused pnode, in which case we have to remember to free fnode
88  // during destruction.
89  //
90  // We have to track this used status because pnode are destructed
91  // whenever the parser pops a token, and as of Bison 3.7.6, the
92  // handling of "%destructor" is broken when
93  // "%define api.value.type variant" is used. See
94  // https://lists.gnu.org/archive/html/bug-bison/2022-03/msg00000.html
95  bool used = false;
96 
97  pnode()
98  : data(nullptr)
99  {
100  }
101 
102  pnode(const spot::fnode* ltl)
103  : data(ltl)
104  {
105  }
106 
107  // We only support move construction.
108  pnode(const pnode& other) = delete;
109  pnode& operator=(const pnode& other) = delete;
110 
111  pnode(pnode&& other)
112  : data(std::move(other.data))
113  {
114  other.used = true;
115  }
116 
117  pnode& operator=(pnode&& other)
118  {
119  data = std::move(other.data);
120  other.used = true;
121  return *this;
122  }
123 
124  ~pnode()
125  {
126  if (used)
127  return;
128  if (auto* n = std::get_if<nary>(&data))
129  {
130  for (auto f: n->children)
131  f->destroy();
132  }
133  else
134  {
135  auto* f = std::get<const spot::fnode*>(data);
136  // The only case where we expect f to be nullptr, is if
137  // parse_ap() return nullptr: then $$ is unset when YYERROR
138  // is called.
139  if (f)
140  f->destroy();
141  }
142  }
143 
144  // Create a new n-ary node from left and right.
145  // This will empty left and right so that their
146  // destructor do nothing.
147  pnode(spot::op o, pnode&& left, pnode&& right)
148  : data(nary{})
149  {
150  nary& n = std::get<nary>(data);
151  n.kind = o;
152  if (auto* nleft = std::get_if<nary>(&left.data);
153  nleft && nleft->kind == o)
154  std::swap(n.children, nleft->children);
155  else
156  n.children.push_back(left);
157  if (auto* nright = std::get_if<nary>(&right.data);
158  nright && nright->kind == o)
159  {
160  auto& rch = nright->children;
161  n.children.insert(n.children.end(), rch.begin(), rch.end());
162  rch.clear();
163  }
164  else
165  {
166  n.children.push_back(right);
167  }
168  }
169 
170  operator const spot::fnode*()
171  {
172  used = true;
173  if (auto* n = std::get_if<nary>(&data))
174  {
175  return spot::fnode::multop(n->kind, n->children);
176  }
177  else
178  {
179  return std::get<const spot::fnode*>(data);
180  }
181  }
182 
183  // Convert to a temporary formula, for printing, do not mark as
184  // used.
185  const spot::formula tmp() const
186  {
187  const spot::fnode* f;
188  if (auto* n = std::get_if<nary>(&data))
189  {
190  for (auto c: n->children)
191  c->clone();
192  f = spot::fnode::multop(n->kind, n->children);
193  }
194  else
195  {
196  f = std::get<const spot::fnode*>(data);
197  assert(f != nullptr);
198  f->clone();
199  }
200  return spot::formula(f);
201  }
202  };
203 
204 
205 
206 #line 207 "parsetl.hh"
207 
208 
209 # include <cstdlib> // std::abort
210 # include <iostream>
211 # include <stdexcept>
212 # include <string>
213 # include <vector>
214 
215 #if defined __cplusplus
216 # define YY_CPLUSPLUS __cplusplus
217 #else
218 # define YY_CPLUSPLUS 199711L
219 #endif
220 
221 // Support move semantics when possible.
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
228 #else
229 # define YY_MOVE
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&
234 #endif
235 
236 // Support noexcept when possible.
237 #if 201103L <= YY_CPLUSPLUS
238 # define YY_NOEXCEPT noexcept
239 # define YY_NOTHROW
240 #else
241 # define YY_NOEXCEPT
242 # define YY_NOTHROW throw ()
243 #endif
244 
245 // Support constexpr when possible.
246 #if 201703 <= YY_CPLUSPLUS
247 # define YY_CONSTEXPR constexpr
248 #else
249 # define YY_CONSTEXPR
250 #endif
251 
252 
253 
254 #ifndef YY_ATTRIBUTE_PURE
255 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
256 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
257 # else
258 # define YY_ATTRIBUTE_PURE
259 # endif
260 #endif
261 
262 #ifndef YY_ATTRIBUTE_UNUSED
263 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
264 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
265 # else
266 # define YY_ATTRIBUTE_UNUSED
267 # endif
268 #endif
269 
270 /* Suppress unused-variable warnings by "using" E. */
271 #if ! defined lint || defined __GNUC__
272 # define YY_USE(E) ((void) (E))
273 #else
274 # define YY_USE(E) /* empty */
275 #endif
276 
277 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
278 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
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")
285 #else
286 # define YY_INITIAL_VALUE(Value) Value
287 #endif
288 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
289 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
290 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
291 #endif
292 #ifndef YY_INITIAL_VALUE
293 # define YY_INITIAL_VALUE(Value) /* Nothing. */
294 #endif
295 
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")
302 #endif
303 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
304 # define YY_IGNORE_USELESS_CAST_BEGIN
305 # define YY_IGNORE_USELESS_CAST_END
306 #endif
307 
308 # ifndef YY_CAST
309 # ifdef __cplusplus
310 # define YY_CAST(Type, Val) static_cast<Type> (Val)
311 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
312 # else
313 # define YY_CAST(Type, Val) ((Type) (Val))
314 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
315 # endif
316 # endif
317 # ifndef YY_NULLPTR
318 # if defined __cplusplus
319 # if 201103L <= __cplusplus
320 # define YY_NULLPTR nullptr
321 # else
322 # define YY_NULLPTR 0
323 # endif
324 # else
325 # define YY_NULLPTR ((void*)0)
326 # endif
327 # endif
328 
329 /* Debug traces. */
330 #ifndef TLYYDEBUG
331 # if defined YYDEBUG
332 #if YYDEBUG
333 # define TLYYDEBUG 1
334 # else
335 # define TLYYDEBUG 0
336 # endif
337 # else /* ! defined YYDEBUG */
338 # define TLYYDEBUG 1
339 # endif /* ! defined YYDEBUG */
340 #endif /* ! defined TLYYDEBUG */
341 
342 namespace tlyy {
343 #line 344 "parsetl.hh"
344 
345 
346 
347 
349  class parser
350  {
351  public:
352 #ifndef TLYYSTYPE
359  {
360  public:
363 
365  semantic_type () YY_NOEXCEPT
366  : yybuffer_ ()
367  {}
368 
370  template <typename T>
371  semantic_type (YY_RVREF (T) t)
372  {
373  new (yyas_<T> ()) T (YY_MOVE (t));
374  }
375 
376 #if 201103L <= YY_CPLUSPLUS
378  semantic_type (const self_type&) = delete;
380  self_type& operator= (const self_type&) = delete;
381 #endif
382 
384  ~semantic_type () YY_NOEXCEPT
385  {}
386 
387 # if 201103L <= YY_CPLUSPLUS
389  template <typename T, typename... U>
390  T&
391  emplace (U&&... u)
392  {
393  return *new (yyas_<T> ()) T (std::forward <U>(u)...);
394  }
395 # else
397  template <typename T>
398  T&
400  {
401  return *new (yyas_<T> ()) T ();
402  }
403 
405  template <typename T>
406  T&
407  emplace (const T& t)
408  {
409  return *new (yyas_<T> ()) T (t);
410  }
411 # endif
412 
415  template <typename T>
416  T&
417  build ()
418  {
419  return emplace<T> ();
420  }
421 
424  template <typename T>
425  T&
426  build (const T& t)
427  {
428  return emplace<T> (t);
429  }
430 
432  template <typename T>
433  T&
434  as () YY_NOEXCEPT
435  {
436  return *yyas_<T> ();
437  }
438 
440  template <typename T>
441  const T&
442  as () const YY_NOEXCEPT
443  {
444  return *yyas_<T> ();
445  }
446 
455  template <typename T>
456  void
457  swap (self_type& that) YY_NOEXCEPT
458  {
459  std::swap (as<T> (), that.as<T> ());
460  }
461 
465  template <typename T>
466  void
467  move (self_type& that)
468  {
469 # if 201103L <= YY_CPLUSPLUS
470  emplace<T> (std::move (that.as<T> ()));
471 # else
472  emplace<T> ();
473  swap<T> (that);
474 # endif
475  that.destroy<T> ();
476  }
477 
478 # if 201103L <= YY_CPLUSPLUS
480  template <typename T>
481  void
482  move (self_type&& that)
483  {
484  emplace<T> (std::move (that.as<T> ()));
485  that.destroy<T> ();
486  }
487 #endif
488 
490  template <typename T>
491  void
492  copy (const self_type& that)
493  {
494  emplace<T> (that.as<T> ());
495  }
496 
498  template <typename T>
499  void
501  {
502  as<T> ().~T ();
503  }
504 
505  private:
506 #if YY_CPLUSPLUS < 201103L
508  semantic_type (const self_type&);
510  self_type& operator= (const self_type&);
511 #endif
512 
514  template <typename T>
515  T*
516  yyas_ () YY_NOEXCEPT
517  {
518  void *yyp = yybuffer_.yyraw;
519  return static_cast<T*> (yyp);
520  }
521 
523  template <typename T>
524  const T*
525  yyas_ () const YY_NOEXCEPT
526  {
527  const void *yyp = yybuffer_.yyraw;
528  return static_cast<const T*> (yyp);
529  }
530 
532  union union_type
533  {
534  // sqbracketargs
535  // gotoargs
536  // starargs
537  // fstarargs
538  // equalargs
539  // delayargs
540  char dummy1[sizeof (minmax_t)];
541 
542  // atomprop
543  // booleanatom
544  // sere
545  // bracedsere
546  // parenthesedsubformula
547  // boolformula
548  // subformula
549  // lbtformula
550  char dummy2[sizeof (pnode)];
551 
552  // "(...) block"
553  // "{...} block"
554  // "{...}! block"
555  // "atomic proposition"
556  char dummy3[sizeof (std::string)];
557 
558  // "number for square bracket operator"
559  // "SVA delay operator"
560  // sqbkt_num
561  char dummy4[sizeof (unsigned)];
562  };
563 
565  enum { size = sizeof (union_type) };
566 
568  union
569  {
571  long double yyalign_me;
573  char yyraw[size];
574  } yybuffer_;
575  };
576 
577 #else
578  typedef TLYYSTYPE semantic_type;
579 #endif
581  typedef spot::location location_type;
582 
584  struct syntax_error : std::runtime_error
585  {
586  syntax_error (const location_type& l, const std::string& m)
587  : std::runtime_error (m)
588  , location (l)
589  {}
590 
591  syntax_error (const syntax_error& s)
592  : std::runtime_error (s.what ())
593  , location (s.location)
594  {}
595 
596  ~syntax_error () YY_NOEXCEPT YY_NOTHROW;
597 
598  location_type location;
599  };
600 
602  struct token
603  {
604  enum token_kind_type
605  {
606  TLYYEMPTY = -2,
607  TLYYEOF = 0, // "end of file"
608  TLYYerror = 256, // error
609  TLYYUNDEF = 257, // "invalid token"
610  START_LTL = 258, // "LTL start marker"
611  START_LBT = 259, // "LBT start marker"
612  START_SERE = 260, // "SERE start marker"
613  START_BOOL = 261, // "BOOLEAN start marker"
614  PAR_OPEN = 262, // "opening parenthesis"
615  PAR_CLOSE = 263, // "closing parenthesis"
616  PAR_BLOCK = 264, // "(...) block"
617  BRA_BLOCK = 265, // "{...} block"
618  BRA_BANG_BLOCK = 266, // "{...}! block"
619  BRACE_OPEN = 267, // "opening brace"
620  BRACE_CLOSE = 268, // "closing brace"
621  BRACE_BANG_CLOSE = 269, // "closing brace-bang"
622  OP_OR = 270, // "or operator"
623  OP_XOR = 271, // "xor operator"
624  OP_AND = 272, // "and operator"
625  OP_SHORT_AND = 273, // "short and operator"
626  OP_IMPLIES = 274, // "implication operator"
627  OP_EQUIV = 275, // "equivalent operator"
628  OP_U = 276, // "until operator"
629  OP_R = 277, // "release operator"
630  OP_W = 278, // "weak until operator"
631  OP_M = 279, // "strong release operator"
632  OP_F = 280, // "sometimes operator"
633  OP_G = 281, // "always operator"
634  OP_X = 282, // "next operator"
635  OP_STRONG_X = 283, // "strong next operator"
636  OP_NOT = 284, // "not operator"
637  OP_XREP = 285, // "X[.] operator"
638  OP_FREP = 286, // "F[.] operator"
639  OP_GREP = 287, // "G[.] operator"
640  OP_STAR = 288, // "star operator"
641  OP_BSTAR = 289, // "bracket star operator"
642  OP_BFSTAR = 290, // "bracket fusion-star operator"
643  OP_PLUS = 291, // "plus operator"
644  OP_FPLUS = 292, // "fusion-plus operator"
645  OP_STAR_OPEN = 293, // "opening bracket for star operator"
646  OP_FSTAR_OPEN = 294, // "opening bracket for fusion-star operator"
647  OP_EQUAL_OPEN = 295, // "opening bracket for equal operator"
648  OP_GOTO_OPEN = 296, // "opening bracket for goto operator"
649  OP_SQBKT_CLOSE = 297, // "closing bracket"
650  OP_SQBKT_STRONG_CLOSE = 298, // "closing !]"
651  OP_SQBKT_NUM = 299, // "number for square bracket operator"
652  OP_UNBOUNDED = 300, // "unbounded mark"
653  OP_SQBKT_SEP = 301, // "separator for square bracket operator"
654  OP_UCONCAT = 302, // "universal concat operator"
655  OP_ECONCAT = 303, // "existential concat operator"
656  OP_UCONCAT_NONO = 304, // "universal non-overlapping concat operator"
657  OP_ECONCAT_NONO = 305, // "existential non-overlapping concat operator"
658  OP_FIRST_MATCH = 306, // "first_match"
659  ATOMIC_PROP = 307, // "atomic proposition"
660  OP_CONCAT = 308, // "concat operator"
661  OP_FUSION = 309, // "fusion operator"
662  CONST_TRUE = 310, // "constant true"
663  CONST_FALSE = 311, // "constant false"
664  END_OF_INPUT = 312, // "end of formula"
665  OP_POST_NEG = 313, // "negative suffix"
666  OP_POST_POS = 314, // "positive suffix"
667  OP_DELAY_N = 315, // "SVA delay operator"
668  OP_DELAY_OPEN = 316, // "opening bracket for SVA delay operator"
669  OP_DELAY_PLUS = 317, // "##[+] operator"
670  OP_DELAY_STAR = 318 // "##[*] operator"
671  };
673  typedef token_kind_type yytokentype;
674  };
675 
677  typedef token::yytokentype token_kind_type;
678 
680  typedef token_kind_type token_type;
681 
683  struct symbol_kind
684  {
686  {
687  YYNTOKENS = 80,
688  S_YYEMPTY = -2,
689  S_YYEOF = 0, // "end of file"
690  S_YYerror = 1, // error
691  S_YYUNDEF = 2, // "invalid token"
692  S_START_LTL = 3, // "LTL start marker"
693  S_START_LBT = 4, // "LBT start marker"
694  S_START_SERE = 5, // "SERE start marker"
695  S_START_BOOL = 6, // "BOOLEAN start marker"
696  S_PAR_OPEN = 7, // "opening parenthesis"
697  S_PAR_CLOSE = 8, // "closing parenthesis"
698  S_PAR_BLOCK = 9, // "(...) block"
699  S_BRA_BLOCK = 10, // "{...} block"
700  S_BRA_BANG_BLOCK = 11, // "{...}! block"
701  S_BRACE_OPEN = 12, // "opening brace"
702  S_BRACE_CLOSE = 13, // "closing brace"
703  S_BRACE_BANG_CLOSE = 14, // "closing brace-bang"
704  S_OP_OR = 15, // "or operator"
705  S_OP_XOR = 16, // "xor operator"
706  S_OP_AND = 17, // "and operator"
707  S_OP_SHORT_AND = 18, // "short and operator"
708  S_OP_IMPLIES = 19, // "implication operator"
709  S_OP_EQUIV = 20, // "equivalent operator"
710  S_OP_U = 21, // "until operator"
711  S_OP_R = 22, // "release operator"
712  S_OP_W = 23, // "weak until operator"
713  S_OP_M = 24, // "strong release operator"
714  S_OP_F = 25, // "sometimes operator"
715  S_OP_G = 26, // "always operator"
716  S_OP_X = 27, // "next operator"
717  S_OP_STRONG_X = 28, // "strong next operator"
718  S_OP_NOT = 29, // "not operator"
719  S_OP_XREP = 30, // "X[.] operator"
720  S_OP_FREP = 31, // "F[.] operator"
721  S_OP_GREP = 32, // "G[.] operator"
722  S_OP_STAR = 33, // "star operator"
723  S_OP_BSTAR = 34, // "bracket star operator"
724  S_OP_BFSTAR = 35, // "bracket fusion-star operator"
725  S_OP_PLUS = 36, // "plus operator"
726  S_OP_FPLUS = 37, // "fusion-plus operator"
727  S_OP_STAR_OPEN = 38, // "opening bracket for star operator"
728  S_OP_FSTAR_OPEN = 39, // "opening bracket for fusion-star operator"
729  S_OP_EQUAL_OPEN = 40, // "opening bracket for equal operator"
730  S_OP_GOTO_OPEN = 41, // "opening bracket for goto operator"
731  S_OP_SQBKT_CLOSE = 42, // "closing bracket"
732  S_OP_SQBKT_STRONG_CLOSE = 43, // "closing !]"
733  S_OP_SQBKT_NUM = 44, // "number for square bracket operator"
734  S_OP_UNBOUNDED = 45, // "unbounded mark"
735  S_OP_SQBKT_SEP = 46, // "separator for square bracket operator"
736  S_OP_UCONCAT = 47, // "universal concat operator"
737  S_OP_ECONCAT = 48, // "existential concat operator"
738  S_OP_UCONCAT_NONO = 49, // "universal non-overlapping concat operator"
739  S_OP_ECONCAT_NONO = 50, // "existential non-overlapping concat operator"
740  S_OP_FIRST_MATCH = 51, // "first_match"
741  S_ATOMIC_PROP = 52, // "atomic proposition"
742  S_OP_CONCAT = 53, // "concat operator"
743  S_OP_FUSION = 54, // "fusion operator"
744  S_CONST_TRUE = 55, // "constant true"
745  S_CONST_FALSE = 56, // "constant false"
746  S_END_OF_INPUT = 57, // "end of formula"
747  S_OP_POST_NEG = 58, // "negative suffix"
748  S_OP_POST_POS = 59, // "positive suffix"
749  S_OP_DELAY_N = 60, // "SVA delay operator"
750  S_OP_DELAY_OPEN = 61, // "opening bracket for SVA delay operator"
751  S_OP_DELAY_PLUS = 62, // "##[+] operator"
752  S_OP_DELAY_STAR = 63, // "##[*] operator"
753  S_64_ = 64, // '!'
754  S_65_ = 65, // '&'
755  S_66_ = 66, // '|'
756  S_67_ = 67, // '^'
757  S_68_i_ = 68, // 'i'
758  S_69_e_ = 69, // 'e'
759  S_70_X_ = 70, // 'X'
760  S_71_F_ = 71, // 'F'
761  S_72_G_ = 72, // 'G'
762  S_73_U_ = 73, // 'U'
763  S_74_V_ = 74, // 'V'
764  S_75_R_ = 75, // 'R'
765  S_76_W_ = 76, // 'W'
766  S_77_M_ = 77, // 'M'
767  S_78_t_ = 78, // 't'
768  S_79_f_ = 79, // 'f'
769  S_YYACCEPT = 80, // $accept
770  S_result = 81, // result
771  S_emptyinput = 82, // emptyinput
772  S_enderror = 83, // enderror
773  S_OP_SQBKT_SEP_unbounded = 84, // OP_SQBKT_SEP_unbounded
774  S_OP_SQBKT_SEP_opt = 85, // OP_SQBKT_SEP_opt
775  S_error_opt = 86, // error_opt
776  S_sqbkt_num = 87, // sqbkt_num
777  S_sqbracketargs = 88, // sqbracketargs
778  S_gotoargs = 89, // gotoargs
779  S_kleen_star = 90, // kleen_star
780  S_starargs = 91, // starargs
781  S_fstarargs = 92, // fstarargs
782  S_equalargs = 93, // equalargs
783  S_delayargs = 94, // delayargs
784  S_atomprop = 95, // atomprop
785  S_booleanatom = 96, // booleanatom
786  S_sere = 97, // sere
787  S_bracedsere = 98, // bracedsere
788  S_parenthesedsubformula = 99, // parenthesedsubformula
789  S_boolformula = 100, // boolformula
790  S_subformula = 101, // subformula
791  S_lbtformula = 102 // lbtformula
792  };
793  };
794 
797 
800 
807  template <typename Base>
808  struct basic_symbol : Base
809  {
811  typedef Base super_type;
812 
815  : value ()
816  , location ()
817  {}
818 
819 #if 201103L <= YY_CPLUSPLUS
821  basic_symbol (basic_symbol&& that)
822  : Base (std::move (that))
823  , value ()
824  , location (std::move (that.location))
825  {
826  switch (this->kind ())
827  {
828  case symbol_kind::S_sqbracketargs: // sqbracketargs
829  case symbol_kind::S_gotoargs: // gotoargs
830  case symbol_kind::S_starargs: // starargs
831  case symbol_kind::S_fstarargs: // fstarargs
832  case symbol_kind::S_equalargs: // equalargs
833  case symbol_kind::S_delayargs: // delayargs
834  value.move< minmax_t > (std::move (that.value));
835  break;
836 
837  case symbol_kind::S_atomprop: // atomprop
838  case symbol_kind::S_booleanatom: // booleanatom
839  case symbol_kind::S_sere: // sere
840  case symbol_kind::S_bracedsere: // bracedsere
841  case symbol_kind::S_parenthesedsubformula: // parenthesedsubformula
842  case symbol_kind::S_boolformula: // boolformula
843  case symbol_kind::S_subformula: // subformula
844  case symbol_kind::S_lbtformula: // lbtformula
845  value.move< pnode > (std::move (that.value));
846  break;
847 
848  case symbol_kind::S_PAR_BLOCK: // "(...) block"
849  case symbol_kind::S_BRA_BLOCK: // "{...} block"
850  case symbol_kind::S_BRA_BANG_BLOCK: // "{...}! block"
851  case symbol_kind::S_ATOMIC_PROP: // "atomic proposition"
852  value.move< std::string > (std::move (that.value));
853  break;
854 
855  case symbol_kind::S_OP_SQBKT_NUM: // "number for square bracket operator"
856  case symbol_kind::S_OP_DELAY_N: // "SVA delay operator"
857  case symbol_kind::S_sqbkt_num: // sqbkt_num
858  value.move< unsigned > (std::move (that.value));
859  break;
860 
861  default:
862  break;
863  }
864 
865  }
866 #endif
867 
869  basic_symbol (const basic_symbol& that);
870 
872 #if 201103L <= YY_CPLUSPLUS
873  basic_symbol (typename Base::kind_type t, location_type&& l)
874  : Base (t)
875  , location (std::move (l))
876  {}
877 #else
878  basic_symbol (typename Base::kind_type t, const location_type& l)
879  : Base (t)
880  , location (l)
881  {}
882 #endif
883 
884 #if 201103L <= YY_CPLUSPLUS
885  basic_symbol (typename Base::kind_type t, minmax_t&& v, location_type&& l)
886  : Base (t)
887  , value (std::move (v))
888  , location (std::move (l))
889  {}
890 #else
891  basic_symbol (typename Base::kind_type t, const minmax_t& v, const location_type& l)
892  : Base (t)
893  , value (v)
894  , location (l)
895  {}
896 #endif
897 
898 #if 201103L <= YY_CPLUSPLUS
899  basic_symbol (typename Base::kind_type t, pnode&& v, location_type&& l)
900  : Base (t)
901  , value (std::move (v))
902  , location (std::move (l))
903  {}
904 #else
905  basic_symbol (typename Base::kind_type t, const pnode& v, const location_type& l)
906  : Base (t)
907  , value (v)
908  , location (l)
909  {}
910 #endif
911 
912 #if 201103L <= YY_CPLUSPLUS
913  basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l)
914  : Base (t)
915  , value (std::move (v))
916  , location (std::move (l))
917  {}
918 #else
919  basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l)
920  : Base (t)
921  , value (v)
922  , location (l)
923  {}
924 #endif
925 
926 #if 201103L <= YY_CPLUSPLUS
927  basic_symbol (typename Base::kind_type t, unsigned&& v, location_type&& l)
928  : Base (t)
929  , value (std::move (v))
930  , location (std::move (l))
931  {}
932 #else
933  basic_symbol (typename Base::kind_type t, const unsigned& v, const location_type& l)
934  : Base (t)
935  , value (v)
936  , location (l)
937  {}
938 #endif
939 
942  {
943  clear ();
944  }
945 
947  void clear () YY_NOEXCEPT
948  {
949  // User destructor.
950  symbol_kind_type yykind = this->kind ();
951  basic_symbol<Base>& yysym = *this;
952  (void) yysym;
953  switch (yykind)
954  {
955  default:
956  break;
957  }
958 
959  // Value type destructor.
960 switch (yykind)
961  {
962  case symbol_kind::S_sqbracketargs: // sqbracketargs
963  case symbol_kind::S_gotoargs: // gotoargs
964  case symbol_kind::S_starargs: // starargs
965  case symbol_kind::S_fstarargs: // fstarargs
966  case symbol_kind::S_equalargs: // equalargs
967  case symbol_kind::S_delayargs: // delayargs
968  value.template destroy< minmax_t > ();
969  break;
970 
971  case symbol_kind::S_atomprop: // atomprop
972  case symbol_kind::S_booleanatom: // booleanatom
973  case symbol_kind::S_sere: // sere
974  case symbol_kind::S_bracedsere: // bracedsere
975  case symbol_kind::S_parenthesedsubformula: // parenthesedsubformula
976  case symbol_kind::S_boolformula: // boolformula
977  case symbol_kind::S_subformula: // subformula
978  case symbol_kind::S_lbtformula: // lbtformula
979  value.template destroy< pnode > ();
980  break;
981 
982  case symbol_kind::S_PAR_BLOCK: // "(...) block"
983  case symbol_kind::S_BRA_BLOCK: // "{...} block"
984  case symbol_kind::S_BRA_BANG_BLOCK: // "{...}! block"
985  case symbol_kind::S_ATOMIC_PROP: // "atomic proposition"
986  value.template destroy< std::string > ();
987  break;
988 
989  case symbol_kind::S_OP_SQBKT_NUM: // "number for square bracket operator"
990  case symbol_kind::S_OP_DELAY_N: // "SVA delay operator"
991  case symbol_kind::S_sqbkt_num: // sqbkt_num
992  value.template destroy< unsigned > ();
993  break;
994 
995  default:
996  break;
997  }
998 
999  Base::clear ();
1000  }
1001 
1003  std::string name () const YY_NOEXCEPT
1004  {
1005  return parser::symbol_name (this->kind ());
1006  }
1007 
1009  symbol_kind_type type_get () const YY_NOEXCEPT;
1010 
1012  bool empty () const YY_NOEXCEPT;
1013 
1015  void move (basic_symbol& s);
1016 
1019 
1022 
1023  private:
1024 #if YY_CPLUSPLUS < 201103L
1026  basic_symbol& operator= (const basic_symbol& that);
1027 #endif
1028  };
1029 
1031  struct by_kind
1032  {
1035 
1036 #if 201103L <= YY_CPLUSPLUS
1038  by_kind (by_kind&& that);
1039 #endif
1040 
1042  by_kind (const by_kind& that);
1043 
1045  typedef token_kind_type kind_type;
1046 
1048  by_kind (kind_type t);
1049 
1051  void clear () YY_NOEXCEPT;
1052 
1054  void move (by_kind& that);
1055 
1058  symbol_kind_type kind () const YY_NOEXCEPT;
1059 
1061  symbol_kind_type type_get () const YY_NOEXCEPT;
1062 
1066  };
1067 
1069  typedef by_kind by_type;
1070 
1073  {
1076 
1079 
1081 #if 201103L <= YY_CPLUSPLUS
1082  symbol_type (int tok, location_type l)
1083  : super_type(token_type (tok), std::move (l))
1084 #else
1085  symbol_type (int tok, const location_type& l)
1086  : super_type(token_type (tok), l)
1087 #endif
1088  {}
1089 #if 201103L <= YY_CPLUSPLUS
1090  symbol_type (int tok, std::string v, location_type l)
1091  : super_type(token_type (tok), std::move (v), std::move (l))
1092 #else
1093  symbol_type (int tok, const std::string& v, const location_type& l)
1094  : super_type(token_type (tok), v, l)
1095 #endif
1096  {}
1097 #if 201103L <= YY_CPLUSPLUS
1098  symbol_type (int tok, unsigned v, location_type l)
1099  : super_type(token_type (tok), std::move (v), std::move (l))
1100 #else
1101  symbol_type (int tok, const unsigned& v, const location_type& l)
1102  : super_type(token_type (tok), v, l)
1103 #endif
1104  {}
1105  };
1106 
1108  parser (spot::parse_error_list &error_list_yyarg, spot::environment &parse_environment_yyarg, spot::formula &result_yyarg);
1109  virtual ~parser ();
1110 
1111 #if 201103L <= YY_CPLUSPLUS
1113  parser (const parser&) = delete;
1115  parser& operator= (const parser&) = delete;
1116 #endif
1117 
1121 
1124  virtual int parse ();
1125 
1126 #if TLYYDEBUG
1128  std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
1130  void set_debug_stream (std::ostream &);
1131 
1133  typedef int debug_level_type;
1135  debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
1138 #endif
1139 
1143  virtual void error (const location_type& loc, const std::string& msg);
1144 
1146  void error (const syntax_error& err);
1147 
1150  static std::string symbol_name (symbol_kind_type yysymbol);
1151 
1152  // Implementation of make_symbol for each symbol type.
1153 #if 201103L <= YY_CPLUSPLUS
1154  static
1155  symbol_type
1156  make_TLYYEOF (location_type l)
1157  {
1158  return symbol_type (token::TLYYEOF, std::move (l));
1159  }
1160 #else
1161  static
1162  symbol_type
1163  make_TLYYEOF (const location_type& l)
1164  {
1165  return symbol_type (token::TLYYEOF, l);
1166  }
1167 #endif
1168 #if 201103L <= YY_CPLUSPLUS
1169  static
1170  symbol_type
1171  make_TLYYerror (location_type l)
1172  {
1173  return symbol_type (token::TLYYerror, std::move (l));
1174  }
1175 #else
1176  static
1177  symbol_type
1178  make_TLYYerror (const location_type& l)
1179  {
1180  return symbol_type (token::TLYYerror, l);
1181  }
1182 #endif
1183 #if 201103L <= YY_CPLUSPLUS
1184  static
1185  symbol_type
1186  make_TLYYUNDEF (location_type l)
1187  {
1188  return symbol_type (token::TLYYUNDEF, std::move (l));
1189  }
1190 #else
1191  static
1192  symbol_type
1193  make_TLYYUNDEF (const location_type& l)
1194  {
1195  return symbol_type (token::TLYYUNDEF, l);
1196  }
1197 #endif
1198 #if 201103L <= YY_CPLUSPLUS
1199  static
1200  symbol_type
1201  make_START_LTL (location_type l)
1202  {
1203  return symbol_type (token::START_LTL, std::move (l));
1204  }
1205 #else
1206  static
1207  symbol_type
1208  make_START_LTL (const location_type& l)
1209  {
1210  return symbol_type (token::START_LTL, l);
1211  }
1212 #endif
1213 #if 201103L <= YY_CPLUSPLUS
1214  static
1215  symbol_type
1216  make_START_LBT (location_type l)
1217  {
1218  return symbol_type (token::START_LBT, std::move (l));
1219  }
1220 #else
1221  static
1222  symbol_type
1223  make_START_LBT (const location_type& l)
1224  {
1225  return symbol_type (token::START_LBT, l);
1226  }
1227 #endif
1228 #if 201103L <= YY_CPLUSPLUS
1229  static
1230  symbol_type
1231  make_START_SERE (location_type l)
1232  {
1233  return symbol_type (token::START_SERE, std::move (l));
1234  }
1235 #else
1236  static
1237  symbol_type
1238  make_START_SERE (const location_type& l)
1239  {
1240  return symbol_type (token::START_SERE, l);
1241  }
1242 #endif
1243 #if 201103L <= YY_CPLUSPLUS
1244  static
1245  symbol_type
1246  make_START_BOOL (location_type l)
1247  {
1248  return symbol_type (token::START_BOOL, std::move (l));
1249  }
1250 #else
1251  static
1252  symbol_type
1253  make_START_BOOL (const location_type& l)
1254  {
1255  return symbol_type (token::START_BOOL, l);
1256  }
1257 #endif
1258 #if 201103L <= YY_CPLUSPLUS
1259  static
1260  symbol_type
1261  make_PAR_OPEN (location_type l)
1262  {
1263  return symbol_type (token::PAR_OPEN, std::move (l));
1264  }
1265 #else
1266  static
1267  symbol_type
1268  make_PAR_OPEN (const location_type& l)
1269  {
1270  return symbol_type (token::PAR_OPEN, l);
1271  }
1272 #endif
1273 #if 201103L <= YY_CPLUSPLUS
1274  static
1275  symbol_type
1276  make_PAR_CLOSE (location_type l)
1277  {
1278  return symbol_type (token::PAR_CLOSE, std::move (l));
1279  }
1280 #else
1281  static
1282  symbol_type
1283  make_PAR_CLOSE (const location_type& l)
1284  {
1285  return symbol_type (token::PAR_CLOSE, l);
1286  }
1287 #endif
1288 #if 201103L <= YY_CPLUSPLUS
1289  static
1290  symbol_type
1291  make_PAR_BLOCK (std::string v, location_type l)
1292  {
1293  return symbol_type (token::PAR_BLOCK, std::move (v), std::move (l));
1294  }
1295 #else
1296  static
1297  symbol_type
1298  make_PAR_BLOCK (const std::string& v, const location_type& l)
1299  {
1300  return symbol_type (token::PAR_BLOCK, v, l);
1301  }
1302 #endif
1303 #if 201103L <= YY_CPLUSPLUS
1304  static
1305  symbol_type
1306  make_BRA_BLOCK (std::string v, location_type l)
1307  {
1308  return symbol_type (token::BRA_BLOCK, std::move (v), std::move (l));
1309  }
1310 #else
1311  static
1312  symbol_type
1313  make_BRA_BLOCK (const std::string& v, const location_type& l)
1314  {
1315  return symbol_type (token::BRA_BLOCK, v, l);
1316  }
1317 #endif
1318 #if 201103L <= YY_CPLUSPLUS
1319  static
1320  symbol_type
1321  make_BRA_BANG_BLOCK (std::string v, location_type l)
1322  {
1323  return symbol_type (token::BRA_BANG_BLOCK, std::move (v), std::move (l));
1324  }
1325 #else
1326  static
1327  symbol_type
1328  make_BRA_BANG_BLOCK (const std::string& v, const location_type& l)
1329  {
1330  return symbol_type (token::BRA_BANG_BLOCK, v, l);
1331  }
1332 #endif
1333 #if 201103L <= YY_CPLUSPLUS
1334  static
1335  symbol_type
1336  make_BRACE_OPEN (location_type l)
1337  {
1338  return symbol_type (token::BRACE_OPEN, std::move (l));
1339  }
1340 #else
1341  static
1342  symbol_type
1343  make_BRACE_OPEN (const location_type& l)
1344  {
1345  return symbol_type (token::BRACE_OPEN, l);
1346  }
1347 #endif
1348 #if 201103L <= YY_CPLUSPLUS
1349  static
1350  symbol_type
1351  make_BRACE_CLOSE (location_type l)
1352  {
1353  return symbol_type (token::BRACE_CLOSE, std::move (l));
1354  }
1355 #else
1356  static
1357  symbol_type
1358  make_BRACE_CLOSE (const location_type& l)
1359  {
1360  return symbol_type (token::BRACE_CLOSE, l);
1361  }
1362 #endif
1363 #if 201103L <= YY_CPLUSPLUS
1364  static
1365  symbol_type
1366  make_BRACE_BANG_CLOSE (location_type l)
1367  {
1368  return symbol_type (token::BRACE_BANG_CLOSE, std::move (l));
1369  }
1370 #else
1371  static
1372  symbol_type
1373  make_BRACE_BANG_CLOSE (const location_type& l)
1374  {
1375  return symbol_type (token::BRACE_BANG_CLOSE, l);
1376  }
1377 #endif
1378 #if 201103L <= YY_CPLUSPLUS
1379  static
1380  symbol_type
1381  make_OP_OR (location_type l)
1382  {
1383  return symbol_type (token::OP_OR, std::move (l));
1384  }
1385 #else
1386  static
1387  symbol_type
1388  make_OP_OR (const location_type& l)
1389  {
1390  return symbol_type (token::OP_OR, l);
1391  }
1392 #endif
1393 #if 201103L <= YY_CPLUSPLUS
1394  static
1395  symbol_type
1396  make_OP_XOR (location_type l)
1397  {
1398  return symbol_type (token::OP_XOR, std::move (l));
1399  }
1400 #else
1401  static
1402  symbol_type
1403  make_OP_XOR (const location_type& l)
1404  {
1405  return symbol_type (token::OP_XOR, l);
1406  }
1407 #endif
1408 #if 201103L <= YY_CPLUSPLUS
1409  static
1410  symbol_type
1411  make_OP_AND (location_type l)
1412  {
1413  return symbol_type (token::OP_AND, std::move (l));
1414  }
1415 #else
1416  static
1417  symbol_type
1418  make_OP_AND (const location_type& l)
1419  {
1420  return symbol_type (token::OP_AND, l);
1421  }
1422 #endif
1423 #if 201103L <= YY_CPLUSPLUS
1424  static
1425  symbol_type
1426  make_OP_SHORT_AND (location_type l)
1427  {
1428  return symbol_type (token::OP_SHORT_AND, std::move (l));
1429  }
1430 #else
1431  static
1432  symbol_type
1433  make_OP_SHORT_AND (const location_type& l)
1434  {
1435  return symbol_type (token::OP_SHORT_AND, l);
1436  }
1437 #endif
1438 #if 201103L <= YY_CPLUSPLUS
1439  static
1440  symbol_type
1441  make_OP_IMPLIES (location_type l)
1442  {
1443  return symbol_type (token::OP_IMPLIES, std::move (l));
1444  }
1445 #else
1446  static
1447  symbol_type
1448  make_OP_IMPLIES (const location_type& l)
1449  {
1450  return symbol_type (token::OP_IMPLIES, l);
1451  }
1452 #endif
1453 #if 201103L <= YY_CPLUSPLUS
1454  static
1455  symbol_type
1456  make_OP_EQUIV (location_type l)
1457  {
1458  return symbol_type (token::OP_EQUIV, std::move (l));
1459  }
1460 #else
1461  static
1462  symbol_type
1463  make_OP_EQUIV (const location_type& l)
1464  {
1465  return symbol_type (token::OP_EQUIV, l);
1466  }
1467 #endif
1468 #if 201103L <= YY_CPLUSPLUS
1469  static
1470  symbol_type
1471  make_OP_U (location_type l)
1472  {
1473  return symbol_type (token::OP_U, std::move (l));
1474  }
1475 #else
1476  static
1477  symbol_type
1478  make_OP_U (const location_type& l)
1479  {
1480  return symbol_type (token::OP_U, l);
1481  }
1482 #endif
1483 #if 201103L <= YY_CPLUSPLUS
1484  static
1485  symbol_type
1486  make_OP_R (location_type l)
1487  {
1488  return symbol_type (token::OP_R, std::move (l));
1489  }
1490 #else
1491  static
1492  symbol_type
1493  make_OP_R (const location_type& l)
1494  {
1495  return symbol_type (token::OP_R, l);
1496  }
1497 #endif
1498 #if 201103L <= YY_CPLUSPLUS
1499  static
1500  symbol_type
1501  make_OP_W (location_type l)
1502  {
1503  return symbol_type (token::OP_W, std::move (l));
1504  }
1505 #else
1506  static
1507  symbol_type
1508  make_OP_W (const location_type& l)
1509  {
1510  return symbol_type (token::OP_W, l);
1511  }
1512 #endif
1513 #if 201103L <= YY_CPLUSPLUS
1514  static
1515  symbol_type
1516  make_OP_M (location_type l)
1517  {
1518  return symbol_type (token::OP_M, std::move (l));
1519  }
1520 #else
1521  static
1522  symbol_type
1523  make_OP_M (const location_type& l)
1524  {
1525  return symbol_type (token::OP_M, l);
1526  }
1527 #endif
1528 #if 201103L <= YY_CPLUSPLUS
1529  static
1530  symbol_type
1531  make_OP_F (location_type l)
1532  {
1533  return symbol_type (token::OP_F, std::move (l));
1534  }
1535 #else
1536  static
1537  symbol_type
1538  make_OP_F (const location_type& l)
1539  {
1540  return symbol_type (token::OP_F, l);
1541  }
1542 #endif
1543 #if 201103L <= YY_CPLUSPLUS
1544  static
1545  symbol_type
1546  make_OP_G (location_type l)
1547  {
1548  return symbol_type (token::OP_G, std::move (l));
1549  }
1550 #else
1551  static
1552  symbol_type
1553  make_OP_G (const location_type& l)
1554  {
1555  return symbol_type (token::OP_G, l);
1556  }
1557 #endif
1558 #if 201103L <= YY_CPLUSPLUS
1559  static
1560  symbol_type
1561  make_OP_X (location_type l)
1562  {
1563  return symbol_type (token::OP_X, std::move (l));
1564  }
1565 #else
1566  static
1567  symbol_type
1568  make_OP_X (const location_type& l)
1569  {
1570  return symbol_type (token::OP_X, l);
1571  }
1572 #endif
1573 #if 201103L <= YY_CPLUSPLUS
1574  static
1575  symbol_type
1576  make_OP_STRONG_X (location_type l)
1577  {
1578  return symbol_type (token::OP_STRONG_X, std::move (l));
1579  }
1580 #else
1581  static
1582  symbol_type
1583  make_OP_STRONG_X (const location_type& l)
1584  {
1585  return symbol_type (token::OP_STRONG_X, l);
1586  }
1587 #endif
1588 #if 201103L <= YY_CPLUSPLUS
1589  static
1590  symbol_type
1591  make_OP_NOT (location_type l)
1592  {
1593  return symbol_type (token::OP_NOT, std::move (l));
1594  }
1595 #else
1596  static
1597  symbol_type
1598  make_OP_NOT (const location_type& l)
1599  {
1600  return symbol_type (token::OP_NOT, l);
1601  }
1602 #endif
1603 #if 201103L <= YY_CPLUSPLUS
1604  static
1605  symbol_type
1606  make_OP_XREP (location_type l)
1607  {
1608  return symbol_type (token::OP_XREP, std::move (l));
1609  }
1610 #else
1611  static
1612  symbol_type
1613  make_OP_XREP (const location_type& l)
1614  {
1615  return symbol_type (token::OP_XREP, l);
1616  }
1617 #endif
1618 #if 201103L <= YY_CPLUSPLUS
1619  static
1620  symbol_type
1621  make_OP_FREP (location_type l)
1622  {
1623  return symbol_type (token::OP_FREP, std::move (l));
1624  }
1625 #else
1626  static
1627  symbol_type
1628  make_OP_FREP (const location_type& l)
1629  {
1630  return symbol_type (token::OP_FREP, l);
1631  }
1632 #endif
1633 #if 201103L <= YY_CPLUSPLUS
1634  static
1635  symbol_type
1636  make_OP_GREP (location_type l)
1637  {
1638  return symbol_type (token::OP_GREP, std::move (l));
1639  }
1640 #else
1641  static
1642  symbol_type
1643  make_OP_GREP (const location_type& l)
1644  {
1645  return symbol_type (token::OP_GREP, l);
1646  }
1647 #endif
1648 #if 201103L <= YY_CPLUSPLUS
1649  static
1650  symbol_type
1651  make_OP_STAR (location_type l)
1652  {
1653  return symbol_type (token::OP_STAR, std::move (l));
1654  }
1655 #else
1656  static
1657  symbol_type
1658  make_OP_STAR (const location_type& l)
1659  {
1660  return symbol_type (token::OP_STAR, l);
1661  }
1662 #endif
1663 #if 201103L <= YY_CPLUSPLUS
1664  static
1665  symbol_type
1666  make_OP_BSTAR (location_type l)
1667  {
1668  return symbol_type (token::OP_BSTAR, std::move (l));
1669  }
1670 #else
1671  static
1672  symbol_type
1673  make_OP_BSTAR (const location_type& l)
1674  {
1675  return symbol_type (token::OP_BSTAR, l);
1676  }
1677 #endif
1678 #if 201103L <= YY_CPLUSPLUS
1679  static
1680  symbol_type
1681  make_OP_BFSTAR (location_type l)
1682  {
1683  return symbol_type (token::OP_BFSTAR, std::move (l));
1684  }
1685 #else
1686  static
1687  symbol_type
1688  make_OP_BFSTAR (const location_type& l)
1689  {
1690  return symbol_type (token::OP_BFSTAR, l);
1691  }
1692 #endif
1693 #if 201103L <= YY_CPLUSPLUS
1694  static
1695  symbol_type
1696  make_OP_PLUS (location_type l)
1697  {
1698  return symbol_type (token::OP_PLUS, std::move (l));
1699  }
1700 #else
1701  static
1702  symbol_type
1703  make_OP_PLUS (const location_type& l)
1704  {
1705  return symbol_type (token::OP_PLUS, l);
1706  }
1707 #endif
1708 #if 201103L <= YY_CPLUSPLUS
1709  static
1710  symbol_type
1711  make_OP_FPLUS (location_type l)
1712  {
1713  return symbol_type (token::OP_FPLUS, std::move (l));
1714  }
1715 #else
1716  static
1717  symbol_type
1718  make_OP_FPLUS (const location_type& l)
1719  {
1720  return symbol_type (token::OP_FPLUS, l);
1721  }
1722 #endif
1723 #if 201103L <= YY_CPLUSPLUS
1724  static
1725  symbol_type
1726  make_OP_STAR_OPEN (location_type l)
1727  {
1728  return symbol_type (token::OP_STAR_OPEN, std::move (l));
1729  }
1730 #else
1731  static
1732  symbol_type
1733  make_OP_STAR_OPEN (const location_type& l)
1734  {
1735  return symbol_type (token::OP_STAR_OPEN, l);
1736  }
1737 #endif
1738 #if 201103L <= YY_CPLUSPLUS
1739  static
1740  symbol_type
1741  make_OP_FSTAR_OPEN (location_type l)
1742  {
1743  return symbol_type (token::OP_FSTAR_OPEN, std::move (l));
1744  }
1745 #else
1746  static
1747  symbol_type
1748  make_OP_FSTAR_OPEN (const location_type& l)
1749  {
1750  return symbol_type (token::OP_FSTAR_OPEN, l);
1751  }
1752 #endif
1753 #if 201103L <= YY_CPLUSPLUS
1754  static
1755  symbol_type
1756  make_OP_EQUAL_OPEN (location_type l)
1757  {
1758  return symbol_type (token::OP_EQUAL_OPEN, std::move (l));
1759  }
1760 #else
1761  static
1762  symbol_type
1763  make_OP_EQUAL_OPEN (const location_type& l)
1764  {
1765  return symbol_type (token::OP_EQUAL_OPEN, l);
1766  }
1767 #endif
1768 #if 201103L <= YY_CPLUSPLUS
1769  static
1770  symbol_type
1771  make_OP_GOTO_OPEN (location_type l)
1772  {
1773  return symbol_type (token::OP_GOTO_OPEN, std::move (l));
1774  }
1775 #else
1776  static
1777  symbol_type
1778  make_OP_GOTO_OPEN (const location_type& l)
1779  {
1780  return symbol_type (token::OP_GOTO_OPEN, l);
1781  }
1782 #endif
1783 #if 201103L <= YY_CPLUSPLUS
1784  static
1785  symbol_type
1786  make_OP_SQBKT_CLOSE (location_type l)
1787  {
1788  return symbol_type (token::OP_SQBKT_CLOSE, std::move (l));
1789  }
1790 #else
1791  static
1792  symbol_type
1793  make_OP_SQBKT_CLOSE (const location_type& l)
1794  {
1795  return symbol_type (token::OP_SQBKT_CLOSE, l);
1796  }
1797 #endif
1798 #if 201103L <= YY_CPLUSPLUS
1799  static
1800  symbol_type
1801  make_OP_SQBKT_STRONG_CLOSE (location_type l)
1802  {
1803  return symbol_type (token::OP_SQBKT_STRONG_CLOSE, std::move (l));
1804  }
1805 #else
1806  static
1807  symbol_type
1808  make_OP_SQBKT_STRONG_CLOSE (const location_type& l)
1809  {
1810  return symbol_type (token::OP_SQBKT_STRONG_CLOSE, l);
1811  }
1812 #endif
1813 #if 201103L <= YY_CPLUSPLUS
1814  static
1815  symbol_type
1816  make_OP_SQBKT_NUM (unsigned v, location_type l)
1817  {
1818  return symbol_type (token::OP_SQBKT_NUM, std::move (v), std::move (l));
1819  }
1820 #else
1821  static
1822  symbol_type
1823  make_OP_SQBKT_NUM (const unsigned& v, const location_type& l)
1824  {
1825  return symbol_type (token::OP_SQBKT_NUM, v, l);
1826  }
1827 #endif
1828 #if 201103L <= YY_CPLUSPLUS
1829  static
1830  symbol_type
1831  make_OP_UNBOUNDED (location_type l)
1832  {
1833  return symbol_type (token::OP_UNBOUNDED, std::move (l));
1834  }
1835 #else
1836  static
1837  symbol_type
1838  make_OP_UNBOUNDED (const location_type& l)
1839  {
1840  return symbol_type (token::OP_UNBOUNDED, l);
1841  }
1842 #endif
1843 #if 201103L <= YY_CPLUSPLUS
1844  static
1845  symbol_type
1846  make_OP_SQBKT_SEP (location_type l)
1847  {
1848  return symbol_type (token::OP_SQBKT_SEP, std::move (l));
1849  }
1850 #else
1851  static
1852  symbol_type
1853  make_OP_SQBKT_SEP (const location_type& l)
1854  {
1855  return symbol_type (token::OP_SQBKT_SEP, l);
1856  }
1857 #endif
1858 #if 201103L <= YY_CPLUSPLUS
1859  static
1860  symbol_type
1861  make_OP_UCONCAT (location_type l)
1862  {
1863  return symbol_type (token::OP_UCONCAT, std::move (l));
1864  }
1865 #else
1866  static
1867  symbol_type
1868  make_OP_UCONCAT (const location_type& l)
1869  {
1870  return symbol_type (token::OP_UCONCAT, l);
1871  }
1872 #endif
1873 #if 201103L <= YY_CPLUSPLUS
1874  static
1875  symbol_type
1876  make_OP_ECONCAT (location_type l)
1877  {
1878  return symbol_type (token::OP_ECONCAT, std::move (l));
1879  }
1880 #else
1881  static
1882  symbol_type
1883  make_OP_ECONCAT (const location_type& l)
1884  {
1885  return symbol_type (token::OP_ECONCAT, l);
1886  }
1887 #endif
1888 #if 201103L <= YY_CPLUSPLUS
1889  static
1890  symbol_type
1891  make_OP_UCONCAT_NONO (location_type l)
1892  {
1893  return symbol_type (token::OP_UCONCAT_NONO, std::move (l));
1894  }
1895 #else
1896  static
1897  symbol_type
1898  make_OP_UCONCAT_NONO (const location_type& l)
1899  {
1900  return symbol_type (token::OP_UCONCAT_NONO, l);
1901  }
1902 #endif
1903 #if 201103L <= YY_CPLUSPLUS
1904  static
1905  symbol_type
1906  make_OP_ECONCAT_NONO (location_type l)
1907  {
1908  return symbol_type (token::OP_ECONCAT_NONO, std::move (l));
1909  }
1910 #else
1911  static
1912  symbol_type
1913  make_OP_ECONCAT_NONO (const location_type& l)
1914  {
1915  return symbol_type (token::OP_ECONCAT_NONO, l);
1916  }
1917 #endif
1918 #if 201103L <= YY_CPLUSPLUS
1919  static
1920  symbol_type
1921  make_OP_FIRST_MATCH (location_type l)
1922  {
1923  return symbol_type (token::OP_FIRST_MATCH, std::move (l));
1924  }
1925 #else
1926  static
1927  symbol_type
1928  make_OP_FIRST_MATCH (const location_type& l)
1929  {
1930  return symbol_type (token::OP_FIRST_MATCH, l);
1931  }
1932 #endif
1933 #if 201103L <= YY_CPLUSPLUS
1934  static
1935  symbol_type
1936  make_ATOMIC_PROP (std::string v, location_type l)
1937  {
1938  return symbol_type (token::ATOMIC_PROP, std::move (v), std::move (l));
1939  }
1940 #else
1941  static
1942  symbol_type
1943  make_ATOMIC_PROP (const std::string& v, const location_type& l)
1944  {
1945  return symbol_type (token::ATOMIC_PROP, v, l);
1946  }
1947 #endif
1948 #if 201103L <= YY_CPLUSPLUS
1949  static
1950  symbol_type
1951  make_OP_CONCAT (location_type l)
1952  {
1953  return symbol_type (token::OP_CONCAT, std::move (l));
1954  }
1955 #else
1956  static
1957  symbol_type
1958  make_OP_CONCAT (const location_type& l)
1959  {
1960  return symbol_type (token::OP_CONCAT, l);
1961  }
1962 #endif
1963 #if 201103L <= YY_CPLUSPLUS
1964  static
1965  symbol_type
1966  make_OP_FUSION (location_type l)
1967  {
1968  return symbol_type (token::OP_FUSION, std::move (l));
1969  }
1970 #else
1971  static
1972  symbol_type
1973  make_OP_FUSION (const location_type& l)
1974  {
1975  return symbol_type (token::OP_FUSION, l);
1976  }
1977 #endif
1978 #if 201103L <= YY_CPLUSPLUS
1979  static
1980  symbol_type
1981  make_CONST_TRUE (location_type l)
1982  {
1983  return symbol_type (token::CONST_TRUE, std::move (l));
1984  }
1985 #else
1986  static
1987  symbol_type
1988  make_CONST_TRUE (const location_type& l)
1989  {
1990  return symbol_type (token::CONST_TRUE, l);
1991  }
1992 #endif
1993 #if 201103L <= YY_CPLUSPLUS
1994  static
1995  symbol_type
1996  make_CONST_FALSE (location_type l)
1997  {
1998  return symbol_type (token::CONST_FALSE, std::move (l));
1999  }
2000 #else
2001  static
2002  symbol_type
2003  make_CONST_FALSE (const location_type& l)
2004  {
2005  return symbol_type (token::CONST_FALSE, l);
2006  }
2007 #endif
2008 #if 201103L <= YY_CPLUSPLUS
2009  static
2010  symbol_type
2011  make_END_OF_INPUT (location_type l)
2012  {
2013  return symbol_type (token::END_OF_INPUT, std::move (l));
2014  }
2015 #else
2016  static
2017  symbol_type
2018  make_END_OF_INPUT (const location_type& l)
2019  {
2020  return symbol_type (token::END_OF_INPUT, l);
2021  }
2022 #endif
2023 #if 201103L <= YY_CPLUSPLUS
2024  static
2025  symbol_type
2026  make_OP_POST_NEG (location_type l)
2027  {
2028  return symbol_type (token::OP_POST_NEG, std::move (l));
2029  }
2030 #else
2031  static
2032  symbol_type
2033  make_OP_POST_NEG (const location_type& l)
2034  {
2035  return symbol_type (token::OP_POST_NEG, l);
2036  }
2037 #endif
2038 #if 201103L <= YY_CPLUSPLUS
2039  static
2040  symbol_type
2041  make_OP_POST_POS (location_type l)
2042  {
2043  return symbol_type (token::OP_POST_POS, std::move (l));
2044  }
2045 #else
2046  static
2047  symbol_type
2048  make_OP_POST_POS (const location_type& l)
2049  {
2050  return symbol_type (token::OP_POST_POS, l);
2051  }
2052 #endif
2053 #if 201103L <= YY_CPLUSPLUS
2054  static
2055  symbol_type
2056  make_OP_DELAY_N (unsigned v, location_type l)
2057  {
2058  return symbol_type (token::OP_DELAY_N, std::move (v), std::move (l));
2059  }
2060 #else
2061  static
2062  symbol_type
2063  make_OP_DELAY_N (const unsigned& v, const location_type& l)
2064  {
2065  return symbol_type (token::OP_DELAY_N, v, l);
2066  }
2067 #endif
2068 #if 201103L <= YY_CPLUSPLUS
2069  static
2070  symbol_type
2071  make_OP_DELAY_OPEN (location_type l)
2072  {
2073  return symbol_type (token::OP_DELAY_OPEN, std::move (l));
2074  }
2075 #else
2076  static
2077  symbol_type
2078  make_OP_DELAY_OPEN (const location_type& l)
2079  {
2080  return symbol_type (token::OP_DELAY_OPEN, l);
2081  }
2082 #endif
2083 #if 201103L <= YY_CPLUSPLUS
2084  static
2085  symbol_type
2086  make_OP_DELAY_PLUS (location_type l)
2087  {
2088  return symbol_type (token::OP_DELAY_PLUS, std::move (l));
2089  }
2090 #else
2091  static
2092  symbol_type
2093  make_OP_DELAY_PLUS (const location_type& l)
2094  {
2095  return symbol_type (token::OP_DELAY_PLUS, l);
2096  }
2097 #endif
2098 #if 201103L <= YY_CPLUSPLUS
2099  static
2100  symbol_type
2101  make_OP_DELAY_STAR (location_type l)
2102  {
2103  return symbol_type (token::OP_DELAY_STAR, std::move (l));
2104  }
2105 #else
2106  static
2107  symbol_type
2108  make_OP_DELAY_STAR (const location_type& l)
2109  {
2110  return symbol_type (token::OP_DELAY_STAR, l);
2111  }
2112 #endif
2113 
2114 
2115  class context
2116  {
2117  public:
2118  context (const parser& yyparser, const symbol_type& yyla);
2119  const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; }
2120  symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }
2121  const location_type& location () const YY_NOEXCEPT { return yyla_.location; }
2122 
2126  int expected_tokens (symbol_kind_type yyarg[], int yyargn) const;
2127 
2128  private:
2129  const parser& yyparser_;
2130  const symbol_type& yyla_;
2131  };
2132 
2133  private:
2134 #if YY_CPLUSPLUS < 201103L
2136  parser (const parser&);
2138  parser& operator= (const parser&);
2139 #endif
2140 
2141 
2143  typedef short state_type;
2144 
2146  int yy_syntax_error_arguments_ (const context& yyctx,
2147  symbol_kind_type yyarg[], int yyargn) const;
2148 
2151  virtual std::string yysyntax_error_ (const context& yyctx) const;
2155  static state_type yy_lr_goto_state_ (state_type yystate, int yysym);
2156 
2159  static bool yy_pact_value_is_default_ (int yyvalue);
2160 
2163  static bool yy_table_value_is_error_ (int yyvalue);
2164 
2165  static const signed char yypact_ninf_;
2166  static const signed char yytable_ninf_;
2167 
2171  static symbol_kind_type yytranslate_ (int t);
2172 
2174  static std::string yytnamerr_ (const char *yystr);
2175 
2177  static const char* const yytname_[];
2178 
2179 
2180  // Tables.
2181  // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2182  // STATE-NUM.
2183  static const short yypact_[];
2184 
2185  // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
2186  // Performed when YYTABLE does not specify something else to do. Zero
2187  // means the default is an error.
2188  static const unsigned char yydefact_[];
2189 
2190  // YYPGOTO[NTERM-NUM].
2191  static const short yypgoto_[];
2192 
2193  // YYDEFGOTO[NTERM-NUM].
2194  static const unsigned char yydefgoto_[];
2195 
2196  // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
2197  // positive, shift that token. If negative, reduce the rule whose
2198  // number is the opposite. If YYTABLE_NINF, syntax error.
2199  static const short yytable_[];
2200 
2201  static const short yycheck_[];
2202 
2203  // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2204  // symbol of state STATE-NUM.
2205  static const signed char yystos_[];
2206 
2207  // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
2208  static const signed char yyr1_[];
2209 
2210  // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
2211  static const signed char yyr2_[];
2212 
2213 
2214 #if TLYYDEBUG
2215  // YYRLINE[YYN] -- Source line where rule number YYN was defined.
2216  static const short yyrline_[];
2218  virtual void yy_reduce_print_ (int r) const;
2220  virtual void yy_stack_print_ () const;
2221 
2223  int yydebug_;
2225  std::ostream* yycdebug_;
2226 
2230  template <typename Base>
2231  void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
2232 #endif
2233 
2238  template <typename Base>
2239  void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
2240 
2241  private:
2243  struct by_state
2244  {
2246  by_state () YY_NOEXCEPT;
2247 
2249  typedef state_type kind_type;
2250 
2252  by_state (kind_type s) YY_NOEXCEPT;
2253 
2255  by_state (const by_state& that) YY_NOEXCEPT;
2256 
2258  void clear () YY_NOEXCEPT;
2259 
2261  void move (by_state& that);
2262 
2265  symbol_kind_type kind () const YY_NOEXCEPT;
2266 
2269  enum { empty_state = 0 };
2270 
2273  state_type state;
2274  };
2275 
2277  struct stack_symbol_type : basic_symbol<by_state>
2278  {
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);
2291 
2294  stack_symbol_type& operator= (const stack_symbol_type& that);
2295 #endif
2296  };
2297 
2299  template <typename T, typename S = std::vector<T> >
2300  class stack
2301  {
2302  public:
2303  // Hide our reversed order.
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;
2308 
2309  stack (size_type n = 200)
2310  : seq_ (n)
2311  {}
2312 
2313 #if 201103L <= YY_CPLUSPLUS
2315  stack (const stack&) = delete;
2317  stack& operator= (const stack&) = delete;
2318 #endif
2319 
2323  const T&
2324  operator[] (index_type i) const
2325  {
2326  return seq_[size_type (size () - 1 - i)];
2327  }
2328 
2332  T&
2333  operator[] (index_type i)
2334  {
2335  return seq_[size_type (size () - 1 - i)];
2336  }
2337 
2341  void
2342  push (YY_MOVE_REF (T) t)
2343  {
2344  seq_.push_back (T ());
2345  operator[] (0).move (t);
2346  }
2347 
2349  void
2350  pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2351  {
2352  for (; 0 < n; --n)
2353  seq_.pop_back ();
2354  }
2355 
2357  void
2358  clear () YY_NOEXCEPT
2359  {
2360  seq_.clear ();
2361  }
2362 
2364  index_type
2365  size () const YY_NOEXCEPT
2366  {
2367  return index_type (seq_.size ());
2368  }
2369 
2371  const_iterator
2372  begin () const YY_NOEXCEPT
2373  {
2374  return seq_.begin ();
2375  }
2376 
2378  const_iterator
2379  end () const YY_NOEXCEPT
2380  {
2381  return seq_.end ();
2382  }
2383 
2385  class slice
2386  {
2387  public:
2388  slice (const stack& stack, index_type range)
2389  : stack_ (stack)
2390  , range_ (range)
2391  {}
2392 
2393  const T&
2394  operator[] (index_type i) const
2395  {
2396  return stack_[range_ - i];
2397  }
2398 
2399  private:
2400  const stack& stack_;
2401  index_type range_;
2402  };
2403 
2404  private:
2405 #if YY_CPLUSPLUS < 201103L
2407  stack (const stack&);
2409  stack& operator= (const stack&);
2410 #endif
2412  S seq_;
2413  };
2414 
2415 
2417  typedef stack<stack_symbol_type> stack_type;
2418 
2420  stack_type yystack_;
2421 
2427  void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2428 
2435  void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
2436 
2438  void yypop_ (int n = 1);
2439 
2441  enum
2442  {
2443  yylast_ = 2385,
2444  yynnts_ = 23,
2445  yyfinal_ = 79
2446  };
2447 
2448 
2449  // User arguments.
2450  spot::parse_error_list &error_list;
2451  spot::environment &parse_environment;
2452  spot::formula &result;
2453 
2454  };
2455 
2456 
2457 } // tlyy
2458 #line 2459 "parsetl.hh"
2459 
2460 
2461 
2462 
2463 #endif // !YY_TLYY_PARSETL_HH_INCLUDED
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
Main class for temporal logic formula.
Definition: formula.hh:717
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)
int operator()()
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)
virtual int parse()
spot::location location_type
Symbol locations.
Definition: parsetl.hh:581
void error(const syntax_error &err)
Report a syntax error.
LTL/PSL formula interface.
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

Please direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.
Generated on Fri Feb 27 2015 10:00:07 for spot by doxygen 1.9.1