ztsdb
parser.hpp
Go to the documentation of this file.
1 // A Bison parser, made by GNU Bison 3.5.1.
2 
3 // Skeleton interface for Bison LALR(1) parsers in C++
4 
5 // Copyright (C) 2002-2015, 2018-2020 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_YY_PARSER_HPP_INCLUDED
45 # define YY_YY_PARSER_HPP_INCLUDED
46 // "%code requires" blocks.
47 #line 30 "parser.y"
48 
49 #include <string>
50 #include <memory>
51 #include "location.hpp"
52 #include "../ast.hpp"
53 #include "../globals.hpp"
54 #include "../timezone/interval.hpp"
55 class ParserCtx; // forward declaration to avoid circular dependency
56 typedef void *yyscan_t;
57 
58 #line 59 "parser.hpp"
59 
60 # include <cassert>
61 # include <cstdlib> // std::abort
62 # include <iostream>
63 # include <stdexcept>
64 # include <string>
65 # include <vector>
66 
67 #if defined __cplusplus
68 # define YY_CPLUSPLUS __cplusplus
69 #else
70 # define YY_CPLUSPLUS 199711L
71 #endif
72 
73 // Support move semantics when possible.
74 #if 201103L <= YY_CPLUSPLUS
75 # define YY_MOVE std::move
76 # define YY_MOVE_OR_COPY move
77 # define YY_MOVE_REF(Type) Type&&
78 # define YY_RVREF(Type) Type&&
79 # define YY_COPY(Type) Type
80 #else
81 # define YY_MOVE
82 # define YY_MOVE_OR_COPY copy
83 # define YY_MOVE_REF(Type) Type&
84 # define YY_RVREF(Type) const Type&
85 # define YY_COPY(Type) const Type&
86 #endif
87 
88 // Support noexcept when possible.
89 #if 201103L <= YY_CPLUSPLUS
90 # define YY_NOEXCEPT noexcept
91 # define YY_NOTHROW
92 #else
93 # define YY_NOEXCEPT
94 # define YY_NOTHROW throw ()
95 #endif
96 
97 // Support constexpr when possible.
98 #if 201703 <= YY_CPLUSPLUS
99 # define YY_CONSTEXPR constexpr
100 #else
101 # define YY_CONSTEXPR
102 #endif
103 
104 #include <typeinfo>
105 #ifndef YY_ASSERT
106 # include <cassert>
107 # define YY_ASSERT assert
108 #endif
109 
110 
111 #ifndef YY_ATTRIBUTE_PURE
112 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
113 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
114 # else
115 # define YY_ATTRIBUTE_PURE
116 # endif
117 #endif
118 
119 #ifndef YY_ATTRIBUTE_UNUSED
120 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
121 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
122 # else
123 # define YY_ATTRIBUTE_UNUSED
124 # endif
125 #endif
126 
127 /* Suppress unused-variable warnings by "using" E. */
128 #if ! defined lint || defined __GNUC__
129 # define YYUSE(E) ((void) (E))
130 #else
131 # define YYUSE(E) /* empty */
132 #endif
133 
134 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
135 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
136 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
137  _Pragma ("GCC diagnostic push") \
138  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
139  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
140 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
141  _Pragma ("GCC diagnostic pop")
142 #else
143 # define YY_INITIAL_VALUE(Value) Value
144 #endif
145 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
146 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
147 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
148 #endif
149 #ifndef YY_INITIAL_VALUE
150 # define YY_INITIAL_VALUE(Value) /* Nothing. */
151 #endif
152 
153 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
154 # define YY_IGNORE_USELESS_CAST_BEGIN \
155  _Pragma ("GCC diagnostic push") \
156  _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
157 # define YY_IGNORE_USELESS_CAST_END \
158  _Pragma ("GCC diagnostic pop")
159 #endif
160 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
161 # define YY_IGNORE_USELESS_CAST_BEGIN
162 # define YY_IGNORE_USELESS_CAST_END
163 #endif
164 
165 # ifndef YY_CAST
166 # ifdef __cplusplus
167 # define YY_CAST(Type, Val) static_cast<Type> (Val)
168 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
169 # else
170 # define YY_CAST(Type, Val) ((Type) (Val))
171 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
172 # endif
173 # endif
174 # ifndef YY_NULLPTR
175 # if defined __cplusplus
176 # if 201103L <= __cplusplus
177 # define YY_NULLPTR nullptr
178 # else
179 # define YY_NULLPTR 0
180 # endif
181 # else
182 # define YY_NULLPTR ((void*)0)
183 # endif
184 # endif
185 
186 /* Debug traces. */
187 #ifndef YYDEBUG
188 # define YYDEBUG 1
189 #endif
190 
191 namespace yy {
192 #line 193 "parser.hpp"
193 
194 
195 
196 
198  class parser
199  {
200  public:
201 #ifndef YYSTYPE
202  class semantic_type
208  {
209  public:
211  typedef semantic_type self_type;
212 
214  semantic_type () YY_NOEXCEPT
215  : yybuffer_ ()
216  , yytypeid_ (YY_NULLPTR)
217  {}
218 
220  template <typename T>
221  semantic_type (YY_RVREF (T) t)
222  : yytypeid_ (&typeid (T))
223  {
224  YY_ASSERT (sizeof (T) <= size);
225  new (yyas_<T> ()) T (YY_MOVE (t));
226  }
227 
229  ~semantic_type () YY_NOEXCEPT
230  {
231  YY_ASSERT (!yytypeid_);
232  }
233 
234 # if 201103L <= YY_CPLUSPLUS
235  template <typename T, typename... U>
237  T&
238  emplace (U&&... u)
239  {
240  YY_ASSERT (!yytypeid_);
241  YY_ASSERT (sizeof (T) <= size);
242  yytypeid_ = & typeid (T);
243  return *new (yyas_<T> ()) T (std::forward <U>(u)...);
244  }
245 # else
246  template <typename T>
248  T&
249  emplace ()
250  {
251  YY_ASSERT (!yytypeid_);
252  YY_ASSERT (sizeof (T) <= size);
253  yytypeid_ = & typeid (T);
254  return *new (yyas_<T> ()) T ();
255  }
256 
258  template <typename T>
259  T&
260  emplace (const T& t)
261  {
262  YY_ASSERT (!yytypeid_);
263  YY_ASSERT (sizeof (T) <= size);
264  yytypeid_ = & typeid (T);
265  return *new (yyas_<T> ()) T (t);
266  }
267 # endif
268 
271  template <typename T>
272  T&
273  build ()
274  {
275  return emplace<T> ();
276  }
277 
280  template <typename T>
281  T&
282  build (const T& t)
283  {
284  return emplace<T> (t);
285  }
286 
288  template <typename T>
289  T&
290  as () YY_NOEXCEPT
291  {
292  YY_ASSERT (yytypeid_);
293  YY_ASSERT (*yytypeid_ == typeid (T));
294  YY_ASSERT (sizeof (T) <= size);
295  return *yyas_<T> ();
296  }
297 
299  template <typename T>
300  const T&
301  as () const YY_NOEXCEPT
302  {
303  YY_ASSERT (yytypeid_);
304  YY_ASSERT (*yytypeid_ == typeid (T));
305  YY_ASSERT (sizeof (T) <= size);
306  return *yyas_<T> ();
307  }
308 
317  template <typename T>
318  void
319  swap (self_type& that) YY_NOEXCEPT
320  {
321  YY_ASSERT (yytypeid_);
322  YY_ASSERT (*yytypeid_ == *that.yytypeid_);
323  std::swap (as<T> (), that.as<T> ());
324  }
325 
329  template <typename T>
330  void
331  move (self_type& that)
332  {
333 # if 201103L <= YY_CPLUSPLUS
334  emplace<T> (std::move (that.as<T> ()));
335 # else
336  emplace<T> ();
337  swap<T> (that);
338 # endif
339  that.destroy<T> ();
340  }
341 
342 # if 201103L <= YY_CPLUSPLUS
343  template <typename T>
345  void
346  move (self_type&& that)
347  {
348  emplace<T> (std::move (that.as<T> ()));
349  that.destroy<T> ();
350  }
351 #endif
352 
354  template <typename T>
355  void
356  copy (const self_type& that)
357  {
358  emplace<T> (that.as<T> ());
359  }
360 
362  template <typename T>
363  void
364  destroy ()
365  {
366  as<T> ().~T ();
367  yytypeid_ = YY_NULLPTR;
368  }
369 
370  private:
372  self_type& operator= (const self_type&);
373  semantic_type (const self_type&);
374 
376  template <typename T>
377  T*
378  yyas_ () YY_NOEXCEPT
379  {
380  void *yyp = yybuffer_.yyraw;
381  return static_cast<T*> (yyp);
382  }
383 
385  template <typename T>
386  const T*
387  yyas_ () const YY_NOEXCEPT
388  {
389  const void *yyp = yybuffer_.yyraw;
390  return static_cast<const T*> (yyp);
391  }
392 
394  union union_type
395  {
396  // farg
397  // aarg
398  // expr
399  char dummy1[sizeof (E*)];
400 
401  // prog
402  // exprlist
403  // formals
404  // actuals
405  char dummy2[sizeof (El*)];
406 
407  // DTIME
408  char dummy3[sizeof (Global::dtime)];
409 
410  // DOUBLE
411  char dummy4[sizeof (double)];
412 
413  // STRING
414  // ERROR
415  // SYMBOL
416  char dummy5[sizeof (string)];
417 
418  // INTERVAL
419  char dummy6[sizeof (tz::interval)];
420 
421  // OP
422  char dummy7[sizeof (unsigned)];
423  };
424 
426  enum { size = sizeof (union_type) };
427 
429  union
430  {
432  long double yyalign_me;
434  char yyraw[size];
435  } yybuffer_;
436 
438  const std::type_info *yytypeid_;
439  };
440 
441 #else
442  typedef YYSTYPE semantic_type;
443 #endif
444  typedef yy::location location_type;
446 
448  struct syntax_error : std::runtime_error
449  {
450  syntax_error (const location_type& l, const std::string& m)
451  : std::runtime_error (m)
452  , location (l)
453  {}
454 
455  syntax_error (const syntax_error& s)
456  : std::runtime_error (s.what ())
457  , location (s.location)
458  {}
459 
460  ~syntax_error () YY_NOEXCEPT YY_NOTHROW;
461 
462  location_type location;
463  };
464 
466  struct token
467  {
468  enum yytokentype
469  {
470  END = 0,
471  DTIME = 258,
472  INTERVAL = 259,
473  DOUBLE = 260,
474  STRING = 261,
475  ERROR = 262,
476  NULL_ = 263,
477  ELLIPSIS = 264,
478  FUNCTION = 265,
479  SYMBOL = 266,
480  OP = 267,
481  TRUE = 268,
482  FALSE = 269,
483  LEFT_ASSIGN = 270,
484  DBL_ASSIGN = 271,
485  EQ_ASSIGN = 272,
486  IF = 273,
487  ELSE = 274,
488  FOR = 275,
489  IN = 276,
490  WHILE = 277,
491  NEXT = 278,
492  BREAK = 279,
493  EQ = 280,
494  NE = 281,
495  LT = 282,
496  LE = 283,
497  GT = 284,
498  GE = 285,
499  AND = 286,
500  OR = 287,
501  AND2 = 288,
502  OR2 = 289,
503  DOLLAR = 290,
504  PLUS = 291,
505  MINUS = 292,
506  MUL = 293,
507  DIV = 294,
508  MOD = 295,
509  POWER = 296,
510  NOT = 297,
511  LCURLY = 298,
512  RCURLY = 299,
513  LPAR = 300,
514  RPAR = 301,
515  LSQUARE = 302,
516  RSQUARE = 303,
517  LLSQUARE = 304,
518  COLON = 305,
519  COMMA = 306,
520  QUERY = 307,
521  STT = 308,
522  REF = 309,
523  ESC = 310,
524  EOA = 311,
525  EXPR = 312,
526  EMPTY_ARG = 313,
527  EMPTY_FUNCALL = 314,
528  SUBSET = 315,
529  DBLSUBSET = 316,
530  FUNCALL = 317,
531  UNOT = 318,
532  UMINUS = 319,
533  UPLUS = 320
534  };
535  };
536 
538  typedef token::yytokentype token_type;
539 
541  typedef int symbol_number_type;
542 
544  enum { empty_symbol = -2 };
545 
547  typedef signed char token_number_type;
548 
555  template <typename Base>
556  struct basic_symbol : Base
557  {
559  typedef Base super_type;
560 
562  basic_symbol ()
563  : value ()
564  , location ()
565  {}
566 
567 #if 201103L <= YY_CPLUSPLUS
568  basic_symbol (basic_symbol&& that);
570 #endif
571 
573  basic_symbol (const basic_symbol& that);
574 
576 #if 201103L <= YY_CPLUSPLUS
577  basic_symbol (typename Base::kind_type t, location_type&& l)
578  : Base (t)
579  , location (std::move (l))
580  {}
581 #else
582  basic_symbol (typename Base::kind_type t, const location_type& l)
583  : Base (t)
584  , location (l)
585  {}
586 #endif
587 #if 201103L <= YY_CPLUSPLUS
588  basic_symbol (typename Base::kind_type t, E*&& v, location_type&& l)
589  : Base (t)
590  , value (std::move (v))
591  , location (std::move (l))
592  {}
593 #else
594  basic_symbol (typename Base::kind_type t, const E*& v, const location_type& l)
595  : Base (t)
596  , value (v)
597  , location (l)
598  {}
599 #endif
600 #if 201103L <= YY_CPLUSPLUS
601  basic_symbol (typename Base::kind_type t, El*&& v, location_type&& l)
602  : Base (t)
603  , value (std::move (v))
604  , location (std::move (l))
605  {}
606 #else
607  basic_symbol (typename Base::kind_type t, const El*& v, const location_type& l)
608  : Base (t)
609  , value (v)
610  , location (l)
611  {}
612 #endif
613 #if 201103L <= YY_CPLUSPLUS
614  basic_symbol (typename Base::kind_type t, Global::dtime&& v, location_type&& l)
615  : Base (t)
616  , value (std::move (v))
617  , location (std::move (l))
618  {}
619 #else
620  basic_symbol (typename Base::kind_type t, const Global::dtime& v, const location_type& l)
621  : Base (t)
622  , value (v)
623  , location (l)
624  {}
625 #endif
626 #if 201103L <= YY_CPLUSPLUS
627  basic_symbol (typename Base::kind_type t, double&& v, location_type&& l)
628  : Base (t)
629  , value (std::move (v))
630  , location (std::move (l))
631  {}
632 #else
633  basic_symbol (typename Base::kind_type t, const double& v, const location_type& l)
634  : Base (t)
635  , value (v)
636  , location (l)
637  {}
638 #endif
639 #if 201103L <= YY_CPLUSPLUS
640  basic_symbol (typename Base::kind_type t, string&& v, location_type&& l)
641  : Base (t)
642  , value (std::move (v))
643  , location (std::move (l))
644  {}
645 #else
646  basic_symbol (typename Base::kind_type t, const string& v, const location_type& l)
647  : Base (t)
648  , value (v)
649  , location (l)
650  {}
651 #endif
652 #if 201103L <= YY_CPLUSPLUS
653  basic_symbol (typename Base::kind_type t, tz::interval&& v, location_type&& l)
654  : Base (t)
655  , value (std::move (v))
656  , location (std::move (l))
657  {}
658 #else
659  basic_symbol (typename Base::kind_type t, const tz::interval& v, const location_type& l)
660  : Base (t)
661  , value (v)
662  , location (l)
663  {}
664 #endif
665 #if 201103L <= YY_CPLUSPLUS
666  basic_symbol (typename Base::kind_type t, unsigned&& v, location_type&& l)
667  : Base (t)
668  , value (std::move (v))
669  , location (std::move (l))
670  {}
671 #else
672  basic_symbol (typename Base::kind_type t, const unsigned& v, const location_type& l)
673  : Base (t)
674  , value (v)
675  , location (l)
676  {}
677 #endif
678 
680  ~basic_symbol ()
681  {
682  clear ();
683  }
684 
686  void clear ()
687  {
688  // User destructor.
689  symbol_number_type yytype = this->type_get ();
690  basic_symbol<Base>& yysym = *this;
691  (void) yysym;
692  switch (yytype)
693  {
694  default:
695  break;
696  }
697 
698  // Type destructor.
699 switch (yytype)
700  {
701  case 70: // farg
702  case 72: // aarg
703  case 73: // expr
704  value.template destroy< E* > ();
705  break;
706 
707  case 67: // prog
708  case 68: // exprlist
709  case 69: // formals
710  case 71: // actuals
711  value.template destroy< El* > ();
712  break;
713 
714  case 3: // DTIME
715  value.template destroy< Global::dtime > ();
716  break;
717 
718  case 5: // DOUBLE
719  value.template destroy< double > ();
720  break;
721 
722  case 6: // STRING
723  case 7: // ERROR
724  case 11: // SYMBOL
725  value.template destroy< string > ();
726  break;
727 
728  case 4: // INTERVAL
729  value.template destroy< tz::interval > ();
730  break;
731 
732  case 12: // OP
733  value.template destroy< unsigned > ();
734  break;
735 
736  default:
737  break;
738  }
739 
740  Base::clear ();
741  }
742 
744  bool empty () const YY_NOEXCEPT;
745 
747  void move (basic_symbol& s);
748 
750  semantic_type value;
751 
753  location_type location;
754 
755  private:
756 #if YY_CPLUSPLUS < 201103L
757  basic_symbol& operator= (const basic_symbol& that);
759 #endif
760  };
761 
763  struct by_type
764  {
766  by_type ();
767 
768 #if 201103L <= YY_CPLUSPLUS
769  by_type (by_type&& that);
771 #endif
772 
774  by_type (const by_type& that);
775 
777  typedef token_type kind_type;
778 
780  by_type (kind_type t);
781 
783  void clear ();
784 
786  void move (by_type& that);
787 
790  symbol_number_type type_get () const YY_NOEXCEPT;
791 
795  int type;
796  };
797 
799  struct symbol_type : basic_symbol<by_type>
800  {
802  typedef basic_symbol<by_type> super_type;
803 
805  symbol_type () {}
806 
808 #if 201103L <= YY_CPLUSPLUS
809  symbol_type (int tok, location_type l)
810  : super_type(token_type (tok), std::move (l))
811  {
812  YY_ASSERT (tok == token::END || tok == token::NULL_ || tok == token::ELLIPSIS || tok == token::FUNCTION || tok == token::TRUE || tok == token::FALSE || tok == token::LEFT_ASSIGN || tok == token::DBL_ASSIGN || tok == token::EQ_ASSIGN || tok == token::IF || tok == token::ELSE || tok == token::FOR || tok == token::IN || tok == token::WHILE || tok == token::NEXT || tok == token::BREAK || tok == token::EQ || tok == token::NE || tok == token::LT || tok == token::LE || tok == token::GT || tok == token::GE || tok == token::AND || tok == token::OR || tok == token::AND2 || tok == token::OR2 || tok == token::DOLLAR || tok == token::PLUS || tok == token::MINUS || tok == token::MUL || tok == token::DIV || tok == token::MOD || tok == token::POWER || tok == token::NOT || tok == token::LCURLY || tok == token::RCURLY || tok == token::LPAR || tok == token::RPAR || tok == token::LSQUARE || tok == token::RSQUARE || tok == token::LLSQUARE || tok == token::COLON || tok == token::COMMA || tok == token::QUERY || tok == token::STT || tok == token::REF || tok == token::ESC || tok == token::EOA || tok == token::EXPR || tok == token::EMPTY_ARG || tok == token::EMPTY_FUNCALL || tok == token::SUBSET || tok == token::DBLSUBSET || tok == token::FUNCALL || tok == token::UNOT || tok == token::UMINUS || tok == token::UPLUS);
813  }
814 #else
815  symbol_type (int tok, const location_type& l)
816  : super_type(token_type (tok), l)
817  {
818  YY_ASSERT (tok == token::END || tok == token::NULL_ || tok == token::ELLIPSIS || tok == token::FUNCTION || tok == token::TRUE || tok == token::FALSE || tok == token::LEFT_ASSIGN || tok == token::DBL_ASSIGN || tok == token::EQ_ASSIGN || tok == token::IF || tok == token::ELSE || tok == token::FOR || tok == token::IN || tok == token::WHILE || tok == token::NEXT || tok == token::BREAK || tok == token::EQ || tok == token::NE || tok == token::LT || tok == token::LE || tok == token::GT || tok == token::GE || tok == token::AND || tok == token::OR || tok == token::AND2 || tok == token::OR2 || tok == token::DOLLAR || tok == token::PLUS || tok == token::MINUS || tok == token::MUL || tok == token::DIV || tok == token::MOD || tok == token::POWER || tok == token::NOT || tok == token::LCURLY || tok == token::RCURLY || tok == token::LPAR || tok == token::RPAR || tok == token::LSQUARE || tok == token::RSQUARE || tok == token::LLSQUARE || tok == token::COLON || tok == token::COMMA || tok == token::QUERY || tok == token::STT || tok == token::REF || tok == token::ESC || tok == token::EOA || tok == token::EXPR || tok == token::EMPTY_ARG || tok == token::EMPTY_FUNCALL || tok == token::SUBSET || tok == token::DBLSUBSET || tok == token::FUNCALL || tok == token::UNOT || tok == token::UMINUS || tok == token::UPLUS);
819  }
820 #endif
821 #if 201103L <= YY_CPLUSPLUS
822  symbol_type (int tok, Global::dtime v, location_type l)
823  : super_type(token_type (tok), std::move (v), std::move (l))
824  {
825  YY_ASSERT (tok == token::DTIME);
826  }
827 #else
828  symbol_type (int tok, const Global::dtime& v, const location_type& l)
829  : super_type(token_type (tok), v, l)
830  {
831  YY_ASSERT (tok == token::DTIME);
832  }
833 #endif
834 #if 201103L <= YY_CPLUSPLUS
835  symbol_type (int tok, double v, location_type l)
836  : super_type(token_type (tok), std::move (v), std::move (l))
837  {
838  YY_ASSERT (tok == token::DOUBLE);
839  }
840 #else
841  symbol_type (int tok, const double& v, const location_type& l)
842  : super_type(token_type (tok), v, l)
843  {
844  YY_ASSERT (tok == token::DOUBLE);
845  }
846 #endif
847 #if 201103L <= YY_CPLUSPLUS
848  symbol_type (int tok, string v, location_type l)
849  : super_type(token_type (tok), std::move (v), std::move (l))
850  {
851  YY_ASSERT (tok == token::STRING || tok == token::ERROR || tok == token::SYMBOL);
852  }
853 #else
854  symbol_type (int tok, const string& v, const location_type& l)
855  : super_type(token_type (tok), v, l)
856  {
857  YY_ASSERT (tok == token::STRING || tok == token::ERROR || tok == token::SYMBOL);
858  }
859 #endif
860 #if 201103L <= YY_CPLUSPLUS
861  symbol_type (int tok, tz::interval v, location_type l)
862  : super_type(token_type (tok), std::move (v), std::move (l))
863  {
864  YY_ASSERT (tok == token::INTERVAL);
865  }
866 #else
867  symbol_type (int tok, const tz::interval& v, const location_type& l)
868  : super_type(token_type (tok), v, l)
869  {
870  YY_ASSERT (tok == token::INTERVAL);
871  }
872 #endif
873 #if 201103L <= YY_CPLUSPLUS
874  symbol_type (int tok, unsigned v, location_type l)
875  : super_type(token_type (tok), std::move (v), std::move (l))
876  {
877  YY_ASSERT (tok == token::OP);
878  }
879 #else
880  symbol_type (int tok, const unsigned& v, const location_type& l)
881  : super_type(token_type (tok), v, l)
882  {
883  YY_ASSERT (tok == token::OP);
884  }
885 #endif
886  };
887 
889  parser (ParserCtx &ctx_yyarg, yyscan_t scanner_yyarg);
890  virtual ~parser ();
891 
894  int operator() ();
895 
898  virtual int parse ();
899 
900 #if YYDEBUG
901  std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
904  void set_debug_stream (std::ostream &);
905 
907  typedef int debug_level_type;
909  debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
911  void set_debug_level (debug_level_type l);
912 #endif
913 
917  virtual void error (const location_type& loc, const std::string& msg);
918 
920  void error (const syntax_error& err);
921 
922  // Implementation of make_symbol for each symbol type.
923 #if 201103L <= YY_CPLUSPLUS
924  static
925  symbol_type
926  make_END (location_type l)
927  {
928  return symbol_type (token::END, std::move (l));
929  }
930 #else
931  static
932  symbol_type
933  make_END (const location_type& l)
934  {
935  return symbol_type (token::END, l);
936  }
937 #endif
938 #if 201103L <= YY_CPLUSPLUS
939  static
940  symbol_type
941  make_DTIME (Global::dtime v, location_type l)
942  {
943  return symbol_type (token::DTIME, std::move (v), std::move (l));
944  }
945 #else
946  static
947  symbol_type
948  make_DTIME (const Global::dtime& v, const location_type& l)
949  {
950  return symbol_type (token::DTIME, v, l);
951  }
952 #endif
953 #if 201103L <= YY_CPLUSPLUS
954  static
955  symbol_type
956  make_INTERVAL (tz::interval v, location_type l)
957  {
958  return symbol_type (token::INTERVAL, std::move (v), std::move (l));
959  }
960 #else
961  static
962  symbol_type
963  make_INTERVAL (const tz::interval& v, const location_type& l)
964  {
965  return symbol_type (token::INTERVAL, v, l);
966  }
967 #endif
968 #if 201103L <= YY_CPLUSPLUS
969  static
970  symbol_type
971  make_DOUBLE (double v, location_type l)
972  {
973  return symbol_type (token::DOUBLE, std::move (v), std::move (l));
974  }
975 #else
976  static
977  symbol_type
978  make_DOUBLE (const double& v, const location_type& l)
979  {
980  return symbol_type (token::DOUBLE, v, l);
981  }
982 #endif
983 #if 201103L <= YY_CPLUSPLUS
984  static
985  symbol_type
986  make_STRING (string v, location_type l)
987  {
988  return symbol_type (token::STRING, std::move (v), std::move (l));
989  }
990 #else
991  static
992  symbol_type
993  make_STRING (const string& v, const location_type& l)
994  {
995  return symbol_type (token::STRING, v, l);
996  }
997 #endif
998 #if 201103L <= YY_CPLUSPLUS
999  static
1000  symbol_type
1001  make_ERROR (string v, location_type l)
1002  {
1003  return symbol_type (token::ERROR, std::move (v), std::move (l));
1004  }
1005 #else
1006  static
1007  symbol_type
1008  make_ERROR (const string& v, const location_type& l)
1009  {
1010  return symbol_type (token::ERROR, v, l);
1011  }
1012 #endif
1013 #if 201103L <= YY_CPLUSPLUS
1014  static
1015  symbol_type
1016  make_NULL_ (location_type l)
1017  {
1018  return symbol_type (token::NULL_, std::move (l));
1019  }
1020 #else
1021  static
1022  symbol_type
1023  make_NULL_ (const location_type& l)
1024  {
1025  return symbol_type (token::NULL_, l);
1026  }
1027 #endif
1028 #if 201103L <= YY_CPLUSPLUS
1029  static
1030  symbol_type
1031  make_ELLIPSIS (location_type l)
1032  {
1033  return symbol_type (token::ELLIPSIS, std::move (l));
1034  }
1035 #else
1036  static
1037  symbol_type
1038  make_ELLIPSIS (const location_type& l)
1039  {
1040  return symbol_type (token::ELLIPSIS, l);
1041  }
1042 #endif
1043 #if 201103L <= YY_CPLUSPLUS
1044  static
1045  symbol_type
1046  make_FUNCTION (location_type l)
1047  {
1048  return symbol_type (token::FUNCTION, std::move (l));
1049  }
1050 #else
1051  static
1052  symbol_type
1053  make_FUNCTION (const location_type& l)
1054  {
1055  return symbol_type (token::FUNCTION, l);
1056  }
1057 #endif
1058 #if 201103L <= YY_CPLUSPLUS
1059  static
1060  symbol_type
1061  make_SYMBOL (string v, location_type l)
1062  {
1063  return symbol_type (token::SYMBOL, std::move (v), std::move (l));
1064  }
1065 #else
1066  static
1067  symbol_type
1068  make_SYMBOL (const string& v, const location_type& l)
1069  {
1070  return symbol_type (token::SYMBOL, v, l);
1071  }
1072 #endif
1073 #if 201103L <= YY_CPLUSPLUS
1074  static
1075  symbol_type
1076  make_OP (unsigned v, location_type l)
1077  {
1078  return symbol_type (token::OP, std::move (v), std::move (l));
1079  }
1080 #else
1081  static
1082  symbol_type
1083  make_OP (const unsigned& v, const location_type& l)
1084  {
1085  return symbol_type (token::OP, v, l);
1086  }
1087 #endif
1088 #if 201103L <= YY_CPLUSPLUS
1089  static
1090  symbol_type
1091  make_TRUE (location_type l)
1092  {
1093  return symbol_type (token::TRUE, std::move (l));
1094  }
1095 #else
1096  static
1097  symbol_type
1098  make_TRUE (const location_type& l)
1099  {
1100  return symbol_type (token::TRUE, l);
1101  }
1102 #endif
1103 #if 201103L <= YY_CPLUSPLUS
1104  static
1105  symbol_type
1106  make_FALSE (location_type l)
1107  {
1108  return symbol_type (token::FALSE, std::move (l));
1109  }
1110 #else
1111  static
1112  symbol_type
1113  make_FALSE (const location_type& l)
1114  {
1115  return symbol_type (token::FALSE, l);
1116  }
1117 #endif
1118 #if 201103L <= YY_CPLUSPLUS
1119  static
1120  symbol_type
1121  make_LEFT_ASSIGN (location_type l)
1122  {
1123  return symbol_type (token::LEFT_ASSIGN, std::move (l));
1124  }
1125 #else
1126  static
1127  symbol_type
1128  make_LEFT_ASSIGN (const location_type& l)
1129  {
1130  return symbol_type (token::LEFT_ASSIGN, l);
1131  }
1132 #endif
1133 #if 201103L <= YY_CPLUSPLUS
1134  static
1135  symbol_type
1136  make_DBL_ASSIGN (location_type l)
1137  {
1138  return symbol_type (token::DBL_ASSIGN, std::move (l));
1139  }
1140 #else
1141  static
1142  symbol_type
1143  make_DBL_ASSIGN (const location_type& l)
1144  {
1145  return symbol_type (token::DBL_ASSIGN, l);
1146  }
1147 #endif
1148 #if 201103L <= YY_CPLUSPLUS
1149  static
1150  symbol_type
1151  make_EQ_ASSIGN (location_type l)
1152  {
1153  return symbol_type (token::EQ_ASSIGN, std::move (l));
1154  }
1155 #else
1156  static
1157  symbol_type
1158  make_EQ_ASSIGN (const location_type& l)
1159  {
1160  return symbol_type (token::EQ_ASSIGN, l);
1161  }
1162 #endif
1163 #if 201103L <= YY_CPLUSPLUS
1164  static
1165  symbol_type
1166  make_IF (location_type l)
1167  {
1168  return symbol_type (token::IF, std::move (l));
1169  }
1170 #else
1171  static
1172  symbol_type
1173  make_IF (const location_type& l)
1174  {
1175  return symbol_type (token::IF, l);
1176  }
1177 #endif
1178 #if 201103L <= YY_CPLUSPLUS
1179  static
1180  symbol_type
1181  make_ELSE (location_type l)
1182  {
1183  return symbol_type (token::ELSE, std::move (l));
1184  }
1185 #else
1186  static
1187  symbol_type
1188  make_ELSE (const location_type& l)
1189  {
1190  return symbol_type (token::ELSE, l);
1191  }
1192 #endif
1193 #if 201103L <= YY_CPLUSPLUS
1194  static
1195  symbol_type
1196  make_FOR (location_type l)
1197  {
1198  return symbol_type (token::FOR, std::move (l));
1199  }
1200 #else
1201  static
1202  symbol_type
1203  make_FOR (const location_type& l)
1204  {
1205  return symbol_type (token::FOR, l);
1206  }
1207 #endif
1208 #if 201103L <= YY_CPLUSPLUS
1209  static
1210  symbol_type
1211  make_IN (location_type l)
1212  {
1213  return symbol_type (token::IN, std::move (l));
1214  }
1215 #else
1216  static
1217  symbol_type
1218  make_IN (const location_type& l)
1219  {
1220  return symbol_type (token::IN, l);
1221  }
1222 #endif
1223 #if 201103L <= YY_CPLUSPLUS
1224  static
1225  symbol_type
1226  make_WHILE (location_type l)
1227  {
1228  return symbol_type (token::WHILE, std::move (l));
1229  }
1230 #else
1231  static
1232  symbol_type
1233  make_WHILE (const location_type& l)
1234  {
1235  return symbol_type (token::WHILE, l);
1236  }
1237 #endif
1238 #if 201103L <= YY_CPLUSPLUS
1239  static
1240  symbol_type
1241  make_NEXT (location_type l)
1242  {
1243  return symbol_type (token::NEXT, std::move (l));
1244  }
1245 #else
1246  static
1247  symbol_type
1248  make_NEXT (const location_type& l)
1249  {
1250  return symbol_type (token::NEXT, l);
1251  }
1252 #endif
1253 #if 201103L <= YY_CPLUSPLUS
1254  static
1255  symbol_type
1256  make_BREAK (location_type l)
1257  {
1258  return symbol_type (token::BREAK, std::move (l));
1259  }
1260 #else
1261  static
1262  symbol_type
1263  make_BREAK (const location_type& l)
1264  {
1265  return symbol_type (token::BREAK, l);
1266  }
1267 #endif
1268 #if 201103L <= YY_CPLUSPLUS
1269  static
1270  symbol_type
1271  make_EQ (location_type l)
1272  {
1273  return symbol_type (token::EQ, std::move (l));
1274  }
1275 #else
1276  static
1277  symbol_type
1278  make_EQ (const location_type& l)
1279  {
1280  return symbol_type (token::EQ, l);
1281  }
1282 #endif
1283 #if 201103L <= YY_CPLUSPLUS
1284  static
1285  symbol_type
1286  make_NE (location_type l)
1287  {
1288  return symbol_type (token::NE, std::move (l));
1289  }
1290 #else
1291  static
1292  symbol_type
1293  make_NE (const location_type& l)
1294  {
1295  return symbol_type (token::NE, l);
1296  }
1297 #endif
1298 #if 201103L <= YY_CPLUSPLUS
1299  static
1300  symbol_type
1301  make_LT (location_type l)
1302  {
1303  return symbol_type (token::LT, std::move (l));
1304  }
1305 #else
1306  static
1307  symbol_type
1308  make_LT (const location_type& l)
1309  {
1310  return symbol_type (token::LT, l);
1311  }
1312 #endif
1313 #if 201103L <= YY_CPLUSPLUS
1314  static
1315  symbol_type
1316  make_LE (location_type l)
1317  {
1318  return symbol_type (token::LE, std::move (l));
1319  }
1320 #else
1321  static
1322  symbol_type
1323  make_LE (const location_type& l)
1324  {
1325  return symbol_type (token::LE, l);
1326  }
1327 #endif
1328 #if 201103L <= YY_CPLUSPLUS
1329  static
1330  symbol_type
1331  make_GT (location_type l)
1332  {
1333  return symbol_type (token::GT, std::move (l));
1334  }
1335 #else
1336  static
1337  symbol_type
1338  make_GT (const location_type& l)
1339  {
1340  return symbol_type (token::GT, l);
1341  }
1342 #endif
1343 #if 201103L <= YY_CPLUSPLUS
1344  static
1345  symbol_type
1346  make_GE (location_type l)
1347  {
1348  return symbol_type (token::GE, std::move (l));
1349  }
1350 #else
1351  static
1352  symbol_type
1353  make_GE (const location_type& l)
1354  {
1355  return symbol_type (token::GE, l);
1356  }
1357 #endif
1358 #if 201103L <= YY_CPLUSPLUS
1359  static
1360  symbol_type
1361  make_AND (location_type l)
1362  {
1363  return symbol_type (token::AND, std::move (l));
1364  }
1365 #else
1366  static
1367  symbol_type
1368  make_AND (const location_type& l)
1369  {
1370  return symbol_type (token::AND, l);
1371  }
1372 #endif
1373 #if 201103L <= YY_CPLUSPLUS
1374  static
1375  symbol_type
1376  make_OR (location_type l)
1377  {
1378  return symbol_type (token::OR, std::move (l));
1379  }
1380 #else
1381  static
1382  symbol_type
1383  make_OR (const location_type& l)
1384  {
1385  return symbol_type (token::OR, l);
1386  }
1387 #endif
1388 #if 201103L <= YY_CPLUSPLUS
1389  static
1390  symbol_type
1391  make_AND2 (location_type l)
1392  {
1393  return symbol_type (token::AND2, std::move (l));
1394  }
1395 #else
1396  static
1397  symbol_type
1398  make_AND2 (const location_type& l)
1399  {
1400  return symbol_type (token::AND2, l);
1401  }
1402 #endif
1403 #if 201103L <= YY_CPLUSPLUS
1404  static
1405  symbol_type
1406  make_OR2 (location_type l)
1407  {
1408  return symbol_type (token::OR2, std::move (l));
1409  }
1410 #else
1411  static
1412  symbol_type
1413  make_OR2 (const location_type& l)
1414  {
1415  return symbol_type (token::OR2, l);
1416  }
1417 #endif
1418 #if 201103L <= YY_CPLUSPLUS
1419  static
1420  symbol_type
1421  make_DOLLAR (location_type l)
1422  {
1423  return symbol_type (token::DOLLAR, std::move (l));
1424  }
1425 #else
1426  static
1427  symbol_type
1428  make_DOLLAR (const location_type& l)
1429  {
1430  return symbol_type (token::DOLLAR, l);
1431  }
1432 #endif
1433 #if 201103L <= YY_CPLUSPLUS
1434  static
1435  symbol_type
1436  make_PLUS (location_type l)
1437  {
1438  return symbol_type (token::PLUS, std::move (l));
1439  }
1440 #else
1441  static
1442  symbol_type
1443  make_PLUS (const location_type& l)
1444  {
1445  return symbol_type (token::PLUS, l);
1446  }
1447 #endif
1448 #if 201103L <= YY_CPLUSPLUS
1449  static
1450  symbol_type
1451  make_MINUS (location_type l)
1452  {
1453  return symbol_type (token::MINUS, std::move (l));
1454  }
1455 #else
1456  static
1457  symbol_type
1458  make_MINUS (const location_type& l)
1459  {
1460  return symbol_type (token::MINUS, l);
1461  }
1462 #endif
1463 #if 201103L <= YY_CPLUSPLUS
1464  static
1465  symbol_type
1466  make_MUL (location_type l)
1467  {
1468  return symbol_type (token::MUL, std::move (l));
1469  }
1470 #else
1471  static
1472  symbol_type
1473  make_MUL (const location_type& l)
1474  {
1475  return symbol_type (token::MUL, l);
1476  }
1477 #endif
1478 #if 201103L <= YY_CPLUSPLUS
1479  static
1480  symbol_type
1481  make_DIV (location_type l)
1482  {
1483  return symbol_type (token::DIV, std::move (l));
1484  }
1485 #else
1486  static
1487  symbol_type
1488  make_DIV (const location_type& l)
1489  {
1490  return symbol_type (token::DIV, l);
1491  }
1492 #endif
1493 #if 201103L <= YY_CPLUSPLUS
1494  static
1495  symbol_type
1496  make_MOD (location_type l)
1497  {
1498  return symbol_type (token::MOD, std::move (l));
1499  }
1500 #else
1501  static
1502  symbol_type
1503  make_MOD (const location_type& l)
1504  {
1505  return symbol_type (token::MOD, l);
1506  }
1507 #endif
1508 #if 201103L <= YY_CPLUSPLUS
1509  static
1510  symbol_type
1511  make_POWER (location_type l)
1512  {
1513  return symbol_type (token::POWER, std::move (l));
1514  }
1515 #else
1516  static
1517  symbol_type
1518  make_POWER (const location_type& l)
1519  {
1520  return symbol_type (token::POWER, l);
1521  }
1522 #endif
1523 #if 201103L <= YY_CPLUSPLUS
1524  static
1525  symbol_type
1526  make_NOT (location_type l)
1527  {
1528  return symbol_type (token::NOT, std::move (l));
1529  }
1530 #else
1531  static
1532  symbol_type
1533  make_NOT (const location_type& l)
1534  {
1535  return symbol_type (token::NOT, l);
1536  }
1537 #endif
1538 #if 201103L <= YY_CPLUSPLUS
1539  static
1540  symbol_type
1541  make_LCURLY (location_type l)
1542  {
1543  return symbol_type (token::LCURLY, std::move (l));
1544  }
1545 #else
1546  static
1547  symbol_type
1548  make_LCURLY (const location_type& l)
1549  {
1550  return symbol_type (token::LCURLY, l);
1551  }
1552 #endif
1553 #if 201103L <= YY_CPLUSPLUS
1554  static
1555  symbol_type
1556  make_RCURLY (location_type l)
1557  {
1558  return symbol_type (token::RCURLY, std::move (l));
1559  }
1560 #else
1561  static
1562  symbol_type
1563  make_RCURLY (const location_type& l)
1564  {
1565  return symbol_type (token::RCURLY, l);
1566  }
1567 #endif
1568 #if 201103L <= YY_CPLUSPLUS
1569  static
1570  symbol_type
1571  make_LPAR (location_type l)
1572  {
1573  return symbol_type (token::LPAR, std::move (l));
1574  }
1575 #else
1576  static
1577  symbol_type
1578  make_LPAR (const location_type& l)
1579  {
1580  return symbol_type (token::LPAR, l);
1581  }
1582 #endif
1583 #if 201103L <= YY_CPLUSPLUS
1584  static
1585  symbol_type
1586  make_RPAR (location_type l)
1587  {
1588  return symbol_type (token::RPAR, std::move (l));
1589  }
1590 #else
1591  static
1592  symbol_type
1593  make_RPAR (const location_type& l)
1594  {
1595  return symbol_type (token::RPAR, l);
1596  }
1597 #endif
1598 #if 201103L <= YY_CPLUSPLUS
1599  static
1600  symbol_type
1601  make_LSQUARE (location_type l)
1602  {
1603  return symbol_type (token::LSQUARE, std::move (l));
1604  }
1605 #else
1606  static
1607  symbol_type
1608  make_LSQUARE (const location_type& l)
1609  {
1610  return symbol_type (token::LSQUARE, l);
1611  }
1612 #endif
1613 #if 201103L <= YY_CPLUSPLUS
1614  static
1615  symbol_type
1616  make_RSQUARE (location_type l)
1617  {
1618  return symbol_type (token::RSQUARE, std::move (l));
1619  }
1620 #else
1621  static
1622  symbol_type
1623  make_RSQUARE (const location_type& l)
1624  {
1625  return symbol_type (token::RSQUARE, l);
1626  }
1627 #endif
1628 #if 201103L <= YY_CPLUSPLUS
1629  static
1630  symbol_type
1631  make_LLSQUARE (location_type l)
1632  {
1633  return symbol_type (token::LLSQUARE, std::move (l));
1634  }
1635 #else
1636  static
1637  symbol_type
1638  make_LLSQUARE (const location_type& l)
1639  {
1640  return symbol_type (token::LLSQUARE, l);
1641  }
1642 #endif
1643 #if 201103L <= YY_CPLUSPLUS
1644  static
1645  symbol_type
1646  make_COLON (location_type l)
1647  {
1648  return symbol_type (token::COLON, std::move (l));
1649  }
1650 #else
1651  static
1652  symbol_type
1653  make_COLON (const location_type& l)
1654  {
1655  return symbol_type (token::COLON, l);
1656  }
1657 #endif
1658 #if 201103L <= YY_CPLUSPLUS
1659  static
1660  symbol_type
1661  make_COMMA (location_type l)
1662  {
1663  return symbol_type (token::COMMA, std::move (l));
1664  }
1665 #else
1666  static
1667  symbol_type
1668  make_COMMA (const location_type& l)
1669  {
1670  return symbol_type (token::COMMA, l);
1671  }
1672 #endif
1673 #if 201103L <= YY_CPLUSPLUS
1674  static
1675  symbol_type
1676  make_QUERY (location_type l)
1677  {
1678  return symbol_type (token::QUERY, std::move (l));
1679  }
1680 #else
1681  static
1682  symbol_type
1683  make_QUERY (const location_type& l)
1684  {
1685  return symbol_type (token::QUERY, l);
1686  }
1687 #endif
1688 #if 201103L <= YY_CPLUSPLUS
1689  static
1690  symbol_type
1691  make_STT (location_type l)
1692  {
1693  return symbol_type (token::STT, std::move (l));
1694  }
1695 #else
1696  static
1697  symbol_type
1698  make_STT (const location_type& l)
1699  {
1700  return symbol_type (token::STT, l);
1701  }
1702 #endif
1703 #if 201103L <= YY_CPLUSPLUS
1704  static
1705  symbol_type
1706  make_REF (location_type l)
1707  {
1708  return symbol_type (token::REF, std::move (l));
1709  }
1710 #else
1711  static
1712  symbol_type
1713  make_REF (const location_type& l)
1714  {
1715  return symbol_type (token::REF, l);
1716  }
1717 #endif
1718 #if 201103L <= YY_CPLUSPLUS
1719  static
1720  symbol_type
1721  make_ESC (location_type l)
1722  {
1723  return symbol_type (token::ESC, std::move (l));
1724  }
1725 #else
1726  static
1727  symbol_type
1728  make_ESC (const location_type& l)
1729  {
1730  return symbol_type (token::ESC, l);
1731  }
1732 #endif
1733 #if 201103L <= YY_CPLUSPLUS
1734  static
1735  symbol_type
1736  make_EOA (location_type l)
1737  {
1738  return symbol_type (token::EOA, std::move (l));
1739  }
1740 #else
1741  static
1742  symbol_type
1743  make_EOA (const location_type& l)
1744  {
1745  return symbol_type (token::EOA, l);
1746  }
1747 #endif
1748 #if 201103L <= YY_CPLUSPLUS
1749  static
1750  symbol_type
1751  make_EXPR (location_type l)
1752  {
1753  return symbol_type (token::EXPR, std::move (l));
1754  }
1755 #else
1756  static
1757  symbol_type
1758  make_EXPR (const location_type& l)
1759  {
1760  return symbol_type (token::EXPR, l);
1761  }
1762 #endif
1763 #if 201103L <= YY_CPLUSPLUS
1764  static
1765  symbol_type
1766  make_EMPTY_ARG (location_type l)
1767  {
1768  return symbol_type (token::EMPTY_ARG, std::move (l));
1769  }
1770 #else
1771  static
1772  symbol_type
1773  make_EMPTY_ARG (const location_type& l)
1774  {
1775  return symbol_type (token::EMPTY_ARG, l);
1776  }
1777 #endif
1778 #if 201103L <= YY_CPLUSPLUS
1779  static
1780  symbol_type
1781  make_EMPTY_FUNCALL (location_type l)
1782  {
1783  return symbol_type (token::EMPTY_FUNCALL, std::move (l));
1784  }
1785 #else
1786  static
1787  symbol_type
1788  make_EMPTY_FUNCALL (const location_type& l)
1789  {
1790  return symbol_type (token::EMPTY_FUNCALL, l);
1791  }
1792 #endif
1793 #if 201103L <= YY_CPLUSPLUS
1794  static
1795  symbol_type
1796  make_SUBSET (location_type l)
1797  {
1798  return symbol_type (token::SUBSET, std::move (l));
1799  }
1800 #else
1801  static
1802  symbol_type
1803  make_SUBSET (const location_type& l)
1804  {
1805  return symbol_type (token::SUBSET, l);
1806  }
1807 #endif
1808 #if 201103L <= YY_CPLUSPLUS
1809  static
1810  symbol_type
1811  make_DBLSUBSET (location_type l)
1812  {
1813  return symbol_type (token::DBLSUBSET, std::move (l));
1814  }
1815 #else
1816  static
1817  symbol_type
1818  make_DBLSUBSET (const location_type& l)
1819  {
1820  return symbol_type (token::DBLSUBSET, l);
1821  }
1822 #endif
1823 #if 201103L <= YY_CPLUSPLUS
1824  static
1825  symbol_type
1826  make_FUNCALL (location_type l)
1827  {
1828  return symbol_type (token::FUNCALL, std::move (l));
1829  }
1830 #else
1831  static
1832  symbol_type
1833  make_FUNCALL (const location_type& l)
1834  {
1835  return symbol_type (token::FUNCALL, l);
1836  }
1837 #endif
1838 #if 201103L <= YY_CPLUSPLUS
1839  static
1840  symbol_type
1841  make_UNOT (location_type l)
1842  {
1843  return symbol_type (token::UNOT, std::move (l));
1844  }
1845 #else
1846  static
1847  symbol_type
1848  make_UNOT (const location_type& l)
1849  {
1850  return symbol_type (token::UNOT, l);
1851  }
1852 #endif
1853 #if 201103L <= YY_CPLUSPLUS
1854  static
1855  symbol_type
1856  make_UMINUS (location_type l)
1857  {
1858  return symbol_type (token::UMINUS, std::move (l));
1859  }
1860 #else
1861  static
1862  symbol_type
1863  make_UMINUS (const location_type& l)
1864  {
1865  return symbol_type (token::UMINUS, l);
1866  }
1867 #endif
1868 #if 201103L <= YY_CPLUSPLUS
1869  static
1870  symbol_type
1871  make_UPLUS (location_type l)
1872  {
1873  return symbol_type (token::UPLUS, std::move (l));
1874  }
1875 #else
1876  static
1877  symbol_type
1878  make_UPLUS (const location_type& l)
1879  {
1880  return symbol_type (token::UPLUS, l);
1881  }
1882 #endif
1883 
1884 
1885  private:
1887  parser (const parser&);
1888  parser& operator= (const parser&);
1889 
1891  typedef unsigned char state_type;
1892 
1896  virtual std::string yysyntax_error_ (state_type yystate,
1897  const symbol_type& yyla) const;
1898 
1902  static state_type yy_lr_goto_state_ (state_type yystate, int yysym);
1903 
1906  static bool yy_pact_value_is_default_ (int yyvalue);
1907 
1910  static bool yy_table_value_is_error_ (int yyvalue);
1911 
1912  static const signed char yypact_ninf_;
1913  static const signed char yytable_ninf_;
1914 
1918  static token_number_type yytranslate_ (int t);
1919 
1920  // Tables.
1921  // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1922  // STATE-NUM.
1923  static const short yypact_[];
1924 
1925  // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1926  // Performed when YYTABLE does not specify something else to do. Zero
1927  // means the default is an error.
1928  static const signed char yydefact_[];
1929 
1930  // YYPGOTO[NTERM-NUM].
1931  static const signed char yypgoto_[];
1932 
1933  // YYDEFGOTO[NTERM-NUM].
1934  static const signed char yydefgoto_[];
1935 
1936  // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1937  // positive, shift that token. If negative, reduce the rule whose
1938  // number is the opposite. If YYTABLE_NINF, syntax error.
1939  static const short yytable_[];
1940 
1941  static const short yycheck_[];
1942 
1943  // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1944  // symbol of state STATE-NUM.
1945  static const signed char yystos_[];
1946 
1947  // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
1948  static const signed char yyr1_[];
1949 
1950  // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
1951  static const signed char yyr2_[];
1952 
1953 
1955  static std::string yytnamerr_ (const char *n);
1956 
1957 
1959  static const char* const yytname_[];
1960 #if YYDEBUG
1961  // YYRLINE[YYN] -- Source line where rule number YYN was defined.
1962  static const short yyrline_[];
1964  virtual void yy_reduce_print_ (int r);
1966  virtual void yystack_print_ ();
1967 
1969  int yydebug_;
1971  std::ostream* yycdebug_;
1972 
1976  template <typename Base>
1977  void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
1978 #endif
1979 
1984  template <typename Base>
1985  void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
1986 
1987  private:
1989  struct by_state
1990  {
1992  by_state () YY_NOEXCEPT;
1993 
1995  typedef state_type kind_type;
1996 
1998  by_state (kind_type s) YY_NOEXCEPT;
1999 
2001  by_state (const by_state& that) YY_NOEXCEPT;
2002 
2004  void clear () YY_NOEXCEPT;
2005 
2007  void move (by_state& that);
2008 
2011  symbol_number_type type_get () const YY_NOEXCEPT;
2012 
2015  enum { empty_state = 0 };
2016 
2019  state_type state;
2020  };
2021 
2023  struct stack_symbol_type : basic_symbol<by_state>
2024  {
2026  typedef basic_symbol<by_state> super_type;
2028  stack_symbol_type ();
2030  stack_symbol_type (YY_RVREF (stack_symbol_type) that);
2032  stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
2033 #if YY_CPLUSPLUS < 201103L
2034  stack_symbol_type& operator= (stack_symbol_type& that);
2037 
2040  stack_symbol_type& operator= (const stack_symbol_type& that);
2041 #endif
2042  };
2043 
2045  template <typename T, typename S = std::vector<T> >
2046  class stack
2047  {
2048  public:
2049  // Hide our reversed order.
2050  typedef typename S::reverse_iterator iterator;
2051  typedef typename S::const_reverse_iterator const_iterator;
2052  typedef typename S::size_type size_type;
2053  typedef typename std::ptrdiff_t index_type;
2054 
2055  stack (size_type n = 200)
2056  : seq_ (n)
2057  {}
2058 
2062  const T&
2063  operator[] (index_type i) const
2064  {
2065  return seq_[size_type (size () - 1 - i)];
2066  }
2067 
2071  T&
2072  operator[] (index_type i)
2073  {
2074  return seq_[size_type (size () - 1 - i)];
2075  }
2076 
2080  void
2081  push (YY_MOVE_REF (T) t)
2082  {
2083  seq_.push_back (T ());
2084  operator[] (0).move (t);
2085  }
2086 
2088  void
2089  pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2090  {
2091  for (; 0 < n; --n)
2092  seq_.pop_back ();
2093  }
2094 
2096  void
2097  clear () YY_NOEXCEPT
2098  {
2099  seq_.clear ();
2100  }
2101 
2103  index_type
2104  size () const YY_NOEXCEPT
2105  {
2106  return index_type (seq_.size ());
2107  }
2108 
2109  std::ptrdiff_t
2110  ssize () const YY_NOEXCEPT
2111  {
2112  return std::ptrdiff_t (size ());
2113  }
2114 
2116  const_iterator
2117  begin () const YY_NOEXCEPT
2118  {
2119  return seq_.rbegin ();
2120  }
2121 
2123  const_iterator
2124  end () const YY_NOEXCEPT
2125  {
2126  return seq_.rend ();
2127  }
2128 
2130  class slice
2131  {
2132  public:
2133  slice (const stack& stack, index_type range)
2134  : stack_ (stack)
2135  , range_ (range)
2136  {}
2137 
2138  const T&
2139  operator[] (index_type i) const
2140  {
2141  return stack_[range_ - i];
2142  }
2143 
2144  private:
2145  const stack& stack_;
2146  index_type range_;
2147  };
2148 
2149  private:
2150  stack (const stack&);
2151  stack& operator= (const stack&);
2153  S seq_;
2154  };
2155 
2156 
2158  typedef stack<stack_symbol_type> stack_type;
2159 
2161  stack_type yystack_;
2162 
2168  void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2169 
2176  void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
2177 
2179  void yypop_ (int n = 1);
2180 
2182  static const token_number_type yy_error_token_ = 1;
2183  static const token_number_type yy_undef_token_ = 2;
2184 
2186  enum
2187  {
2188  yyeof_ = 0,
2189  yylast_ = 1115,
2190  yynnts_ = 8,
2191  yyfinal_ = 42,
2192  yyntokens_ = 66
2193  };
2194 
2195 
2196  // User arguments.
2197  ParserCtx &ctx;
2198  yyscan_t scanner;
2199  };
2200 
2201  inline
2202  parser::token_number_type
2203  parser::yytranslate_ (int t)
2204  {
2205  // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to
2206  // TOKEN-NUM as returned by yylex.
2207  static
2208  const token_number_type
2209  translate_table[] =
2210  {
2211  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2212  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2213  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2214  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2215  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2216  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2217  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2218  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2219  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2220  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2221  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2222  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2223  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2224  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2225  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2226  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2227  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2228  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2229  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2230  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2231  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2232  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2233  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2234  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2235  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2236  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2237  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2238  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2239  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2240  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2241  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2242  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2243  65
2244  };
2245  const int user_token_number_max_ = 320;
2246 
2247  if (t <= 0)
2248  return yyeof_;
2249  else if (t <= user_token_number_max_)
2250  return translate_table[t];
2251  else
2252  return yy_undef_token_;
2253  }
2254 
2255  // basic_symbol.
2256 #if 201103L <= YY_CPLUSPLUS
2257  template <typename Base>
2258  parser::basic_symbol<Base>::basic_symbol (basic_symbol&& that)
2259  : Base (std::move (that))
2260  , value ()
2261  , location (std::move (that.location))
2262  {
2263  switch (this->type_get ())
2264  {
2265  case 70: // farg
2266  case 72: // aarg
2267  case 73: // expr
2268  value.move< E* > (std::move (that.value));
2269  break;
2270 
2271  case 67: // prog
2272  case 68: // exprlist
2273  case 69: // formals
2274  case 71: // actuals
2275  value.move< El* > (std::move (that.value));
2276  break;
2277 
2278  case 3: // DTIME
2279  value.move< Global::dtime > (std::move (that.value));
2280  break;
2281 
2282  case 5: // DOUBLE
2283  value.move< double > (std::move (that.value));
2284  break;
2285 
2286  case 6: // STRING
2287  case 7: // ERROR
2288  case 11: // SYMBOL
2289  value.move< string > (std::move (that.value));
2290  break;
2291 
2292  case 4: // INTERVAL
2293  value.move< tz::interval > (std::move (that.value));
2294  break;
2295 
2296  case 12: // OP
2297  value.move< unsigned > (std::move (that.value));
2298  break;
2299 
2300  default:
2301  break;
2302  }
2303 
2304  }
2305 #endif
2306 
2307  template <typename Base>
2308  parser::basic_symbol<Base>::basic_symbol (const basic_symbol& that)
2309  : Base (that)
2310  , value ()
2311  , location (that.location)
2312  {
2313  switch (this->type_get ())
2314  {
2315  case 70: // farg
2316  case 72: // aarg
2317  case 73: // expr
2318  value.copy< E* > (YY_MOVE (that.value));
2319  break;
2320 
2321  case 67: // prog
2322  case 68: // exprlist
2323  case 69: // formals
2324  case 71: // actuals
2325  value.copy< El* > (YY_MOVE (that.value));
2326  break;
2327 
2328  case 3: // DTIME
2329  value.copy< Global::dtime > (YY_MOVE (that.value));
2330  break;
2331 
2332  case 5: // DOUBLE
2333  value.copy< double > (YY_MOVE (that.value));
2334  break;
2335 
2336  case 6: // STRING
2337  case 7: // ERROR
2338  case 11: // SYMBOL
2339  value.copy< string > (YY_MOVE (that.value));
2340  break;
2341 
2342  case 4: // INTERVAL
2343  value.copy< tz::interval > (YY_MOVE (that.value));
2344  break;
2345 
2346  case 12: // OP
2347  value.copy< unsigned > (YY_MOVE (that.value));
2348  break;
2349 
2350  default:
2351  break;
2352  }
2353 
2354  }
2355 
2356 
2357 
2358  template <typename Base>
2359  bool
2360  parser::basic_symbol<Base>::empty () const YY_NOEXCEPT
2361  {
2362  return Base::type_get () == empty_symbol;
2363  }
2364 
2365  template <typename Base>
2366  void
2367  parser::basic_symbol<Base>::move (basic_symbol& s)
2368  {
2369  super_type::move (s);
2370  switch (this->type_get ())
2371  {
2372  case 70: // farg
2373  case 72: // aarg
2374  case 73: // expr
2375  value.move< E* > (YY_MOVE (s.value));
2376  break;
2377 
2378  case 67: // prog
2379  case 68: // exprlist
2380  case 69: // formals
2381  case 71: // actuals
2382  value.move< El* > (YY_MOVE (s.value));
2383  break;
2384 
2385  case 3: // DTIME
2386  value.move< Global::dtime > (YY_MOVE (s.value));
2387  break;
2388 
2389  case 5: // DOUBLE
2390  value.move< double > (YY_MOVE (s.value));
2391  break;
2392 
2393  case 6: // STRING
2394  case 7: // ERROR
2395  case 11: // SYMBOL
2396  value.move< string > (YY_MOVE (s.value));
2397  break;
2398 
2399  case 4: // INTERVAL
2400  value.move< tz::interval > (YY_MOVE (s.value));
2401  break;
2402 
2403  case 12: // OP
2404  value.move< unsigned > (YY_MOVE (s.value));
2405  break;
2406 
2407  default:
2408  break;
2409  }
2410 
2411  location = YY_MOVE (s.location);
2412  }
2413 
2414  // by_type.
2415  inline
2416  parser::by_type::by_type ()
2417  : type (empty_symbol)
2418  {}
2419 
2420 #if 201103L <= YY_CPLUSPLUS
2421  inline
2422  parser::by_type::by_type (by_type&& that)
2423  : type (that.type)
2424  {
2425  that.clear ();
2426  }
2427 #endif
2428 
2429  inline
2430  parser::by_type::by_type (const by_type& that)
2431  : type (that.type)
2432  {}
2433 
2434  inline
2435  parser::by_type::by_type (token_type t)
2436  : type (yytranslate_ (t))
2437  {}
2438 
2439  inline
2440  void
2441  parser::by_type::clear ()
2442  {
2443  type = empty_symbol;
2444  }
2445 
2446  inline
2447  void
2448  parser::by_type::move (by_type& that)
2449  {
2450  type = that.type;
2451  that.clear ();
2452  }
2453 
2454  inline
2455  int
2456  parser::by_type::type_get () const YY_NOEXCEPT
2457  {
2458  return type;
2459  }
2460 
2461 } // yy
2462 #line 2463 "parser.hpp"
2463 
2464 
2465 
2466 
2467 
2468 #endif // !YY_YY_PARSER_HPP_INCLUDED
E
Definition: ast.hpp:76
yy::parser::semantic_type::semantic_type
semantic_type() YY_NOEXCEPT
Empty construction.
Definition: parser.hpp:214
yy::parser::basic_symbol::~basic_symbol
~basic_symbol()
Destroy the symbol.
Definition: parser.hpp:680
yy::parser::token_number_type
signed char token_number_type
Internal symbol number for tokens (subsumed by symbol_number_type).
Definition: parser.hpp:547
yy::parser::basic_symbol::empty
bool empty() const YY_NOEXCEPT
Whether empty.
Definition: parser.hpp:2360
yy::parser::basic_symbol::move
void move(basic_symbol &s)
Destructive move, s is emptied into this.
Definition: parser.hpp:2367
yy::parser::basic_symbol::clear
void clear()
Destroy contents, and record that is empty.
Definition: parser.hpp:686
yy::parser::parser
parser(ParserCtx &ctx_yyarg, yyscan_t scanner_yyarg)
Build a parser object.
Definition: parser.cpp:193
El
Definition: ast.hpp:145
yy::parser::by_type::type_get
symbol_number_type type_get() const YY_NOEXCEPT
Definition: parser.hpp:2456
yy::parser::basic_symbol::basic_symbol
basic_symbol()
Default constructor.
Definition: parser.hpp:562
yy::parser::semantic_type::emplace
T & emplace()
Instantiate an empty T in here.
Definition: parser.hpp:249
yy::parser::semantic_type::as
T & as() YY_NOEXCEPT
Accessor to a built T.
Definition: parser.hpp:290
yy::parser::semantic_type::as
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
Definition: parser.hpp:301
yy::parser::stack::slice
Present a slice of the top of a stack.
Definition: parser.hpp:2130
yy::parser::semantic_type::move
void move(self_type &that)
Definition: parser.hpp:331
yy::parser::symbol_type::symbol_type
symbol_type()
Empty symbol.
Definition: parser.hpp:805
yy::parser::by_type::type
int type
Definition: parser.hpp:795
yy::parser::by_type::by_type
by_type()
Default constructor.
Definition: parser.hpp:2416
ParserCtx
Definition: parser_ctx.hpp:27
tz::interval
Definition: interval.hpp:31
yy::parser::error
virtual void error(const location_type &loc, const std::string &msg)
Definition: parser.cpp:2010
yy::location
Abstract a location.
Definition: location.hpp:54
yy::parser::basic_symbol
Definition: parser.hpp:556
yy::parser::debug_stream
std::ostream & debug_stream() const YY_ATTRIBUTE_PURE
The current debugging stream.
Definition: parser.cpp:512
yy::parser::operator()
int operator()()
Definition: parser.cpp:560
yy::parser::token_type
token::yytokentype token_type
(External) token type, as returned by yylex.
Definition: parser.hpp:538
yy::parser::by_type::clear
void clear()
Record that this symbol is empty.
Definition: parser.hpp:2441
yy::parser::debug_level
debug_level_type debug_level() const YY_ATTRIBUTE_PURE
The current debugging level.
Definition: parser.cpp:525
cfgyy::parser::semantic_type
Definition: cfgparser.hpp:213
yy::parser::semantic_type::yyalign_me
long double yyalign_me
Strongest alignment constraints.
Definition: parser.hpp:432
yy::parser::semantic_type::yyraw
char yyraw[size]
A buffer large enough to store any of the semantic values.
Definition: parser.hpp:434
yy::parser::semantic_type::~semantic_type
~semantic_type() YY_NOEXCEPT
Destruction, allowed only if empty.
Definition: parser.hpp:229
yy::parser::parse
virtual int parse()
Definition: parser.cpp:566
yy::parser::basic_symbol::value
semantic_type value
The semantic value.
Definition: parser.hpp:750
yy::parser::semantic_type
Definition: parser.hpp:207
location.hpp
yy::parser::basic_symbol::basic_symbol
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructor for valueless symbols, and symbols from each type.
Definition: parser.hpp:582
yy::parser
A Bison parser.
Definition: parser.hpp:198
yy::parser::by_type::kind_type
token_type kind_type
The symbol type as needed by the constructor.
Definition: parser.hpp:777
yy::parser::location_type
yy::location location_type
Symbol locations.
Definition: parser.hpp:445
yy::parser::basic_symbol::super_type
Base super_type
Alias to Base.
Definition: parser.hpp:559
yy::parser::semantic_type::build
T & build(const T &t)
Definition: parser.hpp:282
yy::parser::semantic_type::emplace
T & emplace(const T &t)
Instantiate a T in here from t.
Definition: parser.hpp:260
yy::parser::basic_symbol::location
location_type location
The location.
Definition: parser.hpp:753
yy::parser::token
Tokens.
Definition: parser.hpp:466
yy::parser::symbol_type::symbol_type
symbol_type(int tok, const location_type &l)
Constructor for valueless symbols, and symbols from each type.
Definition: parser.hpp:815
yy::parser::symbol_type
"External" symbols: returned by the scanner.
Definition: parser.hpp:799
state
Definition: tz.hpp:51
yy::parser::semantic_type::destroy
void destroy()
Destroy the stored T.
Definition: parser.hpp:364
yy::parser::semantic_type::semantic_type
semantic_type(YY_RVREF(T) t)
Construct and fill.
Definition: parser.hpp:221
yy::parser::by_type::move
void move(by_type &that)
Steal the symbol type from that.
Definition: parser.hpp:2448
yy::parser::symbol_type::super_type
basic_symbol< by_type > super_type
Superclass.
Definition: parser.hpp:802
yy::parser::by_type
Type access provider for token (enum) based symbols.
Definition: parser.hpp:763
yy::parser::symbol_number_type
int symbol_number_type
Symbol type: an internal symbol number.
Definition: parser.hpp:541
yy::parser::semantic_type::build
T & build()
Definition: parser.hpp:273
yy::parser::syntax_error
Syntax errors thrown from user actions.
Definition: parser.hpp:448
yy::parser::set_debug_stream
void set_debug_stream(std::ostream &)
Set the current debugging stream.
Definition: parser.cpp:518
yy::parser::semantic_type::swap
void swap(self_type &that) YY_NOEXCEPT
Definition: parser.hpp:319
yy::parser::semantic_type::copy
void copy(const self_type &that)
Copy the content of that to this.
Definition: parser.hpp:356
yy::parser::semantic_type::self_type
semantic_type self_type
Type of *this.
Definition: parser.hpp:211
yy::parser::debug_level_type
int debug_level_type
Type for debugging levels.
Definition: parser.hpp:907
yy::parser::set_debug_level
void set_debug_level(debug_level_type l)
Set the current debugging level.
Definition: parser.cpp:531
Generated on Sun Jul 5 2020 18:04:52 for ztsdb by   doxygen 1.8.17