spot  2.8
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 YYDEBUG
316 # define YYDEBUG 1
317 #endif
318 
319 
320 namespace hoayy {
321 #line 322 "parseaut.hh" // lalr1.cc:401
322 
323 
324 
326  class parser
327  {
328  public:
329 #ifndef YYSTYPE
330  union semantic_type
332  {
333  #line 202 "parseaut.yy" // lalr1.cc:401
334 
335  std::string* str;
336  unsigned int num;
337  int b;
339  pair* p;
340  std::list<pair>* list;
342  std::vector<unsigned>* states;
343 
344 #line 345 "parseaut.hh" // lalr1.cc:401
345  };
346 #else
347  typedef YYSTYPE semantic_type;
348 #endif
349  typedef spot::location location_type;
351 
353  struct syntax_error : std::runtime_error
354  {
355  syntax_error (const location_type& l, const std::string& m)
356  : std::runtime_error (m)
357  , location (l)
358  {}
359 
360  syntax_error (const syntax_error& s)
361  : std::runtime_error (s.what ())
362  , location (s.location)
363  {}
364 
365  ~syntax_error () YY_NOEXCEPT YY_NOTHROW;
366 
367  location_type location;
368  };
369 
371  struct token
372  {
373  enum yytokentype
374  {
375  ENDOFFILE = 0,
376  HOA = 258,
377  STATES = 259,
378  START = 260,
379  AP = 261,
380  ALIAS = 262,
381  ACCEPTANCE = 263,
382  ACCNAME = 264,
383  TOOL = 265,
384  NAME = 266,
385  PROPERTIES = 267,
386  BODY = 268,
387  END = 269,
388  STATE = 270,
389  SPOT_HIGHLIGHT_EDGES = 271,
390  SPOT_HIGHLIGHT_STATES = 272,
391  IDENTIFIER = 273,
392  HEADERNAME = 274,
393  ANAME = 275,
394  STRING = 276,
395  INT = 277,
396  DRA = 278,
397  DSA = 279,
398  V2 = 280,
399  EXPLICIT = 281,
400  ACCPAIRS = 282,
401  ACCSIG = 283,
402  ENDOFHEADER = 284,
403  NEVER = 285,
404  SKIP = 286,
405  IF = 287,
406  FI = 288,
407  DO = 289,
408  OD = 290,
409  ARROW = 291,
410  GOTO = 292,
411  FALSE = 293,
412  ATOMIC = 294,
413  ASSERT = 295,
414  FORMULA = 296,
415  ENDAUT = 297,
416  ENDDSTAR = 298,
417  LBTT = 299,
418  INT_S = 300,
419  LBTT_EMPTY = 301,
420  ACC = 302,
421  STATE_NUM = 303,
422  DEST_NUM = 304
423  };
424  };
425 
427  typedef token::yytokentype token_type;
428 
430  typedef int symbol_number_type;
431 
433  enum { empty_symbol = -2 };
434 
436  typedef unsigned char token_number_type;
437 
444  template <typename Base>
445  struct basic_symbol : Base
446  {
448  typedef Base super_type;
449 
452  : value ()
453  , location ()
454  {}
455 
456 #if 201103L <= YY_CPLUSPLUS
457  basic_symbol (basic_symbol&& that);
459 #endif
460 
462  basic_symbol (const basic_symbol& that);
464  basic_symbol (typename Base::kind_type t,
465  YY_MOVE_REF (location_type) l);
466 
468  basic_symbol (typename Base::kind_type t,
469  YY_RVREF (semantic_type) v,
470  YY_RVREF (location_type) l);
471 
474  {
475  clear ();
476  }
477 
479  void clear ()
480  {
481  Base::clear ();
482  }
483 
485  bool empty () const YY_NOEXCEPT;
486 
488  void move (basic_symbol& s);
489 
491  semantic_type value;
492 
494  location_type location;
495 
496  private:
497 #if YY_CPLUSPLUS < 201103L
498  basic_symbol& operator= (const basic_symbol& that);
500 #endif
501  };
502 
504  struct by_type
505  {
507  by_type ();
508 
509 #if 201103L <= YY_CPLUSPLUS
510  by_type (by_type&& that);
512 #endif
513 
515  by_type (const by_type& that);
516 
518  typedef token_type kind_type;
519 
521  by_type (kind_type t);
522 
524  void clear ();
525 
527  void move (by_type& that);
528 
531  symbol_number_type type_get () const YY_NOEXCEPT;
532 
534  token_type token () const YY_NOEXCEPT;
535 
539  int type;
540  };
541 
544  {};
545 
547  parser (void* scanner_yyarg, result_& res_yyarg, spot::location initial_loc_yyarg);
548  virtual ~parser ();
549 
552  int operator() ();
553 
556  virtual int parse ();
557 
558 #if YYDEBUG
559  std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
562  void set_debug_stream (std::ostream &);
563 
565  typedef int debug_level_type;
567  debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
569  void set_debug_level (debug_level_type l);
570 #endif
571 
575  virtual void error (const location_type& loc, const std::string& msg);
576 
578  void error (const syntax_error& err);
579 
580 
581 
582  private:
584  parser (const parser&);
585  parser& operator= (const parser&);
586 
588  typedef int state_type;
589 
593  virtual std::string yysyntax_error_ (state_type yystate,
594  const symbol_type& yyla) const;
595 
599  state_type yy_lr_goto_state_ (state_type yystate, int yysym);
600 
603  static bool yy_pact_value_is_default_ (int yyvalue);
604 
607  static bool yy_table_value_is_error_ (int yyvalue);
608 
609  static const short yypact_ninf_;
610  static const signed char yytable_ninf_;
611 
613  static token_number_type yytranslate_ (int t);
614 
615  // Tables.
616  // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
617  // STATE-NUM.
618  static const short yypact_[];
619 
620  // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
621  // Performed when YYTABLE does not specify something else to do. Zero
622  // means the default is an error.
623  static const unsigned char yydefact_[];
624 
625  // YYPGOTO[NTERM-NUM].
626  static const short yypgoto_[];
627 
628  // YYDEFGOTO[NTERM-NUM].
629  static const short yydefgoto_[];
630 
631  // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
632  // positive, shift that token. If negative, reduce the rule whose
633  // number is the opposite. If YYTABLE_NINF, syntax error.
634  static const short yytable_[];
635 
636  static const short yycheck_[];
637 
638  // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
639  // symbol of state STATE-NUM.
640  static const unsigned char yystos_[];
641 
642  // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
643  static const unsigned char yyr1_[];
644 
645  // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
646  static const unsigned char yyr2_[];
647 
648 
650  static std::string yytnamerr_ (const char *n);
651 
652 
654  static const char* const yytname_[];
655 #if YYDEBUG
656  // YYRLINE[YYN] -- Source line where rule number YYN was defined.
657  static const unsigned short yyrline_[];
659  virtual void yy_reduce_print_ (int r);
661  virtual void yystack_print_ ();
662 
664  int yydebug_;
666  std::ostream* yycdebug_;
667 
671  template <typename Base>
672  void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
673 #endif
674 
679  template <typename Base>
680  void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
681 
682  private:
684  struct by_state
685  {
687  by_state () YY_NOEXCEPT;
688 
690  typedef state_type kind_type;
691 
693  by_state (kind_type s) YY_NOEXCEPT;
694 
696  by_state (const by_state& that) YY_NOEXCEPT;
697 
699  void clear () YY_NOEXCEPT;
700 
702  void move (by_state& that);
703 
706  symbol_number_type type_get () const YY_NOEXCEPT;
707 
709  enum { empty_state = -1 };
710 
713  state_type state;
714  };
715 
717  struct stack_symbol_type : basic_symbol<by_state>
718  {
720  typedef basic_symbol<by_state> super_type;
722  stack_symbol_type ();
724  stack_symbol_type (YY_RVREF (stack_symbol_type) that);
726  stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
727 #if YY_CPLUSPLUS < 201103L
728  stack_symbol_type& operator= (stack_symbol_type& that);
731 #endif
732  };
733 
735  template <typename T, typename S = std::vector<T> >
736  class stack
737  {
738  public:
739  // Hide our reversed order.
740  typedef typename S::reverse_iterator iterator;
741  typedef typename S::const_reverse_iterator const_iterator;
742  typedef typename S::size_type size_type;
743 
744  stack (size_type n = 200)
745  : seq_ (n)
746  {}
747 
751  T&
752  operator[] (size_type i)
753  {
754  return seq_[size () - 1 - i];
755  }
756 
760  T&
761  operator[] (int i)
762  {
763  return operator[] (size_type (i));
764  }
765 
769  const T&
770  operator[] (size_type i) const
771  {
772  return seq_[size () - 1 - i];
773  }
774 
778  const T&
779  operator[] (int i) const
780  {
781  return operator[] (size_type (i));
782  }
783 
787  void
788  push (YY_MOVE_REF (T) t)
789  {
790  seq_.push_back (T ());
791  operator[] (0).move (t);
792  }
793 
795  void
796  pop (int n = 1) YY_NOEXCEPT
797  {
798  for (; 0 < n; --n)
799  seq_.pop_back ();
800  }
801 
803  void
804  clear () YY_NOEXCEPT
805  {
806  seq_.clear ();
807  }
808 
810  size_type
811  size () const YY_NOEXCEPT
812  {
813  return seq_.size ();
814  }
815 
817  const_iterator
818  begin () const YY_NOEXCEPT
819  {
820  return seq_.rbegin ();
821  }
822 
824  const_iterator
825  end () const YY_NOEXCEPT
826  {
827  return seq_.rend ();
828  }
829 
831  class slice
832  {
833  public:
834  slice (const stack& stack, int range)
835  : stack_ (stack)
836  , range_ (range)
837  {}
838 
839  const T&
840  operator[] (int i) const
841  {
842  return stack_[range_ - i];
843  }
844 
845  private:
846  const stack& stack_;
847  int range_;
848  };
849 
850  private:
851  stack (const stack&);
852  stack& operator= (const stack&);
854  S seq_;
855  };
856 
857 
859  typedef stack<stack_symbol_type> stack_type;
860 
862  stack_type yystack_;
863 
869  void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
870 
877  void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
878 
880  void yypop_ (int n = 1);
881 
883  enum
884  {
885  yyeof_ = 0,
886  yylast_ = 235,
887  yynnts_ = 83,
888  yyfinal_ = 24,
889  yyterror_ = 1,
890  yyerrcode_ = 256,
891  yyntokens_ = 65
892  };
893 
894 
895  // User arguments.
896  void* scanner;
897  result_& res;
898  spot::location initial_loc;
899  };
900 
901 
902 
903 } // hoayy
904 #line 905 "parseaut.hh" // lalr1.cc:401
905 
906 
907 
908 
909 #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:331
semantic_type value
The semantic value.
Definition: parseaut.hh:491
Syntax errors thrown from user actions.
Definition: parseaut.hh:353
Definition: parseaut.hh:98
Definition: ngraph.hh:32
token::yytokentype token_type
(External) token type, as returned by yylex.
Definition: parseaut.hh:427
Definition: parseaut.hh:320
Definition: public.hh:92
Definition: parseaut.hh:133
Tokens.
Definition: parseaut.hh:371
Type access provider for token (enum) based symbols.
Definition: parseaut.hh:504
token_type kind_type
The symbol type as needed by the constructor.
Definition: parseaut.hh:518
Base super_type
Alias to Base.
Definition: parseaut.hh:448
unsigned char token_number_type
Internal symbol number for tokens (subsumed by symbol_number_type).
Definition: parseaut.hh:436
A class implementing Kleene&#39;s three-valued logic.
Definition: trival.hh:33
~basic_symbol()
Destroy the symbol.
Definition: parseaut.hh:473
basic_symbol()
Default constructor.
Definition: parseaut.hh:451
spot::location location_type
Symbol locations.
Definition: parseaut.hh:350
Definition: parseaut.hh:73
A Bison parser.
Definition: parseaut.hh:326
"External" symbols: returned by the scanner.
Definition: parseaut.hh:543
Present a slice of the top of a stack.
Definition: parseaut.hh:831
void clear()
Destroy contents, and record that is empty.
Definition: parseaut.hh:479
Definition: parseaut.hh:445
An acceptance formula.
Definition: acc.hh:451
location_type location
The location.
Definition: parseaut.hh:494
int symbol_number_type
Symbol type: an internal symbol number.
Definition: parseaut.hh:430
An acceptance mark.
Definition: acc.hh:81
int debug_level_type
Type for debugging levels.
Definition: parseaut.hh:565

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