spot  2.8.6
parseaut.hh
Go to the documentation of this file.
1 // A Bison parser, made by GNU Bison 3.3.2.
2 
3 // Skeleton interface for Bison LALR(1) parsers in C++
4 
5 // Copyright (C) 2002-2015, 2018-2019 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 // Undocumented macros, especially those whose name start with YY_,
42 // are private implementation details. Do not rely on them.
43 
44 #ifndef YY_HOAYY_PARSEAUT_HH_INCLUDED
45 # define YY_HOAYY_PARSEAUT_HH_INCLUDED
46 // // "%code requires" blocks.
47 #line 33 "parseaut.yy" // lalr1.cc:401
48 
49 #include "config.h"
50 #include <spot/misc/common.hh>
51 #include <string>
52 #include <cstring>
53 #include <sstream>
54 #include <unordered_map>
55 #include <algorithm>
56 #include <spot/twa/formula2bdd.hh>
57 #include <spot/parseaut/public.hh>
58 #include "spot/priv/accmap.hh"
59 #include <spot/tl/parse.hh>
60 #include <spot/twaalgos/alternation.hh>
61 
62 using namespace std::string_literals;
63 
64 #ifndef HAVE_STRVERSCMP
65 // If the libc does not have this, a version is compiled in lib/.
66 extern "C" int strverscmp(const char *s1, const char *s2);
67 #endif
68 
69 // Work around Bison not letting us write
70 // %lex-param { res.h->errors }
71 #define PARSE_ERROR_LIST res.h->errors
72 
73  inline namespace hoayy_support
74  {
75  typedef std::map<int, bdd> map_t;
76 
77  /* Cache parsed formulae. Labels on arcs are frequently identical
78  and it would be a waste of time to parse them to formula
79  over and over, and to register all their atomic_propositions in
80  the bdd_dict. Keep the bdd result around so we can reuse
81  it. */
82  typedef std::map<std::string, bdd> formula_cache;
83 
84  typedef std::pair<int, std::string*> pair;
85  typedef spot::twa_graph::namer<std::string> named_tgba_t;
86 
87  // Note: because this parser is meant to be used on a stream of
88  // automata, it tries hard to recover from errors, so that we get a
89  // chance to reach the end of the current automaton in order to
90  // process the next one. Several variables below are used to keep
91  // track of various error conditions.
92  enum label_style_t { Mixed_Labels, State_Labels, Trans_Labels,
93  Implicit_Labels };
94  enum acc_style_t { Mixed_Acc, State_Acc, Trans_Acc };
95 
96  struct result_
97  {
98  struct state_info
99  {
100  bool declared = false;
101  bool used = false;
102  spot::location used_loc;
103  };
104  spot::parsed_aut_ptr h;
105  spot::twa_ptr aut_or_ks;
107  std::string format_version;
108  spot::location format_version_loc;
109  spot::environment* env;
110  formula_cache fcache;
111  named_tgba_t* namer = nullptr;
112  spot::acc_mapper_int* acc_mapper = nullptr;
113  std::vector<int> ap;
114  std::vector<bdd> guards;
115  std::vector<bdd>::const_iterator cur_guard;
116  // If "Alias: ..." occurs before "AP: ..." in the HOA format we
117  // are in trouble because the parser would like to turn each
118  // alias into a BDD, yet the atomic proposition have not been
119  // declared yet. We solve that by using arbitrary BDD variables
120  // numbers (in fact we use the same number given in the Alias:
121  // definition) and keeping track of the highest variable number
122  // we have seen (unknown_ap_max). Once AP: is encountered,
123  // we can remap everything. If AP: is never encountered an
124  // unknown_ap_max is non-negative, then we can signal an error.
125  int unknown_ap_max = -1;
126  spot::location unknown_ap_max_location;
127  bool in_alias = false;
128  map_t dest_map;
129  std::vector<state_info> info_states; // States declared and used.
130  std::vector<std::pair<spot::location,
131  std::vector<unsigned>>> start; // Initial states;
132  std::unordered_map<std::string, bdd> alias;
133  struct prop_info
134  {
135  spot::location loc;
136  bool val;
137  operator bool() const
138  {
139  return val;
140  };
141  };
142  std::unordered_map<std::string, prop_info> props;
143  spot::location states_loc;
144  spot::location ap_loc;
145  spot::location state_label_loc;
146  spot::location accset_loc;
147  spot::acc_cond::mark_t acc_state;
148  spot::acc_cond::mark_t neg_acc_sets = {};
149  spot::acc_cond::mark_t pos_acc_sets = {};
150  int plus;
151  int minus;
152  std::vector<std::string>* state_names = nullptr;
153  std::map<unsigned, unsigned>* highlight_edges = nullptr;
154  std::map<unsigned, unsigned>* highlight_states = nullptr;
155  std::map<unsigned, unsigned> states_map;
156  std::set<int> ap_set;
157  unsigned cur_state;
158  int states = -1;
159  int ap_count = -1;
160  int accset = -1;
161  bdd state_label;
162  bdd cur_label;
163  bool has_state_label = false;
164  bool ignore_more_ap = false; // Set to true after the first "AP:"
165  // line has been read.
166  bool ignore_acc = false; // Set to true in case of missing
167  // Acceptance: lines.
168  bool ignore_acc_silent = false;
169  bool ignore_more_acc = false; // Set to true after the first
170  // "Acceptance:" line has been read.
171 
172  label_style_t label_style = Mixed_Labels;
173  acc_style_t acc_style = Mixed_Acc;
174 
175  bool accept_all_needed = false;
176  bool accept_all_seen = false;
177  bool aliased_states = false;
178 
179  spot::trival universal = spot::trival::maybe();
180  spot::trival existential = spot::trival::maybe();
181  spot::trival complete = spot::trival::maybe();
182  bool trans_acc_seen = false;
183 
184  std::map<std::string, spot::location> labels;
185 
186  prop_info prop_is_true(const std::string& p)
187  {
188  auto i = props.find(p);
189  if (i == props.end())
190  return prop_info{spot::location(), false};
191  return i->second;
192  }
193 
194  prop_info prop_is_false(const std::string& p)
195  {
196  auto i = props.find(p);
197  if (i == props.end())
198  return prop_info{spot::location(), false};
199  return prop_info{i->second.loc, !i->second.val};
200  }
201 
202  ~result_()
203  {
204  delete namer;
205  delete acc_mapper;
206  }
207  };
208  }
209 
210 #line 211 "parseaut.hh" // lalr1.cc:401
211 
212 
213 # include <cstdlib> // std::abort
214 # include <iostream>
215 # include <stdexcept>
216 # include <string>
217 # include <vector>
218 
219 #if defined __cplusplus
220 # define YY_CPLUSPLUS __cplusplus
221 #else
222 # define YY_CPLUSPLUS 199711L
223 #endif
224 
225 // Support move semantics when possible.
226 #if 201103L <= YY_CPLUSPLUS
227 # define YY_MOVE std::move
228 # define YY_MOVE_OR_COPY move
229 # define YY_MOVE_REF(Type) Type&&
230 # define YY_RVREF(Type) Type&&
231 # define YY_COPY(Type) Type
232 #else
233 # define YY_MOVE
234 # define YY_MOVE_OR_COPY copy
235 # define YY_MOVE_REF(Type) Type&
236 # define YY_RVREF(Type) const Type&
237 # define YY_COPY(Type) const Type&
238 #endif
239 
240 // Support noexcept when possible.
241 #if 201103L <= YY_CPLUSPLUS
242 # define YY_NOEXCEPT noexcept
243 # define YY_NOTHROW
244 #else
245 # define YY_NOEXCEPT
246 # define YY_NOTHROW throw ()
247 #endif
248 
249 // Support constexpr when possible.
250 #if 201703 <= YY_CPLUSPLUS
251 # define YY_CONSTEXPR constexpr
252 #else
253 # define YY_CONSTEXPR
254 #endif
255 
256 
257 
258 #ifndef YY_ATTRIBUTE
259 # if (defined __GNUC__ \
260  && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
261  || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
262 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
263 # else
264 # define YY_ATTRIBUTE(Spec) /* empty */
265 # endif
266 #endif
267 
268 #ifndef YY_ATTRIBUTE_PURE
269 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
270 #endif
271 
272 #ifndef YY_ATTRIBUTE_UNUSED
273 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
274 #endif
275 
276 /* Suppress unused-variable warnings by "using" E. */
277 #if ! defined lint || defined __GNUC__
278 # define YYUSE(E) ((void) (E))
279 #else
280 # define YYUSE(E) /* empty */
281 #endif
282 
283 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
284 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
285 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
286  _Pragma ("GCC diagnostic push") \
287  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
288  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
289 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
290  _Pragma ("GCC diagnostic pop")
291 #else
292 # define YY_INITIAL_VALUE(Value) Value
293 #endif
294 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
295 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
296 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
297 #endif
298 #ifndef YY_INITIAL_VALUE
299 # define YY_INITIAL_VALUE(Value) /* Nothing. */
300 #endif
301 
302 # ifndef YY_NULLPTR
303 # if defined __cplusplus
304 # if 201103L <= __cplusplus
305 # define YY_NULLPTR nullptr
306 # else
307 # define YY_NULLPTR 0
308 # endif
309 # else
310 # define YY_NULLPTR ((void*)0)
311 # endif
312 # endif
313 
314 /* Debug traces. */
315 #ifndef HOAYYDEBUG
316 # if defined YYDEBUG
317 #if YYDEBUG
318 # define HOAYYDEBUG 1
319 # else
320 # define HOAYYDEBUG 0
321 # endif
322 # else /* ! defined YYDEBUG */
323 # define HOAYYDEBUG 1
324 # endif /* ! defined YYDEBUG */
325 #endif /* ! defined HOAYYDEBUG */
326 
327 
328 namespace hoayy {
329 #line 330 "parseaut.hh" // lalr1.cc:401
330 
331 
332 
334  class parser
335  {
336  public:
337 #ifndef HOAYYSTYPE
338  union semantic_type
340  {
341  #line 202 "parseaut.yy" // lalr1.cc:401
342 
343  std::string* str;
344  unsigned int num;
345  int b;
347  pair* p;
348  std::list<pair>* list;
350  std::vector<unsigned>* states;
351 
352 #line 353 "parseaut.hh" // lalr1.cc:401
353  };
354 #else
355  typedef HOAYYSTYPE semantic_type;
356 #endif
357  typedef spot::location location_type;
359 
361  struct syntax_error : std::runtime_error
362  {
363  syntax_error (const location_type& l, const std::string& m)
364  : std::runtime_error (m)
365  , location (l)
366  {}
367 
368  syntax_error (const syntax_error& s)
369  : std::runtime_error (s.what ())
370  , location (s.location)
371  {}
372 
373  ~syntax_error () YY_NOEXCEPT YY_NOTHROW;
374 
375  location_type location;
376  };
377 
379  struct token
380  {
381  enum yytokentype
382  {
383  ENDOFFILE = 0,
384  HOA = 258,
385  STATES = 259,
386  START = 260,
387  AP = 261,
388  ALIAS = 262,
389  ACCEPTANCE = 263,
390  ACCNAME = 264,
391  TOOL = 265,
392  NAME = 266,
393  PROPERTIES = 267,
394  BODY = 268,
395  END = 269,
396  STATE = 270,
397  SPOT_HIGHLIGHT_EDGES = 271,
398  SPOT_HIGHLIGHT_STATES = 272,
399  IDENTIFIER = 273,
400  HEADERNAME = 274,
401  ANAME = 275,
402  STRING = 276,
403  INT = 277,
404  DRA = 278,
405  DSA = 279,
406  V2 = 280,
407  EXPLICIT = 281,
408  ACCPAIRS = 282,
409  ACCSIG = 283,
410  ENDOFHEADER = 284,
411  NEVER = 285,
412  SKIP = 286,
413  IF = 287,
414  FI = 288,
415  DO = 289,
416  OD = 290,
417  ARROW = 291,
418  GOTO = 292,
419  FALSE = 293,
420  ATOMIC = 294,
421  ASSERT = 295,
422  FORMULA = 296,
423  ENDAUT = 297,
424  ENDDSTAR = 298,
425  LBTT = 299,
426  INT_S = 300,
427  LBTT_EMPTY = 301,
428  ACC = 302,
429  STATE_NUM = 303,
430  DEST_NUM = 304
431  };
432  };
433 
435  typedef token::yytokentype token_type;
436 
438  typedef int symbol_number_type;
439 
441  enum { empty_symbol = -2 };
442 
444  typedef unsigned char token_number_type;
445 
452  template <typename Base>
453  struct basic_symbol : Base
454  {
456  typedef Base super_type;
457 
460  : value ()
461  , location ()
462  {}
463 
464 #if 201103L <= YY_CPLUSPLUS
465  basic_symbol (basic_symbol&& that);
467 #endif
468 
470  basic_symbol (const basic_symbol& that);
472  basic_symbol (typename Base::kind_type t,
473  YY_MOVE_REF (location_type) l);
474 
476  basic_symbol (typename Base::kind_type t,
477  YY_RVREF (semantic_type) v,
478  YY_RVREF (location_type) l);
479 
482  {
483  clear ();
484  }
485 
487  void clear ()
488  {
489  Base::clear ();
490  }
491 
493  bool empty () const YY_NOEXCEPT;
494 
496  void move (basic_symbol& s);
497 
499  semantic_type value;
500 
502  location_type location;
503 
504  private:
505 #if YY_CPLUSPLUS < 201103L
506  basic_symbol& operator= (const basic_symbol& that);
508 #endif
509  };
510 
512  struct by_type
513  {
515  by_type ();
516 
517 #if 201103L <= YY_CPLUSPLUS
518  by_type (by_type&& that);
520 #endif
521 
523  by_type (const by_type& that);
524 
526  typedef token_type kind_type;
527 
529  by_type (kind_type t);
530 
532  void clear ();
533 
535  void move (by_type& that);
536 
539  symbol_number_type type_get () const YY_NOEXCEPT;
540 
542  token_type token () const YY_NOEXCEPT;
543 
547  int type;
548  };
549 
552  {};
553 
555  parser (void* scanner_yyarg, result_& res_yyarg, spot::location initial_loc_yyarg);
556  virtual ~parser ();
557 
560  int operator() ();
561 
564  virtual int parse ();
565 
566 #if HOAYYDEBUG
567  std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
570  void set_debug_stream (std::ostream &);
571 
573  typedef int debug_level_type;
575  debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
577  void set_debug_level (debug_level_type l);
578 #endif
579 
583  virtual void error (const location_type& loc, const std::string& msg);
584 
586  void error (const syntax_error& err);
587 
588 
589 
590  private:
592  parser (const parser&);
593  parser& operator= (const parser&);
594 
596  typedef int state_type;
597 
601  virtual std::string yysyntax_error_ (state_type yystate,
602  const symbol_type& yyla) const;
603 
607  state_type yy_lr_goto_state_ (state_type yystate, int yysym);
608 
611  static bool yy_pact_value_is_default_ (int yyvalue);
612 
615  static bool yy_table_value_is_error_ (int yyvalue);
616 
617  static const short yypact_ninf_;
618  static const signed char yytable_ninf_;
619 
621  static token_number_type yytranslate_ (int t);
622 
623  // Tables.
624  // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
625  // STATE-NUM.
626  static const short yypact_[];
627 
628  // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
629  // Performed when YYTABLE does not specify something else to do. Zero
630  // means the default is an error.
631  static const unsigned char yydefact_[];
632 
633  // YYPGOTO[NTERM-NUM].
634  static const short yypgoto_[];
635 
636  // YYDEFGOTO[NTERM-NUM].
637  static const short yydefgoto_[];
638 
639  // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
640  // positive, shift that token. If negative, reduce the rule whose
641  // number is the opposite. If YYTABLE_NINF, syntax error.
642  static const short yytable_[];
643 
644  static const short yycheck_[];
645 
646  // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
647  // symbol of state STATE-NUM.
648  static const unsigned char yystos_[];
649 
650  // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
651  static const unsigned char yyr1_[];
652 
653  // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
654  static const unsigned char yyr2_[];
655 
656 
658  static std::string yytnamerr_ (const char *n);
659 
660 
662  static const char* const yytname_[];
663 #if HOAYYDEBUG
664  // YYRLINE[YYN] -- Source line where rule number YYN was defined.
665  static const unsigned short yyrline_[];
667  virtual void yy_reduce_print_ (int r);
669  virtual void yystack_print_ ();
670 
672  int yydebug_;
674  std::ostream* yycdebug_;
675 
679  template <typename Base>
680  void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
681 #endif
682 
687  template <typename Base>
688  void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
689 
690  private:
692  struct by_state
693  {
695  by_state () YY_NOEXCEPT;
696 
698  typedef state_type kind_type;
699 
701  by_state (kind_type s) YY_NOEXCEPT;
702 
704  by_state (const by_state& that) YY_NOEXCEPT;
705 
707  void clear () YY_NOEXCEPT;
708 
710  void move (by_state& that);
711 
714  symbol_number_type type_get () const YY_NOEXCEPT;
715 
717  enum { empty_state = -1 };
718 
721  state_type state;
722  };
723 
725  struct stack_symbol_type : basic_symbol<by_state>
726  {
728  typedef basic_symbol<by_state> super_type;
730  stack_symbol_type ();
732  stack_symbol_type (YY_RVREF (stack_symbol_type) that);
734  stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
735 #if YY_CPLUSPLUS < 201103L
736  stack_symbol_type& operator= (stack_symbol_type& that);
739 #endif
740  };
741 
743  template <typename T, typename S = std::vector<T> >
744  class stack
745  {
746  public:
747  // Hide our reversed order.
748  typedef typename S::reverse_iterator iterator;
749  typedef typename S::const_reverse_iterator const_iterator;
750  typedef typename S::size_type size_type;
751 
752  stack (size_type n = 200)
753  : seq_ (n)
754  {}
755 
759  T&
760  operator[] (size_type i)
761  {
762  return seq_[size () - 1 - i];
763  }
764 
768  T&
769  operator[] (int i)
770  {
771  return operator[] (size_type (i));
772  }
773 
777  const T&
778  operator[] (size_type i) const
779  {
780  return seq_[size () - 1 - i];
781  }
782 
786  const T&
787  operator[] (int i) const
788  {
789  return operator[] (size_type (i));
790  }
791 
795  void
796  push (YY_MOVE_REF (T) t)
797  {
798  seq_.push_back (T ());
799  operator[] (0).move (t);
800  }
801 
803  void
804  pop (int n = 1) YY_NOEXCEPT
805  {
806  for (; 0 < n; --n)
807  seq_.pop_back ();
808  }
809 
811  void
812  clear () YY_NOEXCEPT
813  {
814  seq_.clear ();
815  }
816 
818  size_type
819  size () const YY_NOEXCEPT
820  {
821  return seq_.size ();
822  }
823 
825  const_iterator
826  begin () const YY_NOEXCEPT
827  {
828  return seq_.rbegin ();
829  }
830 
832  const_iterator
833  end () const YY_NOEXCEPT
834  {
835  return seq_.rend ();
836  }
837 
839  class slice
840  {
841  public:
842  slice (const stack& stack, int range)
843  : stack_ (stack)
844  , range_ (range)
845  {}
846 
847  const T&
848  operator[] (int i) const
849  {
850  return stack_[range_ - i];
851  }
852 
853  private:
854  const stack& stack_;
855  int range_;
856  };
857 
858  private:
859  stack (const stack&);
860  stack& operator= (const stack&);
862  S seq_;
863  };
864 
865 
867  typedef stack<stack_symbol_type> stack_type;
868 
870  stack_type yystack_;
871 
877  void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
878 
885  void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
886 
888  void yypop_ (int n = 1);
889 
891  enum
892  {
893  yyeof_ = 0,
894  yylast_ = 235,
895  yynnts_ = 83,
896  yyfinal_ = 24,
897  yyterror_ = 1,
898  yyerrcode_ = 256,
899  yyntokens_ = 65
900  };
901 
902 
903  // User arguments.
904  void* scanner;
905  result_& res;
906  spot::location initial_loc;
907  };
908 
909 
910 
911 } // hoayy
912 #line 913 "parseaut.hh" // lalr1.cc:401
913 
914 
915 
916 
917 #endif // !YY_HOAYY_PARSEAUT_HH_INCLUDED
Definition: parseaut.hh:96
An environment that describes atomic propositions.
Definition: environment.hh:32
Symbol semantic values.
Definition: parseaut.hh:339
semantic_type value
The semantic value.
Definition: parseaut.hh:499
Syntax errors thrown from user actions.
Definition: parseaut.hh:361
Definition: parseaut.hh:98
Definition: ngraph.hh:32
token::yytokentype token_type
(External) token type, as returned by yylex.
Definition: parseaut.hh:435
Definition: parseaut.hh:328
Definition: public.hh:92
Definition: parseaut.hh:133
Tokens.
Definition: parseaut.hh:379
Type access provider for token (enum) based symbols.
Definition: parseaut.hh:512
token_type kind_type
The symbol type as needed by the constructor.
Definition: parseaut.hh:526
Base super_type
Alias to Base.
Definition: parseaut.hh:456
unsigned char token_number_type
Internal symbol number for tokens (subsumed by symbol_number_type).
Definition: parseaut.hh:444
A class implementing Kleene&#39;s three-valued logic.
Definition: trival.hh:33
~basic_symbol()
Destroy the symbol.
Definition: parseaut.hh:481
basic_symbol()
Default constructor.
Definition: parseaut.hh:459
spot::location location_type
Symbol locations.
Definition: parseaut.hh:358
Definition: parseaut.hh:73
A Bison parser.
Definition: parseaut.hh:334
"External" symbols: returned by the scanner.
Definition: parseaut.hh:551
Present a slice of the top of a stack.
Definition: parseaut.hh:839
void clear()
Destroy contents, and record that is empty.
Definition: parseaut.hh:487
Definition: parseaut.hh:453
An acceptance formula.
Definition: acc.hh:454
location_type location
The location.
Definition: parseaut.hh:502
int symbol_number_type
Symbol type: an internal symbol number.
Definition: parseaut.hh:438
An acceptance mark.
Definition: acc.hh:81
int debug_level_type
Type for debugging levels.
Definition: parseaut.hh:573

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.8.13