1 // A Bison parser, made by GNU Bison 3.5.1.
2
3 // Skeleton implementation 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 // Undocumented macros, especially those whose name start with YY_,
34 // are private implementation details. Do not rely on them.
35
36
37
38
39
40 #include "sqlite3_parser.hpp"
41
42
43 // Unqualified %code blocks.
44 #line 88 "sqlite3_parser.yy"
45
46 #include "ParserDriver.h"
47
unquote_text(std::string str,char quote_char)48 static std::string unquote_text(std::string str, char quote_char)
49 {
50 if(str.front() != quote_char || str.back() != quote_char)
51 return str;
52
53 str = str.substr(1, str.size()-2);
54
55 std::string quote(2, quote_char);
56
57 size_t pos = 0;
58 while((pos = str.find(quote, pos)) != std::string::npos)
59 {
60 str.erase(pos, 1);
61 pos += 1; // Don't remove the other quote char too
62 }
63 return str;
64 }
65
66 #line 67 "sqlite3_parser.cpp"
67
68
69 #ifndef YY_
70 # if defined YYENABLE_NLS && YYENABLE_NLS
71 # if ENABLE_NLS
72 # include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
73 # define YY_(msgid) dgettext ("bison-runtime", msgid)
74 # endif
75 # endif
76 # ifndef YY_
77 # define YY_(msgid) msgid
78 # endif
79 #endif
80
81 // Whether we are compiled with exception support.
82 #ifndef YY_EXCEPTIONS
83 # if defined __GNUC__ && !defined __EXCEPTIONS
84 # define YY_EXCEPTIONS 0
85 # else
86 # define YY_EXCEPTIONS 1
87 # endif
88 #endif
89
90 #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
91 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
92 If N is 0, then set CURRENT to the empty location which ends
93 the previous symbol: RHS[0] (always defined). */
94
95 # ifndef YYLLOC_DEFAULT
96 # define YYLLOC_DEFAULT(Current, Rhs, N) \
97 do \
98 if (N) \
99 { \
100 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
101 (Current).end = YYRHSLOC (Rhs, N).end; \
102 } \
103 else \
104 { \
105 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
106 } \
107 while (false)
108 # endif
109
110
111 // Enable debugging if requested.
112 #if YYDEBUG
113
114 // A pseudo ostream that takes yydebug_ into account.
115 # define YYCDEBUG if (yydebug_) (*yycdebug_)
116
117 # define YY_SYMBOL_PRINT(Title, Symbol) \
118 do { \
119 if (yydebug_) \
120 { \
121 *yycdebug_ << Title << ' '; \
122 yy_print_ (*yycdebug_, Symbol); \
123 *yycdebug_ << '\n'; \
124 } \
125 } while (false)
126
127 # define YY_REDUCE_PRINT(Rule) \
128 do { \
129 if (yydebug_) \
130 yy_reduce_print_ (Rule); \
131 } while (false)
132
133 # define YY_STACK_PRINT() \
134 do { \
135 if (yydebug_) \
136 yystack_print_ (); \
137 } while (false)
138
139 #else // !YYDEBUG
140
141 # define YYCDEBUG if (false) std::cerr
142 # define YY_SYMBOL_PRINT(Title, Symbol) YYUSE (Symbol)
143 # define YY_REDUCE_PRINT(Rule) static_cast<void> (0)
144 # define YY_STACK_PRINT() static_cast<void> (0)
145
146 #endif // !YYDEBUG
147
148 #define yyerrok (yyerrstatus_ = 0)
149 #define yyclearin (yyla.clear ())
150
151 #define YYACCEPT goto yyacceptlab
152 #define YYABORT goto yyabortlab
153 #define YYERROR goto yyerrorlab
154 #define YYRECOVERING() (!!yyerrstatus_)
155
156 #line 10 "sqlite3_parser.yy"
157 namespace sqlb { namespace parser {
158 #line 159 "sqlite3_parser.cpp"
159
160
161 /* Return YYSTR after stripping away unnecessary quotes and
162 backslashes, so that it's suitable for yyerror. The heuristic is
163 that double-quoting is unnecessary unless the string contains an
164 apostrophe, a comma, or backslash (other than backslash-backslash).
165 YYSTR is taken from yytname. */
166 std::string
yytnamerr_(const char * yystr)167 parser::yytnamerr_ (const char *yystr)
168 {
169 if (*yystr == '"')
170 {
171 std::string yyr;
172 char const *yyp = yystr;
173
174 for (;;)
175 switch (*++yyp)
176 {
177 case '\'':
178 case ',':
179 goto do_not_strip_quotes;
180
181 case '\\':
182 if (*++yyp != '\\')
183 goto do_not_strip_quotes;
184 else
185 goto append;
186
187 append:
188 default:
189 yyr += *yyp;
190 break;
191
192 case '"':
193 return yyr;
194 }
195 do_not_strip_quotes: ;
196 }
197
198 return yystr;
199 }
200
201
202 /// Build a parser object.
parser(yyscan_t yyscanner_yyarg,ParserDriver & drv_yyarg)203 parser::parser (yyscan_t yyscanner_yyarg, ParserDriver& drv_yyarg)
204 #if YYDEBUG
205 : yydebug_ (false),
206 yycdebug_ (&std::cerr),
207 #else
208 :
209 #endif
210 yyscanner (yyscanner_yyarg),
211 drv (drv_yyarg)
212 {}
213
~parser()214 parser::~parser ()
215 {}
216
~syntax_error()217 parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW
218 {}
219
220 /*---------------.
221 | Symbol types. |
222 `---------------*/
223
224
225
226 // by_state.
by_state()227 parser::by_state::by_state () YY_NOEXCEPT
228 : state (empty_state)
229 {}
230
by_state(const by_state & that)231 parser::by_state::by_state (const by_state& that) YY_NOEXCEPT
232 : state (that.state)
233 {}
234
235 void
clear()236 parser::by_state::clear () YY_NOEXCEPT
237 {
238 state = empty_state;
239 }
240
241 void
move(by_state & that)242 parser::by_state::move (by_state& that)
243 {
244 state = that.state;
245 that.clear ();
246 }
247
by_state(state_type s)248 parser::by_state::by_state (state_type s) YY_NOEXCEPT
249 : state (s)
250 {}
251
252 parser::symbol_number_type
type_get() const253 parser::by_state::type_get () const YY_NOEXCEPT
254 {
255 if (state == empty_state)
256 return empty_symbol;
257 else
258 return yystos_[+state];
259 }
260
stack_symbol_type()261 parser::stack_symbol_type::stack_symbol_type ()
262 {}
263
stack_symbol_type(YY_RVREF (stack_symbol_type)that)264 parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
265 : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
266 {
267 switch (that.type_get ())
268 {
269 case 158: // columnconstraint
270 value.YY_MOVE_OR_COPY< ColumnConstraintInfo > (YY_MOVE (that.value));
271 break;
272
273 case 159: // columnconstraint_list
274 value.YY_MOVE_OR_COPY< ColumnConstraintInfoVector > (YY_MOVE (that.value));
275 break;
276
277 case 160: // columndef
278 value.YY_MOVE_OR_COPY< ColumndefData > (YY_MOVE (that.value));
279 break;
280
281 case 142: // optional_if_not_exists
282 case 144: // optional_unique
283 case 152: // optional_temporary
284 case 153: // optional_withoutrowid
285 case 157: // optional_always_generated
286 value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
287 break;
288
289 case 168: // tableconstraint
290 value.YY_MOVE_OR_COPY< sqlb::ConstraintPtr > (YY_MOVE (that.value));
291 break;
292
293 case 169: // tableconstraint_list
294 case 170: // optional_tableconstraint_list
295 value.YY_MOVE_OR_COPY< sqlb::ConstraintSet > (YY_MOVE (that.value));
296 break;
297
298 case 149: // createindex_stmt
299 value.YY_MOVE_OR_COPY< sqlb::IndexPtr > (YY_MOVE (that.value));
300 break;
301
302 case 147: // indexed_column
303 value.YY_MOVE_OR_COPY< sqlb::IndexedColumn > (YY_MOVE (that.value));
304 break;
305
306 case 148: // indexed_column_list
307 value.YY_MOVE_OR_COPY< sqlb::IndexedColumnVector > (YY_MOVE (that.value));
308 break;
309
310 case 163: // columnid_list
311 case 164: // optional_columnid_with_paren_list
312 value.YY_MOVE_OR_COPY< sqlb::StringVector > (YY_MOVE (that.value));
313 break;
314
315 case 151: // createvirtualtable_stmt
316 case 171: // createtable_stmt
317 value.YY_MOVE_OR_COPY< sqlb::TablePtr > (YY_MOVE (that.value));
318 break;
319
320 case 27: // "ABORT"
321 case 28: // "ACTION"
322 case 29: // "ALWAYS"
323 case 30: // "AND"
324 case 31: // "AND BETWEEN"
325 case 32: // "AS"
326 case 33: // "ASC"
327 case 34: // "AUTOINCREMENT"
328 case 35: // "BETWEEN"
329 case 36: // "CASCADE"
330 case 37: // "CASE"
331 case 38: // "CAST"
332 case 39: // "CHECK"
333 case 40: // "COLLATE"
334 case 41: // "CONFLICT"
335 case 42: // "CONSTRAINT"
336 case 43: // "CREATE"
337 case 44: // "CURRENT_DATE"
338 case 45: // "CURRENT_TIME"
339 case 46: // "CURRENT_TIMESTAMP"
340 case 47: // "DEFAULT"
341 case 48: // "DEFERRABLE"
342 case 49: // "DEFERRED"
343 case 50: // "DELETE"
344 case 51: // "DESC"
345 case 52: // "DISTINCT"
346 case 53: // "ELSE"
347 case 54: // "END"
348 case 55: // "ESCAPE"
349 case 56: // "EXISTS"
350 case 57: // "FAIL"
351 case 58: // "FALSE"
352 case 59: // "FILTER"
353 case 60: // "FOLLOWING"
354 case 61: // "FOREIGN"
355 case 62: // "GENERATED"
356 case 63: // "GLOB"
357 case 64: // "IF"
358 case 65: // "IGNORE"
359 case 66: // "IMMEDIATE"
360 case 67: // "IN"
361 case 68: // "INDEX"
362 case 69: // "INITIALLY"
363 case 70: // "INSERT"
364 case 71: // "IS"
365 case 72: // "ISNULL"
366 case 73: // "KEY"
367 case 74: // "LIKE"
368 case 75: // "MATCH"
369 case 76: // "NO"
370 case 77: // "NOT"
371 case 78: // "NOTNULL"
372 case 79: // "NULL"
373 case 80: // "ON"
374 case 81: // "OR"
375 case 82: // "OVER"
376 case 83: // "PARTITION"
377 case 84: // "PRECEDING"
378 case 85: // "PRIMARY"
379 case 86: // "RAISE"
380 case 87: // "RANGE"
381 case 88: // "REFERENCES"
382 case 89: // "REGEXP"
383 case 90: // "REPLACE"
384 case 91: // "RESTRICT"
385 case 92: // "ROLLBACK"
386 case 93: // "ROWID"
387 case 94: // "ROWS"
388 case 95: // "SELECT"
389 case 96: // "SET"
390 case 97: // "STORED"
391 case 98: // "TABLE"
392 case 99: // "TEMP"
393 case 100: // "TEMPORARY"
394 case 101: // "THEN"
395 case 102: // "TRUE"
396 case 103: // "UNBOUNDED"
397 case 104: // "UNIQUE"
398 case 105: // "UPDATE"
399 case 106: // "USING"
400 case 107: // "VIRTUAL"
401 case 108: // "WHEN"
402 case 109: // "WHERE"
403 case 110: // "WITHOUT"
404 case 111: // "identifier"
405 case 112: // "numeric"
406 case 113: // "string literal"
407 case 114: // "quoted literal"
408 case 115: // "blob literal"
409 case 116: // "bind parameter"
410 case 120: // literalvalue
411 case 121: // id
412 case 122: // allowed_keywords_as_identifier
413 case 123: // tableid
414 case 124: // columnid
415 case 125: // signednumber
416 case 126: // signednumber_or_numeric
417 case 127: // typename_namelist
418 case 128: // type_name
419 case 129: // unary_expr
420 case 130: // binary_expr
421 case 131: // like_expr
422 case 132: // exprlist_expr
423 case 133: // function_expr
424 case 134: // isnull_expr
425 case 135: // between_expr
426 case 136: // in_expr
427 case 137: // whenthenlist_expr
428 case 138: // case_expr
429 case 139: // raise_expr
430 case 140: // expr
431 case 141: // select_stmt
432 case 143: // optional_sort_order
433 case 145: // optional_where
434 case 146: // tableid_with_uninteresting_schema
435 case 150: // optional_exprlist_with_paren
436 case 154: // optional_conflictclause
437 case 155: // optional_typename
438 case 156: // optional_storage_identifier
439 case 162: // optional_constraintname
440 case 165: // fk_clause_part
441 case 166: // fk_clause_part_list
442 case 167: // optional_fk_clause
443 value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
444 break;
445
446 case 161: // columndef_list
447 value.YY_MOVE_OR_COPY< std::vector<ColumndefData> > (YY_MOVE (that.value));
448 break;
449
450 default:
451 break;
452 }
453
454 #if 201103L <= YY_CPLUSPLUS
455 // that is emptied.
456 that.state = empty_state;
457 #endif
458 }
459
stack_symbol_type(state_type s,YY_MOVE_REF (symbol_type)that)460 parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
461 : super_type (s, YY_MOVE (that.location))
462 {
463 switch (that.type_get ())
464 {
465 case 158: // columnconstraint
466 value.move< ColumnConstraintInfo > (YY_MOVE (that.value));
467 break;
468
469 case 159: // columnconstraint_list
470 value.move< ColumnConstraintInfoVector > (YY_MOVE (that.value));
471 break;
472
473 case 160: // columndef
474 value.move< ColumndefData > (YY_MOVE (that.value));
475 break;
476
477 case 142: // optional_if_not_exists
478 case 144: // optional_unique
479 case 152: // optional_temporary
480 case 153: // optional_withoutrowid
481 case 157: // optional_always_generated
482 value.move< bool > (YY_MOVE (that.value));
483 break;
484
485 case 168: // tableconstraint
486 value.move< sqlb::ConstraintPtr > (YY_MOVE (that.value));
487 break;
488
489 case 169: // tableconstraint_list
490 case 170: // optional_tableconstraint_list
491 value.move< sqlb::ConstraintSet > (YY_MOVE (that.value));
492 break;
493
494 case 149: // createindex_stmt
495 value.move< sqlb::IndexPtr > (YY_MOVE (that.value));
496 break;
497
498 case 147: // indexed_column
499 value.move< sqlb::IndexedColumn > (YY_MOVE (that.value));
500 break;
501
502 case 148: // indexed_column_list
503 value.move< sqlb::IndexedColumnVector > (YY_MOVE (that.value));
504 break;
505
506 case 163: // columnid_list
507 case 164: // optional_columnid_with_paren_list
508 value.move< sqlb::StringVector > (YY_MOVE (that.value));
509 break;
510
511 case 151: // createvirtualtable_stmt
512 case 171: // createtable_stmt
513 value.move< sqlb::TablePtr > (YY_MOVE (that.value));
514 break;
515
516 case 27: // "ABORT"
517 case 28: // "ACTION"
518 case 29: // "ALWAYS"
519 case 30: // "AND"
520 case 31: // "AND BETWEEN"
521 case 32: // "AS"
522 case 33: // "ASC"
523 case 34: // "AUTOINCREMENT"
524 case 35: // "BETWEEN"
525 case 36: // "CASCADE"
526 case 37: // "CASE"
527 case 38: // "CAST"
528 case 39: // "CHECK"
529 case 40: // "COLLATE"
530 case 41: // "CONFLICT"
531 case 42: // "CONSTRAINT"
532 case 43: // "CREATE"
533 case 44: // "CURRENT_DATE"
534 case 45: // "CURRENT_TIME"
535 case 46: // "CURRENT_TIMESTAMP"
536 case 47: // "DEFAULT"
537 case 48: // "DEFERRABLE"
538 case 49: // "DEFERRED"
539 case 50: // "DELETE"
540 case 51: // "DESC"
541 case 52: // "DISTINCT"
542 case 53: // "ELSE"
543 case 54: // "END"
544 case 55: // "ESCAPE"
545 case 56: // "EXISTS"
546 case 57: // "FAIL"
547 case 58: // "FALSE"
548 case 59: // "FILTER"
549 case 60: // "FOLLOWING"
550 case 61: // "FOREIGN"
551 case 62: // "GENERATED"
552 case 63: // "GLOB"
553 case 64: // "IF"
554 case 65: // "IGNORE"
555 case 66: // "IMMEDIATE"
556 case 67: // "IN"
557 case 68: // "INDEX"
558 case 69: // "INITIALLY"
559 case 70: // "INSERT"
560 case 71: // "IS"
561 case 72: // "ISNULL"
562 case 73: // "KEY"
563 case 74: // "LIKE"
564 case 75: // "MATCH"
565 case 76: // "NO"
566 case 77: // "NOT"
567 case 78: // "NOTNULL"
568 case 79: // "NULL"
569 case 80: // "ON"
570 case 81: // "OR"
571 case 82: // "OVER"
572 case 83: // "PARTITION"
573 case 84: // "PRECEDING"
574 case 85: // "PRIMARY"
575 case 86: // "RAISE"
576 case 87: // "RANGE"
577 case 88: // "REFERENCES"
578 case 89: // "REGEXP"
579 case 90: // "REPLACE"
580 case 91: // "RESTRICT"
581 case 92: // "ROLLBACK"
582 case 93: // "ROWID"
583 case 94: // "ROWS"
584 case 95: // "SELECT"
585 case 96: // "SET"
586 case 97: // "STORED"
587 case 98: // "TABLE"
588 case 99: // "TEMP"
589 case 100: // "TEMPORARY"
590 case 101: // "THEN"
591 case 102: // "TRUE"
592 case 103: // "UNBOUNDED"
593 case 104: // "UNIQUE"
594 case 105: // "UPDATE"
595 case 106: // "USING"
596 case 107: // "VIRTUAL"
597 case 108: // "WHEN"
598 case 109: // "WHERE"
599 case 110: // "WITHOUT"
600 case 111: // "identifier"
601 case 112: // "numeric"
602 case 113: // "string literal"
603 case 114: // "quoted literal"
604 case 115: // "blob literal"
605 case 116: // "bind parameter"
606 case 120: // literalvalue
607 case 121: // id
608 case 122: // allowed_keywords_as_identifier
609 case 123: // tableid
610 case 124: // columnid
611 case 125: // signednumber
612 case 126: // signednumber_or_numeric
613 case 127: // typename_namelist
614 case 128: // type_name
615 case 129: // unary_expr
616 case 130: // binary_expr
617 case 131: // like_expr
618 case 132: // exprlist_expr
619 case 133: // function_expr
620 case 134: // isnull_expr
621 case 135: // between_expr
622 case 136: // in_expr
623 case 137: // whenthenlist_expr
624 case 138: // case_expr
625 case 139: // raise_expr
626 case 140: // expr
627 case 141: // select_stmt
628 case 143: // optional_sort_order
629 case 145: // optional_where
630 case 146: // tableid_with_uninteresting_schema
631 case 150: // optional_exprlist_with_paren
632 case 154: // optional_conflictclause
633 case 155: // optional_typename
634 case 156: // optional_storage_identifier
635 case 162: // optional_constraintname
636 case 165: // fk_clause_part
637 case 166: // fk_clause_part_list
638 case 167: // optional_fk_clause
639 value.move< std::string > (YY_MOVE (that.value));
640 break;
641
642 case 161: // columndef_list
643 value.move< std::vector<ColumndefData> > (YY_MOVE (that.value));
644 break;
645
646 default:
647 break;
648 }
649
650 // that is emptied.
651 that.type = empty_symbol;
652 }
653
654 #if YY_CPLUSPLUS < 201103L
655 parser::stack_symbol_type&
operator =(const stack_symbol_type & that)656 parser::stack_symbol_type::operator= (const stack_symbol_type& that)
657 {
658 state = that.state;
659 switch (that.type_get ())
660 {
661 case 158: // columnconstraint
662 value.copy< ColumnConstraintInfo > (that.value);
663 break;
664
665 case 159: // columnconstraint_list
666 value.copy< ColumnConstraintInfoVector > (that.value);
667 break;
668
669 case 160: // columndef
670 value.copy< ColumndefData > (that.value);
671 break;
672
673 case 142: // optional_if_not_exists
674 case 144: // optional_unique
675 case 152: // optional_temporary
676 case 153: // optional_withoutrowid
677 case 157: // optional_always_generated
678 value.copy< bool > (that.value);
679 break;
680
681 case 168: // tableconstraint
682 value.copy< sqlb::ConstraintPtr > (that.value);
683 break;
684
685 case 169: // tableconstraint_list
686 case 170: // optional_tableconstraint_list
687 value.copy< sqlb::ConstraintSet > (that.value);
688 break;
689
690 case 149: // createindex_stmt
691 value.copy< sqlb::IndexPtr > (that.value);
692 break;
693
694 case 147: // indexed_column
695 value.copy< sqlb::IndexedColumn > (that.value);
696 break;
697
698 case 148: // indexed_column_list
699 value.copy< sqlb::IndexedColumnVector > (that.value);
700 break;
701
702 case 163: // columnid_list
703 case 164: // optional_columnid_with_paren_list
704 value.copy< sqlb::StringVector > (that.value);
705 break;
706
707 case 151: // createvirtualtable_stmt
708 case 171: // createtable_stmt
709 value.copy< sqlb::TablePtr > (that.value);
710 break;
711
712 case 27: // "ABORT"
713 case 28: // "ACTION"
714 case 29: // "ALWAYS"
715 case 30: // "AND"
716 case 31: // "AND BETWEEN"
717 case 32: // "AS"
718 case 33: // "ASC"
719 case 34: // "AUTOINCREMENT"
720 case 35: // "BETWEEN"
721 case 36: // "CASCADE"
722 case 37: // "CASE"
723 case 38: // "CAST"
724 case 39: // "CHECK"
725 case 40: // "COLLATE"
726 case 41: // "CONFLICT"
727 case 42: // "CONSTRAINT"
728 case 43: // "CREATE"
729 case 44: // "CURRENT_DATE"
730 case 45: // "CURRENT_TIME"
731 case 46: // "CURRENT_TIMESTAMP"
732 case 47: // "DEFAULT"
733 case 48: // "DEFERRABLE"
734 case 49: // "DEFERRED"
735 case 50: // "DELETE"
736 case 51: // "DESC"
737 case 52: // "DISTINCT"
738 case 53: // "ELSE"
739 case 54: // "END"
740 case 55: // "ESCAPE"
741 case 56: // "EXISTS"
742 case 57: // "FAIL"
743 case 58: // "FALSE"
744 case 59: // "FILTER"
745 case 60: // "FOLLOWING"
746 case 61: // "FOREIGN"
747 case 62: // "GENERATED"
748 case 63: // "GLOB"
749 case 64: // "IF"
750 case 65: // "IGNORE"
751 case 66: // "IMMEDIATE"
752 case 67: // "IN"
753 case 68: // "INDEX"
754 case 69: // "INITIALLY"
755 case 70: // "INSERT"
756 case 71: // "IS"
757 case 72: // "ISNULL"
758 case 73: // "KEY"
759 case 74: // "LIKE"
760 case 75: // "MATCH"
761 case 76: // "NO"
762 case 77: // "NOT"
763 case 78: // "NOTNULL"
764 case 79: // "NULL"
765 case 80: // "ON"
766 case 81: // "OR"
767 case 82: // "OVER"
768 case 83: // "PARTITION"
769 case 84: // "PRECEDING"
770 case 85: // "PRIMARY"
771 case 86: // "RAISE"
772 case 87: // "RANGE"
773 case 88: // "REFERENCES"
774 case 89: // "REGEXP"
775 case 90: // "REPLACE"
776 case 91: // "RESTRICT"
777 case 92: // "ROLLBACK"
778 case 93: // "ROWID"
779 case 94: // "ROWS"
780 case 95: // "SELECT"
781 case 96: // "SET"
782 case 97: // "STORED"
783 case 98: // "TABLE"
784 case 99: // "TEMP"
785 case 100: // "TEMPORARY"
786 case 101: // "THEN"
787 case 102: // "TRUE"
788 case 103: // "UNBOUNDED"
789 case 104: // "UNIQUE"
790 case 105: // "UPDATE"
791 case 106: // "USING"
792 case 107: // "VIRTUAL"
793 case 108: // "WHEN"
794 case 109: // "WHERE"
795 case 110: // "WITHOUT"
796 case 111: // "identifier"
797 case 112: // "numeric"
798 case 113: // "string literal"
799 case 114: // "quoted literal"
800 case 115: // "blob literal"
801 case 116: // "bind parameter"
802 case 120: // literalvalue
803 case 121: // id
804 case 122: // allowed_keywords_as_identifier
805 case 123: // tableid
806 case 124: // columnid
807 case 125: // signednumber
808 case 126: // signednumber_or_numeric
809 case 127: // typename_namelist
810 case 128: // type_name
811 case 129: // unary_expr
812 case 130: // binary_expr
813 case 131: // like_expr
814 case 132: // exprlist_expr
815 case 133: // function_expr
816 case 134: // isnull_expr
817 case 135: // between_expr
818 case 136: // in_expr
819 case 137: // whenthenlist_expr
820 case 138: // case_expr
821 case 139: // raise_expr
822 case 140: // expr
823 case 141: // select_stmt
824 case 143: // optional_sort_order
825 case 145: // optional_where
826 case 146: // tableid_with_uninteresting_schema
827 case 150: // optional_exprlist_with_paren
828 case 154: // optional_conflictclause
829 case 155: // optional_typename
830 case 156: // optional_storage_identifier
831 case 162: // optional_constraintname
832 case 165: // fk_clause_part
833 case 166: // fk_clause_part_list
834 case 167: // optional_fk_clause
835 value.copy< std::string > (that.value);
836 break;
837
838 case 161: // columndef_list
839 value.copy< std::vector<ColumndefData> > (that.value);
840 break;
841
842 default:
843 break;
844 }
845
846 location = that.location;
847 return *this;
848 }
849
850 parser::stack_symbol_type&
operator =(stack_symbol_type & that)851 parser::stack_symbol_type::operator= (stack_symbol_type& that)
852 {
853 state = that.state;
854 switch (that.type_get ())
855 {
856 case 158: // columnconstraint
857 value.move< ColumnConstraintInfo > (that.value);
858 break;
859
860 case 159: // columnconstraint_list
861 value.move< ColumnConstraintInfoVector > (that.value);
862 break;
863
864 case 160: // columndef
865 value.move< ColumndefData > (that.value);
866 break;
867
868 case 142: // optional_if_not_exists
869 case 144: // optional_unique
870 case 152: // optional_temporary
871 case 153: // optional_withoutrowid
872 case 157: // optional_always_generated
873 value.move< bool > (that.value);
874 break;
875
876 case 168: // tableconstraint
877 value.move< sqlb::ConstraintPtr > (that.value);
878 break;
879
880 case 169: // tableconstraint_list
881 case 170: // optional_tableconstraint_list
882 value.move< sqlb::ConstraintSet > (that.value);
883 break;
884
885 case 149: // createindex_stmt
886 value.move< sqlb::IndexPtr > (that.value);
887 break;
888
889 case 147: // indexed_column
890 value.move< sqlb::IndexedColumn > (that.value);
891 break;
892
893 case 148: // indexed_column_list
894 value.move< sqlb::IndexedColumnVector > (that.value);
895 break;
896
897 case 163: // columnid_list
898 case 164: // optional_columnid_with_paren_list
899 value.move< sqlb::StringVector > (that.value);
900 break;
901
902 case 151: // createvirtualtable_stmt
903 case 171: // createtable_stmt
904 value.move< sqlb::TablePtr > (that.value);
905 break;
906
907 case 27: // "ABORT"
908 case 28: // "ACTION"
909 case 29: // "ALWAYS"
910 case 30: // "AND"
911 case 31: // "AND BETWEEN"
912 case 32: // "AS"
913 case 33: // "ASC"
914 case 34: // "AUTOINCREMENT"
915 case 35: // "BETWEEN"
916 case 36: // "CASCADE"
917 case 37: // "CASE"
918 case 38: // "CAST"
919 case 39: // "CHECK"
920 case 40: // "COLLATE"
921 case 41: // "CONFLICT"
922 case 42: // "CONSTRAINT"
923 case 43: // "CREATE"
924 case 44: // "CURRENT_DATE"
925 case 45: // "CURRENT_TIME"
926 case 46: // "CURRENT_TIMESTAMP"
927 case 47: // "DEFAULT"
928 case 48: // "DEFERRABLE"
929 case 49: // "DEFERRED"
930 case 50: // "DELETE"
931 case 51: // "DESC"
932 case 52: // "DISTINCT"
933 case 53: // "ELSE"
934 case 54: // "END"
935 case 55: // "ESCAPE"
936 case 56: // "EXISTS"
937 case 57: // "FAIL"
938 case 58: // "FALSE"
939 case 59: // "FILTER"
940 case 60: // "FOLLOWING"
941 case 61: // "FOREIGN"
942 case 62: // "GENERATED"
943 case 63: // "GLOB"
944 case 64: // "IF"
945 case 65: // "IGNORE"
946 case 66: // "IMMEDIATE"
947 case 67: // "IN"
948 case 68: // "INDEX"
949 case 69: // "INITIALLY"
950 case 70: // "INSERT"
951 case 71: // "IS"
952 case 72: // "ISNULL"
953 case 73: // "KEY"
954 case 74: // "LIKE"
955 case 75: // "MATCH"
956 case 76: // "NO"
957 case 77: // "NOT"
958 case 78: // "NOTNULL"
959 case 79: // "NULL"
960 case 80: // "ON"
961 case 81: // "OR"
962 case 82: // "OVER"
963 case 83: // "PARTITION"
964 case 84: // "PRECEDING"
965 case 85: // "PRIMARY"
966 case 86: // "RAISE"
967 case 87: // "RANGE"
968 case 88: // "REFERENCES"
969 case 89: // "REGEXP"
970 case 90: // "REPLACE"
971 case 91: // "RESTRICT"
972 case 92: // "ROLLBACK"
973 case 93: // "ROWID"
974 case 94: // "ROWS"
975 case 95: // "SELECT"
976 case 96: // "SET"
977 case 97: // "STORED"
978 case 98: // "TABLE"
979 case 99: // "TEMP"
980 case 100: // "TEMPORARY"
981 case 101: // "THEN"
982 case 102: // "TRUE"
983 case 103: // "UNBOUNDED"
984 case 104: // "UNIQUE"
985 case 105: // "UPDATE"
986 case 106: // "USING"
987 case 107: // "VIRTUAL"
988 case 108: // "WHEN"
989 case 109: // "WHERE"
990 case 110: // "WITHOUT"
991 case 111: // "identifier"
992 case 112: // "numeric"
993 case 113: // "string literal"
994 case 114: // "quoted literal"
995 case 115: // "blob literal"
996 case 116: // "bind parameter"
997 case 120: // literalvalue
998 case 121: // id
999 case 122: // allowed_keywords_as_identifier
1000 case 123: // tableid
1001 case 124: // columnid
1002 case 125: // signednumber
1003 case 126: // signednumber_or_numeric
1004 case 127: // typename_namelist
1005 case 128: // type_name
1006 case 129: // unary_expr
1007 case 130: // binary_expr
1008 case 131: // like_expr
1009 case 132: // exprlist_expr
1010 case 133: // function_expr
1011 case 134: // isnull_expr
1012 case 135: // between_expr
1013 case 136: // in_expr
1014 case 137: // whenthenlist_expr
1015 case 138: // case_expr
1016 case 139: // raise_expr
1017 case 140: // expr
1018 case 141: // select_stmt
1019 case 143: // optional_sort_order
1020 case 145: // optional_where
1021 case 146: // tableid_with_uninteresting_schema
1022 case 150: // optional_exprlist_with_paren
1023 case 154: // optional_conflictclause
1024 case 155: // optional_typename
1025 case 156: // optional_storage_identifier
1026 case 162: // optional_constraintname
1027 case 165: // fk_clause_part
1028 case 166: // fk_clause_part_list
1029 case 167: // optional_fk_clause
1030 value.move< std::string > (that.value);
1031 break;
1032
1033 case 161: // columndef_list
1034 value.move< std::vector<ColumndefData> > (that.value);
1035 break;
1036
1037 default:
1038 break;
1039 }
1040
1041 location = that.location;
1042 // that is emptied.
1043 that.state = empty_state;
1044 return *this;
1045 }
1046 #endif
1047
1048 template <typename Base>
1049 void
yy_destroy_(const char * yymsg,basic_symbol<Base> & yysym) const1050 parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
1051 {
1052 if (yymsg)
1053 YY_SYMBOL_PRINT (yymsg, yysym);
1054 }
1055
1056 #if YYDEBUG
1057 template <typename Base>
1058 void
yy_print_(std::ostream & yyo,const basic_symbol<Base> & yysym) const1059 parser::yy_print_ (std::ostream& yyo,
1060 const basic_symbol<Base>& yysym) const
1061 {
1062 std::ostream& yyoutput = yyo;
1063 YYUSE (yyoutput);
1064 symbol_number_type yytype = yysym.type_get ();
1065 #if defined __GNUC__ && ! defined __clang__ && ! defined __ICC && __GNUC__ * 100 + __GNUC_MINOR__ <= 408
1066 // Avoid a (spurious) G++ 4.8 warning about "array subscript is
1067 // below array bounds".
1068 if (yysym.empty ())
1069 std::abort ();
1070 #endif
1071 yyo << (yytype < yyntokens_ ? "token" : "nterm")
1072 << ' ' << yytname_[yytype] << " ("
1073 << yysym.location << ": ";
1074 YYUSE (yytype);
1075 yyo << ')';
1076 }
1077 #endif
1078
1079 void
yypush_(const char * m,YY_MOVE_REF (stack_symbol_type)sym)1080 parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
1081 {
1082 if (m)
1083 YY_SYMBOL_PRINT (m, sym);
1084 yystack_.push (YY_MOVE (sym));
1085 }
1086
1087 void
yypush_(const char * m,state_type s,YY_MOVE_REF (symbol_type)sym)1088 parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
1089 {
1090 #if 201103L <= YY_CPLUSPLUS
1091 yypush_ (m, stack_symbol_type (s, std::move (sym)));
1092 #else
1093 stack_symbol_type ss (s, sym);
1094 yypush_ (m, ss);
1095 #endif
1096 }
1097
1098 void
yypop_(int n)1099 parser::yypop_ (int n)
1100 {
1101 yystack_.pop (n);
1102 }
1103
1104 #if YYDEBUG
1105 std::ostream&
debug_stream() const1106 parser::debug_stream () const
1107 {
1108 return *yycdebug_;
1109 }
1110
1111 void
set_debug_stream(std::ostream & o)1112 parser::set_debug_stream (std::ostream& o)
1113 {
1114 yycdebug_ = &o;
1115 }
1116
1117
1118 parser::debug_level_type
debug_level() const1119 parser::debug_level () const
1120 {
1121 return yydebug_;
1122 }
1123
1124 void
set_debug_level(debug_level_type l)1125 parser::set_debug_level (debug_level_type l)
1126 {
1127 yydebug_ = l;
1128 }
1129 #endif // YYDEBUG
1130
1131 parser::state_type
yy_lr_goto_state_(state_type yystate,int yysym)1132 parser::yy_lr_goto_state_ (state_type yystate, int yysym)
1133 {
1134 int yyr = yypgoto_[yysym - yyntokens_] + yystate;
1135 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
1136 return yytable_[yyr];
1137 else
1138 return yydefgoto_[yysym - yyntokens_];
1139 }
1140
1141 bool
yy_pact_value_is_default_(int yyvalue)1142 parser::yy_pact_value_is_default_ (int yyvalue)
1143 {
1144 return yyvalue == yypact_ninf_;
1145 }
1146
1147 bool
yy_table_value_is_error_(int yyvalue)1148 parser::yy_table_value_is_error_ (int yyvalue)
1149 {
1150 return yyvalue == yytable_ninf_;
1151 }
1152
1153 int
operator ()()1154 parser::operator() ()
1155 {
1156 return parse ();
1157 }
1158
1159 int
parse()1160 parser::parse ()
1161 {
1162 int yyn;
1163 /// Length of the RHS of the rule being reduced.
1164 int yylen = 0;
1165
1166 // Error handling.
1167 int yynerrs_ = 0;
1168 int yyerrstatus_ = 0;
1169
1170 /// The lookahead symbol.
1171 symbol_type yyla;
1172
1173 /// The locations where the error started and ended.
1174 stack_symbol_type yyerror_range[3];
1175
1176 /// The return value of parse ().
1177 int yyresult;
1178
1179 #if YY_EXCEPTIONS
1180 try
1181 #endif // YY_EXCEPTIONS
1182 {
1183 YYCDEBUG << "Starting parse\n";
1184
1185
1186 /* Initialize the stack. The initial state will be set in
1187 yynewstate, since the latter expects the semantical and the
1188 location values to have been already stored, initialize these
1189 stacks with a primary value. */
1190 yystack_.clear ();
1191 yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
1192
1193 /*-----------------------------------------------.
1194 | yynewstate -- push a new symbol on the stack. |
1195 `-----------------------------------------------*/
1196 yynewstate:
1197 YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n';
1198
1199 // Accept?
1200 if (yystack_[0].state == yyfinal_)
1201 YYACCEPT;
1202
1203 goto yybackup;
1204
1205
1206 /*-----------.
1207 | yybackup. |
1208 `-----------*/
1209 yybackup:
1210 // Try to take a decision without lookahead.
1211 yyn = yypact_[+yystack_[0].state];
1212 if (yy_pact_value_is_default_ (yyn))
1213 goto yydefault;
1214
1215 // Read a lookahead token.
1216 if (yyla.empty ())
1217 {
1218 YYCDEBUG << "Reading a token: ";
1219 #if YY_EXCEPTIONS
1220 try
1221 #endif // YY_EXCEPTIONS
1222 {
1223 symbol_type yylookahead (yylex (yyscanner, drv));
1224 yyla.move (yylookahead);
1225 }
1226 #if YY_EXCEPTIONS
1227 catch (const syntax_error& yyexc)
1228 {
1229 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
1230 error (yyexc);
1231 goto yyerrlab1;
1232 }
1233 #endif // YY_EXCEPTIONS
1234 }
1235 YY_SYMBOL_PRINT ("Next token is", yyla);
1236
1237 /* If the proper action on seeing token YYLA.TYPE is to reduce or
1238 to detect an error, take that action. */
1239 yyn += yyla.type_get ();
1240 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ())
1241 {
1242 goto yydefault;
1243 }
1244
1245 // Reduce or error.
1246 yyn = yytable_[yyn];
1247 if (yyn <= 0)
1248 {
1249 if (yy_table_value_is_error_ (yyn))
1250 goto yyerrlab;
1251 yyn = -yyn;
1252 goto yyreduce;
1253 }
1254
1255 // Count tokens shifted since error; after three, turn off error status.
1256 if (yyerrstatus_)
1257 --yyerrstatus_;
1258
1259 // Shift the lookahead token.
1260 yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));
1261 goto yynewstate;
1262
1263
1264 /*-----------------------------------------------------------.
1265 | yydefault -- do the default action for the current state. |
1266 `-----------------------------------------------------------*/
1267 yydefault:
1268 yyn = yydefact_[+yystack_[0].state];
1269 if (yyn == 0)
1270 goto yyerrlab;
1271 goto yyreduce;
1272
1273
1274 /*-----------------------------.
1275 | yyreduce -- do a reduction. |
1276 `-----------------------------*/
1277 yyreduce:
1278 yylen = yyr2_[yyn];
1279 {
1280 stack_symbol_type yylhs;
1281 yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
1282 /* Variants are always initialized to an empty instance of the
1283 correct type. The default '$$ = $1' action is NOT applied
1284 when using variants. */
1285 switch (yyr1_[yyn])
1286 {
1287 case 158: // columnconstraint
1288 yylhs.value.emplace< ColumnConstraintInfo > ();
1289 break;
1290
1291 case 159: // columnconstraint_list
1292 yylhs.value.emplace< ColumnConstraintInfoVector > ();
1293 break;
1294
1295 case 160: // columndef
1296 yylhs.value.emplace< ColumndefData > ();
1297 break;
1298
1299 case 142: // optional_if_not_exists
1300 case 144: // optional_unique
1301 case 152: // optional_temporary
1302 case 153: // optional_withoutrowid
1303 case 157: // optional_always_generated
1304 yylhs.value.emplace< bool > ();
1305 break;
1306
1307 case 168: // tableconstraint
1308 yylhs.value.emplace< sqlb::ConstraintPtr > ();
1309 break;
1310
1311 case 169: // tableconstraint_list
1312 case 170: // optional_tableconstraint_list
1313 yylhs.value.emplace< sqlb::ConstraintSet > ();
1314 break;
1315
1316 case 149: // createindex_stmt
1317 yylhs.value.emplace< sqlb::IndexPtr > ();
1318 break;
1319
1320 case 147: // indexed_column
1321 yylhs.value.emplace< sqlb::IndexedColumn > ();
1322 break;
1323
1324 case 148: // indexed_column_list
1325 yylhs.value.emplace< sqlb::IndexedColumnVector > ();
1326 break;
1327
1328 case 163: // columnid_list
1329 case 164: // optional_columnid_with_paren_list
1330 yylhs.value.emplace< sqlb::StringVector > ();
1331 break;
1332
1333 case 151: // createvirtualtable_stmt
1334 case 171: // createtable_stmt
1335 yylhs.value.emplace< sqlb::TablePtr > ();
1336 break;
1337
1338 case 27: // "ABORT"
1339 case 28: // "ACTION"
1340 case 29: // "ALWAYS"
1341 case 30: // "AND"
1342 case 31: // "AND BETWEEN"
1343 case 32: // "AS"
1344 case 33: // "ASC"
1345 case 34: // "AUTOINCREMENT"
1346 case 35: // "BETWEEN"
1347 case 36: // "CASCADE"
1348 case 37: // "CASE"
1349 case 38: // "CAST"
1350 case 39: // "CHECK"
1351 case 40: // "COLLATE"
1352 case 41: // "CONFLICT"
1353 case 42: // "CONSTRAINT"
1354 case 43: // "CREATE"
1355 case 44: // "CURRENT_DATE"
1356 case 45: // "CURRENT_TIME"
1357 case 46: // "CURRENT_TIMESTAMP"
1358 case 47: // "DEFAULT"
1359 case 48: // "DEFERRABLE"
1360 case 49: // "DEFERRED"
1361 case 50: // "DELETE"
1362 case 51: // "DESC"
1363 case 52: // "DISTINCT"
1364 case 53: // "ELSE"
1365 case 54: // "END"
1366 case 55: // "ESCAPE"
1367 case 56: // "EXISTS"
1368 case 57: // "FAIL"
1369 case 58: // "FALSE"
1370 case 59: // "FILTER"
1371 case 60: // "FOLLOWING"
1372 case 61: // "FOREIGN"
1373 case 62: // "GENERATED"
1374 case 63: // "GLOB"
1375 case 64: // "IF"
1376 case 65: // "IGNORE"
1377 case 66: // "IMMEDIATE"
1378 case 67: // "IN"
1379 case 68: // "INDEX"
1380 case 69: // "INITIALLY"
1381 case 70: // "INSERT"
1382 case 71: // "IS"
1383 case 72: // "ISNULL"
1384 case 73: // "KEY"
1385 case 74: // "LIKE"
1386 case 75: // "MATCH"
1387 case 76: // "NO"
1388 case 77: // "NOT"
1389 case 78: // "NOTNULL"
1390 case 79: // "NULL"
1391 case 80: // "ON"
1392 case 81: // "OR"
1393 case 82: // "OVER"
1394 case 83: // "PARTITION"
1395 case 84: // "PRECEDING"
1396 case 85: // "PRIMARY"
1397 case 86: // "RAISE"
1398 case 87: // "RANGE"
1399 case 88: // "REFERENCES"
1400 case 89: // "REGEXP"
1401 case 90: // "REPLACE"
1402 case 91: // "RESTRICT"
1403 case 92: // "ROLLBACK"
1404 case 93: // "ROWID"
1405 case 94: // "ROWS"
1406 case 95: // "SELECT"
1407 case 96: // "SET"
1408 case 97: // "STORED"
1409 case 98: // "TABLE"
1410 case 99: // "TEMP"
1411 case 100: // "TEMPORARY"
1412 case 101: // "THEN"
1413 case 102: // "TRUE"
1414 case 103: // "UNBOUNDED"
1415 case 104: // "UNIQUE"
1416 case 105: // "UPDATE"
1417 case 106: // "USING"
1418 case 107: // "VIRTUAL"
1419 case 108: // "WHEN"
1420 case 109: // "WHERE"
1421 case 110: // "WITHOUT"
1422 case 111: // "identifier"
1423 case 112: // "numeric"
1424 case 113: // "string literal"
1425 case 114: // "quoted literal"
1426 case 115: // "blob literal"
1427 case 116: // "bind parameter"
1428 case 120: // literalvalue
1429 case 121: // id
1430 case 122: // allowed_keywords_as_identifier
1431 case 123: // tableid
1432 case 124: // columnid
1433 case 125: // signednumber
1434 case 126: // signednumber_or_numeric
1435 case 127: // typename_namelist
1436 case 128: // type_name
1437 case 129: // unary_expr
1438 case 130: // binary_expr
1439 case 131: // like_expr
1440 case 132: // exprlist_expr
1441 case 133: // function_expr
1442 case 134: // isnull_expr
1443 case 135: // between_expr
1444 case 136: // in_expr
1445 case 137: // whenthenlist_expr
1446 case 138: // case_expr
1447 case 139: // raise_expr
1448 case 140: // expr
1449 case 141: // select_stmt
1450 case 143: // optional_sort_order
1451 case 145: // optional_where
1452 case 146: // tableid_with_uninteresting_schema
1453 case 150: // optional_exprlist_with_paren
1454 case 154: // optional_conflictclause
1455 case 155: // optional_typename
1456 case 156: // optional_storage_identifier
1457 case 162: // optional_constraintname
1458 case 165: // fk_clause_part
1459 case 166: // fk_clause_part_list
1460 case 167: // optional_fk_clause
1461 yylhs.value.emplace< std::string > ();
1462 break;
1463
1464 case 161: // columndef_list
1465 yylhs.value.emplace< std::vector<ColumndefData> > ();
1466 break;
1467
1468 default:
1469 break;
1470 }
1471
1472
1473 // Default location.
1474 {
1475 stack_type::slice range (yystack_, yylen);
1476 YYLLOC_DEFAULT (yylhs.location, range, yylen);
1477 yyerror_range[1].location = yylhs.location;
1478 }
1479
1480 // Perform the reduction.
1481 YY_REDUCE_PRINT (yyn);
1482 #if YY_EXCEPTIONS
1483 try
1484 #endif // YY_EXCEPTIONS
1485 {
1486 switch (yyn)
1487 {
1488 case 4:
1489 #line 314 "sqlite3_parser.yy"
1490 { drv.result = yystack_[0].value.as < sqlb::IndexPtr > (); }
1491 #line 1492 "sqlite3_parser.cpp"
1492 break;
1493
1494 case 5:
1495 #line 315 "sqlite3_parser.yy"
1496 { drv.result = yystack_[0].value.as < sqlb::TablePtr > (); }
1497 #line 1498 "sqlite3_parser.cpp"
1498 break;
1499
1500 case 6:
1501 #line 316 "sqlite3_parser.yy"
1502 { drv.result = yystack_[0].value.as < sqlb::TablePtr > (); }
1503 #line 1504 "sqlite3_parser.cpp"
1504 break;
1505
1506 case 7:
1507 #line 324 "sqlite3_parser.yy"
1508 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1509 #line 1510 "sqlite3_parser.cpp"
1510 break;
1511
1512 case 8:
1513 #line 325 "sqlite3_parser.yy"
1514 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1515 #line 1516 "sqlite3_parser.cpp"
1516 break;
1517
1518 case 9:
1519 #line 326 "sqlite3_parser.yy"
1520 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1521 #line 1522 "sqlite3_parser.cpp"
1522 break;
1523
1524 case 10:
1525 #line 327 "sqlite3_parser.yy"
1526 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1527 #line 1528 "sqlite3_parser.cpp"
1528 break;
1529
1530 case 11:
1531 #line 328 "sqlite3_parser.yy"
1532 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1533 #line 1534 "sqlite3_parser.cpp"
1534 break;
1535
1536 case 12:
1537 #line 329 "sqlite3_parser.yy"
1538 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1539 #line 1540 "sqlite3_parser.cpp"
1540 break;
1541
1542 case 13:
1543 #line 330 "sqlite3_parser.yy"
1544 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1545 #line 1546 "sqlite3_parser.cpp"
1546 break;
1547
1548 case 14:
1549 #line 331 "sqlite3_parser.yy"
1550 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1551 #line 1552 "sqlite3_parser.cpp"
1552 break;
1553
1554 case 15:
1555 #line 332 "sqlite3_parser.yy"
1556 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1557 #line 1558 "sqlite3_parser.cpp"
1558 break;
1559
1560 case 16:
1561 #line 336 "sqlite3_parser.yy"
1562 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1563 #line 1564 "sqlite3_parser.cpp"
1564 break;
1565
1566 case 17:
1567 #line 337 "sqlite3_parser.yy"
1568 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1569 #line 1570 "sqlite3_parser.cpp"
1570 break;
1571
1572 case 18:
1573 #line 342 "sqlite3_parser.yy"
1574 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1575 #line 1576 "sqlite3_parser.cpp"
1576 break;
1577
1578 case 19:
1579 #line 343 "sqlite3_parser.yy"
1580 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1581 #line 1582 "sqlite3_parser.cpp"
1582 break;
1583
1584 case 20:
1585 #line 344 "sqlite3_parser.yy"
1586 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1587 #line 1588 "sqlite3_parser.cpp"
1588 break;
1589
1590 case 21:
1591 #line 345 "sqlite3_parser.yy"
1592 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1593 #line 1594 "sqlite3_parser.cpp"
1594 break;
1595
1596 case 22:
1597 #line 346 "sqlite3_parser.yy"
1598 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1599 #line 1600 "sqlite3_parser.cpp"
1600 break;
1601
1602 case 23:
1603 #line 347 "sqlite3_parser.yy"
1604 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1605 #line 1606 "sqlite3_parser.cpp"
1606 break;
1607
1608 case 24:
1609 #line 348 "sqlite3_parser.yy"
1610 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1611 #line 1612 "sqlite3_parser.cpp"
1612 break;
1613
1614 case 25:
1615 #line 349 "sqlite3_parser.yy"
1616 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1617 #line 1618 "sqlite3_parser.cpp"
1618 break;
1619
1620 case 26:
1621 #line 350 "sqlite3_parser.yy"
1622 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1623 #line 1624 "sqlite3_parser.cpp"
1624 break;
1625
1626 case 27:
1627 #line 351 "sqlite3_parser.yy"
1628 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1629 #line 1630 "sqlite3_parser.cpp"
1630 break;
1631
1632 case 28:
1633 #line 352 "sqlite3_parser.yy"
1634 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1635 #line 1636 "sqlite3_parser.cpp"
1636 break;
1637
1638 case 29:
1639 #line 353 "sqlite3_parser.yy"
1640 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1641 #line 1642 "sqlite3_parser.cpp"
1642 break;
1643
1644 case 30:
1645 #line 354 "sqlite3_parser.yy"
1646 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1647 #line 1648 "sqlite3_parser.cpp"
1648 break;
1649
1650 case 31:
1651 #line 355 "sqlite3_parser.yy"
1652 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1653 #line 1654 "sqlite3_parser.cpp"
1654 break;
1655
1656 case 32:
1657 #line 356 "sqlite3_parser.yy"
1658 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1659 #line 1660 "sqlite3_parser.cpp"
1660 break;
1661
1662 case 33:
1663 #line 357 "sqlite3_parser.yy"
1664 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1665 #line 1666 "sqlite3_parser.cpp"
1666 break;
1667
1668 case 34:
1669 #line 358 "sqlite3_parser.yy"
1670 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1671 #line 1672 "sqlite3_parser.cpp"
1672 break;
1673
1674 case 35:
1675 #line 359 "sqlite3_parser.yy"
1676 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1677 #line 1678 "sqlite3_parser.cpp"
1678 break;
1679
1680 case 36:
1681 #line 360 "sqlite3_parser.yy"
1682 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1683 #line 1684 "sqlite3_parser.cpp"
1684 break;
1685
1686 case 37:
1687 #line 361 "sqlite3_parser.yy"
1688 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1689 #line 1690 "sqlite3_parser.cpp"
1690 break;
1691
1692 case 38:
1693 #line 362 "sqlite3_parser.yy"
1694 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1695 #line 1696 "sqlite3_parser.cpp"
1696 break;
1697
1698 case 39:
1699 #line 363 "sqlite3_parser.yy"
1700 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1701 #line 1702 "sqlite3_parser.cpp"
1702 break;
1703
1704 case 40:
1705 #line 364 "sqlite3_parser.yy"
1706 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1707 #line 1708 "sqlite3_parser.cpp"
1708 break;
1709
1710 case 41:
1711 #line 365 "sqlite3_parser.yy"
1712 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1713 #line 1714 "sqlite3_parser.cpp"
1714 break;
1715
1716 case 42:
1717 #line 366 "sqlite3_parser.yy"
1718 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1719 #line 1720 "sqlite3_parser.cpp"
1720 break;
1721
1722 case 43:
1723 #line 367 "sqlite3_parser.yy"
1724 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1725 #line 1726 "sqlite3_parser.cpp"
1726 break;
1727
1728 case 44:
1729 #line 368 "sqlite3_parser.yy"
1730 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1731 #line 1732 "sqlite3_parser.cpp"
1732 break;
1733
1734 case 45:
1735 #line 369 "sqlite3_parser.yy"
1736 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1737 #line 1738 "sqlite3_parser.cpp"
1738 break;
1739
1740 case 46:
1741 #line 370 "sqlite3_parser.yy"
1742 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1743 #line 1744 "sqlite3_parser.cpp"
1744 break;
1745
1746 case 47:
1747 #line 371 "sqlite3_parser.yy"
1748 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1749 #line 1750 "sqlite3_parser.cpp"
1750 break;
1751
1752 case 48:
1753 #line 372 "sqlite3_parser.yy"
1754 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1755 #line 1756 "sqlite3_parser.cpp"
1756 break;
1757
1758 case 49:
1759 #line 373 "sqlite3_parser.yy"
1760 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1761 #line 1762 "sqlite3_parser.cpp"
1762 break;
1763
1764 case 50:
1765 #line 374 "sqlite3_parser.yy"
1766 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1767 #line 1768 "sqlite3_parser.cpp"
1768 break;
1769
1770 case 51:
1771 #line 375 "sqlite3_parser.yy"
1772 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1773 #line 1774 "sqlite3_parser.cpp"
1774 break;
1775
1776 case 52:
1777 #line 376 "sqlite3_parser.yy"
1778 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1779 #line 1780 "sqlite3_parser.cpp"
1780 break;
1781
1782 case 53:
1783 #line 377 "sqlite3_parser.yy"
1784 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1785 #line 1786 "sqlite3_parser.cpp"
1786 break;
1787
1788 case 54:
1789 #line 378 "sqlite3_parser.yy"
1790 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1791 #line 1792 "sqlite3_parser.cpp"
1792 break;
1793
1794 case 55:
1795 #line 379 "sqlite3_parser.yy"
1796 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1797 #line 1798 "sqlite3_parser.cpp"
1798 break;
1799
1800 case 56:
1801 #line 380 "sqlite3_parser.yy"
1802 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1803 #line 1804 "sqlite3_parser.cpp"
1804 break;
1805
1806 case 57:
1807 #line 384 "sqlite3_parser.yy"
1808 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1809 #line 1810 "sqlite3_parser.cpp"
1810 break;
1811
1812 case 58:
1813 #line 385 "sqlite3_parser.yy"
1814 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1815 #line 1816 "sqlite3_parser.cpp"
1816 break;
1817
1818 case 59:
1819 #line 386 "sqlite3_parser.yy"
1820 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1821 #line 1822 "sqlite3_parser.cpp"
1822 break;
1823
1824 case 60:
1825 #line 387 "sqlite3_parser.yy"
1826 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1827 #line 1828 "sqlite3_parser.cpp"
1828 break;
1829
1830 case 61:
1831 #line 388 "sqlite3_parser.yy"
1832 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1833 #line 1834 "sqlite3_parser.cpp"
1834 break;
1835
1836 case 62:
1837 #line 389 "sqlite3_parser.yy"
1838 { yylhs.value.as < std::string > () = unquote_text(yystack_[0].value.as < std::string > (), '\''); }
1839 #line 1840 "sqlite3_parser.cpp"
1840 break;
1841
1842 case 63:
1843 #line 393 "sqlite3_parser.yy"
1844 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1845 #line 1846 "sqlite3_parser.cpp"
1846 break;
1847
1848 case 64:
1849 #line 394 "sqlite3_parser.yy"
1850 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1851 #line 1852 "sqlite3_parser.cpp"
1852 break;
1853
1854 case 65:
1855 #line 395 "sqlite3_parser.yy"
1856 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1857 #line 1858 "sqlite3_parser.cpp"
1858 break;
1859
1860 case 66:
1861 #line 396 "sqlite3_parser.yy"
1862 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1863 #line 1864 "sqlite3_parser.cpp"
1864 break;
1865
1866 case 67:
1867 #line 397 "sqlite3_parser.yy"
1868 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1869 #line 1870 "sqlite3_parser.cpp"
1870 break;
1871
1872 case 68:
1873 #line 398 "sqlite3_parser.yy"
1874 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1875 #line 1876 "sqlite3_parser.cpp"
1876 break;
1877
1878 case 69:
1879 #line 399 "sqlite3_parser.yy"
1880 { yylhs.value.as < std::string > () = unquote_text(yystack_[0].value.as < std::string > (), '\''); }
1881 #line 1882 "sqlite3_parser.cpp"
1882 break;
1883
1884 case 70:
1885 #line 403 "sqlite3_parser.yy"
1886 { yylhs.value.as < std::string > () = "+" + yystack_[0].value.as < std::string > (); }
1887 #line 1888 "sqlite3_parser.cpp"
1888 break;
1889
1890 case 71:
1891 #line 404 "sqlite3_parser.yy"
1892 { yylhs.value.as < std::string > () = "-" + yystack_[0].value.as < std::string > (); }
1893 #line 1894 "sqlite3_parser.cpp"
1894 break;
1895
1896 case 72:
1897 #line 408 "sqlite3_parser.yy"
1898 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1899 #line 1900 "sqlite3_parser.cpp"
1900 break;
1901
1902 case 73:
1903 #line 409 "sqlite3_parser.yy"
1904 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1905 #line 1906 "sqlite3_parser.cpp"
1906 break;
1907
1908 case 74:
1909 #line 413 "sqlite3_parser.yy"
1910 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1911 #line 1912 "sqlite3_parser.cpp"
1912 break;
1913
1914 case 75:
1915 #line 414 "sqlite3_parser.yy"
1916 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
1917 #line 1918 "sqlite3_parser.cpp"
1918 break;
1919
1920 case 76:
1921 #line 418 "sqlite3_parser.yy"
1922 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
1923 #line 1924 "sqlite3_parser.cpp"
1924 break;
1925
1926 case 77:
1927 #line 419 "sqlite3_parser.yy"
1928 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + "(" + yystack_[1].value.as < std::string > () + ")"; }
1929 #line 1930 "sqlite3_parser.cpp"
1930 break;
1931
1932 case 78:
1933 #line 420 "sqlite3_parser.yy"
1934 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + "(" + yystack_[3].value.as < std::string > () + ", " + yystack_[1].value.as < std::string > () + ")"; }
1935 #line 1936 "sqlite3_parser.cpp"
1936 break;
1937
1938 case 79:
1939 #line 424 "sqlite3_parser.yy"
1940 { yylhs.value.as < std::string > () = "-" + yystack_[0].value.as < std::string > (); }
1941 #line 1942 "sqlite3_parser.cpp"
1942 break;
1943
1944 case 80:
1945 #line 425 "sqlite3_parser.yy"
1946 { yylhs.value.as < std::string > () = "+" + yystack_[0].value.as < std::string > (); }
1947 #line 1948 "sqlite3_parser.cpp"
1948 break;
1949
1950 case 81:
1951 #line 426 "sqlite3_parser.yy"
1952 { yylhs.value.as < std::string > () = "~" + yystack_[0].value.as < std::string > (); }
1953 #line 1954 "sqlite3_parser.cpp"
1954 break;
1955
1956 case 82:
1957 #line 427 "sqlite3_parser.yy"
1958 { yylhs.value.as < std::string > () = "NOT " + yystack_[0].value.as < std::string > (); }
1959 #line 1960 "sqlite3_parser.cpp"
1960 break;
1961
1962 case 83:
1963 #line 431 "sqlite3_parser.yy"
1964 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " || " + yystack_[0].value.as < std::string > (); }
1965 #line 1966 "sqlite3_parser.cpp"
1966 break;
1967
1968 case 84:
1969 #line 432 "sqlite3_parser.yy"
1970 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " * " + yystack_[0].value.as < std::string > (); }
1971 #line 1972 "sqlite3_parser.cpp"
1972 break;
1973
1974 case 85:
1975 #line 433 "sqlite3_parser.yy"
1976 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " / " + yystack_[0].value.as < std::string > (); }
1977 #line 1978 "sqlite3_parser.cpp"
1978 break;
1979
1980 case 86:
1981 #line 434 "sqlite3_parser.yy"
1982 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " % " + yystack_[0].value.as < std::string > (); }
1983 #line 1984 "sqlite3_parser.cpp"
1984 break;
1985
1986 case 87:
1987 #line 435 "sqlite3_parser.yy"
1988 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " + " + yystack_[0].value.as < std::string > (); }
1989 #line 1990 "sqlite3_parser.cpp"
1990 break;
1991
1992 case 88:
1993 #line 436 "sqlite3_parser.yy"
1994 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " - " + yystack_[0].value.as < std::string > (); }
1995 #line 1996 "sqlite3_parser.cpp"
1996 break;
1997
1998 case 89:
1999 #line 437 "sqlite3_parser.yy"
2000 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " << " + yystack_[0].value.as < std::string > (); }
2001 #line 2002 "sqlite3_parser.cpp"
2002 break;
2003
2004 case 90:
2005 #line 438 "sqlite3_parser.yy"
2006 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " >> " + yystack_[0].value.as < std::string > (); }
2007 #line 2008 "sqlite3_parser.cpp"
2008 break;
2009
2010 case 91:
2011 #line 439 "sqlite3_parser.yy"
2012 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " & " + yystack_[0].value.as < std::string > (); }
2013 #line 2014 "sqlite3_parser.cpp"
2014 break;
2015
2016 case 92:
2017 #line 440 "sqlite3_parser.yy"
2018 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " | " + yystack_[0].value.as < std::string > (); }
2019 #line 2020 "sqlite3_parser.cpp"
2020 break;
2021
2022 case 93:
2023 #line 441 "sqlite3_parser.yy"
2024 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " < " + yystack_[0].value.as < std::string > (); }
2025 #line 2026 "sqlite3_parser.cpp"
2026 break;
2027
2028 case 94:
2029 #line 442 "sqlite3_parser.yy"
2030 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " <= " + yystack_[0].value.as < std::string > (); }
2031 #line 2032 "sqlite3_parser.cpp"
2032 break;
2033
2034 case 95:
2035 #line 443 "sqlite3_parser.yy"
2036 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " > " + yystack_[0].value.as < std::string > (); }
2037 #line 2038 "sqlite3_parser.cpp"
2038 break;
2039
2040 case 96:
2041 #line 444 "sqlite3_parser.yy"
2042 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " >= " + yystack_[0].value.as < std::string > (); }
2043 #line 2044 "sqlite3_parser.cpp"
2044 break;
2045
2046 case 97:
2047 #line 445 "sqlite3_parser.yy"
2048 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " = " + yystack_[0].value.as < std::string > (); }
2049 #line 2050 "sqlite3_parser.cpp"
2050 break;
2051
2052 case 98:
2053 #line 446 "sqlite3_parser.yy"
2054 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " == " + yystack_[0].value.as < std::string > (); }
2055 #line 2056 "sqlite3_parser.cpp"
2056 break;
2057
2058 case 99:
2059 #line 447 "sqlite3_parser.yy"
2060 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " != " + yystack_[0].value.as < std::string > (); }
2061 #line 2062 "sqlite3_parser.cpp"
2062 break;
2063
2064 case 100:
2065 #line 448 "sqlite3_parser.yy"
2066 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " <> " + yystack_[0].value.as < std::string > (); }
2067 #line 2068 "sqlite3_parser.cpp"
2068 break;
2069
2070 case 101:
2071 #line 449 "sqlite3_parser.yy"
2072 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " IS " + yystack_[0].value.as < std::string > (); }
2073 #line 2074 "sqlite3_parser.cpp"
2074 break;
2075
2076 case 102:
2077 #line 450 "sqlite3_parser.yy"
2078 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " AND " + yystack_[0].value.as < std::string > (); }
2079 #line 2080 "sqlite3_parser.cpp"
2080 break;
2081
2082 case 103:
2083 #line 451 "sqlite3_parser.yy"
2084 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " OR " + yystack_[0].value.as < std::string > (); }
2085 #line 2086 "sqlite3_parser.cpp"
2086 break;
2087
2088 case 104:
2089 #line 455 "sqlite3_parser.yy"
2090 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " LIKE " + yystack_[0].value.as < std::string > (); }
2091 #line 2092 "sqlite3_parser.cpp"
2092 break;
2093
2094 case 105:
2095 #line 456 "sqlite3_parser.yy"
2096 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " GLOB " + yystack_[0].value.as < std::string > (); }
2097 #line 2098 "sqlite3_parser.cpp"
2098 break;
2099
2100 case 106:
2101 #line 457 "sqlite3_parser.yy"
2102 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " MATCH " + yystack_[0].value.as < std::string > (); }
2103 #line 2104 "sqlite3_parser.cpp"
2104 break;
2105
2106 case 107:
2107 #line 458 "sqlite3_parser.yy"
2108 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " REGEXP " + yystack_[0].value.as < std::string > (); }
2109 #line 2110 "sqlite3_parser.cpp"
2110 break;
2111
2112 case 108:
2113 #line 459 "sqlite3_parser.yy"
2114 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " NOT LIKE " + yystack_[0].value.as < std::string > (); }
2115 #line 2116 "sqlite3_parser.cpp"
2116 break;
2117
2118 case 109:
2119 #line 460 "sqlite3_parser.yy"
2120 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " NOT GLOB " + yystack_[0].value.as < std::string > (); }
2121 #line 2122 "sqlite3_parser.cpp"
2122 break;
2123
2124 case 110:
2125 #line 461 "sqlite3_parser.yy"
2126 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " NOT MATCH " + yystack_[0].value.as < std::string > (); }
2127 #line 2128 "sqlite3_parser.cpp"
2128 break;
2129
2130 case 111:
2131 #line 462 "sqlite3_parser.yy"
2132 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " NOT REGEXP " + yystack_[0].value.as < std::string > (); }
2133 #line 2134 "sqlite3_parser.cpp"
2134 break;
2135
2136 case 112:
2137 #line 463 "sqlite3_parser.yy"
2138 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " LIKE " + yystack_[2].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2139 #line 2140 "sqlite3_parser.cpp"
2140 break;
2141
2142 case 113:
2143 #line 464 "sqlite3_parser.yy"
2144 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " GLOB " + yystack_[2].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2145 #line 2146 "sqlite3_parser.cpp"
2146 break;
2147
2148 case 114:
2149 #line 465 "sqlite3_parser.yy"
2150 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " MATCH " + yystack_[2].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2151 #line 2152 "sqlite3_parser.cpp"
2152 break;
2153
2154 case 115:
2155 #line 466 "sqlite3_parser.yy"
2156 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " REGEXP " + yystack_[2].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2157 #line 2158 "sqlite3_parser.cpp"
2158 break;
2159
2160 case 116:
2161 #line 467 "sqlite3_parser.yy"
2162 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT LIKE " + yystack_[3].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2163 #line 2164 "sqlite3_parser.cpp"
2164 break;
2165
2166 case 117:
2167 #line 468 "sqlite3_parser.yy"
2168 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT GLOB " + yystack_[3].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2169 #line 2170 "sqlite3_parser.cpp"
2170 break;
2171
2172 case 118:
2173 #line 469 "sqlite3_parser.yy"
2174 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT MATCH " + yystack_[3].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2175 #line 2176 "sqlite3_parser.cpp"
2176 break;
2177
2178 case 119:
2179 #line 470 "sqlite3_parser.yy"
2180 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT REGEXP " + yystack_[3].value.as < std::string > () + " ESCAPE " + yystack_[0].value.as < std::string > (); }
2181 #line 2182 "sqlite3_parser.cpp"
2182 break;
2183
2184 case 120:
2185 #line 474 "sqlite3_parser.yy"
2186 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2187 #line 2188 "sqlite3_parser.cpp"
2188 break;
2189
2190 case 121:
2191 #line 475 "sqlite3_parser.yy"
2192 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + ", " + yystack_[0].value.as < std::string > (); }
2193 #line 2194 "sqlite3_parser.cpp"
2194 break;
2195
2196 case 122:
2197 #line 479 "sqlite3_parser.yy"
2198 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + "(" + yystack_[1].value.as < std::string > () + ")"; }
2199 #line 2200 "sqlite3_parser.cpp"
2200 break;
2201
2202 case 123:
2203 #line 480 "sqlite3_parser.yy"
2204 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + "(DISTINCT " + yystack_[1].value.as < std::string > () + ")"; }
2205 #line 2206 "sqlite3_parser.cpp"
2206 break;
2207
2208 case 124:
2209 #line 481 "sqlite3_parser.yy"
2210 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + "()"; }
2211 #line 2212 "sqlite3_parser.cpp"
2212 break;
2213
2214 case 125:
2215 #line 482 "sqlite3_parser.yy"
2216 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + "(*)"; }
2217 #line 2218 "sqlite3_parser.cpp"
2218 break;
2219
2220 case 126:
2221 #line 486 "sqlite3_parser.yy"
2222 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " ISNULL"; }
2223 #line 2224 "sqlite3_parser.cpp"
2224 break;
2225
2226 case 127:
2227 #line 487 "sqlite3_parser.yy"
2228 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " NOTNULL"; }
2229 #line 2230 "sqlite3_parser.cpp"
2230 break;
2231
2232 case 128:
2233 #line 488 "sqlite3_parser.yy"
2234 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " NOT NULL"; }
2235 #line 2236 "sqlite3_parser.cpp"
2236 break;
2237
2238 case 129:
2239 #line 492 "sqlite3_parser.yy"
2240 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " BETWEEN " + yystack_[2].value.as < std::string > () + " AND " + yystack_[0].value.as < std::string > (); }
2241 #line 2242 "sqlite3_parser.cpp"
2242 break;
2243
2244 case 130:
2245 #line 493 "sqlite3_parser.yy"
2246 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT BETWEEN " + yystack_[2].value.as < std::string > () + " AND " + yystack_[0].value.as < std::string > (); }
2247 #line 2248 "sqlite3_parser.cpp"
2248 break;
2249
2250 case 131:
2251 #line 497 "sqlite3_parser.yy"
2252 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " IN ()"; }
2253 #line 2254 "sqlite3_parser.cpp"
2254 break;
2255
2256 case 132:
2257 #line 498 "sqlite3_parser.yy"
2258 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " IN (" + yystack_[1].value.as < std::string > () + ")"; }
2259 #line 2260 "sqlite3_parser.cpp"
2260 break;
2261
2262 case 133:
2263 #line 499 "sqlite3_parser.yy"
2264 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " IN (" + yystack_[1].value.as < std::string > () + ")"; }
2265 #line 2266 "sqlite3_parser.cpp"
2266 break;
2267
2268 case 134:
2269 #line 500 "sqlite3_parser.yy"
2270 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " IN " + sqlb::escapeIdentifier(yystack_[2].value.as < std::string > ()) + "." + sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2271 #line 2272 "sqlite3_parser.cpp"
2272 break;
2273
2274 case 135:
2275 #line 501 "sqlite3_parser.yy"
2276 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " IN " + sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2277 #line 2278 "sqlite3_parser.cpp"
2278 break;
2279
2280 case 136:
2281 #line 502 "sqlite3_parser.yy"
2282 { yylhs.value.as < std::string > () = yystack_[6].value.as < std::string > () + " IN " + sqlb::escapeIdentifier(yystack_[4].value.as < std::string > ()) + "." + yystack_[2].value.as < std::string > () + "()"; }
2283 #line 2284 "sqlite3_parser.cpp"
2284 break;
2285
2286 case 137:
2287 #line 503 "sqlite3_parser.yy"
2288 { yylhs.value.as < std::string > () = yystack_[7].value.as < std::string > () + " IN " + sqlb::escapeIdentifier(yystack_[5].value.as < std::string > ()) + "." + yystack_[3].value.as < std::string > () + "(" + yystack_[1].value.as < std::string > () + ")"; }
2289 #line 2290 "sqlite3_parser.cpp"
2290 break;
2291
2292 case 138:
2293 #line 504 "sqlite3_parser.yy"
2294 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " IN " + yystack_[3].value.as < std::string > () + "(" + yystack_[1].value.as < std::string > () + ")"; }
2295 #line 2296 "sqlite3_parser.cpp"
2296 break;
2297
2298 case 139:
2299 #line 505 "sqlite3_parser.yy"
2300 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " NOT IN ()"; }
2301 #line 2302 "sqlite3_parser.cpp"
2302 break;
2303
2304 case 140:
2305 #line 506 "sqlite3_parser.yy"
2306 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT IN (" + yystack_[1].value.as < std::string > () + ")"; }
2307 #line 2308 "sqlite3_parser.cpp"
2308 break;
2309
2310 case 141:
2311 #line 507 "sqlite3_parser.yy"
2312 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT IN (" + yystack_[1].value.as < std::string > () + ")"; }
2313 #line 2314 "sqlite3_parser.cpp"
2314 break;
2315
2316 case 142:
2317 #line 508 "sqlite3_parser.yy"
2318 { yylhs.value.as < std::string > () = yystack_[5].value.as < std::string > () + " NOT IN " + sqlb::escapeIdentifier(yystack_[2].value.as < std::string > ()) + "." + sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2319 #line 2320 "sqlite3_parser.cpp"
2320 break;
2321
2322 case 143:
2323 #line 509 "sqlite3_parser.yy"
2324 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " NOT IN " + sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2325 #line 2326 "sqlite3_parser.cpp"
2326 break;
2327
2328 case 144:
2329 #line 510 "sqlite3_parser.yy"
2330 { yylhs.value.as < std::string > () = yystack_[7].value.as < std::string > () + " NOT IN " + sqlb::escapeIdentifier(yystack_[4].value.as < std::string > ()) + "." + yystack_[2].value.as < std::string > () + "()"; }
2331 #line 2332 "sqlite3_parser.cpp"
2332 break;
2333
2334 case 145:
2335 #line 511 "sqlite3_parser.yy"
2336 { yylhs.value.as < std::string > () = yystack_[8].value.as < std::string > () + " NOT IN " + sqlb::escapeIdentifier(yystack_[5].value.as < std::string > ()) + "." + yystack_[3].value.as < std::string > () + "(" + yystack_[1].value.as < std::string > () + ")"; }
2337 #line 2338 "sqlite3_parser.cpp"
2338 break;
2339
2340 case 146:
2341 #line 512 "sqlite3_parser.yy"
2342 { yylhs.value.as < std::string > () = yystack_[6].value.as < std::string > () + " NOT IN " + yystack_[3].value.as < std::string > () + "(" + yystack_[1].value.as < std::string > () + ")"; }
2343 #line 2344 "sqlite3_parser.cpp"
2344 break;
2345
2346 case 147:
2347 #line 516 "sqlite3_parser.yy"
2348 { yylhs.value.as < std::string > () = "WHEN " + yystack_[2].value.as < std::string > () + " THEN " + yystack_[0].value.as < std::string > (); }
2349 #line 2350 "sqlite3_parser.cpp"
2350 break;
2351
2352 case 148:
2353 #line 517 "sqlite3_parser.yy"
2354 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " WHEN" + yystack_[2].value.as < std::string > () + " THEN " + yystack_[0].value.as < std::string > (); }
2355 #line 2356 "sqlite3_parser.cpp"
2356 break;
2357
2358 case 149:
2359 #line 521 "sqlite3_parser.yy"
2360 { yylhs.value.as < std::string > () = "CASE " + yystack_[4].value.as < std::string > () + " " + yystack_[3].value.as < std::string > () + " ELSE " + yystack_[1].value.as < std::string > () + " END"; }
2361 #line 2362 "sqlite3_parser.cpp"
2362 break;
2363
2364 case 150:
2365 #line 522 "sqlite3_parser.yy"
2366 { yylhs.value.as < std::string > () = "CASE " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " END"; }
2367 #line 2368 "sqlite3_parser.cpp"
2368 break;
2369
2370 case 151:
2371 #line 523 "sqlite3_parser.yy"
2372 { yylhs.value.as < std::string > () = "CASE " + yystack_[3].value.as < std::string > () + " ELSE " + yystack_[1].value.as < std::string > () + " END"; }
2373 #line 2374 "sqlite3_parser.cpp"
2374 break;
2375
2376 case 152:
2377 #line 524 "sqlite3_parser.yy"
2378 { yylhs.value.as < std::string > () = "CASE " + yystack_[1].value.as < std::string > () + " END"; }
2379 #line 2380 "sqlite3_parser.cpp"
2380 break;
2381
2382 case 153:
2383 #line 528 "sqlite3_parser.yy"
2384 { yylhs.value.as < std::string > () = "RAISE(IGNORE)"; }
2385 #line 2386 "sqlite3_parser.cpp"
2386 break;
2387
2388 case 154:
2389 #line 529 "sqlite3_parser.yy"
2390 { yylhs.value.as < std::string > () = "RAISE(ROLLBACK, " + yystack_[1].value.as < std::string > () + ")"; }
2391 #line 2392 "sqlite3_parser.cpp"
2392 break;
2393
2394 case 155:
2395 #line 530 "sqlite3_parser.yy"
2396 { yylhs.value.as < std::string > () = "RAISE(ABORT, " + yystack_[1].value.as < std::string > () + ")"; }
2397 #line 2398 "sqlite3_parser.cpp"
2398 break;
2399
2400 case 156:
2401 #line 531 "sqlite3_parser.yy"
2402 { yylhs.value.as < std::string > () = "RAISE(FAIL, " + yystack_[1].value.as < std::string > () + ")"; }
2403 #line 2404 "sqlite3_parser.cpp"
2404 break;
2405
2406 case 157:
2407 #line 535 "sqlite3_parser.yy"
2408 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2409 #line 2410 "sqlite3_parser.cpp"
2410 break;
2411
2412 case 158:
2413 #line 536 "sqlite3_parser.yy"
2414 { yylhs.value.as < std::string > () = sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2415 #line 2416 "sqlite3_parser.cpp"
2416 break;
2417
2418 case 159:
2419 #line 537 "sqlite3_parser.yy"
2420 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2421 #line 2422 "sqlite3_parser.cpp"
2422 break;
2423
2424 case 160:
2425 #line 538 "sqlite3_parser.yy"
2426 { yylhs.value.as < std::string > () = sqlb::escapeIdentifier(yystack_[4].value.as < std::string > ()) + "." + sqlb::escapeIdentifier(yystack_[2].value.as < std::string > ()) + "." + sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2427 #line 2428 "sqlite3_parser.cpp"
2428 break;
2429
2430 case 161:
2431 #line 539 "sqlite3_parser.yy"
2432 { yylhs.value.as < std::string > () = sqlb::escapeIdentifier(yystack_[2].value.as < std::string > ()) + "." + sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2433 #line 2434 "sqlite3_parser.cpp"
2434 break;
2435
2436 case 162:
2437 #line 540 "sqlite3_parser.yy"
2438 { yylhs.value.as < std::string > () = sqlb::escapeIdentifier(yystack_[0].value.as < std::string > ()); }
2439 #line 2440 "sqlite3_parser.cpp"
2440 break;
2441
2442 case 163:
2443 #line 541 "sqlite3_parser.yy"
2444 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2445 #line 2446 "sqlite3_parser.cpp"
2446 break;
2447
2448 case 164:
2449 #line 542 "sqlite3_parser.yy"
2450 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2451 #line 2452 "sqlite3_parser.cpp"
2452 break;
2453
2454 case 165:
2455 #line 543 "sqlite3_parser.yy"
2456 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2457 #line 2458 "sqlite3_parser.cpp"
2458 break;
2459
2460 case 166:
2461 #line 544 "sqlite3_parser.yy"
2462 { yylhs.value.as < std::string > () = "(" + yystack_[1].value.as < std::string > () + ")"; }
2463 #line 2464 "sqlite3_parser.cpp"
2464 break;
2465
2466 case 167:
2467 #line 545 "sqlite3_parser.yy"
2468 { yylhs.value.as < std::string > () = "CAST(" + yystack_[3].value.as < std::string > () + " AS " + yystack_[1].value.as < std::string > () + ")"; }
2469 #line 2470 "sqlite3_parser.cpp"
2470 break;
2471
2472 case 168:
2473 #line 546 "sqlite3_parser.yy"
2474 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " COLLATE " + yystack_[0].value.as < std::string > (); }
2475 #line 2476 "sqlite3_parser.cpp"
2476 break;
2477
2478 case 169:
2479 #line 547 "sqlite3_parser.yy"
2480 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2481 #line 2482 "sqlite3_parser.cpp"
2482 break;
2483
2484 case 170:
2485 #line 548 "sqlite3_parser.yy"
2486 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2487 #line 2488 "sqlite3_parser.cpp"
2488 break;
2489
2490 case 171:
2491 #line 549 "sqlite3_parser.yy"
2492 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2493 #line 2494 "sqlite3_parser.cpp"
2494 break;
2495
2496 case 172:
2497 #line 550 "sqlite3_parser.yy"
2498 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2499 #line 2500 "sqlite3_parser.cpp"
2500 break;
2501
2502 case 173:
2503 #line 551 "sqlite3_parser.yy"
2504 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2505 #line 2506 "sqlite3_parser.cpp"
2506 break;
2507
2508 case 174:
2509 #line 552 "sqlite3_parser.yy"
2510 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2511 #line 2512 "sqlite3_parser.cpp"
2512 break;
2513
2514 case 175:
2515 #line 561 "sqlite3_parser.yy"
2516 { yylhs.value.as < std::string > () = "SELECT"; }
2517 #line 2518 "sqlite3_parser.cpp"
2518 break;
2519
2520 case 176:
2521 #line 569 "sqlite3_parser.yy"
2522 { yylhs.value.as < bool > () = false; }
2523 #line 2524 "sqlite3_parser.cpp"
2524 break;
2525
2526 case 177:
2527 #line 570 "sqlite3_parser.yy"
2528 { yylhs.value.as < bool > () = true; }
2529 #line 2530 "sqlite3_parser.cpp"
2530 break;
2531
2532 case 178:
2533 #line 574 "sqlite3_parser.yy"
2534 { yylhs.value.as < std::string > () = ""; }
2535 #line 2536 "sqlite3_parser.cpp"
2536 break;
2537
2538 case 179:
2539 #line 575 "sqlite3_parser.yy"
2540 { yylhs.value.as < std::string > () = "ASC"; }
2541 #line 2542 "sqlite3_parser.cpp"
2542 break;
2543
2544 case 180:
2545 #line 576 "sqlite3_parser.yy"
2546 { yylhs.value.as < std::string > () = "DESC"; }
2547 #line 2548 "sqlite3_parser.cpp"
2548 break;
2549
2550 case 181:
2551 #line 584 "sqlite3_parser.yy"
2552 { yylhs.value.as < bool > () = false; }
2553 #line 2554 "sqlite3_parser.cpp"
2554 break;
2555
2556 case 182:
2557 #line 585 "sqlite3_parser.yy"
2558 { yylhs.value.as < bool > () = true; }
2559 #line 2560 "sqlite3_parser.cpp"
2560 break;
2561
2562 case 183:
2563 #line 589 "sqlite3_parser.yy"
2564 { yylhs.value.as < std::string > () = ""; }
2565 #line 2566 "sqlite3_parser.cpp"
2566 break;
2567
2568 case 184:
2569 #line 590 "sqlite3_parser.yy"
2570 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2571 #line 2572 "sqlite3_parser.cpp"
2572 break;
2573
2574 case 185:
2575 #line 594 "sqlite3_parser.yy"
2576 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2577 #line 2578 "sqlite3_parser.cpp"
2578 break;
2579
2580 case 186:
2581 #line 595 "sqlite3_parser.yy"
2582 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2583 #line 2584 "sqlite3_parser.cpp"
2584 break;
2585
2586 case 187:
2587 #line 596 "sqlite3_parser.yy"
2588 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2589 #line 2590 "sqlite3_parser.cpp"
2590 break;
2591
2592 case 188:
2593 #line 600 "sqlite3_parser.yy"
2594 {
2595 // If the expression is only one column name and nothing else, treat it as a column name; otherwise as an expression.
2596 char quote = getIdentifierQuoteChar();
2597 if((quote == '[' && std::count(yystack_[1].value.as < std::string > ().begin(), yystack_[1].value.as < std::string > ().end(), quote) == 1 && yystack_[1].value.as < std::string > ().front() == '[' && yystack_[1].value.as < std::string > ().back() == ']') ||
2598 (quote != '[' && std::count(yystack_[1].value.as < std::string > ().begin(), yystack_[1].value.as < std::string > ().end(), quote) == 2 && yystack_[1].value.as < std::string > ().front() == quote && yystack_[1].value.as < std::string > ().back() == quote))
2599 {
2600 yylhs.value.as < sqlb::IndexedColumn > () = sqlb::IndexedColumn(unquote_text(yystack_[1].value.as < std::string > (), quote), false, yystack_[0].value.as < std::string > ());
2601 } else {
2602 yylhs.value.as < sqlb::IndexedColumn > () = sqlb::IndexedColumn(yystack_[1].value.as < std::string > (), true, yystack_[0].value.as < std::string > ());
2603 }
2604 }
2605 #line 2606 "sqlite3_parser.cpp"
2606 break;
2607
2608 case 189:
2609 #line 614 "sqlite3_parser.yy"
2610 { yylhs.value.as < sqlb::IndexedColumnVector > () = sqlb::IndexedColumnVector(1, yystack_[0].value.as < sqlb::IndexedColumn > ()); }
2611 #line 2612 "sqlite3_parser.cpp"
2612 break;
2613
2614 case 190:
2615 #line 615 "sqlite3_parser.yy"
2616 { yylhs.value.as < sqlb::IndexedColumnVector > () = yystack_[2].value.as < sqlb::IndexedColumnVector > (); yylhs.value.as < sqlb::IndexedColumnVector > ().push_back(yystack_[0].value.as < sqlb::IndexedColumn > ()); }
2617 #line 2618 "sqlite3_parser.cpp"
2618 break;
2619
2620 case 191:
2621 #line 619 "sqlite3_parser.yy"
2622 {
2623 yylhs.value.as < sqlb::IndexPtr > () = sqlb::IndexPtr(new sqlb::Index(yystack_[6].value.as < std::string > ()));
2624 yylhs.value.as < sqlb::IndexPtr > ()->setTable(yystack_[4].value.as < std::string > ());
2625 yylhs.value.as < sqlb::IndexPtr > ()->setUnique(yystack_[9].value.as < bool > ());
2626 yylhs.value.as < sqlb::IndexPtr > ()->setWhereExpr(yystack_[0].value.as < std::string > ());
2627 yylhs.value.as < sqlb::IndexPtr > ()->fields = yystack_[2].value.as < sqlb::IndexedColumnVector > ();
2628 yylhs.value.as < sqlb::IndexPtr > ()->setFullyParsed(true);
2629 }
2630 #line 2631 "sqlite3_parser.cpp"
2631 break;
2632
2633 case 192:
2634 #line 634 "sqlite3_parser.yy"
2635 { yylhs.value.as < std::string > () = {}; }
2636 #line 2637 "sqlite3_parser.cpp"
2637 break;
2638
2639 case 193:
2640 #line 635 "sqlite3_parser.yy"
2641 { yylhs.value.as < std::string > () = {}; }
2642 #line 2643 "sqlite3_parser.cpp"
2643 break;
2644
2645 case 194:
2646 #line 636 "sqlite3_parser.yy"
2647 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > (); }
2648 #line 2649 "sqlite3_parser.cpp"
2649 break;
2650
2651 case 195:
2652 #line 640 "sqlite3_parser.yy"
2653 {
2654 yylhs.value.as < sqlb::TablePtr > () = sqlb::TablePtr(new sqlb::Table(yystack_[3].value.as < std::string > ()));
2655 yylhs.value.as < sqlb::TablePtr > ()->setVirtualUsing(yystack_[1].value.as < std::string > ());
2656 yylhs.value.as < sqlb::TablePtr > ()->setFullyParsed(false);
2657 }
2658 #line 2659 "sqlite3_parser.cpp"
2659 break;
2660
2661 case 196:
2662 #line 652 "sqlite3_parser.yy"
2663 { yylhs.value.as < bool > () = false; }
2664 #line 2665 "sqlite3_parser.cpp"
2665 break;
2666
2667 case 197:
2668 #line 653 "sqlite3_parser.yy"
2669 { yylhs.value.as < bool > () = true; }
2670 #line 2671 "sqlite3_parser.cpp"
2671 break;
2672
2673 case 198:
2674 #line 654 "sqlite3_parser.yy"
2675 { yylhs.value.as < bool > () = true; }
2676 #line 2677 "sqlite3_parser.cpp"
2677 break;
2678
2679 case 199:
2680 #line 658 "sqlite3_parser.yy"
2681 { yylhs.value.as < bool > () = false; }
2682 #line 2683 "sqlite3_parser.cpp"
2683 break;
2684
2685 case 200:
2686 #line 659 "sqlite3_parser.yy"
2687 { yylhs.value.as < bool > () = true; }
2688 #line 2689 "sqlite3_parser.cpp"
2689 break;
2690
2691 case 201:
2692 #line 663 "sqlite3_parser.yy"
2693 { yylhs.value.as < std::string > () = ""; }
2694 #line 2695 "sqlite3_parser.cpp"
2695 break;
2696
2697 case 202:
2698 #line 664 "sqlite3_parser.yy"
2699 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2700 #line 2701 "sqlite3_parser.cpp"
2701 break;
2702
2703 case 203:
2704 #line 665 "sqlite3_parser.yy"
2705 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2706 #line 2707 "sqlite3_parser.cpp"
2707 break;
2708
2709 case 204:
2710 #line 666 "sqlite3_parser.yy"
2711 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2712 #line 2713 "sqlite3_parser.cpp"
2713 break;
2714
2715 case 205:
2716 #line 667 "sqlite3_parser.yy"
2717 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2718 #line 2719 "sqlite3_parser.cpp"
2719 break;
2720
2721 case 206:
2722 #line 668 "sqlite3_parser.yy"
2723 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2724 #line 2725 "sqlite3_parser.cpp"
2725 break;
2726
2727 case 207:
2728 #line 672 "sqlite3_parser.yy"
2729 { yylhs.value.as < std::string > () = ""; }
2730 #line 2731 "sqlite3_parser.cpp"
2731 break;
2732
2733 case 208:
2734 #line 673 "sqlite3_parser.yy"
2735 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
2736 #line 2737 "sqlite3_parser.cpp"
2737 break;
2738
2739 case 209:
2740 #line 677 "sqlite3_parser.yy"
2741 { yylhs.value.as < std::string > () = "VIRTUAL"; }
2742 #line 2743 "sqlite3_parser.cpp"
2743 break;
2744
2745 case 210:
2746 #line 678 "sqlite3_parser.yy"
2747 { yylhs.value.as < std::string > () = "STORED"; }
2748 #line 2749 "sqlite3_parser.cpp"
2749 break;
2750
2751 case 211:
2752 #line 679 "sqlite3_parser.yy"
2753 { yylhs.value.as < std::string > () = "VIRTUAL"; }
2754 #line 2755 "sqlite3_parser.cpp"
2755 break;
2756
2757 case 212:
2758 #line 683 "sqlite3_parser.yy"
2759 { yylhs.value.as < bool > () = false; }
2760 #line 2761 "sqlite3_parser.cpp"
2761 break;
2762
2763 case 213:
2764 #line 684 "sqlite3_parser.yy"
2765 { yylhs.value.as < bool > () = true; }
2766 #line 2767 "sqlite3_parser.cpp"
2767 break;
2768
2769 case 214:
2770 #line 688 "sqlite3_parser.yy"
2771 {
2772 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::PrimaryKey;
2773 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = true;
2774 sqlb::PrimaryKeyConstraint* pk = new sqlb::PrimaryKeyConstraint({sqlb::IndexedColumn("", false, yystack_[1].value.as < std::string > ())});
2775 pk->setName(yystack_[4].value.as < std::string > ());
2776 pk->setConflictAction(yystack_[0].value.as < std::string > ());
2777 yylhs.value.as < ColumnConstraintInfo > ().table_constraint = sqlb::ConstraintPtr(pk);
2778 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = true;
2779 }
2780 #line 2781 "sqlite3_parser.cpp"
2781 break;
2782
2783 case 215:
2784 #line 697 "sqlite3_parser.yy"
2785 {
2786 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::PrimaryKey;
2787 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = true;
2788 sqlb::PrimaryKeyConstraint* pk = new sqlb::PrimaryKeyConstraint({sqlb::IndexedColumn("", false, yystack_[2].value.as < std::string > ())});
2789 pk->setName(yystack_[5].value.as < std::string > ());
2790 pk->setConflictAction(yystack_[1].value.as < std::string > ());
2791 pk->setAutoIncrement(true);
2792 yylhs.value.as < ColumnConstraintInfo > ().table_constraint = sqlb::ConstraintPtr(pk);
2793 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = true;
2794 }
2795 #line 2796 "sqlite3_parser.cpp"
2796 break;
2797
2798 case 216:
2799 #line 707 "sqlite3_parser.yy"
2800 {
2801 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::NotNull;
2802 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2803 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[3].value.as < std::string > () == "" && yystack_[0].value.as < std::string > () == "");
2804 }
2805 #line 2806 "sqlite3_parser.cpp"
2806 break;
2807
2808 case 217:
2809 #line 712 "sqlite3_parser.yy"
2810 {
2811 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::None;
2812 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2813 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = true;
2814 }
2815 #line 2816 "sqlite3_parser.cpp"
2816 break;
2817
2818 case 218:
2819 #line 717 "sqlite3_parser.yy"
2820 {
2821 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Unique;
2822 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2823 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "" && yystack_[0].value.as < std::string > () == "");
2824 }
2825 #line 2826 "sqlite3_parser.cpp"
2826 break;
2827
2828 case 219:
2829 #line 722 "sqlite3_parser.yy"
2830 {
2831 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Check;
2832 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2833 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[1].value.as < std::string > ();
2834 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[4].value.as < std::string > () == "");
2835 }
2836 #line 2837 "sqlite3_parser.cpp"
2837 break;
2838
2839 case 220:
2840 #line 728 "sqlite3_parser.yy"
2841 {
2842 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Default;
2843 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2844 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[0].value.as < std::string > ();
2845 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "");
2846 }
2847 #line 2848 "sqlite3_parser.cpp"
2848 break;
2849
2850 case 221:
2851 #line 734 "sqlite3_parser.yy"
2852 {
2853 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Default;
2854 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2855 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[0].value.as < std::string > ();
2856 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "");
2857 }
2858 #line 2859 "sqlite3_parser.cpp"
2859 break;
2860
2861 case 222:
2862 #line 740 "sqlite3_parser.yy"
2863 {
2864 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Default;
2865 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2866 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[0].value.as < std::string > ();
2867 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "");
2868 }
2869 #line 2870 "sqlite3_parser.cpp"
2870 break;
2871
2872 case 223:
2873 #line 746 "sqlite3_parser.yy"
2874 { // We must allow the same keywords as unquoted default values as in the columnid context.
2875 // But we do not use columnid here in order to avoid reduce/reduce conflicts.
2876 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Default;
2877 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2878 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[0].value.as < std::string > ();
2879 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "");
2880 }
2881 #line 2882 "sqlite3_parser.cpp"
2882 break;
2883
2884 case 224:
2885 #line 753 "sqlite3_parser.yy"
2886 { // Same as above.
2887 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Default;
2888 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2889 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[0].value.as < std::string > ();
2890 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "");
2891 }
2892 #line 2893 "sqlite3_parser.cpp"
2893 break;
2894
2895 case 225:
2896 #line 759 "sqlite3_parser.yy"
2897 {
2898 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Default;
2899 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2900 yylhs.value.as < ColumnConstraintInfo > ().text = "(" + yystack_[1].value.as < std::string > () + ")";
2901 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[4].value.as < std::string > () == "");
2902 }
2903 #line 2904 "sqlite3_parser.cpp"
2904 break;
2905
2906 case 226:
2907 #line 765 "sqlite3_parser.yy"
2908 {
2909 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Collate;
2910 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2911 yylhs.value.as < ColumnConstraintInfo > ().text = yystack_[0].value.as < std::string > ();
2912 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = (yystack_[2].value.as < std::string > () == "");
2913 }
2914 #line 2915 "sqlite3_parser.cpp"
2915 break;
2916
2917 case 227:
2918 #line 771 "sqlite3_parser.yy"
2919 { // TODO Solve shift/reduce conflict. It is not super important though as shifting seems to be right here.
2920 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::ForeignKey;
2921 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = true;
2922 sqlb::ForeignKeyClause* fk = new sqlb::ForeignKeyClause();
2923 fk->setName(yystack_[4].value.as < std::string > ());
2924 fk->setTable(yystack_[2].value.as < std::string > ());
2925 fk->setColumns(yystack_[1].value.as < sqlb::StringVector > ());
2926 fk->setConstraint(yystack_[0].value.as < std::string > ());
2927 yylhs.value.as < ColumnConstraintInfo > ().table_constraint = sqlb::ConstraintPtr(fk);
2928 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = true;
2929 }
2930 #line 2931 "sqlite3_parser.cpp"
2931 break;
2932
2933 case 228:
2934 #line 782 "sqlite3_parser.yy"
2935 { // TODO Solve shift/reduce conflict.
2936 yylhs.value.as < ColumnConstraintInfo > ().type = ColumnConstraintInfo::Generated;
2937 yylhs.value.as < ColumnConstraintInfo > ().is_table_constraint = false;
2938 yylhs.value.as < ColumnConstraintInfo > ().generated_constraint.setExpression(yystack_[2].value.as < std::string > ());
2939 yylhs.value.as < ColumnConstraintInfo > ().generated_constraint.setStorage(yystack_[0].value.as < std::string > ());
2940 yylhs.value.as < ColumnConstraintInfo > ().generated_constraint.setName(yystack_[6].value.as < std::string > ());
2941 yylhs.value.as < ColumnConstraintInfo > ().fully_parsed = true;
2942 }
2943 #line 2944 "sqlite3_parser.cpp"
2944 break;
2945
2946 case 229:
2947 #line 793 "sqlite3_parser.yy"
2948 { yylhs.value.as < ColumnConstraintInfoVector > () = { yystack_[0].value.as < ColumnConstraintInfo > () }; }
2949 #line 2950 "sqlite3_parser.cpp"
2950 break;
2951
2952 case 230:
2953 #line 794 "sqlite3_parser.yy"
2954 { yylhs.value.as < ColumnConstraintInfoVector > () = yystack_[1].value.as < ColumnConstraintInfoVector > (); yylhs.value.as < ColumnConstraintInfoVector > ().push_back(yystack_[0].value.as < ColumnConstraintInfo > ()); }
2955 #line 2956 "sqlite3_parser.cpp"
2956 break;
2957
2958 case 231:
2959 #line 798 "sqlite3_parser.yy"
2960 {
2961 sqlb::Field f(yystack_[2].value.as < std::string > (), yystack_[1].value.as < std::string > ());
2962 bool fully_parsed = true;
2963 sqlb::ConstraintSet table_constraints{};
2964 for(auto c : yystack_[0].value.as < ColumnConstraintInfoVector > ())
2965 {
2966 if(c.fully_parsed == false)
2967 fully_parsed = false;
2968
2969 if(c.type == ColumnConstraintInfo::None)
2970 continue;
2971
2972 if(c.is_table_constraint)
2973 {
2974 if(c.table_constraint->columnList().empty())
2975 c.table_constraint->setColumnList({yystack_[2].value.as < std::string > ()});
2976 else
2977 c.table_constraint->replaceInColumnList("", yystack_[2].value.as < std::string > ());
2978 table_constraints.insert(c.table_constraint);
2979 } else {
2980 if(c.type == ColumnConstraintInfo::NotNull) {
2981 f.setNotNull(true);
2982 } else if(c.type == ColumnConstraintInfo::Unique) {
2983 f.setUnique(true);
2984 } else if(c.type == ColumnConstraintInfo::Check) {
2985 f.setCheck(c.text);
2986 } else if(c.type == ColumnConstraintInfo::Default) {
2987 f.setDefaultValue(c.text);
2988 } else if(c.type == ColumnConstraintInfo::Collate) {
2989 f.setCollation(c.text);
2990 } else if(c.type == ColumnConstraintInfo::Generated) {
2991 f.setGenerated(c.generated_constraint);
2992
2993 // This is a hack which removes any "GENERATED ALWAYS" from the end of the type name.
2994 // As of now these are shifted to the type instead of reducing the type when seeing the GENERATED identifier.
2995 // TODO Remove this once the grammar is conflict free
2996 const std::string generated_always = "GENERATED ALWAYS";
2997 if(f.type().size() >= generated_always.size() && f.type().compare(f.type().size() - generated_always.size(), generated_always.size(), generated_always) == 0)
2998 {
2999 std::string type = f.type().substr(0, f.type().size()-generated_always.size());
3000 if(type.back() == ' ')
3001 type.pop_back();
3002 f.setType(type);
3003 }
3004 } else {
3005 fully_parsed = false;
3006 }
3007 }
3008 }
3009
3010 yylhs.value.as < ColumndefData > () = std::make_tuple(f, table_constraints, fully_parsed);
3011 }
3012 #line 3013 "sqlite3_parser.cpp"
3013 break;
3014
3015 case 232:
3016 #line 850 "sqlite3_parser.yy"
3017 { yylhs.value.as < ColumndefData > () = std::make_tuple(sqlb::Field(yystack_[1].value.as < std::string > (), yystack_[0].value.as < std::string > ()), sqlb::ConstraintSet{}, true); }
3018 #line 3019 "sqlite3_parser.cpp"
3019 break;
3020
3021 case 233:
3022 #line 854 "sqlite3_parser.yy"
3023 { yylhs.value.as < std::vector<ColumndefData> > () = {yystack_[0].value.as < ColumndefData > ()}; }
3024 #line 3025 "sqlite3_parser.cpp"
3025 break;
3026
3027 case 234:
3028 #line 855 "sqlite3_parser.yy"
3029 { yylhs.value.as < std::vector<ColumndefData> > () = yystack_[2].value.as < std::vector<ColumndefData> > (); yylhs.value.as < std::vector<ColumndefData> > ().push_back(yystack_[0].value.as < ColumndefData > ()); }
3030 #line 3031 "sqlite3_parser.cpp"
3031 break;
3032
3033 case 235:
3034 #line 859 "sqlite3_parser.yy"
3035 { yylhs.value.as < std::string > () = ""; }
3036 #line 3037 "sqlite3_parser.cpp"
3037 break;
3038
3039 case 236:
3040 #line 860 "sqlite3_parser.yy"
3041 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
3042 #line 3043 "sqlite3_parser.cpp"
3043 break;
3044
3045 case 237:
3046 #line 864 "sqlite3_parser.yy"
3047 { yylhs.value.as < sqlb::StringVector > () = sqlb::StringVector(1, yystack_[0].value.as < std::string > ()); }
3048 #line 3049 "sqlite3_parser.cpp"
3049 break;
3050
3051 case 238:
3052 #line 865 "sqlite3_parser.yy"
3053 { yylhs.value.as < sqlb::StringVector > () = yystack_[2].value.as < sqlb::StringVector > (); yylhs.value.as < sqlb::StringVector > ().push_back(yystack_[0].value.as < std::string > ()); }
3054 #line 3055 "sqlite3_parser.cpp"
3055 break;
3056
3057 case 239:
3058 #line 869 "sqlite3_parser.yy"
3059 { yylhs.value.as < sqlb::StringVector > () = sqlb::StringVector(); }
3060 #line 3061 "sqlite3_parser.cpp"
3061 break;
3062
3063 case 240:
3064 #line 870 "sqlite3_parser.yy"
3065 { yylhs.value.as < sqlb::StringVector > () = yystack_[1].value.as < sqlb::StringVector > (); }
3066 #line 3067 "sqlite3_parser.cpp"
3067 break;
3068
3069 case 241:
3070 #line 874 "sqlite3_parser.yy"
3071 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3072 #line 3073 "sqlite3_parser.cpp"
3073 break;
3074
3075 case 242:
3076 #line 875 "sqlite3_parser.yy"
3077 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3078 #line 3079 "sqlite3_parser.cpp"
3079 break;
3080
3081 case 243:
3082 #line 876 "sqlite3_parser.yy"
3083 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3084 #line 3085 "sqlite3_parser.cpp"
3085 break;
3086
3087 case 244:
3088 #line 877 "sqlite3_parser.yy"
3089 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3090 #line 3091 "sqlite3_parser.cpp"
3091 break;
3092
3093 case 245:
3094 #line 878 "sqlite3_parser.yy"
3095 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3096 #line 3097 "sqlite3_parser.cpp"
3097 break;
3098
3099 case 246:
3100 #line 879 "sqlite3_parser.yy"
3101 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3102 #line 3103 "sqlite3_parser.cpp"
3103 break;
3104
3105 case 247:
3106 #line 880 "sqlite3_parser.yy"
3107 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3108 #line 3109 "sqlite3_parser.cpp"
3109 break;
3110
3111 case 248:
3112 #line 881 "sqlite3_parser.yy"
3113 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3114 #line 3115 "sqlite3_parser.cpp"
3115 break;
3116
3117 case 249:
3118 #line 882 "sqlite3_parser.yy"
3119 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3120 #line 3121 "sqlite3_parser.cpp"
3121 break;
3122
3123 case 250:
3124 #line 883 "sqlite3_parser.yy"
3125 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3126 #line 3127 "sqlite3_parser.cpp"
3127 break;
3128
3129 case 251:
3130 #line 884 "sqlite3_parser.yy"
3131 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3132 #line 3133 "sqlite3_parser.cpp"
3133 break;
3134
3135 case 252:
3136 #line 885 "sqlite3_parser.yy"
3137 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3138 #line 3139 "sqlite3_parser.cpp"
3139 break;
3140
3141 case 253:
3142 #line 886 "sqlite3_parser.yy"
3143 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3144 #line 3145 "sqlite3_parser.cpp"
3145 break;
3146
3147 case 254:
3148 #line 887 "sqlite3_parser.yy"
3149 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3150 #line 3151 "sqlite3_parser.cpp"
3151 break;
3152
3153 case 255:
3154 #line 888 "sqlite3_parser.yy"
3155 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3156 #line 3157 "sqlite3_parser.cpp"
3157 break;
3158
3159 case 256:
3160 #line 889 "sqlite3_parser.yy"
3161 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3162 #line 3163 "sqlite3_parser.cpp"
3163 break;
3164
3165 case 257:
3166 #line 893 "sqlite3_parser.yy"
3167 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
3168 #line 3169 "sqlite3_parser.cpp"
3169 break;
3170
3171 case 258:
3172 #line 894 "sqlite3_parser.yy"
3173 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3174 #line 3175 "sqlite3_parser.cpp"
3175 break;
3176
3177 case 259:
3178 #line 898 "sqlite3_parser.yy"
3179 { yylhs.value.as < std::string > () = ""; }
3180 #line 3181 "sqlite3_parser.cpp"
3181 break;
3182
3183 case 260:
3184 #line 899 "sqlite3_parser.yy"
3185 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
3186 #line 3187 "sqlite3_parser.cpp"
3187 break;
3188
3189 case 261:
3190 #line 900 "sqlite3_parser.yy"
3191 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3192 #line 3193 "sqlite3_parser.cpp"
3193 break;
3194
3195 case 262:
3196 #line 901 "sqlite3_parser.yy"
3197 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3198 #line 3199 "sqlite3_parser.cpp"
3199 break;
3200
3201 case 263:
3202 #line 902 "sqlite3_parser.yy"
3203 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3204 #line 3205 "sqlite3_parser.cpp"
3205 break;
3206
3207 case 264:
3208 #line 903 "sqlite3_parser.yy"
3209 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " " + yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3210 #line 3211 "sqlite3_parser.cpp"
3211 break;
3212
3213 case 265:
3214 #line 904 "sqlite3_parser.yy"
3215 { yylhs.value.as < std::string > () = yystack_[4].value.as < std::string > () + " " + yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3216 #line 3217 "sqlite3_parser.cpp"
3217 break;
3218
3219 case 266:
3220 #line 905 "sqlite3_parser.yy"
3221 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3222 #line 3223 "sqlite3_parser.cpp"
3223 break;
3224
3225 case 267:
3226 #line 906 "sqlite3_parser.yy"
3227 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3228 #line 3229 "sqlite3_parser.cpp"
3229 break;
3230
3231 case 268:
3232 #line 907 "sqlite3_parser.yy"
3233 { yylhs.value.as < std::string > () = yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3234 #line 3235 "sqlite3_parser.cpp"
3235 break;
3236
3237 case 269:
3238 #line 908 "sqlite3_parser.yy"
3239 { yylhs.value.as < std::string > () = yystack_[0].value.as < std::string > (); }
3240 #line 3241 "sqlite3_parser.cpp"
3241 break;
3242
3243 case 270:
3244 #line 909 "sqlite3_parser.yy"
3245 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3246 #line 3247 "sqlite3_parser.cpp"
3247 break;
3248
3249 case 271:
3250 #line 910 "sqlite3_parser.yy"
3251 { yylhs.value.as < std::string > () = yystack_[3].value.as < std::string > () + " " + yystack_[2].value.as < std::string > () + " " + yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3252 #line 3253 "sqlite3_parser.cpp"
3253 break;
3254
3255 case 272:
3256 #line 911 "sqlite3_parser.yy"
3257 { yylhs.value.as < std::string > () = yystack_[1].value.as < std::string > () + " " + yystack_[0].value.as < std::string > (); }
3258 #line 3259 "sqlite3_parser.cpp"
3259 break;
3260
3261 case 273:
3262 #line 915 "sqlite3_parser.yy"
3263 {
3264 sqlb::PrimaryKeyConstraint* pk = new sqlb::PrimaryKeyConstraint(yystack_[2].value.as < sqlb::IndexedColumnVector > ());
3265 pk->setName(yystack_[6].value.as < std::string > ());
3266 pk->setConflictAction(yystack_[0].value.as < std::string > ());
3267 yylhs.value.as < sqlb::ConstraintPtr > () = sqlb::ConstraintPtr(pk);
3268 }
3269 #line 3270 "sqlite3_parser.cpp"
3270 break;
3271
3272 case 274:
3273 #line 921 "sqlite3_parser.yy"
3274 {
3275 sqlb::PrimaryKeyConstraint* pk = new sqlb::PrimaryKeyConstraint(yystack_[3].value.as < sqlb::IndexedColumnVector > ());
3276 pk->setName(yystack_[7].value.as < std::string > ());
3277 pk->setConflictAction(yystack_[0].value.as < std::string > ());
3278 pk->setAutoIncrement(true);
3279 yylhs.value.as < sqlb::ConstraintPtr > () = sqlb::ConstraintPtr(pk);
3280 }
3281 #line 3282 "sqlite3_parser.cpp"
3282 break;
3283
3284 case 275:
3285 #line 928 "sqlite3_parser.yy"
3286 {
3287 sqlb::UniqueConstraint* u = new sqlb::UniqueConstraint(yystack_[2].value.as < sqlb::IndexedColumnVector > ());
3288 u->setName(yystack_[5].value.as < std::string > ());
3289 u->setConflictAction(yystack_[0].value.as < std::string > ());
3290 yylhs.value.as < sqlb::ConstraintPtr > () = sqlb::ConstraintPtr(u);
3291 }
3292 #line 3293 "sqlite3_parser.cpp"
3293 break;
3294
3295 case 276:
3296 #line 934 "sqlite3_parser.yy"
3297 {
3298 yylhs.value.as < sqlb::ConstraintPtr > () = sqlb::ConstraintPtr(new sqlb::CheckConstraint(yystack_[1].value.as < std::string > ()));
3299 yylhs.value.as < sqlb::ConstraintPtr > ()->setName(yystack_[4].value.as < std::string > ());
3300 }
3301 #line 3302 "sqlite3_parser.cpp"
3302 break;
3303
3304 case 277:
3305 #line 938 "sqlite3_parser.yy"
3306 {
3307 yylhs.value.as < sqlb::ConstraintPtr > () = sqlb::ConstraintPtr(new sqlb::ForeignKeyClause(yystack_[2].value.as < std::string > (), yystack_[1].value.as < sqlb::StringVector > (), yystack_[0].value.as < std::string > ()));
3308 yylhs.value.as < sqlb::ConstraintPtr > ()->setColumnList(yystack_[5].value.as < sqlb::StringVector > ());
3309 yylhs.value.as < sqlb::ConstraintPtr > ()->setName(yystack_[9].value.as < std::string > ());
3310 }
3311 #line 3312 "sqlite3_parser.cpp"
3312 break;
3313
3314 case 278:
3315 #line 946 "sqlite3_parser.yy"
3316 { yylhs.value.as < sqlb::ConstraintSet > () = {yystack_[0].value.as < sqlb::ConstraintPtr > ()}; }
3317 #line 3318 "sqlite3_parser.cpp"
3318 break;
3319
3320 case 279:
3321 #line 947 "sqlite3_parser.yy"
3322 { yylhs.value.as < sqlb::ConstraintSet > () = yystack_[2].value.as < sqlb::ConstraintSet > (); yylhs.value.as < sqlb::ConstraintSet > ().insert(yystack_[0].value.as < sqlb::ConstraintPtr > ()); }
3323 #line 3324 "sqlite3_parser.cpp"
3324 break;
3325
3326 case 280:
3327 #line 948 "sqlite3_parser.yy"
3328 { yylhs.value.as < sqlb::ConstraintSet > () = yystack_[1].value.as < sqlb::ConstraintSet > (); yylhs.value.as < sqlb::ConstraintSet > ().insert(yystack_[0].value.as < sqlb::ConstraintPtr > ()); }
3329 #line 3330 "sqlite3_parser.cpp"
3330 break;
3331
3332 case 281:
3333 #line 952 "sqlite3_parser.yy"
3334 { yylhs.value.as < sqlb::ConstraintSet > () = {}; }
3335 #line 3336 "sqlite3_parser.cpp"
3336 break;
3337
3338 case 282:
3339 #line 953 "sqlite3_parser.yy"
3340 { yylhs.value.as < sqlb::ConstraintSet > () = yystack_[0].value.as < sqlb::ConstraintSet > (); }
3341 #line 3342 "sqlite3_parser.cpp"
3342 break;
3343
3344 case 283:
3345 #line 957 "sqlite3_parser.yy"
3346 {
3347 yylhs.value.as < sqlb::TablePtr > () = sqlb::TablePtr(new sqlb::Table(yystack_[2].value.as < std::string > ()));
3348 yylhs.value.as < sqlb::TablePtr > ()->setFullyParsed(false);
3349 }
3350 #line 3351 "sqlite3_parser.cpp"
3351 break;
3352
3353 case 284:
3354 #line 961 "sqlite3_parser.yy"
3355 {
3356 yylhs.value.as < sqlb::TablePtr > () = sqlb::TablePtr(new sqlb::Table(yystack_[5].value.as < std::string > ()));
3357 yylhs.value.as < sqlb::TablePtr > ()->setWithoutRowidTable(yystack_[0].value.as < bool > ());
3358 yylhs.value.as < sqlb::TablePtr > ()->setConstraints(yystack_[2].value.as < sqlb::ConstraintSet > ());
3359 yylhs.value.as < sqlb::TablePtr > ()->setFullyParsed(true);
3360
3361 for(const auto& column : yystack_[3].value.as < std::vector<ColumndefData> > ())
3362 {
3363 sqlb::Field f;
3364 sqlb::ConstraintSet c;
3365 bool fully_parsed;
3366 std::tie(f, c, fully_parsed) = column;
3367
3368 if(fully_parsed == false)
3369 yylhs.value.as < sqlb::TablePtr > ()->setFullyParsed(false);
3370 yylhs.value.as < sqlb::TablePtr > ()->fields.push_back(f);
3371 for(const auto& i : c)
3372 yylhs.value.as < sqlb::TablePtr > ()->addConstraint(i);
3373 }
3374 }
3375 #line 3376 "sqlite3_parser.cpp"
3376 break;
3377
3378
3379 #line 3380 "sqlite3_parser.cpp"
3380
3381 default:
3382 break;
3383 }
3384 }
3385 #if YY_EXCEPTIONS
3386 catch (const syntax_error& yyexc)
3387 {
3388 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
3389 error (yyexc);
3390 YYERROR;
3391 }
3392 #endif // YY_EXCEPTIONS
3393 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
3394 yypop_ (yylen);
3395 yylen = 0;
3396 YY_STACK_PRINT ();
3397
3398 // Shift the result of the reduction.
3399 yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
3400 }
3401 goto yynewstate;
3402
3403
3404 /*--------------------------------------.
3405 | yyerrlab -- here on detecting error. |
3406 `--------------------------------------*/
3407 yyerrlab:
3408 // If not already recovering from an error, report this error.
3409 if (!yyerrstatus_)
3410 {
3411 ++yynerrs_;
3412 error (yyla.location, yysyntax_error_ (yystack_[0].state, yyla));
3413 }
3414
3415
3416 yyerror_range[1].location = yyla.location;
3417 if (yyerrstatus_ == 3)
3418 {
3419 /* If just tried and failed to reuse lookahead token after an
3420 error, discard it. */
3421
3422 // Return failure if at end of input.
3423 if (yyla.type_get () == yyeof_)
3424 YYABORT;
3425 else if (!yyla.empty ())
3426 {
3427 yy_destroy_ ("Error: discarding", yyla);
3428 yyla.clear ();
3429 }
3430 }
3431
3432 // Else will try to reuse lookahead token after shifting the error token.
3433 goto yyerrlab1;
3434
3435
3436 /*---------------------------------------------------.
3437 | yyerrorlab -- error raised explicitly by YYERROR. |
3438 `---------------------------------------------------*/
3439 yyerrorlab:
3440 /* Pacify compilers when the user code never invokes YYERROR and
3441 the label yyerrorlab therefore never appears in user code. */
3442 if (false)
3443 YYERROR;
3444
3445 /* Do not reclaim the symbols of the rule whose action triggered
3446 this YYERROR. */
3447 yypop_ (yylen);
3448 yylen = 0;
3449 goto yyerrlab1;
3450
3451
3452 /*-------------------------------------------------------------.
3453 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3454 `-------------------------------------------------------------*/
3455 yyerrlab1:
3456 yyerrstatus_ = 3; // Each real token shifted decrements this.
3457 {
3458 stack_symbol_type error_token;
3459 for (;;)
3460 {
3461 yyn = yypact_[+yystack_[0].state];
3462 if (!yy_pact_value_is_default_ (yyn))
3463 {
3464 yyn += yy_error_token_;
3465 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yy_error_token_)
3466 {
3467 yyn = yytable_[yyn];
3468 if (0 < yyn)
3469 break;
3470 }
3471 }
3472
3473 // Pop the current state because it cannot handle the error token.
3474 if (yystack_.size () == 1)
3475 YYABORT;
3476
3477 yyerror_range[1].location = yystack_[0].location;
3478 yy_destroy_ ("Error: popping", yystack_[0]);
3479 yypop_ ();
3480 YY_STACK_PRINT ();
3481 }
3482
3483 yyerror_range[2].location = yyla.location;
3484 YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
3485
3486 // Shift the error token.
3487 error_token.state = state_type (yyn);
3488 yypush_ ("Shifting", YY_MOVE (error_token));
3489 }
3490 goto yynewstate;
3491
3492
3493 /*-------------------------------------.
3494 | yyacceptlab -- YYACCEPT comes here. |
3495 `-------------------------------------*/
3496 yyacceptlab:
3497 yyresult = 0;
3498 goto yyreturn;
3499
3500
3501 /*-----------------------------------.
3502 | yyabortlab -- YYABORT comes here. |
3503 `-----------------------------------*/
3504 yyabortlab:
3505 yyresult = 1;
3506 goto yyreturn;
3507
3508
3509 /*-----------------------------------------------------.
3510 | yyreturn -- parsing is finished, return the result. |
3511 `-----------------------------------------------------*/
3512 yyreturn:
3513 if (!yyla.empty ())
3514 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
3515
3516 /* Do not reclaim the symbols of the rule whose action triggered
3517 this YYABORT or YYACCEPT. */
3518 yypop_ (yylen);
3519 while (1 < yystack_.size ())
3520 {
3521 yy_destroy_ ("Cleanup: popping", yystack_[0]);
3522 yypop_ ();
3523 }
3524
3525 return yyresult;
3526 }
3527 #if YY_EXCEPTIONS
3528 catch (...)
3529 {
3530 YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
3531 // Do not try to display the values of the reclaimed symbols,
3532 // as their printers might throw an exception.
3533 if (!yyla.empty ())
3534 yy_destroy_ (YY_NULLPTR, yyla);
3535
3536 while (1 < yystack_.size ())
3537 {
3538 yy_destroy_ (YY_NULLPTR, yystack_[0]);
3539 yypop_ ();
3540 }
3541 throw;
3542 }
3543 #endif // YY_EXCEPTIONS
3544 }
3545
3546 void
error(const syntax_error & yyexc)3547 parser::error (const syntax_error& yyexc)
3548 {
3549 error (yyexc.location, yyexc.what ());
3550 }
3551
3552 // Generate an error message.
3553 std::string
yysyntax_error_(state_type yystate,const symbol_type & yyla) const3554 parser::yysyntax_error_ (state_type yystate, const symbol_type& yyla) const
3555 {
3556 // Number of reported tokens (one for the "unexpected", one per
3557 // "expected").
3558 std::ptrdiff_t yycount = 0;
3559 // Its maximum.
3560 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
3561 // Arguments of yyformat.
3562 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3563
3564 /* There are many possibilities here to consider:
3565 - If this state is a consistent state with a default action, then
3566 the only way this function was invoked is if the default action
3567 is an error action. In that case, don't check for expected
3568 tokens because there are none.
3569 - The only way there can be no lookahead present (in yyla) is
3570 if this state is a consistent state with a default action.
3571 Thus, detecting the absence of a lookahead is sufficient to
3572 determine that there is no unexpected or expected token to
3573 report. In that case, just report a simple "syntax error".
3574 - Don't assume there isn't a lookahead just because this state is
3575 a consistent state with a default action. There might have
3576 been a previous inconsistent state, consistent state with a
3577 non-default action, or user semantic action that manipulated
3578 yyla. (However, yyla is currently not documented for users.)
3579 - Of course, the expected token list depends on states to have
3580 correct lookahead information, and it depends on the parser not
3581 to perform extra reductions after fetching a lookahead from the
3582 scanner and before detecting a syntax error. Thus, state merging
3583 (from LALR or IELR) and default reductions corrupt the expected
3584 token list. However, the list is correct for canonical LR with
3585 one exception: it will still contain any token that will not be
3586 accepted due to an error action in a later state.
3587 */
3588 if (!yyla.empty ())
3589 {
3590 symbol_number_type yytoken = yyla.type_get ();
3591 yyarg[yycount++] = yytname_[yytoken];
3592
3593 int yyn = yypact_[+yystate];
3594 if (!yy_pact_value_is_default_ (yyn))
3595 {
3596 /* Start YYX at -YYN if negative to avoid negative indexes in
3597 YYCHECK. In other words, skip the first -YYN actions for
3598 this state because they are default actions. */
3599 int yyxbegin = yyn < 0 ? -yyn : 0;
3600 // Stay within bounds of both yycheck and yytname.
3601 int yychecklim = yylast_ - yyn + 1;
3602 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
3603 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
3604 if (yycheck_[yyx + yyn] == yyx && yyx != yy_error_token_
3605 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
3606 {
3607 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3608 {
3609 yycount = 1;
3610 break;
3611 }
3612 else
3613 yyarg[yycount++] = yytname_[yyx];
3614 }
3615 }
3616 }
3617
3618 char const* yyformat = YY_NULLPTR;
3619 switch (yycount)
3620 {
3621 #define YYCASE_(N, S) \
3622 case N: \
3623 yyformat = S; \
3624 break
3625 default: // Avoid compiler warnings.
3626 YYCASE_ (0, YY_("syntax error"));
3627 YYCASE_ (1, YY_("syntax error, unexpected %s"));
3628 YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
3629 YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
3630 YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
3631 YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
3632 #undef YYCASE_
3633 }
3634
3635 std::string yyres;
3636 // Argument number.
3637 std::ptrdiff_t yyi = 0;
3638 for (char const* yyp = yyformat; *yyp; ++yyp)
3639 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
3640 {
3641 yyres += yytnamerr_ (yyarg[yyi++]);
3642 ++yyp;
3643 }
3644 else
3645 yyres += *yyp;
3646 return yyres;
3647 }
3648
3649
3650 const short parser::yypact_ninf_ = -340;
3651
3652 const short parser::yytable_ninf_ = -283;
3653
3654 const short
3655 parser::yypact_[] =
3656 {
3657 -8, 189, 39, 91, -340, -340, -340, -340, -340, -340,
3658 17, 53, 43, -340, -340, 73, 73, 73, 30, 2227,
3659 2227, 2227, 108, -340, -340, -340, -340, -340, -340, -340,
3660 -340, -340, -340, -340, -340, -340, -340, -340, -340, -340,
3661 -340, -340, -340, -340, -340, -340, -340, -340, -340, -340,
3662 -340, -340, -340, -340, -340, -340, -340, -340, -340, -340,
3663 169, -340, -340, -340, -340, -340, -340, -340, 174, -340,
3664 -340, 83, 112, 22, -340, 2315, 2315, -78, 2315, 2139,
3665 103, -340, -340, -340, -340, 209, 229, -340, -340, -340,
3666 -340, -340, -340, -340, 2315, -340, 212, -340, -340, 951,
3667 -340, 1407, -340, 1613, -340, 90, 2051, 235, 1407, -340,
3668 1407, 1407, 1407, 1065, 250, -340, -340, -340, -340, 1407,
3669 -340, 274, -340, -340, -340, -340, -340, -340, 37, -340,
3670 -340, -340, -340, 165, -340, -340, -340, -340, -340, -340,
3671 3208, 2746, -340, 171, 5, -340, -78, -340, 106, -9,
3672 -340, -18, -340, 116, 134, 176, -340, -340, -340, 1407,
3673 -35, 482, 1407, 3318, 7, 609, -78, -340, 1407, 1407,
3674 1407, 1407, 1407, 1407, 1407, 1407, 1407, 1407, 1407, 1407,
3675 1407, 1407, 1407, 1407, 1407, 1407, 1407, 1407, 1407, -78,
3676 1407, 1705, 1407, -340, 1407, 1407, 56, -340, 1407, 1407,
3677 -340, -340, -340, 175, 1407, 179, 182, -340, -340, 193,
3678 -340, -340, 280, -78, 1521, 273, 228, -340, 236, 2315,
3679 230, 276, 308, 239, 243, 315, 278, -340, 237, -340,
3680 -340, 1904, 1407, -340, 1407, -31, 2823, 319, 334, 337,
3681 338, -340, 339, 1407, 231, 341, 3208, 232, 232, 4,
3682 4, 177, 4, 177, 307, 313, 313, 215, 215, 215,
3683 215, 313, 313, 177, 177, 3318, 2900, -340, 141, 723,
3684 233, -340, 313, 194, 260, 1407, 1407, 1797, 1407, 1407,
3685 -340, 1407, 3285, 454, 1407, -340, -340, -340, -340, -340,
3686 5, 1407, -340, 1407, -340, -340, -340, -340, -340, -340,
3687 230, -1, 345, 309, -340, 346, 1407, 348, 349, 1407,
3688 -340, -340, 1407, 2977, 1993, 1407, -340, 2315, 242, 244,
3689 -340, 245, -340, 241, -340, -78, 1407, 1407, -340, 246,
3690 350, 1407, 2315, 1407, 1407, 3054, 1932, 837, 251, -340,
3691 2021, 2451, 2533, 1407, 3208, 355, 2423, 2505, -340, 230,
3692 2139, 49, -10, 1407, 2587, 2139, 1407, 253, 3208, -340,
3693 1407, 3131, 356, 357, 358, 359, -340, -340, 313, 313,
3694 -340, -340, 256, 366, -340, 313, 313, 1407, 1407, -340,
3695 257, 367, 1407, 2315, 1407, 1407, 1407, 313, -340, -340,
3696 -340, 343, -340, 261, 303, -78, 325, 1, -340, 63,
3697 -340, -340, -340, -340, -340, -340, 2669, -340, 286, 110,
3698 230, 3208, -340, -340, -340, -340, -340, -340, 1179, 313,
3699 313, -340, -340, 291, 372, -340, 313, 313, 313, -340,
3700 -340, 2139, -25, -340, 310, 9, 12, 13, 311, 330,
3701 -340, 21, 293, 230, 378, -340, -340, 295, -340, 1293,
3702 -340, -340, -340, -20, -340, 360, -340, 54, -340, 361,
3703 -340, 55, -340, 362, -340, 89, 93, 314, -340, -340,
3704 -340, 2315, -340, 230, -340, -340, 299, -340, -340, -340,
3705 -340, -340, -340, -340, -340, -340, -340, -340, -340, -340,
3706 124, 345, -340, -340, -340, -340, 49, -340
3707 };
3708
3709 const short
3710 parser::yydefact_[] =
3711 {
3712 0, 181, 0, 2, 4, 5, 6, 197, 198, 182,
3713 0, 0, 0, 1, 3, 176, 176, 176, 0, 0,
3714 0, 0, 0, 18, 19, 20, 21, 22, 23, 24,
3715 59, 58, 60, 25, 26, 27, 28, 29, 30, 31,
3716 32, 35, 37, 36, 33, 34, 38, 39, 40, 41,
3717 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
3718 53, 52, 54, 55, 56, 16, 62, 17, 61, 57,
3719 187, 0, 0, 0, 177, 0, 0, 0, 0, 0,
3720 0, 53, 61, 186, 185, 192, 0, 65, 64, 66,
3721 67, 69, 68, 63, 207, 233, 281, 175, 283, 0,
3722 195, 0, 74, 76, 208, 235, 235, 0, 0, 193,
3723 0, 0, 0, 0, 23, 14, 13, 15, 12, 0,
3724 10, 43, 11, 7, 8, 9, 159, 157, 162, 158,
3725 163, 164, 169, 0, 165, 170, 171, 172, 173, 174,
3726 120, 178, 189, 0, 0, 75, 0, 229, 235, 212,
3727 234, 0, 278, 235, 199, 0, 80, 79, 81, 0,
3728 0, 0, 0, 82, 0, 0, 0, 194, 0, 0,
3729 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3730 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3731 0, 0, 0, 126, 0, 0, 0, 127, 0, 0,
3732 179, 180, 188, 183, 0, 0, 0, 73, 72, 0,
3733 236, 230, 0, 0, 0, 0, 0, 217, 0, 0,
3734 201, 0, 0, 0, 0, 0, 235, 280, 0, 284,
3735 166, 0, 0, 152, 0, 0, 0, 0, 0, 0,
3736 0, 124, 0, 0, 0, 161, 121, 87, 88, 84,
3737 85, 91, 86, 92, 83, 97, 98, 95, 96, 93,
3738 94, 99, 100, 89, 90, 102, 0, 168, 105, 0,
3739 61, 135, 101, 104, 106, 0, 0, 0, 0, 0,
3740 128, 0, 103, 107, 0, 191, 190, 70, 71, 77,
3741 0, 0, 226, 0, 224, 221, 222, 223, 220, 213,
3742 201, 178, 239, 0, 218, 0, 0, 0, 0, 0,
3743 279, 200, 0, 0, 0, 0, 150, 0, 0, 0,
3744 153, 0, 125, 0, 122, 0, 0, 0, 131, 0,
3745 0, 0, 0, 0, 0, 0, 109, 0, 61, 143,
3746 108, 110, 111, 0, 184, 0, 0, 0, 216, 201,
3747 0, 259, 0, 0, 0, 0, 0, 0, 147, 151,
3748 0, 0, 0, 0, 0, 0, 123, 160, 129, 113,
3749 133, 132, 0, 61, 134, 112, 114, 0, 0, 139,
3750 0, 0, 0, 0, 0, 0, 0, 115, 78, 219,
3751 225, 214, 237, 0, 269, 0, 0, 0, 257, 260,
3752 227, 203, 204, 205, 206, 202, 0, 276, 0, 0,
3753 201, 148, 149, 167, 155, 156, 154, 138, 0, 130,
3754 117, 141, 140, 0, 61, 142, 116, 118, 119, 215,
3755 240, 0, 0, 256, 272, 0, 0, 0, 263, 0,
3756 258, 209, 0, 201, 0, 275, 136, 0, 146, 0,
3757 238, 267, 268, 0, 243, 0, 244, 0, 253, 0,
3758 254, 0, 248, 0, 249, 0, 0, 266, 210, 211,
3759 228, 0, 273, 201, 137, 144, 0, 270, 271, 245,
3760 242, 241, 255, 252, 251, 250, 247, 246, 261, 262,
3761 0, 239, 274, 145, 264, 265, 259, 277
3762 };
3763
3764 const short
3765 parser::yypgoto_[] =
3766 {
3767 -340, -340, -340, 170, -19, -13, -66, -339, 172, 95,
3768 -340, 70, -340, -340, -340, -104, -340, -340, -340, -340,
3769 234, -340, -340, 255, -254, 167, 92, -340, -340, 201,
3770 187, -282, -340, -340, -340, -340, -340, -297, -340, -340,
3771 -340, 248, -340, 288, -340, -79, 42, -99, 0, -340,
3772 -98, -148, -340, -340, -340
3773 };
3774
3775 const short
3776 parser::yydefgoto_[] =
3777 {
3778 -1, 2, 3, 127, 128, 129, 70, 94, 208, 209,
3779 103, 104, 130, 131, 132, 133, 134, 135, 136, 137,
3780 160, 138, 139, 140, 98, 19, 202, 11, 285, 71,
3781 142, 143, 4, 100, 5, 12, 229, 304, 105, 470,
3782 221, 147, 148, 95, 96, 151, 393, 351, 398, 399,
3783 400, 152, 153, 107, 6
3784 };
3785
3786 const short
3787 parser::yytable_[] =
3788 {
3789 68, 68, 68, 348, 155, 227, 69, 69, 69, 83,
3790 84, 392, 86, 205, 206, 330, 392, 401, 232, 233,
3791 176, 222, 315, 316, 451, 79, 149, 357, 102, 477,
3792 212, 213, 200, 65, 237, 1, 67, 145, 214, 13,
3793 165, 452, 166, 223, 189, 454, 478, 402, 458, 462,
3794 201, 435, 391, 215, 80, 403, 82, 82, 85, 82,
3795 92, 244, 69, 69, 238, 69, 93, 224, 216, 149,
3796 217, 436, 239, 234, 409, 82, 218, 234, 310, 219,
3797 404, 69, 405, 381, 82, 455, 225, 92, 459, 463,
3798 69, 275, 450, 93, -232, 220, -232, 394, 14, 240,
3799 456, 480, 483, 460, 464, 457, 437, 22, 461, 465,
3800 -231, 438, -231, 445, 443, 15, 204, 207, 468, 276,
3801 -282, 16, 226, 277, 395, 271, 396, 210, 469, 397,
3802 278, 279, 146, 481, 484, 280, 486, 18, 395, 323,
3803 439, 17, 488, 397, 444, 281, 472, 245, 146, 169,
3804 170, 171, 172, 302, 173, 174, 175, 176, 146, 489,
3805 179, 180, 181, 182, 74, 329, 185, 186, 487, 167,
3806 267, 168, 270, 494, 75, 203, 492, 204, 69, 76,
3807 230, 189, 168, 20, 21, 169, 170, 171, 172, 77,
3808 495, 174, 78, 176, 292, 296, 327, 289, 97, 290,
3809 82, 297, 169, 170, 171, 172, 69, 173, 174, 175,
3810 176, 339, 99, 179, 180, 181, 182, 189, 106, 185,
3811 186, 72, 73, 169, 170, 171, 172, 372, 173, 174,
3812 175, 176, 101, 380, 189, 324, 331, 168, 332, 154,
3813 185, 186, 171, 172, 228, 366, 174, 168, 176, 333,
3814 370, 102, 168, 162, 382, 189, 383, 410, 338, 204,
3815 417, 421, 168, 168, 69, 430, 374, 431, 169, 170,
3816 171, 172, 189, 173, 174, 175, 176, 164, 423, 179,
3817 180, 181, 182, 291, 284, 185, 186, -196, 7, 8,
3818 442, 287, 431, 9, 288, 448, 10, 168, 82, 474,
3819 189, 168, 299, 493, 69, 168, 367, 300, 305, 301,
3820 303, 306, 307, 373, 447, 334, 308, 425, 309, 69,
3821 146, 169, 170, 171, 172, 318, 173, 174, 175, 176,
3822 311, 92, 179, 180, 181, 182, 92, 93, 185, 186,
3823 319, 320, 93, 322, 321, 476, 325, 189, 350, 353,
3824 352, 355, 356, 189, 371, 363, 141, 364, 365, 388,
3825 413, 414, 415, 416, 424, 156, 157, 158, 161, 418,
3826 69, 422, 432, 434, 163, 449, 433, 429, 467, 453,
3827 466, 471, 473, 490, 295, 345, 298, 362, 479, 482,
3828 485, 286, 496, 349, 150, 235, 211, 408, 497, 440,
3829 0, 0, 0, 0, 0, 491, 0, 0, 0, 0,
3830 0, 0, 92, 0, 231, 0, 0, 236, 93, 0,
3831 0, 0, 0, 246, 247, 248, 249, 250, 251, 252,
3832 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
3833 263, 264, 265, 266, 0, 268, 0, 272, 0, 273,
3834 274, 0, 82, 282, 283, 0, 0, 0, 69, 141,
3835 0, 0, 169, 170, 171, 172, 0, 173, 174, 175,
3836 176, 0, 0, 179, 180, 181, 182, 0, 0, 185,
3837 186, 0, 0, 0, 0, 0, 0, 313, 0, 314,
3838 169, 170, 171, 172, 189, 173, 174, 175, 176, 177,
3839 178, 179, 180, 181, 182, 183, 184, 185, 186, 343,
3840 0, 0, 187, 0, 0, 0, 0, 188, 0, 0,
3841 0, 0, 189, 0, 0, 0, 0, 0, 0, 0,
3842 335, 336, 0, 340, 341, 0, 342, 0, 0, 344,
3843 0, 0, 0, 0, 0, 190, 346, 0, 347, 191,
3844 0, 0, 0, 192, 193, 0, 194, 195, 0, 196,
3845 197, 354, 0, 198, 141, 0, 0, 358, 0, 0,
3846 361, 199, 0, 0, 0, 0, 0, 0, 0, 0,
3847 0, 368, 369, 0, 0, 0, 0, 0, 375, 376,
3848 159, 0, 0, 0, 0, 0, 0, 0, 387, 0,
3849 0, 0, 0, 0, 0, 0, 0, 0, 406, 0,
3850 0, 141, 108, 241, 0, 411, 0, 110, 111, 242,
3851 0, 112, 0, 0, 0, 0, 0, 0, 0, 0,
3852 0, 0, 419, 420, 0, 0, 23, 24, 25, 426,
3853 427, 428, 26, 0, 0, 27, 113, 114, 0, 0,
3854 29, 0, 0, 115, 116, 117, 0, 0, 33, 0,
3855 34, 243, 0, 35, 0, 0, 36, 118, 37, 38,
3856 0, 39, 40, 0, 41, 42, 0, 0, 43, 0,
3857 0, 0, 44, 45, 46, 47, 119, 0, 120, 0,
3858 0, 48, 49, 50, 0, 121, 52, 0, 53, 54,
3859 55, 56, 57, 58, 0, 0, 59, 0, 81, 61,
3860 0, 122, 62, 0, 0, 0, 63, 0, 0, 64,
3861 65, 123, 124, 67, 125, 126, 108, 328, 0, 0,
3862 0, 110, 111, 0, 0, 112, 0, 0, 0, 0,
3863 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3864 23, 24, 25, 0, 0, 0, 26, 0, 0, 27,
3865 113, 114, 0, 0, 29, 0, 0, 115, 116, 117,
3866 0, 0, 33, 0, 34, 0, 0, 35, 0, 0,
3867 36, 118, 37, 38, 0, 39, 40, 0, 41, 42,
3868 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
3869 119, 0, 120, 0, 0, 48, 49, 50, 0, 121,
3870 52, 0, 53, 54, 55, 56, 57, 58, 97, 0,
3871 59, 0, 81, 61, 0, 122, 62, 0, 0, 0,
3872 63, 0, 0, 64, 65, 123, 124, 67, 125, 126,
3873 108, 379, 0, 0, 0, 110, 111, 0, 0, 112,
3874 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3875 0, 0, 0, 0, 23, 24, 25, 0, 0, 0,
3876 26, 0, 0, 27, 113, 114, 0, 0, 29, 0,
3877 0, 115, 116, 117, 0, 0, 33, 0, 34, 0,
3878 0, 35, 0, 0, 36, 118, 37, 38, 0, 39,
3879 40, 0, 41, 42, 0, 0, 43, 0, 0, 0,
3880 44, 45, 46, 47, 119, 0, 120, 0, 0, 48,
3881 49, 50, 0, 121, 52, 0, 53, 54, 55, 56,
3882 57, 58, 97, 0, 59, 0, 81, 61, 0, 122,
3883 62, 0, 0, 0, 63, 0, 0, 64, 65, 123,
3884 124, 67, 125, 126, 108, 109, 0, 0, 0, 110,
3885 111, 0, 0, 112, 0, 0, 0, 0, 0, 0,
3886 0, 0, 0, 0, 0, 0, 0, 0, 23, 24,
3887 25, 0, 0, 0, 26, 0, 0, 27, 113, 114,
3888 0, 0, 29, 0, 0, 115, 116, 117, 0, 0,
3889 33, 0, 34, 0, 0, 35, 0, 0, 36, 118,
3890 37, 38, 0, 39, 40, 0, 41, 42, 0, 0,
3891 43, 0, 0, 0, 44, 45, 46, 47, 119, 0,
3892 120, 0, 0, 48, 49, 50, 0, 121, 52, 0,
3893 53, 54, 55, 56, 57, 58, 0, 0, 59, 0,
3894 81, 61, 0, 122, 62, 0, 0, 0, 63, 0,
3895 0, 64, 65, 123, 124, 67, 125, 126, 108, 0,
3896 0, 0, 0, 110, 111, 0, 0, 112, 0, 0,
3897 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3898 0, 0, 23, 24, 25, 0, 0, 0, 26, 0,
3899 0, 27, 113, 114, 0, 0, 29, 0, 0, 115,
3900 116, 117, 0, 0, 33, 0, 34, 0, 0, 35,
3901 0, 0, 36, 118, 37, 38, 0, 39, 40, 0,
3902 41, 42, 0, 0, 43, 0, 0, 0, 44, 45,
3903 46, 47, 119, 0, 120, 0, 0, 48, 49, 50,
3904 0, 121, 52, 0, 53, 54, 55, 56, 57, 58,
3905 0, 0, 59, 0, 81, 61, 0, 122, 62, 0,
3906 0, 0, 63, 159, 0, 64, 65, 123, 124, 67,
3907 125, 126, 108, 446, 0, 0, 0, 110, 111, 0,
3908 0, 112, 0, 0, 0, 0, 0, 0, 0, 0,
3909 0, 0, 0, 0, 0, 0, 23, 24, 25, 0,
3910 0, 0, 26, 0, 0, 27, 113, 114, 0, 0,
3911 29, 0, 0, 115, 116, 117, 0, 0, 33, 0,
3912 34, 0, 0, 35, 0, 0, 36, 118, 37, 38,
3913 0, 39, 40, 0, 41, 42, 0, 0, 43, 0,
3914 0, 0, 44, 45, 46, 47, 119, 0, 120, 0,
3915 0, 48, 49, 50, 0, 121, 52, 0, 53, 54,
3916 55, 56, 57, 58, 0, 0, 59, 0, 81, 61,
3917 0, 122, 62, 0, 0, 0, 63, 0, 0, 64,
3918 65, 123, 124, 67, 125, 126, 108, 475, 0, 0,
3919 0, 110, 111, 0, 0, 112, 0, 0, 0, 0,
3920 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3921 23, 24, 25, 0, 0, 0, 26, 0, 0, 27,
3922 113, 114, 0, 0, 29, 0, 0, 115, 116, 117,
3923 0, 0, 33, 0, 34, 0, 0, 35, 0, 0,
3924 36, 118, 37, 38, 0, 39, 40, 0, 41, 42,
3925 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
3926 119, 0, 120, 0, 0, 48, 49, 50, 0, 121,
3927 52, 0, 53, 54, 55, 56, 57, 58, 0, 0,
3928 59, 0, 81, 61, 0, 122, 62, 0, 0, 0,
3929 63, 0, 0, 64, 65, 123, 124, 67, 125, 126,
3930 108, 0, 0, 0, 0, 110, 111, 0, 0, 112,
3931 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3932 0, 0, 0, 0, 23, 24, 25, 0, 0, 0,
3933 26, 0, 0, 27, 113, 114, 0, 0, 29, 0,
3934 0, 115, 116, 117, 0, 0, 33, 0, 34, 0,
3935 0, 35, 0, 0, 36, 118, 37, 38, 0, 39,
3936 40, 0, 41, 42, 0, 0, 43, 0, 0, 0,
3937 44, 45, 46, 47, 119, 0, 120, 0, 0, 48,
3938 49, 50, 0, 121, 52, 0, 53, 54, 55, 56,
3939 57, 58, 0, 0, 59, 0, 81, 61, 0, 122,
3940 62, 0, 0, 0, 63, 0, 0, 64, 65, 123,
3941 124, 67, 125, 126, 293, 0, 0, 0, 0, 205,
3942 206, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3943 0, 0, 0, 0, 0, 0, 0, 0, 23, 24,
3944 25, 0, 0, 0, 26, 0, 0, 27, 0, 28,
3945 0, 0, 29, 0, 0, 115, 116, 117, 0, 0,
3946 33, 0, 34, 0, 0, 35, 0, 0, 36, 118,
3947 37, 38, 0, 39, 40, 294, 41, 42, 0, 0,
3948 43, 0, 0, 0, 44, 45, 46, 47, 0, 0,
3949 120, 0, 0, 48, 49, 50, 0, 51, 52, 0,
3950 53, 54, 55, 56, 57, 58, 144, 0, 59, 0,
3951 81, 61, 0, 122, 62, 0, 0, 0, 63, 0,
3952 0, 64, 65, 123, 124, 67, 125, 0, 0, 0,
3953 23, 24, 25, 0, 0, 0, 26, 0, 0, 27,
3954 0, 28, 0, 0, 29, 0, 0, 30, 31, 32,
3955 0, 0, 33, 0, 34, 0, 0, 35, 0, 0,
3956 36, 0, 37, 38, 0, 39, 40, 0, 41, 42,
3957 0, 0, 43, 0, 0, 0, 44, 45, 46, 47,
3958 0, 0, 0, 0, 0, 48, 49, 50, 0, 51,
3959 52, 0, 53, 54, 55, 56, 57, 58, 269, 0,
3960 59, 0, 81, 61, 0, 0, 62, 0, 0, 0,
3961 63, 0, 0, 64, 65, 0, 66, 67, 0, 0,
3962 0, 0, 23, 24, 25, 0, 0, 0, 26, 0,
3963 0, 27, 0, 28, 0, 0, 29, 0, 0, 30,
3964 31, 32, 0, 0, 33, 0, 34, 0, 0, 35,
3965 0, 0, 36, 0, 37, 38, 0, 39, 40, 0,
3966 41, 42, 0, 0, 43, 0, 0, 0, 44, 45,
3967 46, 47, 0, 0, 0, 0, 0, 48, 49, 50,
3968 0, 51, 52, 0, 53, 54, 55, 56, 57, 58,
3969 337, 0, 59, 0, 81, 61, 0, 0, 62, 0,
3970 0, 0, 63, 0, 0, 64, 65, 0, 66, 67,
3971 0, 0, 0, 0, 23, 24, 25, 0, 0, 0,
3972 26, 0, 0, 27, 0, 28, 0, 0, 29, 0,
3973 0, 30, 31, 32, 0, 0, 33, 0, 34, 0,
3974 0, 35, 0, 0, 36, 0, 37, 38, 0, 39,
3975 40, 0, 41, 42, 0, 0, 43, 0, 0, 0,
3976 44, 45, 46, 47, 0, 0, 0, 0, 0, 48,
3977 49, 50, 0, 51, 52, 0, 53, 54, 55, 56,
3978 57, 58, 0, 0, 59, 0, 81, 61, 0, 0,
3979 62, 0, 0, 0, 63, 0, 0, 64, 65, 0,
3980 66, 67, 169, 170, 171, 172, 0, 173, 174, 175,
3981 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
3982 186, 0, 0, 0, 187, 0, 0, 0, 0, 188,
3983 169, 170, 171, 172, 189, 173, 174, 175, 176, 0,
3984 0, 179, 180, 181, 182, 0, 0, 185, 186, 0,
3985 0, 0, 0, 0, 0, 0, 0, 190, 0, 0,
3986 0, 191, 189, 0, 0, 192, 193, 0, 194, 195,
3987 0, 196, 197, 0, 0, 198, 0, 378, 0, 0,
3988 0, 0, 0, 199, 0, 0, 0, 0, 0, 0,
3989 0, 169, 170, 171, 172, 312, 173, 174, 175, 176,
3990 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
3991 0, 0, 0, 187, 0, 0, 0, 0, 188, 169,
3992 170, 171, 172, 189, 173, 174, 175, 176, 0, 0,
3993 179, 180, 181, 182, 0, 0, 185, 186, 0, 0,
3994 0, 0, 0, 0, 0, 0, 190, 0, 0, 0,
3995 191, 189, 0, 0, 192, 193, 0, 194, 195, 0,
3996 196, 197, 0, 0, 198, 0, 384, 0, 23, 24,
3997 25, 0, 199, 0, 26, 0, 0, 27, 0, 28,
3998 0, 0, 29, 146, 360, 87, 88, 89, 0, 0,
3999 33, 0, 34, 0, 0, 35, 0, 0, 36, 0,
4000 37, 38, 0, 39, 40, 90, 41, 42, 0, 0,
4001 43, 0, 0, 0, 44, 45, 46, 47, 0, 0,
4002 0, 0, 0, 48, 49, 50, 0, 51, 52, 0,
4003 53, 54, 55, 56, 57, 58, 0, 0, 59, 0,
4004 81, 61, 0, 0, 62, 0, 0, 0, 63, 0,
4005 0, 64, 65, 0, 91, 67, 23, 24, 25, 0,
4006 0, 0, 26, 0, 0, 27, 0, 28, 0, 0,
4007 29, 0, 0, 87, 88, 89, 0, 0, 33, 0,
4008 34, 0, 0, 35, 0, 0, 36, 0, 37, 38,
4009 0, 39, 40, 90, 41, 42, 0, 0, 43, 0,
4010 0, 0, 44, 45, 46, 47, 0, 0, 0, 0,
4011 0, 48, 49, 50, 0, 51, 52, 0, 53, 54,
4012 55, 56, 57, 58, 0, 0, 59, 0, 81, 61,
4013 0, 0, 62, 0, 0, 0, 63, 0, 0, 64,
4014 65, 0, 91, 67, 23, 24, 25, 0, 0, 0,
4015 26, 0, 0, 27, 0, 28, 0, 0, 29, 0,
4016 0, 30, 31, 32, 0, 0, 33, 0, 34, 0,
4017 0, 35, 0, 0, 36, 0, 37, 38, 0, 39,
4018 40, 0, 41, 42, 0, 0, 43, 0, 0, 0,
4019 44, 45, 46, 47, 0, 0, 0, 0, 0, 48,
4020 49, 50, 0, 51, 52, 0, 53, 54, 55, 56,
4021 57, 58, 0, 0, 59, 0, 60, 61, 0, 0,
4022 62, 0, 0, 0, 63, 0, 0, 64, 65, 0,
4023 66, 67, 23, 24, 25, 0, 0, 0, 26, 0,
4024 0, 27, 0, 28, 0, 0, 29, 0, 0, 30,
4025 31, 32, 0, 0, 33, 0, 34, 0, 0, 35,
4026 0, 0, 36, 0, 37, 38, 0, 39, 40, 0,
4027 41, 42, 0, 0, 43, 0, 0, 0, 44, 45,
4028 46, 47, 0, 0, 0, 0, 0, 48, 49, 50,
4029 0, 51, 52, 0, 53, 54, 55, 56, 57, 58,
4030 0, 0, 59, 0, 81, 61, 0, 0, 62, 0,
4031 0, 0, 63, 0, 0, 64, 65, 389, 66, 67,
4032 0, 169, 170, 171, 172, 0, 173, 174, 175, 176,
4033 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
4034 0, 0, 0, 187, 0, 0, 0, 0, 188, 169,
4035 170, 171, 172, 189, 173, 174, 175, 176, 0, 0,
4036 179, 180, 181, 182, 0, 0, 185, 186, 0, 0,
4037 0, 0, 0, 0, 0, 0, 190, 0, 0, 0,
4038 191, 189, 0, 0, 192, 193, 0, 194, 195, 0,
4039 196, 197, 0, 0, 198, 0, 385, 0, 0, 390,
4040 0, 0, 199, 169, 170, 171, 172, 0, 173, 174,
4041 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
4042 185, 186, 0, 0, 0, 187, 0, 0, 0, 0,
4043 188, 169, 170, 171, 172, 189, 173, 174, 175, 176,
4044 0, 0, 179, 180, 181, 182, 0, 0, 185, 186,
4045 0, 0, 0, 0, 0, 0, 0, 0, 190, 0,
4046 0, 0, 191, 189, 0, 0, 192, 193, 0, 194,
4047 195, 0, 196, 197, 0, 0, 198, 0, 386, 0,
4048 0, 407, 0, 0, 199, 169, 170, 171, 172, 0,
4049 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
4050 183, 184, 185, 186, 0, 0, 0, 187, 0, 0,
4051 0, 0, 188, 0, 0, 0, 0, 189, 0, 0,
4052 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4053 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4054 190, 0, 0, 0, 191, 0, 0, 0, 192, 193,
4055 0, 194, 195, 0, 196, 197, 0, 0, 198, 0,
4056 0, 0, 0, 441, 0, 0, 199, 169, 170, 171,
4057 172, 0, 173, 174, 175, 176, 177, 178, 179, 180,
4058 181, 182, 183, 184, 185, 186, 0, 0, 0, 187,
4059 0, 0, 0, 0, 188, 0, 0, 0, 0, 189,
4060 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4061 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4062 0, 0, 190, 0, 0, 0, 191, 0, 0, 0,
4063 192, 193, 0, 194, 195, 0, 196, 197, 0, 0,
4064 198, 0, 0, 0, 169, 170, 171, 172, 199, 173,
4065 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
4066 184, 185, 186, 0, 0, 0, 187, 0, 0, 200,
4067 0, 188, 0, 0, 0, 0, 189, 0, 0, 0,
4068 0, 0, 0, 0, 0, 0, 0, 201, 0, 0,
4069 0, 0, 0, 0, 0, 0, 0, 0, 0, 190,
4070 0, 0, 0, 191, 0, 0, 0, 192, 193, 0,
4071 194, 195, 0, 196, 197, 0, 0, 198, 0, 0,
4072 0, 169, 170, 171, 172, 199, 173, 174, 175, 176,
4073 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
4074 0, 0, 0, 187, 0, 317, 0, 0, 188, 0,
4075 0, 0, 0, 189, 0, 0, 0, 0, 0, 0,
4076 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4077 0, 0, 0, 0, 0, 0, 190, 0, 0, 0,
4078 191, 0, 0, 0, 192, 193, 0, 194, 195, 0,
4079 196, 197, 0, 0, 198, 0, 0, 0, 169, 170,
4080 171, 172, 199, 173, 174, 175, 176, 177, 178, 179,
4081 180, 181, 182, 183, 184, 185, 186, 0, 0, 0,
4082 187, 326, 0, 0, 0, 188, 0, 0, 0, 0,
4083 189, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4084 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4085 0, 0, 0, 190, 0, 0, 0, 191, 0, 0,
4086 0, 192, 193, 0, 194, 195, 0, 196, 197, 0,
4087 0, 198, 0, 0, 0, 169, 170, 171, 172, 199,
4088 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
4089 183, 184, 185, 186, 0, 0, 0, 187, 0, 0,
4090 0, 0, 188, 0, 0, 0, 0, 189, 0, 0,
4091 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4092 0, 359, 0, 0, 0, 0, 0, 0, 0, 0,
4093 190, 0, 0, 0, 191, 0, 0, 0, 192, 193,
4094 0, 194, 195, 0, 196, 197, 0, 0, 198, 0,
4095 0, 0, 169, 170, 171, 172, 199, 173, 174, 175,
4096 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
4097 186, 0, 0, 0, 187, 377, 0, 0, 0, 188,
4098 0, 0, 0, 0, 189, 0, 0, 0, 0, 0,
4099 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4100 0, 0, 0, 0, 0, 0, 0, 190, 0, 0,
4101 0, 191, 0, 0, 0, 192, 193, 0, 194, 195,
4102 0, 196, 197, 0, 0, 198, 0, 0, 0, 169,
4103 170, 171, 172, 199, 173, 174, 175, 176, 177, 178,
4104 179, 180, 181, 182, 183, 184, 185, 186, 0, 0,
4105 0, 187, 0, 0, 0, 0, 188, 0, 0, 0,
4106 0, 189, 0, 0, 0, 0, 0, 0, 0, 0,
4107 0, 0, 0, 0, 0, 412, 0, 0, 0, 0,
4108 0, 0, 0, 0, 190, 0, 0, 0, 191, 0,
4109 0, 0, 192, 193, 0, 194, 195, 0, 196, 197,
4110 0, 0, 198, 0, 0, 0, 169, 170, 171, 172,
4111 199, 173, 174, 175, 176, 177, 178, 179, 180, 181,
4112 182, 183, 184, 185, 186, 0, 0, 0, 187, 0,
4113 0, 0, 0, 188, 0, 0, 0, 0, 189, 0,
4114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4116 0, 190, 0, 0, 0, 191, 0, 0, 0, 192,
4117 193, 0, 194, 195, 0, 196, 197, 0, 0, 198,
4118 0, 0, 0, 169, 170, 171, 172, 199, 173, 174,
4119 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
4120 185, 186, 0, 0, 0, 187, 0, 0, 0, 0,
4121 188, 0, 0, 0, 0, 189, 169, 170, 171, 172,
4122 0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
4123 182, 183, 184, 185, 186, 0, 0, 0, 190, 0,
4124 0, 0, 191, 188, 0, 0, 192, 193, 189, 194,
4125 195, 0, 196, 197, 0, 0, 0, 0, 0, 0,
4126 0, 0, 0, 0, 199, 0, 0, 0, 0, 0,
4127 0, 190, 0, 0, 0, 191, 0, 0, 0, 192,
4128 193, 0, 194, 195, 0, 196, 197, 0, 0, 0,
4129 0, 0, 0, 0, 0, 0, 0, 199
4130 };
4131
4132 const short
4133 parser::yycheck_[] =
4134 {
4135 19, 20, 21, 300, 108, 153, 19, 20, 21, 75,
4136 76, 350, 78, 8, 9, 269, 355, 27, 53, 54,
4137 16, 39, 53, 54, 49, 3, 105, 309, 94, 49,
4138 39, 40, 33, 111, 27, 43, 114, 103, 47, 0,
4139 3, 66, 5, 61, 40, 36, 66, 57, 36, 36,
4140 51, 50, 349, 62, 32, 65, 75, 76, 77, 78,
4141 79, 165, 75, 76, 57, 78, 79, 85, 77, 148,
4142 79, 70, 65, 108, 356, 94, 85, 108, 226, 88,
4143 90, 94, 92, 337, 103, 76, 104, 106, 76, 76,
4144 103, 35, 431, 106, 4, 104, 6, 48, 7, 92,
4145 91, 47, 47, 91, 91, 96, 105, 77, 96, 96,
4146 4, 48, 6, 410, 4, 98, 6, 112, 97, 63,
4147 4, 68, 6, 67, 75, 191, 77, 146, 107, 80,
4148 74, 75, 42, 79, 79, 79, 47, 64, 75, 243,
4149 77, 98, 49, 80, 34, 89, 443, 166, 42, 8,
4150 9, 10, 11, 219, 13, 14, 15, 16, 42, 66,
4151 19, 20, 21, 22, 56, 269, 25, 26, 79, 4,
4152 189, 6, 191, 49, 5, 4, 473, 6, 191, 5,
4153 4, 40, 6, 16, 17, 8, 9, 10, 11, 106,
4154 66, 14, 80, 16, 213, 214, 55, 4, 95, 6,
4155 219, 214, 8, 9, 10, 11, 219, 13, 14, 15,
4156 16, 277, 3, 19, 20, 21, 22, 40, 6, 25,
4157 26, 20, 21, 8, 9, 10, 11, 331, 13, 14,
4158 15, 16, 3, 337, 40, 4, 3, 6, 5, 4,
4159 25, 26, 10, 11, 110, 4, 14, 6, 16, 55,
4160 4, 317, 6, 3, 3, 40, 5, 4, 277, 6,
4161 4, 4, 6, 6, 277, 4, 332, 6, 8, 9,
4162 10, 11, 40, 13, 14, 15, 16, 3, 382, 19,
4163 20, 21, 22, 3, 109, 25, 26, 98, 99, 100,
4164 4, 112, 6, 104, 112, 4, 107, 6, 317, 4,
4165 40, 6, 29, 4, 317, 6, 325, 79, 32, 73,
4166 80, 3, 73, 332, 418, 55, 73, 383, 3, 332,
4167 42, 8, 9, 10, 11, 6, 13, 14, 15, 16,
4168 93, 350, 19, 20, 21, 22, 355, 350, 25, 26,
4169 6, 4, 355, 4, 6, 449, 5, 40, 3, 3,
4170 41, 3, 3, 40, 4, 113, 101, 113, 113, 4,
4171 4, 4, 4, 4, 383, 110, 111, 112, 113, 3,
4172 383, 4, 69, 48, 119, 3, 395, 34, 48, 69,
4173 69, 88, 4, 69, 214, 290, 214, 317, 28, 28,
4174 28, 204, 491, 301, 106, 161, 148, 355, 496, 399,
4175 -1, -1, -1, -1, -1, 471, -1, -1, -1, -1,
4176 -1, -1, 431, -1, 159, -1, -1, 162, 431, -1,
4177 -1, -1, -1, 168, 169, 170, 171, 172, 173, 174,
4178 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
4179 185, 186, 187, 188, -1, 190, -1, 192, -1, 194,
4180 195, -1, 471, 198, 199, -1, -1, -1, 471, 204,
4181 -1, -1, 8, 9, 10, 11, -1, 13, 14, 15,
4182 16, -1, -1, 19, 20, 21, 22, -1, -1, 25,
4183 26, -1, -1, -1, -1, -1, -1, 232, -1, 234,
4184 8, 9, 10, 11, 40, 13, 14, 15, 16, 17,
4185 18, 19, 20, 21, 22, 23, 24, 25, 26, 55,
4186 -1, -1, 30, -1, -1, -1, -1, 35, -1, -1,
4187 -1, -1, 40, -1, -1, -1, -1, -1, -1, -1,
4188 275, 276, -1, 278, 279, -1, 281, -1, -1, 284,
4189 -1, -1, -1, -1, -1, 63, 291, -1, 293, 67,
4190 -1, -1, -1, 71, 72, -1, 74, 75, -1, 77,
4191 78, 306, -1, 81, 309, -1, -1, 312, -1, -1,
4192 315, 89, -1, -1, -1, -1, -1, -1, -1, -1,
4193 -1, 326, 327, -1, -1, -1, -1, -1, 333, 334,
4194 108, -1, -1, -1, -1, -1, -1, -1, 343, -1,
4195 -1, -1, -1, -1, -1, -1, -1, -1, 353, -1,
4196 -1, 356, 3, 4, -1, 360, -1, 8, 9, 10,
4197 -1, 12, -1, -1, -1, -1, -1, -1, -1, -1,
4198 -1, -1, 377, 378, -1, -1, 27, 28, 29, 384,
4199 385, 386, 33, -1, -1, 36, 37, 38, -1, -1,
4200 41, -1, -1, 44, 45, 46, -1, -1, 49, -1,
4201 51, 52, -1, 54, -1, -1, 57, 58, 59, 60,
4202 -1, 62, 63, -1, 65, 66, -1, -1, 69, -1,
4203 -1, -1, 73, 74, 75, 76, 77, -1, 79, -1,
4204 -1, 82, 83, 84, -1, 86, 87, -1, 89, 90,
4205 91, 92, 93, 94, -1, -1, 97, -1, 99, 100,
4206 -1, 102, 103, -1, -1, -1, 107, -1, -1, 110,
4207 111, 112, 113, 114, 115, 116, 3, 4, -1, -1,
4208 -1, 8, 9, -1, -1, 12, -1, -1, -1, -1,
4209 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4210 27, 28, 29, -1, -1, -1, 33, -1, -1, 36,
4211 37, 38, -1, -1, 41, -1, -1, 44, 45, 46,
4212 -1, -1, 49, -1, 51, -1, -1, 54, -1, -1,
4213 57, 58, 59, 60, -1, 62, 63, -1, 65, 66,
4214 -1, -1, 69, -1, -1, -1, 73, 74, 75, 76,
4215 77, -1, 79, -1, -1, 82, 83, 84, -1, 86,
4216 87, -1, 89, 90, 91, 92, 93, 94, 95, -1,
4217 97, -1, 99, 100, -1, 102, 103, -1, -1, -1,
4218 107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4219 3, 4, -1, -1, -1, 8, 9, -1, -1, 12,
4220 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4221 -1, -1, -1, -1, 27, 28, 29, -1, -1, -1,
4222 33, -1, -1, 36, 37, 38, -1, -1, 41, -1,
4223 -1, 44, 45, 46, -1, -1, 49, -1, 51, -1,
4224 -1, 54, -1, -1, 57, 58, 59, 60, -1, 62,
4225 63, -1, 65, 66, -1, -1, 69, -1, -1, -1,
4226 73, 74, 75, 76, 77, -1, 79, -1, -1, 82,
4227 83, 84, -1, 86, 87, -1, 89, 90, 91, 92,
4228 93, 94, 95, -1, 97, -1, 99, 100, -1, 102,
4229 103, -1, -1, -1, 107, -1, -1, 110, 111, 112,
4230 113, 114, 115, 116, 3, 4, -1, -1, -1, 8,
4231 9, -1, -1, 12, -1, -1, -1, -1, -1, -1,
4232 -1, -1, -1, -1, -1, -1, -1, -1, 27, 28,
4233 29, -1, -1, -1, 33, -1, -1, 36, 37, 38,
4234 -1, -1, 41, -1, -1, 44, 45, 46, -1, -1,
4235 49, -1, 51, -1, -1, 54, -1, -1, 57, 58,
4236 59, 60, -1, 62, 63, -1, 65, 66, -1, -1,
4237 69, -1, -1, -1, 73, 74, 75, 76, 77, -1,
4238 79, -1, -1, 82, 83, 84, -1, 86, 87, -1,
4239 89, 90, 91, 92, 93, 94, -1, -1, 97, -1,
4240 99, 100, -1, 102, 103, -1, -1, -1, 107, -1,
4241 -1, 110, 111, 112, 113, 114, 115, 116, 3, -1,
4242 -1, -1, -1, 8, 9, -1, -1, 12, -1, -1,
4243 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4244 -1, -1, 27, 28, 29, -1, -1, -1, 33, -1,
4245 -1, 36, 37, 38, -1, -1, 41, -1, -1, 44,
4246 45, 46, -1, -1, 49, -1, 51, -1, -1, 54,
4247 -1, -1, 57, 58, 59, 60, -1, 62, 63, -1,
4248 65, 66, -1, -1, 69, -1, -1, -1, 73, 74,
4249 75, 76, 77, -1, 79, -1, -1, 82, 83, 84,
4250 -1, 86, 87, -1, 89, 90, 91, 92, 93, 94,
4251 -1, -1, 97, -1, 99, 100, -1, 102, 103, -1,
4252 -1, -1, 107, 108, -1, 110, 111, 112, 113, 114,
4253 115, 116, 3, 4, -1, -1, -1, 8, 9, -1,
4254 -1, 12, -1, -1, -1, -1, -1, -1, -1, -1,
4255 -1, -1, -1, -1, -1, -1, 27, 28, 29, -1,
4256 -1, -1, 33, -1, -1, 36, 37, 38, -1, -1,
4257 41, -1, -1, 44, 45, 46, -1, -1, 49, -1,
4258 51, -1, -1, 54, -1, -1, 57, 58, 59, 60,
4259 -1, 62, 63, -1, 65, 66, -1, -1, 69, -1,
4260 -1, -1, 73, 74, 75, 76, 77, -1, 79, -1,
4261 -1, 82, 83, 84, -1, 86, 87, -1, 89, 90,
4262 91, 92, 93, 94, -1, -1, 97, -1, 99, 100,
4263 -1, 102, 103, -1, -1, -1, 107, -1, -1, 110,
4264 111, 112, 113, 114, 115, 116, 3, 4, -1, -1,
4265 -1, 8, 9, -1, -1, 12, -1, -1, -1, -1,
4266 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4267 27, 28, 29, -1, -1, -1, 33, -1, -1, 36,
4268 37, 38, -1, -1, 41, -1, -1, 44, 45, 46,
4269 -1, -1, 49, -1, 51, -1, -1, 54, -1, -1,
4270 57, 58, 59, 60, -1, 62, 63, -1, 65, 66,
4271 -1, -1, 69, -1, -1, -1, 73, 74, 75, 76,
4272 77, -1, 79, -1, -1, 82, 83, 84, -1, 86,
4273 87, -1, 89, 90, 91, 92, 93, 94, -1, -1,
4274 97, -1, 99, 100, -1, 102, 103, -1, -1, -1,
4275 107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4276 3, -1, -1, -1, -1, 8, 9, -1, -1, 12,
4277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4278 -1, -1, -1, -1, 27, 28, 29, -1, -1, -1,
4279 33, -1, -1, 36, 37, 38, -1, -1, 41, -1,
4280 -1, 44, 45, 46, -1, -1, 49, -1, 51, -1,
4281 -1, 54, -1, -1, 57, 58, 59, 60, -1, 62,
4282 63, -1, 65, 66, -1, -1, 69, -1, -1, -1,
4283 73, 74, 75, 76, 77, -1, 79, -1, -1, 82,
4284 83, 84, -1, 86, 87, -1, 89, 90, 91, 92,
4285 93, 94, -1, -1, 97, -1, 99, 100, -1, 102,
4286 103, -1, -1, -1, 107, -1, -1, 110, 111, 112,
4287 113, 114, 115, 116, 3, -1, -1, -1, -1, 8,
4288 9, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4289 -1, -1, -1, -1, -1, -1, -1, -1, 27, 28,
4290 29, -1, -1, -1, 33, -1, -1, 36, -1, 38,
4291 -1, -1, 41, -1, -1, 44, 45, 46, -1, -1,
4292 49, -1, 51, -1, -1, 54, -1, -1, 57, 58,
4293 59, 60, -1, 62, 63, 64, 65, 66, -1, -1,
4294 69, -1, -1, -1, 73, 74, 75, 76, -1, -1,
4295 79, -1, -1, 82, 83, 84, -1, 86, 87, -1,
4296 89, 90, 91, 92, 93, 94, 3, -1, 97, -1,
4297 99, 100, -1, 102, 103, -1, -1, -1, 107, -1,
4298 -1, 110, 111, 112, 113, 114, 115, -1, -1, -1,
4299 27, 28, 29, -1, -1, -1, 33, -1, -1, 36,
4300 -1, 38, -1, -1, 41, -1, -1, 44, 45, 46,
4301 -1, -1, 49, -1, 51, -1, -1, 54, -1, -1,
4302 57, -1, 59, 60, -1, 62, 63, -1, 65, 66,
4303 -1, -1, 69, -1, -1, -1, 73, 74, 75, 76,
4304 -1, -1, -1, -1, -1, 82, 83, 84, -1, 86,
4305 87, -1, 89, 90, 91, 92, 93, 94, 3, -1,
4306 97, -1, 99, 100, -1, -1, 103, -1, -1, -1,
4307 107, -1, -1, 110, 111, -1, 113, 114, -1, -1,
4308 -1, -1, 27, 28, 29, -1, -1, -1, 33, -1,
4309 -1, 36, -1, 38, -1, -1, 41, -1, -1, 44,
4310 45, 46, -1, -1, 49, -1, 51, -1, -1, 54,
4311 -1, -1, 57, -1, 59, 60, -1, 62, 63, -1,
4312 65, 66, -1, -1, 69, -1, -1, -1, 73, 74,
4313 75, 76, -1, -1, -1, -1, -1, 82, 83, 84,
4314 -1, 86, 87, -1, 89, 90, 91, 92, 93, 94,
4315 3, -1, 97, -1, 99, 100, -1, -1, 103, -1,
4316 -1, -1, 107, -1, -1, 110, 111, -1, 113, 114,
4317 -1, -1, -1, -1, 27, 28, 29, -1, -1, -1,
4318 33, -1, -1, 36, -1, 38, -1, -1, 41, -1,
4319 -1, 44, 45, 46, -1, -1, 49, -1, 51, -1,
4320 -1, 54, -1, -1, 57, -1, 59, 60, -1, 62,
4321 63, -1, 65, 66, -1, -1, 69, -1, -1, -1,
4322 73, 74, 75, 76, -1, -1, -1, -1, -1, 82,
4323 83, 84, -1, 86, 87, -1, 89, 90, 91, 92,
4324 93, 94, -1, -1, 97, -1, 99, 100, -1, -1,
4325 103, -1, -1, -1, 107, -1, -1, 110, 111, -1,
4326 113, 114, 8, 9, 10, 11, -1, 13, 14, 15,
4327 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
4328 26, -1, -1, -1, 30, -1, -1, -1, -1, 35,
4329 8, 9, 10, 11, 40, 13, 14, 15, 16, -1,
4330 -1, 19, 20, 21, 22, -1, -1, 25, 26, -1,
4331 -1, -1, -1, -1, -1, -1, -1, 63, -1, -1,
4332 -1, 67, 40, -1, -1, 71, 72, -1, 74, 75,
4333 -1, 77, 78, -1, -1, 81, -1, 55, -1, -1,
4334 -1, -1, -1, 89, -1, -1, -1, -1, -1, -1,
4335 -1, 8, 9, 10, 11, 101, 13, 14, 15, 16,
4336 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4337 -1, -1, -1, 30, -1, -1, -1, -1, 35, 8,
4338 9, 10, 11, 40, 13, 14, 15, 16, -1, -1,
4339 19, 20, 21, 22, -1, -1, 25, 26, -1, -1,
4340 -1, -1, -1, -1, -1, -1, 63, -1, -1, -1,
4341 67, 40, -1, -1, 71, 72, -1, 74, 75, -1,
4342 77, 78, -1, -1, 81, -1, 55, -1, 27, 28,
4343 29, -1, 89, -1, 33, -1, -1, 36, -1, 38,
4344 -1, -1, 41, 42, 101, 44, 45, 46, -1, -1,
4345 49, -1, 51, -1, -1, 54, -1, -1, 57, -1,
4346 59, 60, -1, 62, 63, 64, 65, 66, -1, -1,
4347 69, -1, -1, -1, 73, 74, 75, 76, -1, -1,
4348 -1, -1, -1, 82, 83, 84, -1, 86, 87, -1,
4349 89, 90, 91, 92, 93, 94, -1, -1, 97, -1,
4350 99, 100, -1, -1, 103, -1, -1, -1, 107, -1,
4351 -1, 110, 111, -1, 113, 114, 27, 28, 29, -1,
4352 -1, -1, 33, -1, -1, 36, -1, 38, -1, -1,
4353 41, -1, -1, 44, 45, 46, -1, -1, 49, -1,
4354 51, -1, -1, 54, -1, -1, 57, -1, 59, 60,
4355 -1, 62, 63, 64, 65, 66, -1, -1, 69, -1,
4356 -1, -1, 73, 74, 75, 76, -1, -1, -1, -1,
4357 -1, 82, 83, 84, -1, 86, 87, -1, 89, 90,
4358 91, 92, 93, 94, -1, -1, 97, -1, 99, 100,
4359 -1, -1, 103, -1, -1, -1, 107, -1, -1, 110,
4360 111, -1, 113, 114, 27, 28, 29, -1, -1, -1,
4361 33, -1, -1, 36, -1, 38, -1, -1, 41, -1,
4362 -1, 44, 45, 46, -1, -1, 49, -1, 51, -1,
4363 -1, 54, -1, -1, 57, -1, 59, 60, -1, 62,
4364 63, -1, 65, 66, -1, -1, 69, -1, -1, -1,
4365 73, 74, 75, 76, -1, -1, -1, -1, -1, 82,
4366 83, 84, -1, 86, 87, -1, 89, 90, 91, 92,
4367 93, 94, -1, -1, 97, -1, 99, 100, -1, -1,
4368 103, -1, -1, -1, 107, -1, -1, 110, 111, -1,
4369 113, 114, 27, 28, 29, -1, -1, -1, 33, -1,
4370 -1, 36, -1, 38, -1, -1, 41, -1, -1, 44,
4371 45, 46, -1, -1, 49, -1, 51, -1, -1, 54,
4372 -1, -1, 57, -1, 59, 60, -1, 62, 63, -1,
4373 65, 66, -1, -1, 69, -1, -1, -1, 73, 74,
4374 75, 76, -1, -1, -1, -1, -1, 82, 83, 84,
4375 -1, 86, 87, -1, 89, 90, 91, 92, 93, 94,
4376 -1, -1, 97, -1, 99, 100, -1, -1, 103, -1,
4377 -1, -1, 107, -1, -1, 110, 111, 4, 113, 114,
4378 -1, 8, 9, 10, 11, -1, 13, 14, 15, 16,
4379 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4380 -1, -1, -1, 30, -1, -1, -1, -1, 35, 8,
4381 9, 10, 11, 40, 13, 14, 15, 16, -1, -1,
4382 19, 20, 21, 22, -1, -1, 25, 26, -1, -1,
4383 -1, -1, -1, -1, -1, -1, 63, -1, -1, -1,
4384 67, 40, -1, -1, 71, 72, -1, 74, 75, -1,
4385 77, 78, -1, -1, 81, -1, 55, -1, -1, 4,
4386 -1, -1, 89, 8, 9, 10, 11, -1, 13, 14,
4387 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4388 25, 26, -1, -1, -1, 30, -1, -1, -1, -1,
4389 35, 8, 9, 10, 11, 40, 13, 14, 15, 16,
4390 -1, -1, 19, 20, 21, 22, -1, -1, 25, 26,
4391 -1, -1, -1, -1, -1, -1, -1, -1, 63, -1,
4392 -1, -1, 67, 40, -1, -1, 71, 72, -1, 74,
4393 75, -1, 77, 78, -1, -1, 81, -1, 55, -1,
4394 -1, 4, -1, -1, 89, 8, 9, 10, 11, -1,
4395 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
4396 23, 24, 25, 26, -1, -1, -1, 30, -1, -1,
4397 -1, -1, 35, -1, -1, -1, -1, 40, -1, -1,
4398 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4399 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4400 63, -1, -1, -1, 67, -1, -1, -1, 71, 72,
4401 -1, 74, 75, -1, 77, 78, -1, -1, 81, -1,
4402 -1, -1, -1, 4, -1, -1, 89, 8, 9, 10,
4403 11, -1, 13, 14, 15, 16, 17, 18, 19, 20,
4404 21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
4405 -1, -1, -1, -1, 35, -1, -1, -1, -1, 40,
4406 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4407 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4408 -1, -1, 63, -1, -1, -1, 67, -1, -1, -1,
4409 71, 72, -1, 74, 75, -1, 77, 78, -1, -1,
4410 81, -1, -1, -1, 8, 9, 10, 11, 89, 13,
4411 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
4412 24, 25, 26, -1, -1, -1, 30, -1, -1, 33,
4413 -1, 35, -1, -1, -1, -1, 40, -1, -1, -1,
4414 -1, -1, -1, -1, -1, -1, -1, 51, -1, -1,
4415 -1, -1, -1, -1, -1, -1, -1, -1, -1, 63,
4416 -1, -1, -1, 67, -1, -1, -1, 71, 72, -1,
4417 74, 75, -1, 77, 78, -1, -1, 81, -1, -1,
4418 -1, 8, 9, 10, 11, 89, 13, 14, 15, 16,
4419 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4420 -1, -1, -1, 30, -1, 32, -1, -1, 35, -1,
4421 -1, -1, -1, 40, -1, -1, -1, -1, -1, -1,
4422 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4423 -1, -1, -1, -1, -1, -1, 63, -1, -1, -1,
4424 67, -1, -1, -1, 71, 72, -1, 74, 75, -1,
4425 77, 78, -1, -1, 81, -1, -1, -1, 8, 9,
4426 10, 11, 89, 13, 14, 15, 16, 17, 18, 19,
4427 20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
4428 30, 31, -1, -1, -1, 35, -1, -1, -1, -1,
4429 40, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4430 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4431 -1, -1, -1, 63, -1, -1, -1, 67, -1, -1,
4432 -1, 71, 72, -1, 74, 75, -1, 77, 78, -1,
4433 -1, 81, -1, -1, -1, 8, 9, 10, 11, 89,
4434 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
4435 23, 24, 25, 26, -1, -1, -1, 30, -1, -1,
4436 -1, -1, 35, -1, -1, -1, -1, 40, -1, -1,
4437 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4438 -1, 54, -1, -1, -1, -1, -1, -1, -1, -1,
4439 63, -1, -1, -1, 67, -1, -1, -1, 71, 72,
4440 -1, 74, 75, -1, 77, 78, -1, -1, 81, -1,
4441 -1, -1, 8, 9, 10, 11, 89, 13, 14, 15,
4442 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
4443 26, -1, -1, -1, 30, 31, -1, -1, -1, 35,
4444 -1, -1, -1, -1, 40, -1, -1, -1, -1, -1,
4445 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4446 -1, -1, -1, -1, -1, -1, -1, 63, -1, -1,
4447 -1, 67, -1, -1, -1, 71, 72, -1, 74, 75,
4448 -1, 77, 78, -1, -1, 81, -1, -1, -1, 8,
4449 9, 10, 11, 89, 13, 14, 15, 16, 17, 18,
4450 19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
4451 -1, 30, -1, -1, -1, -1, 35, -1, -1, -1,
4452 -1, 40, -1, -1, -1, -1, -1, -1, -1, -1,
4453 -1, -1, -1, -1, -1, 54, -1, -1, -1, -1,
4454 -1, -1, -1, -1, 63, -1, -1, -1, 67, -1,
4455 -1, -1, 71, 72, -1, 74, 75, -1, 77, 78,
4456 -1, -1, 81, -1, -1, -1, 8, 9, 10, 11,
4457 89, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4458 22, 23, 24, 25, 26, -1, -1, -1, 30, -1,
4459 -1, -1, -1, 35, -1, -1, -1, -1, 40, -1,
4460 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4461 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4462 -1, 63, -1, -1, -1, 67, -1, -1, -1, 71,
4463 72, -1, 74, 75, -1, 77, 78, -1, -1, 81,
4464 -1, -1, -1, 8, 9, 10, 11, 89, 13, 14,
4465 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4466 25, 26, -1, -1, -1, 30, -1, -1, -1, -1,
4467 35, -1, -1, -1, -1, 40, 8, 9, 10, 11,
4468 -1, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4469 22, 23, 24, 25, 26, -1, -1, -1, 63, -1,
4470 -1, -1, 67, 35, -1, -1, 71, 72, 40, 74,
4471 75, -1, 77, 78, -1, -1, -1, -1, -1, -1,
4472 -1, -1, -1, -1, 89, -1, -1, -1, -1, -1,
4473 -1, 63, -1, -1, -1, 67, -1, -1, -1, 71,
4474 72, -1, 74, 75, -1, 77, 78, -1, -1, -1,
4475 -1, -1, -1, -1, -1, -1, -1, 89
4476 };
4477
4478 const unsigned char
4479 parser::yystos_[] =
4480 {
4481 0, 43, 118, 119, 149, 151, 171, 99, 100, 104,
4482 107, 144, 152, 0, 7, 98, 68, 98, 64, 142,
4483 142, 142, 77, 27, 28, 29, 33, 36, 38, 41,
4484 44, 45, 46, 49, 51, 54, 57, 59, 60, 62,
4485 63, 65, 66, 69, 73, 74, 75, 76, 82, 83,
4486 84, 86, 87, 89, 90, 91, 92, 93, 94, 97,
4487 99, 100, 103, 107, 110, 111, 113, 114, 121, 122,
4488 123, 146, 146, 146, 56, 5, 5, 106, 80, 3,
4489 32, 99, 121, 123, 123, 121, 123, 44, 45, 46,
4490 64, 113, 121, 122, 124, 160, 161, 95, 141, 3,
4491 150, 3, 123, 127, 128, 155, 6, 170, 3, 4,
4492 8, 9, 12, 37, 38, 44, 45, 46, 58, 77,
4493 79, 86, 102, 112, 113, 115, 116, 120, 121, 122,
4494 129, 130, 131, 132, 133, 134, 135, 136, 138, 139,
4495 140, 140, 147, 148, 3, 123, 42, 158, 159, 162,
4496 160, 162, 168, 169, 4, 132, 140, 140, 140, 108,
4497 137, 140, 3, 140, 3, 3, 5, 4, 6, 8,
4498 9, 10, 11, 13, 14, 15, 16, 17, 18, 19,
4499 20, 21, 22, 23, 24, 25, 26, 30, 35, 40,
4500 63, 67, 71, 72, 74, 75, 77, 78, 81, 89,
4501 33, 51, 143, 4, 6, 8, 9, 112, 125, 126,
4502 121, 158, 39, 40, 47, 62, 77, 79, 85, 88,
4503 104, 157, 39, 61, 85, 104, 6, 168, 110, 153,
4504 4, 140, 53, 54, 108, 137, 140, 27, 57, 65,
4505 92, 4, 10, 52, 132, 121, 140, 140, 140, 140,
4506 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
4507 140, 140, 140, 140, 140, 140, 140, 121, 140, 3,
4508 121, 123, 140, 140, 140, 35, 63, 67, 74, 75,
4509 79, 89, 140, 140, 109, 145, 147, 112, 112, 4,
4510 6, 3, 121, 3, 64, 120, 121, 122, 125, 29,
4511 79, 73, 123, 80, 154, 32, 3, 73, 73, 3,
4512 168, 93, 101, 140, 140, 53, 54, 32, 6, 6,
4513 4, 6, 4, 132, 4, 5, 31, 55, 4, 132,
4514 141, 3, 5, 55, 55, 140, 140, 3, 121, 123,
4515 140, 140, 140, 55, 140, 126, 140, 140, 154, 143,
4516 3, 164, 41, 3, 140, 3, 3, 148, 140, 54,
4517 101, 140, 128, 113, 113, 113, 4, 121, 140, 140,
4518 4, 4, 132, 121, 123, 140, 140, 31, 55, 4,
4519 132, 141, 3, 5, 55, 55, 55, 140, 4, 4,
4520 4, 154, 124, 163, 48, 75, 77, 80, 165, 166,
4521 167, 27, 57, 65, 90, 92, 140, 4, 163, 148,
4522 4, 140, 54, 4, 4, 4, 4, 4, 3, 140,
4523 140, 4, 4, 132, 121, 123, 140, 140, 140, 34,
4524 4, 6, 69, 121, 48, 50, 70, 105, 48, 77,
4525 165, 4, 4, 4, 34, 154, 4, 132, 4, 3,
4526 124, 49, 66, 69, 36, 76, 91, 96, 36, 76,
4527 91, 96, 36, 76, 91, 96, 69, 48, 97, 107,
4528 156, 88, 154, 4, 4, 4, 132, 49, 66, 28,
4529 47, 79, 28, 47, 79, 28, 47, 79, 49, 66,
4530 69, 123, 154, 4, 49, 66, 164, 167
4531 };
4532
4533 const unsigned char
4534 parser::yyr1_[] =
4535 {
4536 0, 117, 118, 118, 119, 119, 119, 120, 120, 120,
4537 120, 120, 120, 120, 120, 120, 121, 121, 122, 122,
4538 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
4539 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
4540 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
4541 122, 122, 122, 122, 122, 122, 122, 123, 123, 123,
4542 123, 123, 123, 124, 124, 124, 124, 124, 124, 124,
4543 125, 125, 126, 126, 127, 127, 128, 128, 128, 129,
4544 129, 129, 129, 130, 130, 130, 130, 130, 130, 130,
4545 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
4546 130, 130, 130, 130, 131, 131, 131, 131, 131, 131,
4547 131, 131, 131, 131, 131, 131, 131, 131, 131, 131,
4548 132, 132, 133, 133, 133, 133, 134, 134, 134, 135,
4549 135, 136, 136, 136, 136, 136, 136, 136, 136, 136,
4550 136, 136, 136, 136, 136, 136, 136, 137, 137, 138,
4551 138, 138, 138, 139, 139, 139, 139, 140, 140, 140,
4552 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
4553 140, 140, 140, 140, 140, 141, 142, 142, 143, 143,
4554 143, 144, 144, 145, 145, 146, 146, 146, 147, 148,
4555 148, 149, 150, 150, 150, 151, 152, 152, 152, 153,
4556 153, 154, 154, 154, 154, 154, 154, 155, 155, 156,
4557 156, 156, 157, 157, 158, 158, 158, 158, 158, 158,
4558 158, 158, 158, 158, 158, 158, 158, 158, 158, 159,
4559 159, 160, 160, 161, 161, 162, 162, 163, 163, 164,
4560 164, 165, 165, 165, 165, 165, 165, 165, 165, 165,
4561 165, 165, 165, 165, 165, 165, 165, 166, 166, 167,
4562 167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
4563 167, 167, 167, 168, 168, 168, 168, 168, 169, 169,
4564 169, 170, 170, 171, 171
4565 };
4566
4567 const signed char
4568 parser::yyr2_[] =
4569 {
4570 0, 2, 1, 2, 1, 1, 1, 1, 1, 1,
4571 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4572 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4573 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4574 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4575 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4576 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4577 2, 2, 1, 1, 1, 2, 1, 4, 6, 2,
4578 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
4579 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4580 3, 3, 3, 3, 3, 3, 3, 3, 4, 4,
4581 4, 4, 5, 5, 5, 5, 6, 6, 6, 6,
4582 1, 3, 4, 5, 3, 4, 2, 2, 3, 5,
4583 6, 4, 5, 5, 5, 3, 7, 8, 6, 5,
4584 6, 6, 6, 4, 8, 9, 7, 4, 5, 6,
4585 4, 5, 3, 4, 6, 6, 6, 1, 1, 1,
4586 5, 3, 1, 1, 1, 1, 3, 6, 3, 1,
4587 1, 1, 1, 1, 1, 1, 0, 3, 0, 1,
4588 1, 0, 1, 0, 2, 3, 3, 1, 2, 1,
4589 3, 11, 0, 2, 3, 8, 0, 1, 1, 0,
4590 2, 0, 3, 3, 3, 3, 3, 0, 1, 0,
4591 1, 1, 0, 2, 5, 6, 4, 2, 3, 5,
4592 3, 3, 3, 3, 3, 5, 3, 5, 7, 1,
4593 2, 3, 2, 1, 3, 0, 2, 1, 3, 0,
4594 3, 4, 4, 3, 3, 4, 4, 4, 3, 3,
4595 4, 4, 4, 3, 3, 4, 2, 1, 2, 0,
4596 1, 4, 4, 2, 5, 5, 3, 3, 3, 1,
4597 4, 4, 2, 7, 8, 6, 5, 10, 1, 3,
4598 2, 0, 2, 7, 10
4599 };
4600
4601
4602
4603 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
4604 // First, the terminals, then, starting at \a yyntokens_, nonterminals.
4605 const char*
4606 const parser::yytname_[] =
4607 {
4608 "\"end of file\"", "error", "$undefined", "\"(\"", "\")\"", "\".\"",
4609 "\",\"", "\";\"", "\"+\"", "\"-\"", "\"*\"", "\"/\"", "\"~\"", "\"&\"",
4610 "\"%\"", "\"|\"", "\"||\"", "\"=\"", "\"==\"", "\">\"", "\">=\"",
4611 "\"<\"", "\"<=\"", "\"!=\"", "\"<>\"", "\"<<\"", "\">>\"", "\"ABORT\"",
4612 "\"ACTION\"", "\"ALWAYS\"", "\"AND\"", "\"AND BETWEEN\"", "\"AS\"",
4613 "\"ASC\"", "\"AUTOINCREMENT\"", "\"BETWEEN\"", "\"CASCADE\"", "\"CASE\"",
4614 "\"CAST\"", "\"CHECK\"", "\"COLLATE\"", "\"CONFLICT\"", "\"CONSTRAINT\"",
4615 "\"CREATE\"", "\"CURRENT_DATE\"", "\"CURRENT_TIME\"",
4616 "\"CURRENT_TIMESTAMP\"", "\"DEFAULT\"", "\"DEFERRABLE\"", "\"DEFERRED\"",
4617 "\"DELETE\"", "\"DESC\"", "\"DISTINCT\"", "\"ELSE\"", "\"END\"",
4618 "\"ESCAPE\"", "\"EXISTS\"", "\"FAIL\"", "\"FALSE\"", "\"FILTER\"",
4619 "\"FOLLOWING\"", "\"FOREIGN\"", "\"GENERATED\"", "\"GLOB\"", "\"IF\"",
4620 "\"IGNORE\"", "\"IMMEDIATE\"", "\"IN\"", "\"INDEX\"", "\"INITIALLY\"",
4621 "\"INSERT\"", "\"IS\"", "\"ISNULL\"", "\"KEY\"", "\"LIKE\"", "\"MATCH\"",
4622 "\"NO\"", "\"NOT\"", "\"NOTNULL\"", "\"NULL\"", "\"ON\"", "\"OR\"",
4623 "\"OVER\"", "\"PARTITION\"", "\"PRECEDING\"", "\"PRIMARY\"", "\"RAISE\"",
4624 "\"RANGE\"", "\"REFERENCES\"", "\"REGEXP\"", "\"REPLACE\"",
4625 "\"RESTRICT\"", "\"ROLLBACK\"", "\"ROWID\"", "\"ROWS\"", "\"SELECT\"",
4626 "\"SET\"", "\"STORED\"", "\"TABLE\"", "\"TEMP\"", "\"TEMPORARY\"",
4627 "\"THEN\"", "\"TRUE\"", "\"UNBOUNDED\"", "\"UNIQUE\"", "\"UPDATE\"",
4628 "\"USING\"", "\"VIRTUAL\"", "\"WHEN\"", "\"WHERE\"", "\"WITHOUT\"",
4629 "\"identifier\"", "\"numeric\"", "\"string literal\"",
4630 "\"quoted literal\"", "\"blob literal\"", "\"bind parameter\"",
4631 "$accept", "sql", "statement", "literalvalue", "id",
4632 "allowed_keywords_as_identifier", "tableid", "columnid", "signednumber",
4633 "signednumber_or_numeric", "typename_namelist", "type_name",
4634 "unary_expr", "binary_expr", "like_expr", "exprlist_expr",
4635 "function_expr", "isnull_expr", "between_expr", "in_expr",
4636 "whenthenlist_expr", "case_expr", "raise_expr", "expr", "select_stmt",
4637 "optional_if_not_exists", "optional_sort_order", "optional_unique",
4638 "optional_where", "tableid_with_uninteresting_schema", "indexed_column",
4639 "indexed_column_list", "createindex_stmt",
4640 "optional_exprlist_with_paren", "createvirtualtable_stmt",
4641 "optional_temporary", "optional_withoutrowid", "optional_conflictclause",
4642 "optional_typename", "optional_storage_identifier",
4643 "optional_always_generated", "columnconstraint", "columnconstraint_list",
4644 "columndef", "columndef_list", "optional_constraintname",
4645 "columnid_list", "optional_columnid_with_paren_list", "fk_clause_part",
4646 "fk_clause_part_list", "optional_fk_clause", "tableconstraint",
4647 "tableconstraint_list", "optional_tableconstraint_list",
4648 "createtable_stmt", YY_NULLPTR
4649 };
4650
4651 #if YYDEBUG
4652 const short
4653 parser::yyrline_[] =
4654 {
4655 0, 309, 309, 310, 314, 315, 316, 324, 325, 326,
4656 327, 328, 329, 330, 331, 332, 336, 337, 342, 343,
4657 344, 345, 346, 347, 348, 349, 350, 351, 352, 353,
4658 354, 355, 356, 357, 358, 359, 360, 361, 362, 363,
4659 364, 365, 366, 367, 368, 369, 370, 371, 372, 373,
4660 374, 375, 376, 377, 378, 379, 380, 384, 385, 386,
4661 387, 388, 389, 393, 394, 395, 396, 397, 398, 399,
4662 403, 404, 408, 409, 413, 414, 418, 419, 420, 424,
4663 425, 426, 427, 431, 432, 433, 434, 435, 436, 437,
4664 438, 439, 440, 441, 442, 443, 444, 445, 446, 447,
4665 448, 449, 450, 451, 455, 456, 457, 458, 459, 460,
4666 461, 462, 463, 464, 465, 466, 467, 468, 469, 470,
4667 474, 475, 479, 480, 481, 482, 486, 487, 488, 492,
4668 493, 497, 498, 499, 500, 501, 502, 503, 504, 505,
4669 506, 507, 508, 509, 510, 511, 512, 516, 517, 521,
4670 522, 523, 524, 528, 529, 530, 531, 535, 536, 537,
4671 538, 539, 540, 541, 542, 543, 544, 545, 546, 547,
4672 548, 549, 550, 551, 552, 561, 569, 570, 574, 575,
4673 576, 584, 585, 589, 590, 594, 595, 596, 600, 614,
4674 615, 619, 634, 635, 636, 640, 652, 653, 654, 658,
4675 659, 663, 664, 665, 666, 667, 668, 672, 673, 677,
4676 678, 679, 683, 684, 688, 697, 707, 712, 717, 722,
4677 728, 734, 740, 746, 753, 759, 765, 771, 782, 793,
4678 794, 798, 850, 854, 855, 859, 860, 864, 865, 869,
4679 870, 874, 875, 876, 877, 878, 879, 880, 881, 882,
4680 883, 884, 885, 886, 887, 888, 889, 893, 894, 898,
4681 899, 900, 901, 902, 903, 904, 905, 906, 907, 908,
4682 909, 910, 911, 915, 921, 928, 934, 938, 946, 947,
4683 948, 952, 953, 957, 961
4684 };
4685
4686 // Print the state stack on the debug stream.
4687 void
yystack_print_()4688 parser::yystack_print_ ()
4689 {
4690 *yycdebug_ << "Stack now";
4691 for (stack_type::const_iterator
4692 i = yystack_.begin (),
4693 i_end = yystack_.end ();
4694 i != i_end; ++i)
4695 *yycdebug_ << ' ' << int (i->state);
4696 *yycdebug_ << '\n';
4697 }
4698
4699 // Report on the debug stream that the rule \a yyrule is going to be reduced.
4700 void
yy_reduce_print_(int yyrule)4701 parser::yy_reduce_print_ (int yyrule)
4702 {
4703 int yylno = yyrline_[yyrule];
4704 int yynrhs = yyr2_[yyrule];
4705 // Print the symbols being reduced, and their result.
4706 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
4707 << " (line " << yylno << "):\n";
4708 // The symbols being reduced.
4709 for (int yyi = 0; yyi < yynrhs; yyi++)
4710 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
4711 yystack_[(yynrhs) - (yyi + 1)]);
4712 }
4713 #endif // YYDEBUG
4714
4715
4716 #line 10 "sqlite3_parser.yy"
4717 } } // sqlb::parser
4718 #line 4719 "sqlite3_parser.cpp"
4719
4720 #line 983 "sqlite3_parser.yy"
4721
4722
error(const location_type & l,const std::string & m)4723 void sqlb::parser::parser::error(const location_type& l, const std::string& m)
4724 {
4725 std::cerr << l << ": " << m << std::endl;
4726 }
4727