Kea 2.2.0
d2_parser.cc
Go to the documentation of this file.
1// A Bison parser, made by GNU Bison 3.8.2.
2
3// Skeleton implementation for Bison LALR(1) parsers in C++
4
5// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
6
7// This program is free software: you can redistribute it and/or modify
8// it under the terms of the GNU General Public License as published by
9// the Free Software Foundation, either version 3 of the License, or
10// (at your option) any later version.
11
12// This program is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15// GNU General Public License for more details.
16
17// You should have received a copy of the GNU General Public License
18// along with this program. If not, see <https://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// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
34// especially those whose name start with YY_ or yy_. They are
35// private implementation details that can be changed or removed.
36
37
38// Take the name prefix into account.
39#define yylex d2_parser_lex
40
41
42
43#include "d2_parser.h"
44
45
46// Unqualified %code blocks.
47#line 34 "d2_parser.yy"
48
49#include <d2/parser_context.h>
50
51#line 52 "d2_parser.cc"
52
53
54#ifndef YY_
55# if defined YYENABLE_NLS && YYENABLE_NLS
56# if ENABLE_NLS
57# include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
58# define YY_(msgid) dgettext ("bison-runtime", msgid)
59# endif
60# endif
61# ifndef YY_
62# define YY_(msgid) msgid
63# endif
64#endif
65
66
67// Whether we are compiled with exception support.
68#ifndef YY_EXCEPTIONS
69# if defined __GNUC__ && !defined __EXCEPTIONS
70# define YY_EXCEPTIONS 0
71# else
72# define YY_EXCEPTIONS 1
73# endif
74#endif
75
76#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
77/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
78 If N is 0, then set CURRENT to the empty location which ends
79 the previous symbol: RHS[0] (always defined). */
80
81# ifndef YYLLOC_DEFAULT
82# define YYLLOC_DEFAULT(Current, Rhs, N) \
83 do \
84 if (N) \
85 { \
86 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
87 (Current).end = YYRHSLOC (Rhs, N).end; \
88 } \
89 else \
90 { \
91 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
92 } \
93 while (false)
94# endif
95
96
97// Enable debugging if requested.
98#if D2_PARSER_DEBUG
99
100// A pseudo ostream that takes yydebug_ into account.
101# define YYCDEBUG if (yydebug_) (*yycdebug_)
102
103# define YY_SYMBOL_PRINT(Title, Symbol) \
104 do { \
105 if (yydebug_) \
106 { \
107 *yycdebug_ << Title << ' '; \
108 yy_print_ (*yycdebug_, Symbol); \
109 *yycdebug_ << '\n'; \
110 } \
111 } while (false)
112
113# define YY_REDUCE_PRINT(Rule) \
114 do { \
115 if (yydebug_) \
116 yy_reduce_print_ (Rule); \
117 } while (false)
118
119# define YY_STACK_PRINT() \
120 do { \
121 if (yydebug_) \
122 yy_stack_print_ (); \
123 } while (false)
124
125#else // !D2_PARSER_DEBUG
126
127# define YYCDEBUG if (false) std::cerr
128# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol)
129# define YY_REDUCE_PRINT(Rule) static_cast<void> (0)
130# define YY_STACK_PRINT() static_cast<void> (0)
131
132#endif // !D2_PARSER_DEBUG
133
134#define yyerrok (yyerrstatus_ = 0)
135#define yyclearin (yyla.clear ())
136
137#define YYACCEPT goto yyacceptlab
138#define YYABORT goto yyabortlab
139#define YYERROR goto yyerrorlab
140#define YYRECOVERING() (!!yyerrstatus_)
141
142#line 14 "d2_parser.yy"
143namespace isc { namespace d2 {
144#line 145 "d2_parser.cc"
145
148#if D2_PARSER_DEBUG
149 : yydebug_ (false),
150 yycdebug_ (&std::cerr),
151#else
152 :
153#endif
154 ctx (ctx_yyarg)
155 {}
156
158 {}
159
161 {}
162
163 /*---------.
164 | symbol. |
165 `---------*/
166
167
168
169 // by_state.
170 D2Parser::by_state::by_state () YY_NOEXCEPT
171 : state (empty_state)
172 {}
173
174 D2Parser::by_state::by_state (const by_state& that) YY_NOEXCEPT
175 : state (that.state)
176 {}
177
178 void
179 D2Parser::by_state::clear () YY_NOEXCEPT
180 {
181 state = empty_state;
182 }
183
184 void
185 D2Parser::by_state::move (by_state& that)
186 {
187 state = that.state;
188 that.clear ();
189 }
190
191 D2Parser::by_state::by_state (state_type s) YY_NOEXCEPT
192 : state (s)
193 {}
194
196 D2Parser::by_state::kind () const YY_NOEXCEPT
197 {
198 if (state == empty_state)
200 else
201 return YY_CAST (symbol_kind_type, yystos_[+state]);
202 }
203
204 D2Parser::stack_symbol_type::stack_symbol_type ()
205 {}
206
207 D2Parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
208 : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
209 {
210 switch (that.kind ())
211 {
212 case symbol_kind::S_value: // value
213 case symbol_kind::S_map_value: // map_value
214 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
215 value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
216 break;
217
218 case symbol_kind::S_BOOLEAN: // "boolean"
219 value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
220 break;
221
222 case symbol_kind::S_FLOAT: // "floating point"
223 value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
224 break;
225
226 case symbol_kind::S_INTEGER: // "integer"
227 value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
228 break;
229
230 case symbol_kind::S_STRING: // "constant string"
231 value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
232 break;
233
234 default:
235 break;
236 }
237
238#if 201103L <= YY_CPLUSPLUS
239 // that is emptied.
240 that.state = empty_state;
241#endif
242 }
243
244 D2Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
245 : super_type (s, YY_MOVE (that.location))
246 {
247 switch (that.kind ())
248 {
249 case symbol_kind::S_value: // value
250 case symbol_kind::S_map_value: // map_value
251 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
252 value.move< ElementPtr > (YY_MOVE (that.value));
253 break;
254
255 case symbol_kind::S_BOOLEAN: // "boolean"
256 value.move< bool > (YY_MOVE (that.value));
257 break;
258
259 case symbol_kind::S_FLOAT: // "floating point"
260 value.move< double > (YY_MOVE (that.value));
261 break;
262
263 case symbol_kind::S_INTEGER: // "integer"
264 value.move< int64_t > (YY_MOVE (that.value));
265 break;
266
267 case symbol_kind::S_STRING: // "constant string"
268 value.move< std::string > (YY_MOVE (that.value));
269 break;
270
271 default:
272 break;
273 }
274
275 // that is emptied.
276 that.kind_ = symbol_kind::S_YYEMPTY;
277 }
278
279#if YY_CPLUSPLUS < 201103L
280 D2Parser::stack_symbol_type&
281 D2Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
282 {
283 state = that.state;
284 switch (that.kind ())
285 {
286 case symbol_kind::S_value: // value
287 case symbol_kind::S_map_value: // map_value
288 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
289 value.copy< ElementPtr > (that.value);
290 break;
291
292 case symbol_kind::S_BOOLEAN: // "boolean"
293 value.copy< bool > (that.value);
294 break;
295
296 case symbol_kind::S_FLOAT: // "floating point"
297 value.copy< double > (that.value);
298 break;
299
300 case symbol_kind::S_INTEGER: // "integer"
301 value.copy< int64_t > (that.value);
302 break;
303
304 case symbol_kind::S_STRING: // "constant string"
305 value.copy< std::string > (that.value);
306 break;
307
308 default:
309 break;
310 }
311
312 location = that.location;
313 return *this;
314 }
315
316 D2Parser::stack_symbol_type&
317 D2Parser::stack_symbol_type::operator= (stack_symbol_type& that)
318 {
319 state = that.state;
320 switch (that.kind ())
321 {
322 case symbol_kind::S_value: // value
323 case symbol_kind::S_map_value: // map_value
324 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
325 value.move< ElementPtr > (that.value);
326 break;
327
328 case symbol_kind::S_BOOLEAN: // "boolean"
329 value.move< bool > (that.value);
330 break;
331
332 case symbol_kind::S_FLOAT: // "floating point"
333 value.move< double > (that.value);
334 break;
335
336 case symbol_kind::S_INTEGER: // "integer"
337 value.move< int64_t > (that.value);
338 break;
339
340 case symbol_kind::S_STRING: // "constant string"
341 value.move< std::string > (that.value);
342 break;
343
344 default:
345 break;
346 }
347
348 location = that.location;
349 // that is emptied.
350 that.state = empty_state;
351 return *this;
352 }
353#endif
354
355 template <typename Base>
356 void
357 D2Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
358 {
359 if (yymsg)
360 YY_SYMBOL_PRINT (yymsg, yysym);
361 }
362
363#if D2_PARSER_DEBUG
364 template <typename Base>
365 void
366 D2Parser::yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const
367 {
368 std::ostream& yyoutput = yyo;
369 YY_USE (yyoutput);
370 if (yysym.empty ())
371 yyo << "empty symbol";
372 else
373 {
374 symbol_kind_type yykind = yysym.kind ();
375 yyo << (yykind < YYNTOKENS ? "token" : "nterm")
376 << ' ' << yysym.name () << " ("
377 << yysym.location << ": ";
378 switch (yykind)
379 {
380 case symbol_kind::S_STRING: // "constant string"
381#line 116 "d2_parser.yy"
382 { yyoutput << yysym.value.template as < std::string > (); }
383#line 384 "d2_parser.cc"
384 break;
385
386 case symbol_kind::S_INTEGER: // "integer"
387#line 116 "d2_parser.yy"
388 { yyoutput << yysym.value.template as < int64_t > (); }
389#line 390 "d2_parser.cc"
390 break;
391
392 case symbol_kind::S_FLOAT: // "floating point"
393#line 116 "d2_parser.yy"
394 { yyoutput << yysym.value.template as < double > (); }
395#line 396 "d2_parser.cc"
396 break;
397
398 case symbol_kind::S_BOOLEAN: // "boolean"
399#line 116 "d2_parser.yy"
400 { yyoutput << yysym.value.template as < bool > (); }
401#line 402 "d2_parser.cc"
402 break;
403
404 case symbol_kind::S_value: // value
405#line 116 "d2_parser.yy"
406 { yyoutput << yysym.value.template as < ElementPtr > (); }
407#line 408 "d2_parser.cc"
408 break;
409
410 case symbol_kind::S_map_value: // map_value
411#line 116 "d2_parser.yy"
412 { yyoutput << yysym.value.template as < ElementPtr > (); }
413#line 414 "d2_parser.cc"
414 break;
415
416 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
417#line 116 "d2_parser.yy"
418 { yyoutput << yysym.value.template as < ElementPtr > (); }
419#line 420 "d2_parser.cc"
420 break;
421
422 default:
423 break;
424 }
425 yyo << ')';
426 }
427 }
428#endif
429
430 void
431 D2Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
432 {
433 if (m)
434 YY_SYMBOL_PRINT (m, sym);
435 yystack_.push (YY_MOVE (sym));
436 }
437
438 void
439 D2Parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
440 {
441#if 201103L <= YY_CPLUSPLUS
442 yypush_ (m, stack_symbol_type (s, std::move (sym)));
443#else
444 stack_symbol_type ss (s, sym);
445 yypush_ (m, ss);
446#endif
447 }
448
449 void
450 D2Parser::yypop_ (int n) YY_NOEXCEPT
451 {
452 yystack_.pop (n);
453 }
454
455#if D2_PARSER_DEBUG
456 std::ostream&
458 {
459 return *yycdebug_;
460 }
461
462 void
464 {
465 yycdebug_ = &o;
466 }
467
468
471 {
472 return yydebug_;
473 }
474
475 void
477 {
478 yydebug_ = l;
479 }
480#endif // D2_PARSER_DEBUG
481
482 D2Parser::state_type
483 D2Parser::yy_lr_goto_state_ (state_type yystate, int yysym)
484 {
485 int yyr = yypgoto_[yysym - YYNTOKENS] + yystate;
486 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
487 return yytable_[yyr];
488 else
489 return yydefgoto_[yysym - YYNTOKENS];
490 }
491
492 bool
493 D2Parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT
494 {
495 return yyvalue == yypact_ninf_;
496 }
497
498 bool
499 D2Parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT
500 {
501 return yyvalue == yytable_ninf_;
502 }
503
504 int
506 {
507 return parse ();
508 }
509
510 int
512 {
513 int yyn;
515 int yylen = 0;
516
517 // Error handling.
518 int yynerrs_ = 0;
519 int yyerrstatus_ = 0;
520
522 symbol_type yyla;
523
525 stack_symbol_type yyerror_range[3];
526
528 int yyresult;
529
530#if YY_EXCEPTIONS
531 try
532#endif // YY_EXCEPTIONS
533 {
534 YYCDEBUG << "Starting parse\n";
535
536
537 /* Initialize the stack. The initial state will be set in
538 yynewstate, since the latter expects the semantical and the
539 location values to have been already stored, initialize these
540 stacks with a primary value. */
541 yystack_.clear ();
542 yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
543
544 /*-----------------------------------------------.
545 | yynewstate -- push a new symbol on the stack. |
546 `-----------------------------------------------*/
547 yynewstate:
548 YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n';
550
551 // Accept?
552 if (yystack_[0].state == yyfinal_)
553 YYACCEPT;
554
555 goto yybackup;
556
557
558 /*-----------.
559 | yybackup. |
560 `-----------*/
561 yybackup:
562 // Try to take a decision without lookahead.
563 yyn = yypact_[+yystack_[0].state];
564 if (yy_pact_value_is_default_ (yyn))
565 goto yydefault;
566
567 // Read a lookahead token.
568 if (yyla.empty ())
569 {
570 YYCDEBUG << "Reading a token\n";
571#if YY_EXCEPTIONS
572 try
573#endif // YY_EXCEPTIONS
574 {
575 symbol_type yylookahead (yylex (ctx));
576 yyla.move (yylookahead);
577 }
578#if YY_EXCEPTIONS
579 catch (const syntax_error& yyexc)
580 {
581 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
582 error (yyexc);
583 goto yyerrlab1;
584 }
585#endif // YY_EXCEPTIONS
586 }
587 YY_SYMBOL_PRINT ("Next token is", yyla);
588
589 if (yyla.kind () == symbol_kind::S_YYerror)
590 {
591 // The scanner already issued an error message, process directly
592 // to error recovery. But do not keep the error token as
593 // lookahead, it is too special and may lead us to an endless
594 // loop in error recovery. */
595 yyla.kind_ = symbol_kind::S_YYUNDEF;
596 goto yyerrlab1;
597 }
598
599 /* If the proper action on seeing token YYLA.TYPE is to reduce or
600 to detect an error, take that action. */
601 yyn += yyla.kind ();
602 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ())
603 {
604 goto yydefault;
605 }
606
607 // Reduce or error.
608 yyn = yytable_[yyn];
609 if (yyn <= 0)
610 {
611 if (yy_table_value_is_error_ (yyn))
612 goto yyerrlab;
613 yyn = -yyn;
614 goto yyreduce;
615 }
616
617 // Count tokens shifted since error; after three, turn off error status.
618 if (yyerrstatus_)
619 --yyerrstatus_;
620
621 // Shift the lookahead token.
622 yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));
623 goto yynewstate;
624
625
626 /*-----------------------------------------------------------.
627 | yydefault -- do the default action for the current state. |
628 `-----------------------------------------------------------*/
629 yydefault:
630 yyn = yydefact_[+yystack_[0].state];
631 if (yyn == 0)
632 goto yyerrlab;
633 goto yyreduce;
634
635
636 /*-----------------------------.
637 | yyreduce -- do a reduction. |
638 `-----------------------------*/
639 yyreduce:
640 yylen = yyr2_[yyn];
641 {
642 stack_symbol_type yylhs;
643 yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
644 /* Variants are always initialized to an empty instance of the
645 correct type. The default '$$ = $1' action is NOT applied
646 when using variants. */
647 switch (yyr1_[yyn])
648 {
649 case symbol_kind::S_value: // value
650 case symbol_kind::S_map_value: // map_value
651 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
652 yylhs.value.emplace< ElementPtr > ();
653 break;
654
655 case symbol_kind::S_BOOLEAN: // "boolean"
656 yylhs.value.emplace< bool > ();
657 break;
658
659 case symbol_kind::S_FLOAT: // "floating point"
660 yylhs.value.emplace< double > ();
661 break;
662
663 case symbol_kind::S_INTEGER: // "integer"
664 yylhs.value.emplace< int64_t > ();
665 break;
666
667 case symbol_kind::S_STRING: // "constant string"
668 yylhs.value.emplace< std::string > ();
669 break;
670
671 default:
672 break;
673 }
674
675
676 // Default location.
677 {
678 stack_type::slice range (yystack_, yylen);
679 YYLLOC_DEFAULT (yylhs.location, range, yylen);
680 yyerror_range[1].location = yylhs.location;
681 }
682
683 // Perform the reduction.
684 YY_REDUCE_PRINT (yyn);
685#if YY_EXCEPTIONS
686 try
687#endif // YY_EXCEPTIONS
688 {
689 switch (yyn)
690 {
691 case 2: // $@1: %empty
692#line 125 "d2_parser.yy"
693 { ctx.ctx_ = ctx.NO_KEYWORD; }
694#line 695 "d2_parser.cc"
695 break;
696
697 case 4: // $@2: %empty
698#line 126 "d2_parser.yy"
699 { ctx.ctx_ = ctx.CONFIG; }
700#line 701 "d2_parser.cc"
701 break;
702
703 case 6: // $@3: %empty
704#line 127 "d2_parser.yy"
705 { ctx.ctx_ = ctx.DHCPDDNS; }
706#line 707 "d2_parser.cc"
707 break;
708
709 case 8: // $@4: %empty
710#line 128 "d2_parser.yy"
711 { ctx.ctx_ = ctx.TSIG_KEY; }
712#line 713 "d2_parser.cc"
713 break;
714
715 case 10: // $@5: %empty
716#line 129 "d2_parser.yy"
717 { ctx.ctx_ = ctx.TSIG_KEYS; }
718#line 719 "d2_parser.cc"
719 break;
720
721 case 12: // $@6: %empty
722#line 130 "d2_parser.yy"
723 { ctx.ctx_ = ctx.DDNS_DOMAIN; }
724#line 725 "d2_parser.cc"
725 break;
726
727 case 14: // $@7: %empty
728#line 131 "d2_parser.yy"
729 { ctx.ctx_ = ctx.DDNS_DOMAINS; }
730#line 731 "d2_parser.cc"
731 break;
732
733 case 16: // $@8: %empty
734#line 132 "d2_parser.yy"
735 { ctx.ctx_ = ctx.DNS_SERVERS; }
736#line 737 "d2_parser.cc"
737 break;
738
739 case 18: // $@9: %empty
740#line 133 "d2_parser.yy"
741 { ctx.ctx_ = ctx.DNS_SERVERS; }
742#line 743 "d2_parser.cc"
743 break;
744
745 case 20: // $@10: %empty
746#line 134 "d2_parser.yy"
747 { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
748#line 749 "d2_parser.cc"
749 break;
750
751 case 22: // value: "integer"
752#line 142 "d2_parser.yy"
753 { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); }
754#line 755 "d2_parser.cc"
755 break;
756
757 case 23: // value: "floating point"
758#line 143 "d2_parser.yy"
759 { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); }
760#line 761 "d2_parser.cc"
761 break;
762
763 case 24: // value: "boolean"
764#line 144 "d2_parser.yy"
765 { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); }
766#line 767 "d2_parser.cc"
767 break;
768
769 case 25: // value: "constant string"
770#line 145 "d2_parser.yy"
771 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); }
772#line 773 "d2_parser.cc"
773 break;
774
775 case 26: // value: "null"
776#line 146 "d2_parser.yy"
777 { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
778#line 779 "d2_parser.cc"
779 break;
780
781 case 27: // value: map2
782#line 147 "d2_parser.yy"
783 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
784#line 785 "d2_parser.cc"
785 break;
786
787 case 28: // value: list_generic
788#line 148 "d2_parser.yy"
789 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
790#line 791 "d2_parser.cc"
791 break;
792
793 case 29: // sub_json: value
794#line 151 "d2_parser.yy"
795 {
796 // Push back the JSON value on the stack
797 ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ());
798}
799#line 800 "d2_parser.cc"
800 break;
801
802 case 30: // $@11: %empty
803#line 156 "d2_parser.yy"
804 {
805 // This code is executed when we're about to start parsing
806 // the content of the map
807 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
808 ctx.stack_.push_back(m);
809}
810#line 811 "d2_parser.cc"
811 break;
812
813 case 31: // map2: "{" $@11 map_content "}"
814#line 161 "d2_parser.yy"
815 {
816 // map parsing completed. If we ever want to do any wrap up
817 // (maybe some sanity checking), this would be the best place
818 // for it.
819}
820#line 821 "d2_parser.cc"
821 break;
822
823 case 32: // map_value: map2
824#line 167 "d2_parser.yy"
825 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
826#line 827 "d2_parser.cc"
827 break;
828
829 case 35: // not_empty_map: "constant string" ":" value
830#line 174 "d2_parser.yy"
831 {
832 // map containing a single entry
833 ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
834 ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
835 }
836#line 837 "d2_parser.cc"
837 break;
838
839 case 36: // not_empty_map: not_empty_map "," "constant string" ":" value
840#line 179 "d2_parser.yy"
841 {
842 // map consisting of a shorter map followed by
843 // comma and string:value
844 ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
845 ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
846 }
847#line 848 "d2_parser.cc"
848 break;
849
850 case 37: // not_empty_map: not_empty_map ","
851#line 185 "d2_parser.yy"
852 {
853 ctx.warnAboutExtraCommas(yystack_[0].location);
854 }
855#line 856 "d2_parser.cc"
856 break;
857
858 case 38: // $@12: %empty
859#line 190 "d2_parser.yy"
860 {
861 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
862 ctx.stack_.push_back(l);
863}
864#line 865 "d2_parser.cc"
865 break;
866
867 case 39: // list_generic: "[" $@12 list_content "]"
868#line 193 "d2_parser.yy"
869 {
870 // list parsing complete. Put any sanity checking here
871}
872#line 873 "d2_parser.cc"
873 break;
874
875 case 42: // not_empty_list: value
876#line 201 "d2_parser.yy"
877 {
878 // List consisting of a single element.
879 ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
880 }
881#line 882 "d2_parser.cc"
882 break;
883
884 case 43: // not_empty_list: not_empty_list "," value
885#line 205 "d2_parser.yy"
886 {
887 // List ending with , and a value.
888 ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
889 }
890#line 891 "d2_parser.cc"
891 break;
892
893 case 44: // not_empty_list: not_empty_list ","
894#line 209 "d2_parser.yy"
895 {
896 ctx.warnAboutExtraCommas(yystack_[0].location);
897 }
898#line 899 "d2_parser.cc"
899 break;
900
901 case 45: // unknown_map_entry: "constant string" ":"
902#line 219 "d2_parser.yy"
903 {
904 const std::string& where = ctx.contextName();
905 const std::string& keyword = yystack_[1].value.as < std::string > ();
906 error(yystack_[1].location,
907 "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
908}
909#line 910 "d2_parser.cc"
910 break;
911
912 case 46: // $@13: %empty
913#line 228 "d2_parser.yy"
914 {
915 // This code is executed when we're about to start parsing
916 // the content of the map
917 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
918 ctx.stack_.push_back(m);
919}
920#line 921 "d2_parser.cc"
921 break;
922
923 case 47: // syntax_map: "{" $@13 global_object "}"
924#line 233 "d2_parser.yy"
925 {
926 // map parsing completed. If we ever want to do any wrap up
927 // (maybe some sanity checking), this would be the best place
928 // for it.
929}
930#line 931 "d2_parser.cc"
931 break;
932
933 case 48: // $@14: %empty
934#line 241 "d2_parser.yy"
935 {
936 ctx.unique("DhcpDdns", ctx.loc2pos(yystack_[0].location));
937 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
938 ctx.stack_.back()->set("DhcpDdns", m);
939 ctx.stack_.push_back(m);
940 ctx.enter(ctx.DHCPDDNS);
941}
942#line 943 "d2_parser.cc"
943 break;
944
945 case 49: // global_object: "DhcpDdns" $@14 ":" "{" dhcpddns_params "}"
946#line 247 "d2_parser.yy"
947 {
948 ctx.stack_.pop_back();
949 ctx.leave();
950}
951#line 952 "d2_parser.cc"
952 break;
953
954 case 51: // global_object_comma: global_object ","
955#line 254 "d2_parser.yy"
956 {
957 ctx.warnAboutExtraCommas(yystack_[0].location);
958}
959#line 960 "d2_parser.cc"
960 break;
961
962 case 52: // $@15: %empty
963#line 258 "d2_parser.yy"
964 {
965 // Parse the dhcpddns map
966 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
967 ctx.stack_.push_back(m);
968}
969#line 970 "d2_parser.cc"
970 break;
971
972 case 53: // sub_dhcpddns: "{" $@15 dhcpddns_params "}"
973#line 262 "d2_parser.yy"
974 {
975 // parsing completed
976}
977#line 978 "d2_parser.cc"
978 break;
979
980 case 56: // dhcpddns_params: dhcpddns_params ","
981#line 268 "d2_parser.yy"
982 {
983 ctx.warnAboutExtraCommas(yystack_[0].location);
984 }
985#line 986 "d2_parser.cc"
986 break;
987
988 case 71: // $@16: %empty
989#line 290 "d2_parser.yy"
990 {
991 ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location));
992 ctx.enter(ctx.NO_KEYWORD);
993}
994#line 995 "d2_parser.cc"
995 break;
996
997 case 72: // ip_address: "ip-address" $@16 ":" "constant string"
998#line 293 "d2_parser.yy"
999 {
1000 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1001 ctx.stack_.back()->set("ip-address", s);
1002 ctx.leave();
1003}
1004#line 1005 "d2_parser.cc"
1005 break;
1006
1007 case 73: // port: "port" ":" "integer"
1008#line 299 "d2_parser.yy"
1009 {
1010 ctx.unique("port", ctx.loc2pos(yystack_[2].location));
1011 if (yystack_[0].value.as < int64_t > () <= 0 || yystack_[0].value.as < int64_t > () >= 65536 ) {
1012 error(yystack_[0].location, "port must be greater than zero but less than 65536");
1013 }
1014 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1015 ctx.stack_.back()->set("port", i);
1016}
1017#line 1018 "d2_parser.cc"
1018 break;
1019
1020 case 74: // dns_server_timeout: "dns-server-timeout" ":" "integer"
1021#line 308 "d2_parser.yy"
1022 {
1023 ctx.unique("dns-server-timeout", ctx.loc2pos(yystack_[2].location));
1024 if (yystack_[0].value.as < int64_t > () <= 0) {
1025 error(yystack_[0].location, "dns-server-timeout must be greater than zero");
1026 } else {
1027 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1028 ctx.stack_.back()->set("dns-server-timeout", i);
1029 }
1030}
1031#line 1032 "d2_parser.cc"
1032 break;
1033
1034 case 75: // $@17: %empty
1035#line 318 "d2_parser.yy"
1036 {
1037 ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location));
1038 ctx.enter(ctx.NCR_PROTOCOL);
1039}
1040#line 1041 "d2_parser.cc"
1041 break;
1042
1043 case 76: // ncr_protocol: "ncr-protocol" $@17 ":" ncr_protocol_value
1044#line 321 "d2_parser.yy"
1045 {
1046 ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ());
1047 ctx.leave();
1048}
1049#line 1050 "d2_parser.cc"
1050 break;
1051
1052 case 77: // ncr_protocol_value: "UDP"
1053#line 327 "d2_parser.yy"
1054 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
1055#line 1056 "d2_parser.cc"
1056 break;
1057
1058 case 78: // ncr_protocol_value: "TCP"
1059#line 328 "d2_parser.yy"
1060 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
1061#line 1062 "d2_parser.cc"
1062 break;
1063
1064 case 79: // $@18: %empty
1065#line 331 "d2_parser.yy"
1066 {
1067 ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location));
1068 ctx.enter(ctx.NCR_FORMAT);
1069}
1070#line 1071 "d2_parser.cc"
1071 break;
1072
1073 case 80: // ncr_format: "ncr-format" $@18 ":" "JSON"
1074#line 334 "d2_parser.yy"
1075 {
1076 ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
1077 ctx.stack_.back()->set("ncr-format", json);
1078 ctx.leave();
1079}
1080#line 1081 "d2_parser.cc"
1081 break;
1082
1083 case 81: // $@19: %empty
1084#line 340 "d2_parser.yy"
1085 {
1086 ctx.enter(ctx.NO_KEYWORD);
1087}
1088#line 1089 "d2_parser.cc"
1089 break;
1090
1091 case 82: // user_context: "user-context" $@19 ":" map_value
1092#line 342 "d2_parser.yy"
1093 {
1094 ElementPtr parent = ctx.stack_.back();
1095 ElementPtr user_context = yystack_[0].value.as < ElementPtr > ();
1096 ConstElementPtr old = parent->get("user-context");
1097
1098 // Handle already existing user context
1099 if (old) {
1100 // Check if it was a comment or a duplicate
1101 if ((old->size() != 1) || !old->contains("comment")) {
1102 std::stringstream msg;
1103 msg << "duplicate user-context entries (previous at "
1104 << old->getPosition().str() << ")";
1105 error(yystack_[3].location, msg.str());
1106 }
1107 // Merge the comment
1108 user_context->set("comment", old->get("comment"));
1109 }
1110
1111 // Set the user context
1112 parent->set("user-context", user_context);
1113 ctx.leave();
1114}
1115#line 1116 "d2_parser.cc"
1116 break;
1117
1118 case 83: // $@20: %empty
1119#line 365 "d2_parser.yy"
1120 {
1121 ctx.enter(ctx.NO_KEYWORD);
1122}
1123#line 1124 "d2_parser.cc"
1124 break;
1125
1126 case 84: // comment: "comment" $@20 ":" "constant string"
1127#line 367 "d2_parser.yy"
1128 {
1129 ElementPtr parent = ctx.stack_.back();
1130 ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
1131 ElementPtr comment(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1132 user_context->set("comment", comment);
1133
1134 // Handle already existing user context
1135 ConstElementPtr old = parent->get("user-context");
1136 if (old) {
1137 // Check for duplicate comment
1138 if (old->contains("comment")) {
1139 std::stringstream msg;
1140 msg << "duplicate user-context/comment entries (previous at "
1141 << old->getPosition().str() << ")";
1142 error(yystack_[3].location, msg.str());
1143 }
1144 // Merge the user context in the comment
1145 merge(user_context, old);
1146 }
1147
1148 // Set the user context
1149 parent->set("user-context", user_context);
1150 ctx.leave();
1151}
1152#line 1153 "d2_parser.cc"
1153 break;
1154
1155 case 85: // $@21: %empty
1156#line 392 "d2_parser.yy"
1157 {
1158 ctx.unique("forward-ddns", ctx.loc2pos(yystack_[0].location));
1159 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1160 ctx.stack_.back()->set("forward-ddns", m);
1161 ctx.stack_.push_back(m);
1162 ctx.enter(ctx.FORWARD_DDNS);
1163}
1164#line 1165 "d2_parser.cc"
1165 break;
1166
1167 case 86: // forward_ddns: "forward-ddns" $@21 ":" "{" ddns_mgr_params "}"
1168#line 398 "d2_parser.yy"
1169 {
1170 ctx.stack_.pop_back();
1171 ctx.leave();
1172}
1173#line 1174 "d2_parser.cc"
1174 break;
1175
1176 case 87: // $@22: %empty
1177#line 403 "d2_parser.yy"
1178 {
1179 ctx.unique("reverse-ddns", ctx.loc2pos(yystack_[0].location));
1180 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1181 ctx.stack_.back()->set("reverse-ddns", m);
1182 ctx.stack_.push_back(m);
1183 ctx.enter(ctx.REVERSE_DDNS);
1184}
1185#line 1186 "d2_parser.cc"
1186 break;
1187
1188 case 88: // reverse_ddns: "reverse-ddns" $@22 ":" "{" ddns_mgr_params "}"
1189#line 409 "d2_parser.yy"
1190 {
1191 ctx.stack_.pop_back();
1192 ctx.leave();
1193}
1194#line 1195 "d2_parser.cc"
1195 break;
1196
1197 case 93: // not_empty_ddns_mgr_params: ddns_mgr_params ","
1198#line 420 "d2_parser.yy"
1199 {
1200 ctx.warnAboutExtraCommas(yystack_[0].location);
1201 }
1202#line 1203 "d2_parser.cc"
1203 break;
1204
1205 case 96: // $@23: %empty
1206#line 431 "d2_parser.yy"
1207 {
1208 ctx.unique("ddns-domains", ctx.loc2pos(yystack_[0].location));
1209 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1210 ctx.stack_.back()->set("ddns-domains", l);
1211 ctx.stack_.push_back(l);
1212 ctx.enter(ctx.DDNS_DOMAINS);
1213}
1214#line 1215 "d2_parser.cc"
1215 break;
1216
1217 case 97: // ddns_domains: "ddns-domains" $@23 ":" "[" ddns_domain_list "]"
1218#line 437 "d2_parser.yy"
1219 {
1220 ctx.stack_.pop_back();
1221 ctx.leave();
1222}
1223#line 1224 "d2_parser.cc"
1224 break;
1225
1226 case 98: // $@24: %empty
1227#line 442 "d2_parser.yy"
1228 {
1229 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1230 ctx.stack_.push_back(l);
1231}
1232#line 1233 "d2_parser.cc"
1233 break;
1234
1235 case 99: // sub_ddns_domains: "[" $@24 ddns_domain_list "]"
1236#line 445 "d2_parser.yy"
1237 {
1238 // parsing completed
1239}
1240#line 1241 "d2_parser.cc"
1241 break;
1242
1243 case 104: // not_empty_ddns_domain_list: not_empty_ddns_domain_list ","
1244#line 455 "d2_parser.yy"
1245 {
1246 ctx.warnAboutExtraCommas(yystack_[0].location);
1247 }
1248#line 1249 "d2_parser.cc"
1249 break;
1250
1251 case 105: // $@25: %empty
1252#line 460 "d2_parser.yy"
1253 {
1254 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1255 ctx.stack_.back()->add(m);
1256 ctx.stack_.push_back(m);
1257}
1258#line 1259 "d2_parser.cc"
1259 break;
1260
1261 case 106: // ddns_domain: "{" $@25 ddns_domain_params "}"
1262#line 464 "d2_parser.yy"
1263 {
1264 ctx.stack_.pop_back();
1265}
1266#line 1267 "d2_parser.cc"
1267 break;
1268
1269 case 107: // $@26: %empty
1270#line 468 "d2_parser.yy"
1271 {
1272 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1273 ctx.stack_.push_back(m);
1274}
1275#line 1276 "d2_parser.cc"
1276 break;
1277
1278 case 108: // sub_ddns_domain: "{" $@26 ddns_domain_params "}"
1279#line 471 "d2_parser.yy"
1280 {
1281 // parsing completed
1282}
1283#line 1284 "d2_parser.cc"
1284 break;
1285
1286 case 111: // ddns_domain_params: ddns_domain_params ","
1287#line 477 "d2_parser.yy"
1288 {
1289 ctx.warnAboutExtraCommas(yystack_[0].location);
1290 }
1291#line 1292 "d2_parser.cc"
1292 break;
1293
1294 case 118: // $@27: %empty
1295#line 491 "d2_parser.yy"
1296 {
1297 ctx.unique("name", ctx.loc2pos(yystack_[0].location));
1298 ctx.enter(ctx.NO_KEYWORD);
1299}
1300#line 1301 "d2_parser.cc"
1301 break;
1302
1303 case 119: // ddns_domain_name: "name" $@27 ":" "constant string"
1304#line 494 "d2_parser.yy"
1305 {
1306 if (yystack_[0].value.as < std::string > () == "") {
1307 error(yystack_[1].location, "Ddns domain name cannot be blank");
1308 }
1309 ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1310 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1311 ctx.stack_.back()->set("name", name);
1312 ctx.leave();
1313}
1314#line 1315 "d2_parser.cc"
1315 break;
1316
1317 case 120: // $@28: %empty
1318#line 504 "d2_parser.yy"
1319 {
1320 ctx.unique("key-name", ctx.loc2pos(yystack_[0].location));
1321 ctx.enter(ctx.NO_KEYWORD);
1322}
1323#line 1324 "d2_parser.cc"
1324 break;
1325
1326 case 121: // ddns_key_name: "key-name" $@28 ":" "constant string"
1327#line 507 "d2_parser.yy"
1328 {
1329 ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1330 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1331 ctx.stack_.back()->set("key-name", name);
1332 ctx.leave();
1333}
1334#line 1335 "d2_parser.cc"
1335 break;
1336
1337 case 122: // $@29: %empty
1338#line 517 "d2_parser.yy"
1339 {
1340 ctx.unique("dns-servers", ctx.loc2pos(yystack_[0].location));
1341 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1342 ctx.stack_.back()->set("dns-servers", l);
1343 ctx.stack_.push_back(l);
1344 ctx.enter(ctx.DNS_SERVERS);
1345}
1346#line 1347 "d2_parser.cc"
1347 break;
1348
1349 case 123: // dns_servers: "dns-servers" $@29 ":" "[" dns_server_list "]"
1350#line 523 "d2_parser.yy"
1351 {
1352 ctx.stack_.pop_back();
1353 ctx.leave();
1354}
1355#line 1356 "d2_parser.cc"
1356 break;
1357
1358 case 124: // $@30: %empty
1359#line 528 "d2_parser.yy"
1360 {
1361 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1362 ctx.stack_.push_back(l);
1363}
1364#line 1365 "d2_parser.cc"
1365 break;
1366
1367 case 125: // sub_dns_servers: "[" $@30 dns_server_list "]"
1368#line 531 "d2_parser.yy"
1369 {
1370 // parsing completed
1371}
1372#line 1373 "d2_parser.cc"
1373 break;
1374
1375 case 128: // dns_server_list: dns_server_list ","
1376#line 537 "d2_parser.yy"
1377 {
1378 ctx.warnAboutExtraCommas(yystack_[0].location);
1379 }
1380#line 1381 "d2_parser.cc"
1381 break;
1382
1383 case 129: // $@31: %empty
1384#line 542 "d2_parser.yy"
1385 {
1386 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1387 ctx.stack_.back()->add(m);
1388 ctx.stack_.push_back(m);
1389}
1390#line 1391 "d2_parser.cc"
1391 break;
1392
1393 case 130: // dns_server: "{" $@31 dns_server_params "}"
1394#line 546 "d2_parser.yy"
1395 {
1396 ctx.stack_.pop_back();
1397}
1398#line 1399 "d2_parser.cc"
1399 break;
1400
1401 case 131: // $@32: %empty
1402#line 550 "d2_parser.yy"
1403 {
1404 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1405 ctx.stack_.push_back(m);
1406}
1407#line 1408 "d2_parser.cc"
1408 break;
1409
1410 case 132: // sub_dns_server: "{" $@32 dns_server_params "}"
1411#line 553 "d2_parser.yy"
1412 {
1413 // parsing completed
1414}
1415#line 1416 "d2_parser.cc"
1416 break;
1417
1418 case 135: // dns_server_params: dns_server_params ","
1419#line 559 "d2_parser.yy"
1420 {
1421 ctx.warnAboutExtraCommas(yystack_[0].location);
1422 }
1423#line 1424 "d2_parser.cc"
1424 break;
1425
1426 case 143: // $@33: %empty
1427#line 573 "d2_parser.yy"
1428 {
1429 ctx.unique("hostname", ctx.loc2pos(yystack_[0].location));
1430 ctx.enter(ctx.NO_KEYWORD);
1431}
1432#line 1433 "d2_parser.cc"
1433 break;
1434
1435 case 144: // dns_server_hostname: "hostname" $@33 ":" "constant string"
1436#line 576 "d2_parser.yy"
1437 {
1438 if (yystack_[0].value.as < std::string > () != "") {
1439 error(yystack_[1].location, "hostname is not yet supported");
1440 }
1441 ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1442 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1443 ctx.stack_.back()->set("hostname", name);
1444 ctx.leave();
1445}
1446#line 1447 "d2_parser.cc"
1447 break;
1448
1449 case 145: // $@34: %empty
1450#line 586 "d2_parser.yy"
1451 {
1452 ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location));
1453 ctx.enter(ctx.NO_KEYWORD);
1454}
1455#line 1456 "d2_parser.cc"
1456 break;
1457
1458 case 146: // dns_server_ip_address: "ip-address" $@34 ":" "constant string"
1459#line 589 "d2_parser.yy"
1460 {
1461 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1462 ctx.stack_.back()->set("ip-address", s);
1463 ctx.leave();
1464}
1465#line 1466 "d2_parser.cc"
1466 break;
1467
1468 case 147: // dns_server_port: "port" ":" "integer"
1469#line 595 "d2_parser.yy"
1470 {
1471 ctx.unique("port", ctx.loc2pos(yystack_[2].location));
1472 if (yystack_[0].value.as < int64_t > () <= 0 || yystack_[0].value.as < int64_t > () >= 65536 ) {
1473 error(yystack_[0].location, "port must be greater than zero but less than 65536");
1474 }
1475 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1476 ctx.stack_.back()->set("port", i);
1477}
1478#line 1479 "d2_parser.cc"
1479 break;
1480
1481 case 148: // $@35: %empty
1482#line 610 "d2_parser.yy"
1483 {
1484 ctx.unique("tsig-keys", ctx.loc2pos(yystack_[0].location));
1485 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1486 ctx.stack_.back()->set("tsig-keys", l);
1487 ctx.stack_.push_back(l);
1488 ctx.enter(ctx.TSIG_KEYS);
1489}
1490#line 1491 "d2_parser.cc"
1491 break;
1492
1493 case 149: // tsig_keys: "tsig-keys" $@35 ":" "[" tsig_keys_list "]"
1494#line 616 "d2_parser.yy"
1495 {
1496 ctx.stack_.pop_back();
1497 ctx.leave();
1498}
1499#line 1500 "d2_parser.cc"
1500 break;
1501
1502 case 150: // $@36: %empty
1503#line 621 "d2_parser.yy"
1504 {
1505 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1506 ctx.stack_.push_back(l);
1507}
1508#line 1509 "d2_parser.cc"
1509 break;
1510
1511 case 151: // sub_tsig_keys: "[" $@36 tsig_keys_list "]"
1512#line 624 "d2_parser.yy"
1513 {
1514 // parsing completed
1515}
1516#line 1517 "d2_parser.cc"
1517 break;
1518
1519 case 156: // not_empty_tsig_keys_list: not_empty_tsig_keys_list ","
1520#line 634 "d2_parser.yy"
1521 {
1522 ctx.warnAboutExtraCommas(yystack_[0].location);
1523 }
1524#line 1525 "d2_parser.cc"
1525 break;
1526
1527 case 157: // $@37: %empty
1528#line 639 "d2_parser.yy"
1529 {
1530 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1531 ctx.stack_.back()->add(m);
1532 ctx.stack_.push_back(m);
1533}
1534#line 1535 "d2_parser.cc"
1535 break;
1536
1537 case 158: // tsig_key: "{" $@37 tsig_key_params "}"
1538#line 643 "d2_parser.yy"
1539 {
1540 ctx.stack_.pop_back();
1541}
1542#line 1543 "d2_parser.cc"
1543 break;
1544
1545 case 159: // $@38: %empty
1546#line 647 "d2_parser.yy"
1547 {
1548 // Parse tsig key list entry map
1549 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1550 ctx.stack_.push_back(m);
1551}
1552#line 1553 "d2_parser.cc"
1553 break;
1554
1555 case 160: // sub_tsig_key: "{" $@38 tsig_key_params "}"
1556#line 651 "d2_parser.yy"
1557 {
1558 // parsing completed
1559}
1560#line 1561 "d2_parser.cc"
1561 break;
1562
1563 case 163: // tsig_key_params: tsig_key_params ","
1564#line 658 "d2_parser.yy"
1565 {
1566 ctx.warnAboutExtraCommas(yystack_[0].location);
1567 }
1568#line 1569 "d2_parser.cc"
1569 break;
1570
1571 case 171: // $@39: %empty
1572#line 672 "d2_parser.yy"
1573 {
1574 ctx.unique("name", ctx.loc2pos(yystack_[0].location));
1575 ctx.enter(ctx.NO_KEYWORD);
1576}
1577#line 1578 "d2_parser.cc"
1578 break;
1579
1580 case 172: // tsig_key_name: "name" $@39 ":" "constant string"
1581#line 675 "d2_parser.yy"
1582 {
1583 if (yystack_[0].value.as < std::string > () == "") {
1584 error(yystack_[1].location, "TSIG key name cannot be blank");
1585 }
1586 ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1587 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1588 ctx.stack_.back()->set("name", name);
1589 ctx.leave();
1590}
1591#line 1592 "d2_parser.cc"
1592 break;
1593
1594 case 173: // $@40: %empty
1595#line 685 "d2_parser.yy"
1596 {
1597 ctx.unique("algorithm", ctx.loc2pos(yystack_[0].location));
1598 ctx.enter(ctx.NO_KEYWORD);
1599}
1600#line 1601 "d2_parser.cc"
1601 break;
1602
1603 case 174: // tsig_key_algorithm: "algorithm" $@40 ":" "constant string"
1604#line 688 "d2_parser.yy"
1605 {
1606 if (yystack_[0].value.as < std::string > () == "") {
1607 error(yystack_[1].location, "TSIG key algorithm cannot be blank");
1608 }
1609 ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1610 ctx.stack_.back()->set("algorithm", elem);
1611 ctx.leave();
1612}
1613#line 1614 "d2_parser.cc"
1614 break;
1615
1616 case 175: // tsig_key_digest_bits: "digest-bits" ":" "integer"
1617#line 697 "d2_parser.yy"
1618 {
1619 ctx.unique("digest-bits", ctx.loc2pos(yystack_[2].location));
1620 if (yystack_[0].value.as < int64_t > () < 0 || (yystack_[0].value.as < int64_t > () > 0 && (yystack_[0].value.as < int64_t > () % 8 != 0))) {
1621 error(yystack_[0].location, "TSIG key digest-bits must either be zero or a positive, multiple of eight");
1622 }
1623 ElementPtr elem(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1624 ctx.stack_.back()->set("digest-bits", elem);
1625}
1626#line 1627 "d2_parser.cc"
1627 break;
1628
1629 case 176: // $@41: %empty
1630#line 706 "d2_parser.yy"
1631 {
1632 ctx.unique("secret", ctx.loc2pos(yystack_[0].location));
1633 ctx.enter(ctx.NO_KEYWORD);
1634}
1635#line 1636 "d2_parser.cc"
1636 break;
1637
1638 case 177: // tsig_key_secret: "secret" $@41 ":" "constant string"
1639#line 709 "d2_parser.yy"
1640 {
1641 if (yystack_[0].value.as < std::string > () == "") {
1642 error(yystack_[1].location, "TSIG key secret cannot be blank");
1643 }
1644 ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1645 ctx.stack_.back()->set("secret", elem);
1646 ctx.leave();
1647}
1648#line 1649 "d2_parser.cc"
1649 break;
1650
1651 case 178: // $@42: %empty
1652#line 723 "d2_parser.yy"
1653 {
1654 ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location));
1655 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1656 ctx.stack_.back()->set("control-socket", m);
1657 ctx.stack_.push_back(m);
1658 ctx.enter(ctx.CONTROL_SOCKET);
1659}
1660#line 1661 "d2_parser.cc"
1661 break;
1662
1663 case 179: // control_socket: "control-socket" $@42 ":" "{" control_socket_params "}"
1664#line 729 "d2_parser.yy"
1665 {
1666 ctx.stack_.pop_back();
1667 ctx.leave();
1668}
1669#line 1670 "d2_parser.cc"
1670 break;
1671
1672 case 182: // control_socket_params: control_socket_params ","
1673#line 736 "d2_parser.yy"
1674 {
1675 ctx.warnAboutExtraCommas(yystack_[0].location);
1676 }
1677#line 1678 "d2_parser.cc"
1678 break;
1679
1680 case 188: // $@43: %empty
1681#line 748 "d2_parser.yy"
1682 {
1683 ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location));
1684 ctx.enter(ctx.NO_KEYWORD);
1685}
1686#line 1687 "d2_parser.cc"
1687 break;
1688
1689 case 189: // control_socket_type: "socket-type" $@43 ":" "constant string"
1690#line 751 "d2_parser.yy"
1691 {
1692 ElementPtr stype(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1693 ctx.stack_.back()->set("socket-type", stype);
1694 ctx.leave();
1695}
1696#line 1697 "d2_parser.cc"
1697 break;
1698
1699 case 190: // $@44: %empty
1700#line 757 "d2_parser.yy"
1701 {
1702 ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location));
1703 ctx.enter(ctx.NO_KEYWORD);
1704}
1705#line 1706 "d2_parser.cc"
1706 break;
1707
1708 case 191: // control_socket_name: "socket-name" $@44 ":" "constant string"
1709#line 760 "d2_parser.yy"
1710 {
1711 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1712 ctx.stack_.back()->set("socket-name", name);
1713 ctx.leave();
1714}
1715#line 1716 "d2_parser.cc"
1716 break;
1717
1718 case 192: // $@45: %empty
1719#line 768 "d2_parser.yy"
1720 {
1721 ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location));
1722 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1723 ctx.stack_.back()->set("hooks-libraries", l);
1724 ctx.stack_.push_back(l);
1725 ctx.enter(ctx.HOOKS_LIBRARIES);
1726}
1727#line 1728 "d2_parser.cc"
1728 break;
1729
1730 case 193: // hooks_libraries: "hooks-libraries" $@45 ":" "[" hooks_libraries_list "]"
1731#line 774 "d2_parser.yy"
1732 {
1733 ctx.stack_.pop_back();
1734 ctx.leave();
1735}
1736#line 1737 "d2_parser.cc"
1737 break;
1738
1739 case 198: // not_empty_hooks_libraries_list: not_empty_hooks_libraries_list ","
1740#line 785 "d2_parser.yy"
1741 {
1742 ctx.warnAboutExtraCommas(yystack_[0].location);
1743 }
1744#line 1745 "d2_parser.cc"
1745 break;
1746
1747 case 199: // $@46: %empty
1748#line 790 "d2_parser.yy"
1749 {
1750 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1751 ctx.stack_.back()->add(m);
1752 ctx.stack_.push_back(m);
1753}
1754#line 1755 "d2_parser.cc"
1755 break;
1756
1757 case 200: // hooks_library: "{" $@46 hooks_params "}"
1758#line 794 "d2_parser.yy"
1759 {
1760 // The library hooks parameter is required
1761 ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
1762 ctx.stack_.pop_back();
1763}
1764#line 1765 "d2_parser.cc"
1765 break;
1766
1767 case 201: // $@47: %empty
1768#line 800 "d2_parser.yy"
1769 {
1770 // Parse the hooks-libraries list entry map
1771 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1772 ctx.stack_.push_back(m);
1773}
1774#line 1775 "d2_parser.cc"
1775 break;
1776
1777 case 202: // sub_hooks_library: "{" $@47 hooks_params "}"
1778#line 804 "d2_parser.yy"
1779 {
1780 // The library hooks parameter is required
1781 ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
1782 // parsing completed
1783}
1784#line 1785 "d2_parser.cc"
1785 break;
1786
1787 case 205: // hooks_params: hooks_params ","
1788#line 812 "d2_parser.yy"
1789 {
1790 ctx.warnAboutExtraCommas(yystack_[0].location);
1791 }
1792#line 1793 "d2_parser.cc"
1793 break;
1794
1795 case 209: // $@48: %empty
1796#line 822 "d2_parser.yy"
1797 {
1798 ctx.unique("library", ctx.loc2pos(yystack_[0].location));
1799 ctx.enter(ctx.NO_KEYWORD);
1800}
1801#line 1802 "d2_parser.cc"
1802 break;
1803
1804 case 210: // library: "library" $@48 ":" "constant string"
1805#line 825 "d2_parser.yy"
1806 {
1807 ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1808 ctx.stack_.back()->set("library", lib);
1809 ctx.leave();
1810}
1811#line 1812 "d2_parser.cc"
1812 break;
1813
1814 case 211: // $@49: %empty
1815#line 831 "d2_parser.yy"
1816 {
1817 ctx.unique("parameters", ctx.loc2pos(yystack_[0].location));
1818 ctx.enter(ctx.NO_KEYWORD);
1819}
1820#line 1821 "d2_parser.cc"
1821 break;
1822
1823 case 212: // parameters: "parameters" $@49 ":" map_value
1824#line 834 "d2_parser.yy"
1825 {
1826 ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ());
1827 ctx.leave();
1828}
1829#line 1830 "d2_parser.cc"
1830 break;
1831
1832 case 213: // $@50: %empty
1833#line 841 "d2_parser.yy"
1834 {
1835 ctx.unique("loggers", ctx.loc2pos(yystack_[0].location));
1836 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1837 ctx.stack_.back()->set("loggers", l);
1838 ctx.stack_.push_back(l);
1839 ctx.enter(ctx.LOGGERS);
1840}
1841#line 1842 "d2_parser.cc"
1842 break;
1843
1844 case 214: // loggers: "loggers" $@50 ":" "[" loggers_entries "]"
1845#line 847 "d2_parser.yy"
1846 {
1847 ctx.stack_.pop_back();
1848 ctx.leave();
1849}
1850#line 1851 "d2_parser.cc"
1851 break;
1852
1853 case 217: // loggers_entries: loggers_entries ","
1854#line 856 "d2_parser.yy"
1855 {
1856 ctx.warnAboutExtraCommas(yystack_[0].location);
1857 }
1858#line 1859 "d2_parser.cc"
1859 break;
1860
1861 case 218: // $@51: %empty
1862#line 862 "d2_parser.yy"
1863 {
1864 ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
1865 ctx.stack_.back()->add(l);
1866 ctx.stack_.push_back(l);
1867}
1868#line 1869 "d2_parser.cc"
1869 break;
1870
1871 case 219: // logger_entry: "{" $@51 logger_params "}"
1872#line 866 "d2_parser.yy"
1873 {
1874 ctx.stack_.pop_back();
1875}
1876#line 1877 "d2_parser.cc"
1877 break;
1878
1879 case 222: // logger_params: logger_params ","
1880#line 872 "d2_parser.yy"
1881 {
1882 ctx.warnAboutExtraCommas(yystack_[0].location);
1883 }
1884#line 1885 "d2_parser.cc"
1885 break;
1886
1887 case 230: // $@52: %empty
1888#line 886 "d2_parser.yy"
1889 {
1890 ctx.unique("name", ctx.loc2pos(yystack_[0].location));
1891 ctx.enter(ctx.NO_KEYWORD);
1892}
1893#line 1894 "d2_parser.cc"
1894 break;
1895
1896 case 231: // name: "name" $@52 ":" "constant string"
1897#line 889 "d2_parser.yy"
1898 {
1899 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1900 ctx.stack_.back()->set("name", name);
1901 ctx.leave();
1902}
1903#line 1904 "d2_parser.cc"
1904 break;
1905
1906 case 232: // debuglevel: "debuglevel" ":" "integer"
1907#line 895 "d2_parser.yy"
1908 {
1909 ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location));
1910 ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1911 ctx.stack_.back()->set("debuglevel", dl);
1912}
1913#line 1914 "d2_parser.cc"
1914 break;
1915
1916 case 233: // $@53: %empty
1917#line 901 "d2_parser.yy"
1918 {
1919 ctx.unique("severity", ctx.loc2pos(yystack_[0].location));
1920 ctx.enter(ctx.NO_KEYWORD);
1921}
1922#line 1923 "d2_parser.cc"
1923 break;
1924
1925 case 234: // severity: "severity" $@53 ":" "constant string"
1926#line 904 "d2_parser.yy"
1927 {
1928 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1929 ctx.stack_.back()->set("severity", sev);
1930 ctx.leave();
1931}
1932#line 1933 "d2_parser.cc"
1933 break;
1934
1935 case 235: // $@54: %empty
1936#line 910 "d2_parser.yy"
1937 {
1938 ctx.unique("output_options", ctx.loc2pos(yystack_[0].location));
1939 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1940 ctx.stack_.back()->set("output_options", l);
1941 ctx.stack_.push_back(l);
1942 ctx.enter(ctx.OUTPUT_OPTIONS);
1943}
1944#line 1945 "d2_parser.cc"
1945 break;
1946
1947 case 236: // output_options_list: "output_options" $@54 ":" "[" output_options_list_content "]"
1948#line 916 "d2_parser.yy"
1949 {
1950 ctx.stack_.pop_back();
1951 ctx.leave();
1952}
1953#line 1954 "d2_parser.cc"
1954 break;
1955
1956 case 239: // output_options_list_content: output_options_list_content ","
1957#line 923 "d2_parser.yy"
1958 {
1959 ctx.warnAboutExtraCommas(yystack_[0].location);
1960 }
1961#line 1962 "d2_parser.cc"
1962 break;
1963
1964 case 240: // $@55: %empty
1965#line 928 "d2_parser.yy"
1966 {
1967 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1968 ctx.stack_.back()->add(m);
1969 ctx.stack_.push_back(m);
1970}
1971#line 1972 "d2_parser.cc"
1972 break;
1973
1974 case 241: // output_entry: "{" $@55 output_params_list "}"
1975#line 932 "d2_parser.yy"
1976 {
1977 ctx.stack_.pop_back();
1978}
1979#line 1980 "d2_parser.cc"
1980 break;
1981
1982 case 244: // output_params_list: output_params_list ","
1983#line 938 "d2_parser.yy"
1984 {
1985 ctx.warnAboutExtraCommas(yystack_[0].location);
1986 }
1987#line 1988 "d2_parser.cc"
1988 break;
1989
1990 case 250: // $@56: %empty
1991#line 950 "d2_parser.yy"
1992 {
1993 ctx.unique("output", ctx.loc2pos(yystack_[0].location));
1994 ctx.enter(ctx.NO_KEYWORD);
1995}
1996#line 1997 "d2_parser.cc"
1997 break;
1998
1999 case 251: // output: "output" $@56 ":" "constant string"
2000#line 953 "d2_parser.yy"
2001 {
2002 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2003 ctx.stack_.back()->set("output", sev);
2004 ctx.leave();
2005}
2006#line 2007 "d2_parser.cc"
2007 break;
2008
2009 case 252: // flush: "flush" ":" "boolean"
2010#line 959 "d2_parser.yy"
2011 {
2012 ctx.unique("flush", ctx.loc2pos(yystack_[2].location));
2013 ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2014 ctx.stack_.back()->set("flush", flush);
2015}
2016#line 2017 "d2_parser.cc"
2017 break;
2018
2019 case 253: // maxsize: "maxsize" ":" "integer"
2020#line 965 "d2_parser.yy"
2021 {
2022 ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location));
2023 ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2024 ctx.stack_.back()->set("maxsize", maxsize);
2025}
2026#line 2027 "d2_parser.cc"
2027 break;
2028
2029 case 254: // maxver: "maxver" ":" "integer"
2030#line 971 "d2_parser.yy"
2031 {
2032 ctx.unique("maxver", ctx.loc2pos(yystack_[2].location));
2033 ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2034 ctx.stack_.back()->set("maxver", maxver);
2035}
2036#line 2037 "d2_parser.cc"
2037 break;
2038
2039 case 255: // $@57: %empty
2040#line 977 "d2_parser.yy"
2041 {
2042 ctx.unique("pattern", ctx.loc2pos(yystack_[0].location));
2043 ctx.enter(ctx.NO_KEYWORD);
2044}
2045#line 2046 "d2_parser.cc"
2046 break;
2047
2048 case 256: // pattern: "pattern" $@57 ":" "constant string"
2049#line 980 "d2_parser.yy"
2050 {
2051 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2052 ctx.stack_.back()->set("pattern", sev);
2053 ctx.leave();
2054}
2055#line 2056 "d2_parser.cc"
2056 break;
2057
2058
2059#line 2060 "d2_parser.cc"
2060
2061 default:
2062 break;
2063 }
2064 }
2065#if YY_EXCEPTIONS
2066 catch (const syntax_error& yyexc)
2067 {
2068 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
2069 error (yyexc);
2070 YYERROR;
2071 }
2072#endif // YY_EXCEPTIONS
2073 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
2074 yypop_ (yylen);
2075 yylen = 0;
2076
2077 // Shift the result of the reduction.
2078 yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
2079 }
2080 goto yynewstate;
2081
2082
2083 /*--------------------------------------.
2084 | yyerrlab -- here on detecting error. |
2085 `--------------------------------------*/
2086 yyerrlab:
2087 // If not already recovering from an error, report this error.
2088 if (!yyerrstatus_)
2089 {
2090 ++yynerrs_;
2091 context yyctx (*this, yyla);
2092 std::string msg = yysyntax_error_ (yyctx);
2093 error (yyla.location, YY_MOVE (msg));
2094 }
2095
2096
2097 yyerror_range[1].location = yyla.location;
2098 if (yyerrstatus_ == 3)
2099 {
2100 /* If just tried and failed to reuse lookahead token after an
2101 error, discard it. */
2102
2103 // Return failure if at end of input.
2104 if (yyla.kind () == symbol_kind::S_YYEOF)
2105 YYABORT;
2106 else if (!yyla.empty ())
2107 {
2108 yy_destroy_ ("Error: discarding", yyla);
2109 yyla.clear ();
2110 }
2111 }
2112
2113 // Else will try to reuse lookahead token after shifting the error token.
2114 goto yyerrlab1;
2115
2116
2117 /*---------------------------------------------------.
2118 | yyerrorlab -- error raised explicitly by YYERROR. |
2119 `---------------------------------------------------*/
2120 yyerrorlab:
2121 /* Pacify compilers when the user code never invokes YYERROR and
2122 the label yyerrorlab therefore never appears in user code. */
2123 if (false)
2124 YYERROR;
2125
2126 /* Do not reclaim the symbols of the rule whose action triggered
2127 this YYERROR. */
2128 yypop_ (yylen);
2129 yylen = 0;
2130 YY_STACK_PRINT ();
2131 goto yyerrlab1;
2132
2133
2134 /*-------------------------------------------------------------.
2135 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2136 `-------------------------------------------------------------*/
2137 yyerrlab1:
2138 yyerrstatus_ = 3; // Each real token shifted decrements this.
2139 // Pop stack until we find a state that shifts the error token.
2140 for (;;)
2141 {
2142 yyn = yypact_[+yystack_[0].state];
2143 if (!yy_pact_value_is_default_ (yyn))
2144 {
2146 if (0 <= yyn && yyn <= yylast_
2147 && yycheck_[yyn] == symbol_kind::S_YYerror)
2148 {
2149 yyn = yytable_[yyn];
2150 if (0 < yyn)
2151 break;
2152 }
2153 }
2154
2155 // Pop the current state because it cannot handle the error token.
2156 if (yystack_.size () == 1)
2157 YYABORT;
2158
2159 yyerror_range[1].location = yystack_[0].location;
2160 yy_destroy_ ("Error: popping", yystack_[0]);
2161 yypop_ ();
2162 YY_STACK_PRINT ();
2163 }
2164 {
2165 stack_symbol_type error_token;
2166
2167 yyerror_range[2].location = yyla.location;
2168 YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
2169
2170 // Shift the error token.
2171 error_token.state = state_type (yyn);
2172 yypush_ ("Shifting", YY_MOVE (error_token));
2173 }
2174 goto yynewstate;
2175
2176
2177 /*-------------------------------------.
2178 | yyacceptlab -- YYACCEPT comes here. |
2179 `-------------------------------------*/
2180 yyacceptlab:
2181 yyresult = 0;
2182 goto yyreturn;
2183
2184
2185 /*-----------------------------------.
2186 | yyabortlab -- YYABORT comes here. |
2187 `-----------------------------------*/
2188 yyabortlab:
2189 yyresult = 1;
2190 goto yyreturn;
2191
2192
2193 /*-----------------------------------------------------.
2194 | yyreturn -- parsing is finished, return the result. |
2195 `-----------------------------------------------------*/
2196 yyreturn:
2197 if (!yyla.empty ())
2198 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
2199
2200 /* Do not reclaim the symbols of the rule whose action triggered
2201 this YYABORT or YYACCEPT. */
2202 yypop_ (yylen);
2203 YY_STACK_PRINT ();
2204 while (1 < yystack_.size ())
2205 {
2206 yy_destroy_ ("Cleanup: popping", yystack_[0]);
2207 yypop_ ();
2208 }
2209
2210 return yyresult;
2211 }
2212#if YY_EXCEPTIONS
2213 catch (...)
2214 {
2215 YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
2216 // Do not try to display the values of the reclaimed symbols,
2217 // as their printers might throw an exception.
2218 if (!yyla.empty ())
2219 yy_destroy_ (YY_NULLPTR, yyla);
2220
2221 while (1 < yystack_.size ())
2222 {
2223 yy_destroy_ (YY_NULLPTR, yystack_[0]);
2224 yypop_ ();
2225 }
2226 throw;
2227 }
2228#endif // YY_EXCEPTIONS
2229 }
2230
2231 void
2233 {
2234 error (yyexc.location, yyexc.what ());
2235 }
2236
2237 /* Return YYSTR after stripping away unnecessary quotes and
2238 backslashes, so that it's suitable for yyerror. The heuristic is
2239 that double-quoting is unnecessary unless the string contains an
2240 apostrophe, a comma, or backslash (other than backslash-backslash).
2241 YYSTR is taken from yytname. */
2242 std::string
2243 D2Parser::yytnamerr_ (const char *yystr)
2244 {
2245 if (*yystr == '"')
2246 {
2247 std::string yyr;
2248 char const *yyp = yystr;
2249
2250 for (;;)
2251 switch (*++yyp)
2252 {
2253 case '\'':
2254 case ',':
2255 goto do_not_strip_quotes;
2256
2257 case '\\':
2258 if (*++yyp != '\\')
2259 goto do_not_strip_quotes;
2260 else
2261 goto append;
2262
2263 append:
2264 default:
2265 yyr += *yyp;
2266 break;
2267
2268 case '"':
2269 return yyr;
2270 }
2271 do_not_strip_quotes: ;
2272 }
2273
2274 return yystr;
2275 }
2276
2277 std::string
2279 {
2280 return yytnamerr_ (yytname_[yysymbol]);
2281 }
2282
2283
2284
2285 // D2Parser::context.
2286 D2Parser::context::context (const D2Parser& yyparser, const symbol_type& yyla)
2287 : yyparser_ (yyparser)
2288 , yyla_ (yyla)
2289 {}
2290
2291 int
2293 {
2294 // Actual number of expected tokens
2295 int yycount = 0;
2296
2297 const int yyn = yypact_[+yyparser_.yystack_[0].state];
2298 if (!yy_pact_value_is_default_ (yyn))
2299 {
2300 /* Start YYX at -YYN if negative to avoid negative indexes in
2301 YYCHECK. In other words, skip the first -YYN actions for
2302 this state because they are default actions. */
2303 const int yyxbegin = yyn < 0 ? -yyn : 0;
2304 // Stay within bounds of both yycheck and yytname.
2305 const int yychecklim = yylast_ - yyn + 1;
2306 const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2307 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
2308 if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror
2309 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
2310 {
2311 if (!yyarg)
2312 ++yycount;
2313 else if (yycount == yyargn)
2314 return 0;
2315 else
2316 yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx);
2317 }
2318 }
2319
2320 if (yyarg && yycount == 0 && 0 < yyargn)
2321 yyarg[0] = symbol_kind::S_YYEMPTY;
2322 return yycount;
2323 }
2324
2325
2326
2327
2328
2329
2330 int
2331 D2Parser::yy_syntax_error_arguments_ (const context& yyctx,
2332 symbol_kind_type yyarg[], int yyargn) const
2333 {
2334 /* There are many possibilities here to consider:
2335 - If this state is a consistent state with a default action, then
2336 the only way this function was invoked is if the default action
2337 is an error action. In that case, don't check for expected
2338 tokens because there are none.
2339 - The only way there can be no lookahead present (in yyla) is
2340 if this state is a consistent state with a default action.
2341 Thus, detecting the absence of a lookahead is sufficient to
2342 determine that there is no unexpected or expected token to
2343 report. In that case, just report a simple "syntax error".
2344 - Don't assume there isn't a lookahead just because this state is
2345 a consistent state with a default action. There might have
2346 been a previous inconsistent state, consistent state with a
2347 non-default action, or user semantic action that manipulated
2348 yyla. (However, yyla is currently not documented for users.)
2349 - Of course, the expected token list depends on states to have
2350 correct lookahead information, and it depends on the parser not
2351 to perform extra reductions after fetching a lookahead from the
2352 scanner and before detecting a syntax error. Thus, state merging
2353 (from LALR or IELR) and default reductions corrupt the expected
2354 token list. However, the list is correct for canonical LR with
2355 one exception: it will still contain any token that will not be
2356 accepted due to an error action in a later state.
2357 */
2358
2359 if (!yyctx.lookahead ().empty ())
2360 {
2361 if (yyarg)
2362 yyarg[0] = yyctx.token ();
2363 int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1);
2364 return yyn + 1;
2365 }
2366 return 0;
2367 }
2368
2369 // Generate an error message.
2370 std::string
2371 D2Parser::yysyntax_error_ (const context& yyctx) const
2372 {
2373 // Its maximum.
2374 enum { YYARGS_MAX = 5 };
2375 // Arguments of yyformat.
2376 symbol_kind_type yyarg[YYARGS_MAX];
2377 int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX);
2378
2379 char const* yyformat = YY_NULLPTR;
2380 switch (yycount)
2381 {
2382#define YYCASE_(N, S) \
2383 case N: \
2384 yyformat = S; \
2385 break
2386 default: // Avoid compiler warnings.
2387 YYCASE_ (0, YY_("syntax error"));
2388 YYCASE_ (1, YY_("syntax error, unexpected %s"));
2389 YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
2390 YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2391 YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2392 YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2393#undef YYCASE_
2394 }
2395
2396 std::string yyres;
2397 // Argument number.
2398 std::ptrdiff_t yyi = 0;
2399 for (char const* yyp = yyformat; *yyp; ++yyp)
2400 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
2401 {
2402 yyres += symbol_name (yyarg[yyi++]);
2403 ++yyp;
2404 }
2405 else
2406 yyres += *yyp;
2407 return yyres;
2408 }
2409
2410
2411 const short D2Parser::yypact_ninf_ = -212;
2412
2413 const signed char D2Parser::yytable_ninf_ = -1;
2414
2415 const short
2416 D2Parser::yypact_[] =
2417 {
2418 49, -212, -212, -212, -212, -212, -212, -212, -212, -212,
2419 -212, 10, 8, 24, 30, 42, 48, 64, 128, 74,
2420 136, 127, -212, -212, -212, -212, -212, -212, -212, -212,
2421 -212, -212, -212, -212, -212, -212, -212, -212, -212, -212,
2422 -212, -212, -212, -212, -212, -212, -212, -212, -212, -212,
2423 -212, -212, 8, -22, 33, 7, 31, 146, 38, 156,
2424 28, 160, 37, -212, 137, 163, 166, 164, 168, -212,
2425 22, -212, -212, 169, 170, -212, -212, -212, -212, -212,
2426 -212, -212, -212, -212, -212, 171, -212, 76, -212, -212,
2427 -212, -212, -212, -212, -212, -212, -212, -212, -212, -212,
2428 -212, -212, -212, 172, -212, -212, -212, -212, -212, 79,
2429 -212, -212, -212, -212, -212, -212, 173, 174, -212, -212,
2430 -212, -212, -212, -212, -212, 103, -212, -212, -212, -212,
2431 -212, 175, 177, -212, -212, 178, -212, -212, -212, -212,
2432 -212, 104, -212, -212, -212, -212, -212, 77, -212, -212,
2433 -212, -212, 105, -212, -212, -212, -212, 8, 8, -212,
2434 121, 179, -212, -212, 180, 130, 131, 181, 182, 183,
2435 186, 187, 188, 189, 190, 191, 192, -212, 7, -212,
2436 193, 140, 195, 196, 31, -212, 31, -212, 146, 197,
2437 198, 201, 38, -212, 38, -212, 156, 205, 154, 206,
2438 28, -212, 28, 160, -212, 207, 209, -13, -212, -212,
2439 -212, 210, 208, 162, -212, -212, 153, 199, 213, 165,
2440 214, 216, 211, 217, 220, 221, -212, 176, -212, 184,
2441 185, -212, 106, -212, 203, 222, 204, -212, 107, -212,
2442 215, -212, 218, -212, 115, -212, 219, 213, -212, 8,
2443 7, -212, -212, -212, -212, -212, -212, -212, -212, -15,
2444 -15, 146, 13, 223, 224, -212, -212, -212, -212, -212,
2445 160, -212, -212, -212, -212, -212, -212, -212, -212, 116,
2446 -212, -212, 117, -212, -212, -212, 118, 226, -212, -212,
2447 -212, -212, -212, 119, -212, -212, -212, -212, 228, 225,
2448 -212, -212, 129, -212, 158, -212, 231, -15, -212, -212,
2449 -212, 232, 233, 13, -212, 37, -212, 223, 36, 224,
2450 -212, -212, 234, -212, 227, 229, -212, 149, -212, -212,
2451 -212, 236, -212, -212, -212, -212, 151, -212, -212, -212,
2452 -212, -212, -212, 156, -212, -212, -212, 239, 240, 194,
2453 241, 36, -212, 242, 230, 244, -212, 235, -212, -212,
2454 -212, 243, -212, -212, 159, -212, 46, 243, -212, -212,
2455 249, 250, 251, -212, 152, -212, -212, -212, -212, -212,
2456 -212, -212, 252, 237, 212, 245, 260, 46, -212, 247,
2457 -212, -212, -212, 248, -212, -212, -212
2458 };
2459
2460 const short
2461 D2Parser::yydefact_[] =
2462 {
2463 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
2464 20, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2465 0, 0, 1, 38, 30, 26, 25, 22, 23, 24,
2466 29, 3, 27, 28, 46, 5, 52, 7, 159, 9,
2467 150, 11, 107, 13, 98, 15, 131, 17, 124, 19,
2468 201, 21, 40, 33, 0, 0, 0, 152, 0, 100,
2469 0, 0, 0, 42, 0, 41, 0, 0, 34, 48,
2470 0, 50, 71, 0, 0, 75, 79, 81, 83, 85,
2471 87, 148, 178, 192, 213, 0, 70, 0, 54, 57,
2472 58, 59, 60, 61, 68, 69, 62, 63, 64, 65,
2473 66, 67, 173, 0, 176, 171, 170, 168, 169, 0,
2474 161, 164, 165, 166, 167, 157, 0, 153, 154, 120,
2475 122, 118, 117, 115, 116, 0, 109, 112, 113, 114,
2476 105, 0, 101, 102, 145, 0, 143, 142, 140, 141,
2477 139, 0, 133, 136, 137, 138, 129, 0, 126, 209,
2478 211, 206, 0, 203, 207, 208, 39, 44, 0, 31,
2479 37, 0, 51, 47, 0, 0, 0, 0, 0, 0,
2480 0, 0, 0, 0, 0, 0, 0, 45, 56, 53,
2481 0, 0, 0, 0, 163, 160, 0, 151, 156, 0,
2482 0, 0, 111, 108, 0, 99, 104, 0, 0, 0,
2483 135, 132, 0, 128, 125, 0, 0, 205, 202, 43,
2484 35, 0, 0, 0, 73, 74, 0, 0, 0, 0,
2485 0, 0, 0, 0, 0, 0, 55, 0, 175, 0,
2486 0, 162, 0, 155, 0, 0, 0, 110, 0, 103,
2487 0, 147, 0, 134, 0, 127, 0, 0, 204, 0,
2488 0, 72, 77, 78, 76, 80, 32, 82, 84, 89,
2489 89, 152, 0, 194, 0, 174, 177, 172, 158, 121,
2490 0, 119, 106, 146, 144, 130, 210, 212, 36, 0,
2491 96, 95, 0, 90, 91, 94, 0, 0, 188, 190,
2492 187, 185, 186, 0, 180, 183, 184, 199, 0, 195,
2493 196, 218, 0, 215, 0, 49, 0, 93, 86, 88,
2494 149, 0, 0, 182, 179, 0, 193, 198, 0, 217,
2495 214, 123, 0, 92, 0, 0, 181, 0, 197, 230,
2496 235, 0, 233, 229, 227, 228, 0, 220, 223, 225,
2497 226, 224, 216, 100, 189, 191, 200, 0, 0, 0,
2498 0, 222, 219, 0, 0, 0, 232, 0, 221, 97,
2499 231, 0, 234, 240, 0, 237, 0, 239, 236, 250,
2500 0, 0, 0, 255, 0, 242, 245, 246, 247, 248,
2501 249, 238, 0, 0, 0, 0, 0, 244, 241, 0,
2502 252, 253, 254, 0, 243, 251, 256
2503 };
2504
2505 const short
2506 D2Parser::yypgoto_[] =
2507 {
2508 -212, -212, -212, -212, -212, -212, -212, -212, -212, -212,
2509 -212, -212, -41, -212, -211, -212, -18, -212, -212, -212,
2510 -212, -212, -212, -56, -212, -212, -212, -212, -212, -212,
2511 -212, -12, 68, -212, -212, -212, -212, -212, -212, -212,
2512 -212, -212, -55, -212, -44, -212, -212, -212, -212, -212,
2513 5, -212, -60, -212, -212, -212, -212, -77, -212, 71,
2514 -212, -212, -212, 83, 81, -212, -212, -51, -212, -212,
2515 -212, -212, -212, -2, 75, -212, -212, -212, 69, 80,
2516 -212, -212, -212, -212, -212, -212, -212, -212, -212, 18,
2517 -212, 93, -212, -212, -212, 96, 99, -212, -212, -212,
2518 -212, -212, -212, -212, -212, -212, -212, -28, -212, -212,
2519 -212, -212, -212, -212, -212, -212, -29, -212, -212, -212,
2520 -26, 84, -212, -212, -212, -212, -212, -212, -212, -25,
2521 -212, -212, -61, -212, -212, -212, -212, -212, -212, -212,
2522 -212, -74, -212, -212, -89, -212, -212, -212, -212, -212,
2523 -212, -212
2524 };
2525
2526 const short
2527 D2Parser::yydefgoto_[] =
2528 {
2529 0, 11, 12, 13, 14, 15, 16, 17, 18, 19,
2530 20, 21, 30, 31, 32, 53, 257, 67, 68, 33,
2531 52, 64, 65, 86, 35, 54, 70, 161, 71, 37,
2532 55, 87, 88, 89, 164, 90, 91, 92, 167, 254,
2533 93, 168, 94, 169, 95, 170, 96, 171, 97, 172,
2534 282, 283, 284, 285, 306, 45, 59, 131, 132, 133,
2535 194, 43, 58, 125, 126, 127, 191, 128, 189, 129,
2536 190, 49, 61, 147, 148, 202, 47, 60, 141, 142,
2537 143, 199, 144, 197, 145, 98, 173, 41, 57, 116,
2538 117, 118, 186, 39, 56, 109, 110, 111, 183, 112,
2539 180, 113, 114, 182, 99, 174, 293, 294, 295, 311,
2540 296, 312, 100, 175, 298, 299, 300, 315, 51, 62,
2541 152, 153, 154, 205, 155, 206, 101, 176, 302, 303,
2542 318, 336, 337, 338, 347, 339, 340, 350, 341, 348,
2543 364, 365, 366, 374, 375, 376, 382, 377, 378, 379,
2544 380, 386
2545 };
2546
2547 const short
2548 D2Parser::yytable_[] =
2549 {
2550 106, 107, 122, 123, 137, 138, 151, 256, 280, 140,
2551 22, 63, 108, 23, 124, 24, 139, 25, 72, 73,
2552 74, 75, 149, 150, 76, 162, 77, 78, 79, 80,
2553 163, 34, 77, 78, 81, 66, 256, 36, 82, 134,
2554 135, 83, 85, 69, 84, 288, 289, 77, 78, 38,
2555 77, 78, 119, 40, 136, 77, 78, 77, 78, 102,
2556 103, 104, 119, 120, 85, 26, 27, 28, 29, 105,
2557 85, 42, 149, 150, 329, 330, 121, 331, 332, 178,
2558 203, 46, 184, 204, 179, 85, 369, 185, 85, 370,
2559 371, 372, 373, 85, 85, 85, 1, 2, 3, 4,
2560 5, 6, 7, 8, 9, 10, 192, 200, 207, 184,
2561 192, 193, 201, 208, 268, 272, 209, 210, 200, 178,
2562 307, 307, 313, 275, 305, 308, 309, 314, 106, 107,
2563 106, 107, 319, 44, 50, 320, 122, 123, 122, 123,
2564 108, 48, 108, 156, 137, 138, 137, 138, 124, 140,
2565 124, 140, 207, 115, 351, 387, 139, 346, 139, 352,
2566 388, 203, 367, 130, 321, 368, 157, 146, 252, 253,
2567 158, 160, 159, 165, 166, 177, 181, 188, 211, 187,
2568 196, 195, 198, 212, 213, 216, 217, 218, 214, 215,
2569 219, 220, 221, 222, 223, 224, 225, 227, 228, 229,
2570 230, 234, 235, 281, 281, 236, 290, 291, 278, 240,
2571 242, 246, 241, 247, 249, 250, 261, 255, 292, 251,
2572 24, 259, 258, 260, 262, 263, 264, 270, 317, 277,
2573 297, 301, 310, 265, 316, 322, 324, 325, 279, 343,
2574 349, 266, 267, 354, 355, 357, 226, 323, 359, 361,
2575 363, 281, 356, 383, 384, 385, 389, 290, 291, 151,
2576 269, 271, 333, 334, 393, 286, 353, 239, 304, 292,
2577 391, 244, 273, 237, 335, 274, 276, 238, 245, 287,
2578 243, 233, 232, 231, 344, 326, 345, 360, 328, 327,
2579 358, 248, 362, 381, 342, 333, 334, 390, 394, 0,
2580 0, 0, 0, 392, 395, 396, 0, 335
2581 };
2582
2583 const short
2584 D2Parser::yycheck_[] =
2585 {
2586 56, 56, 58, 58, 60, 60, 62, 218, 23, 60,
2587 0, 52, 56, 5, 58, 7, 60, 9, 11, 12,
2588 13, 14, 35, 36, 17, 3, 19, 20, 21, 22,
2589 8, 7, 19, 20, 27, 57, 247, 7, 31, 11,
2590 12, 34, 57, 10, 37, 32, 33, 19, 20, 7,
2591 19, 20, 24, 5, 26, 19, 20, 19, 20, 28,
2592 29, 30, 24, 25, 57, 57, 58, 59, 60, 38,
2593 57, 7, 35, 36, 38, 39, 38, 41, 42, 3,
2594 3, 7, 3, 6, 8, 57, 40, 8, 57, 43,
2595 44, 45, 46, 57, 57, 57, 47, 48, 49, 50,
2596 51, 52, 53, 54, 55, 56, 3, 3, 3, 3,
2597 3, 8, 8, 8, 8, 8, 157, 158, 3, 3,
2598 3, 3, 3, 8, 8, 8, 8, 8, 184, 184,
2599 186, 186, 3, 5, 7, 6, 192, 192, 194, 194,
2600 184, 5, 186, 6, 200, 200, 202, 202, 192, 200,
2601 194, 202, 3, 7, 3, 3, 200, 8, 202, 8,
2602 8, 3, 3, 7, 6, 6, 3, 7, 15, 16,
2603 4, 3, 8, 4, 4, 4, 4, 3, 57, 6,
2604 3, 6, 4, 4, 4, 4, 4, 4, 58, 58,
2605 4, 4, 4, 4, 4, 4, 4, 4, 58, 4,
2606 4, 4, 4, 259, 260, 4, 262, 262, 249, 4,
2607 4, 4, 58, 4, 4, 7, 5, 18, 262, 57,
2608 7, 7, 57, 7, 7, 5, 5, 5, 3, 247,
2609 7, 7, 6, 57, 6, 4, 4, 4, 250, 5,
2610 4, 57, 57, 4, 4, 4, 178, 307, 6, 5,
2611 7, 307, 58, 4, 4, 4, 4, 313, 313, 315,
2612 57, 57, 318, 318, 4, 260, 343, 196, 270, 313,
2613 58, 202, 57, 192, 318, 57, 57, 194, 203, 261,
2614 200, 188, 186, 184, 57, 313, 57, 57, 317, 315,
2615 351, 207, 57, 367, 319, 351, 351, 60, 387, -1,
2616 -1, -1, -1, 58, 57, 57, -1, 351
2617 };
2618
2619 const unsigned char
2620 D2Parser::yystos_[] =
2621 {
2622 0, 47, 48, 49, 50, 51, 52, 53, 54, 55,
2623 56, 62, 63, 64, 65, 66, 67, 68, 69, 70,
2624 71, 72, 0, 5, 7, 9, 57, 58, 59, 60,
2625 73, 74, 75, 80, 7, 85, 7, 90, 7, 154,
2626 5, 148, 7, 122, 5, 116, 7, 137, 5, 132,
2627 7, 179, 81, 76, 86, 91, 155, 149, 123, 117,
2628 138, 133, 180, 73, 82, 83, 57, 78, 79, 10,
2629 87, 89, 11, 12, 13, 14, 17, 19, 20, 21,
2630 22, 27, 31, 34, 37, 57, 84, 92, 93, 94,
2631 96, 97, 98, 101, 103, 105, 107, 109, 146, 165,
2632 173, 187, 28, 29, 30, 38, 84, 103, 105, 156,
2633 157, 158, 160, 162, 163, 7, 150, 151, 152, 24,
2634 25, 38, 84, 103, 105, 124, 125, 126, 128, 130,
2635 7, 118, 119, 120, 11, 12, 26, 84, 103, 105,
2636 128, 139, 140, 141, 143, 145, 7, 134, 135, 35,
2637 36, 84, 181, 182, 183, 185, 6, 3, 4, 8,
2638 3, 88, 3, 8, 95, 4, 4, 99, 102, 104,
2639 106, 108, 110, 147, 166, 174, 188, 4, 3, 8,
2640 161, 4, 164, 159, 3, 8, 153, 6, 3, 129,
2641 131, 127, 3, 8, 121, 6, 3, 144, 4, 142,
2642 3, 8, 136, 3, 6, 184, 186, 3, 8, 73,
2643 73, 57, 4, 4, 58, 58, 4, 4, 4, 4,
2644 4, 4, 4, 4, 4, 4, 93, 4, 58, 4,
2645 4, 157, 156, 152, 4, 4, 4, 125, 124, 120,
2646 4, 58, 4, 140, 139, 135, 4, 4, 182, 4,
2647 7, 57, 15, 16, 100, 18, 75, 77, 57, 7,
2648 7, 5, 7, 5, 5, 57, 57, 57, 8, 57,
2649 5, 57, 8, 57, 57, 8, 57, 77, 73, 92,
2650 23, 84, 111, 112, 113, 114, 111, 150, 32, 33,
2651 84, 103, 105, 167, 168, 169, 171, 7, 175, 176,
2652 177, 7, 189, 190, 134, 8, 115, 3, 8, 8,
2653 6, 170, 172, 3, 8, 178, 6, 3, 191, 3,
2654 6, 6, 4, 113, 4, 4, 168, 181, 177, 38,
2655 39, 41, 42, 84, 103, 105, 192, 193, 194, 196,
2656 197, 199, 190, 5, 57, 57, 8, 195, 200, 4,
2657 198, 3, 8, 118, 4, 4, 58, 4, 193, 6,
2658 57, 5, 57, 7, 201, 202, 203, 3, 6, 40,
2659 43, 44, 45, 46, 204, 205, 206, 208, 209, 210,
2660 211, 202, 207, 4, 4, 4, 212, 3, 8, 4,
2661 60, 58, 58, 4, 205, 57, 57
2662 };
2663
2664 const unsigned char
2665 D2Parser::yyr1_[] =
2666 {
2667 0, 61, 63, 62, 64, 62, 65, 62, 66, 62,
2668 67, 62, 68, 62, 69, 62, 70, 62, 71, 62,
2669 72, 62, 73, 73, 73, 73, 73, 73, 73, 74,
2670 76, 75, 77, 78, 78, 79, 79, 79, 81, 80,
2671 82, 82, 83, 83, 83, 84, 86, 85, 88, 87,
2672 87, 89, 91, 90, 92, 92, 92, 93, 93, 93,
2673 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
2674 93, 95, 94, 96, 97, 99, 98, 100, 100, 102,
2675 101, 104, 103, 106, 105, 108, 107, 110, 109, 111,
2676 111, 112, 112, 112, 113, 113, 115, 114, 117, 116,
2677 118, 118, 119, 119, 119, 121, 120, 123, 122, 124,
2678 124, 124, 125, 125, 125, 125, 125, 125, 127, 126,
2679 129, 128, 131, 130, 133, 132, 134, 134, 134, 136,
2680 135, 138, 137, 139, 139, 139, 140, 140, 140, 140,
2681 140, 140, 140, 142, 141, 144, 143, 145, 147, 146,
2682 149, 148, 150, 150, 151, 151, 151, 153, 152, 155,
2683 154, 156, 156, 156, 157, 157, 157, 157, 157, 157,
2684 157, 159, 158, 161, 160, 162, 164, 163, 166, 165,
2685 167, 167, 167, 168, 168, 168, 168, 168, 170, 169,
2686 172, 171, 174, 173, 175, 175, 176, 176, 176, 178,
2687 177, 180, 179, 181, 181, 181, 181, 182, 182, 184,
2688 183, 186, 185, 188, 187, 189, 189, 189, 191, 190,
2689 192, 192, 192, 193, 193, 193, 193, 193, 193, 193,
2690 195, 194, 196, 198, 197, 200, 199, 201, 201, 201,
2691 203, 202, 204, 204, 204, 205, 205, 205, 205, 205,
2692 207, 206, 208, 209, 210, 212, 211
2693 };
2694
2695 const signed char
2696 D2Parser::yyr2_[] =
2697 {
2698 0, 2, 0, 3, 0, 3, 0, 3, 0, 3,
2699 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
2700 0, 3, 1, 1, 1, 1, 1, 1, 1, 1,
2701 0, 4, 1, 0, 1, 3, 5, 2, 0, 4,
2702 0, 1, 1, 3, 2, 2, 0, 4, 0, 6,
2703 1, 2, 0, 4, 1, 3, 2, 1, 1, 1,
2704 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2705 1, 0, 4, 3, 3, 0, 4, 1, 1, 0,
2706 4, 0, 4, 0, 4, 0, 6, 0, 6, 0,
2707 1, 1, 3, 2, 1, 1, 0, 6, 0, 4,
2708 0, 1, 1, 3, 2, 0, 4, 0, 4, 1,
2709 3, 2, 1, 1, 1, 1, 1, 1, 0, 4,
2710 0, 4, 0, 6, 0, 4, 1, 3, 2, 0,
2711 4, 0, 4, 1, 3, 2, 1, 1, 1, 1,
2712 1, 1, 1, 0, 4, 0, 4, 3, 0, 6,
2713 0, 4, 0, 1, 1, 3, 2, 0, 4, 0,
2714 4, 1, 3, 2, 1, 1, 1, 1, 1, 1,
2715 1, 0, 4, 0, 4, 3, 0, 4, 0, 6,
2716 1, 3, 2, 1, 1, 1, 1, 1, 0, 4,
2717 0, 4, 0, 6, 0, 1, 1, 3, 2, 0,
2718 4, 0, 4, 1, 3, 2, 1, 1, 1, 0,
2719 4, 0, 4, 0, 6, 1, 3, 2, 0, 4,
2720 1, 3, 2, 1, 1, 1, 1, 1, 1, 1,
2721 0, 4, 3, 0, 4, 0, 6, 1, 3, 2,
2722 0, 4, 1, 3, 2, 1, 1, 1, 1, 1,
2723 0, 4, 3, 3, 3, 0, 4
2724 };
2725
2726
2727#if D2_PARSER_DEBUG || 1
2728 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2729 // First, the terminals, then, starting at \a YYNTOKENS, nonterminals.
2730 const char*
2731 const D2Parser::yytname_[] =
2732 {
2733 "\"end of file\"", "error", "\"invalid token\"", "\",\"", "\":\"",
2734 "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"DhcpDdns\"",
2735 "\"ip-address\"", "\"port\"", "\"dns-server-timeout\"",
2736 "\"ncr-protocol\"", "\"UDP\"", "\"TCP\"", "\"ncr-format\"", "\"JSON\"",
2737 "\"user-context\"", "\"comment\"", "\"forward-ddns\"",
2738 "\"reverse-ddns\"", "\"ddns-domains\"", "\"key-name\"",
2739 "\"dns-servers\"", "\"hostname\"", "\"tsig-keys\"", "\"algorithm\"",
2740 "\"digest-bits\"", "\"secret\"", "\"control-socket\"", "\"socket-type\"",
2741 "\"socket-name\"", "\"hooks-libraries\"", "\"library\"",
2742 "\"parameters\"", "\"loggers\"", "\"name\"", "\"output_options\"",
2743 "\"output\"", "\"debuglevel\"", "\"severity\"", "\"flush\"",
2744 "\"maxsize\"", "\"maxver\"", "\"pattern\"", "TOPLEVEL_JSON",
2745 "TOPLEVEL_DHCPDDNS", "SUB_DHCPDDNS", "SUB_TSIG_KEY", "SUB_TSIG_KEYS",
2746 "SUB_DDNS_DOMAIN", "SUB_DDNS_DOMAINS", "SUB_DNS_SERVER",
2747 "SUB_DNS_SERVERS", "SUB_HOOKS_LIBRARY", "\"constant string\"",
2748 "\"integer\"", "\"floating point\"", "\"boolean\"", "$accept", "start",
2749 "$@1", "$@2", "$@3", "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10",
2750 "value", "sub_json", "map2", "$@11", "map_value", "map_content",
2751 "not_empty_map", "list_generic", "$@12", "list_content",
2752 "not_empty_list", "unknown_map_entry", "syntax_map", "$@13",
2753 "global_object", "$@14", "global_object_comma", "sub_dhcpddns", "$@15",
2754 "dhcpddns_params", "dhcpddns_param", "ip_address", "$@16", "port",
2755 "dns_server_timeout", "ncr_protocol", "$@17", "ncr_protocol_value",
2756 "ncr_format", "$@18", "user_context", "$@19", "comment", "$@20",
2757 "forward_ddns", "$@21", "reverse_ddns", "$@22", "ddns_mgr_params",
2758 "not_empty_ddns_mgr_params", "ddns_mgr_param", "ddns_domains", "$@23",
2759 "sub_ddns_domains", "$@24", "ddns_domain_list",
2760 "not_empty_ddns_domain_list", "ddns_domain", "$@25", "sub_ddns_domain",
2761 "$@26", "ddns_domain_params", "ddns_domain_param", "ddns_domain_name",
2762 "$@27", "ddns_key_name", "$@28", "dns_servers", "$@29",
2763 "sub_dns_servers", "$@30", "dns_server_list", "dns_server", "$@31",
2764 "sub_dns_server", "$@32", "dns_server_params", "dns_server_param",
2765 "dns_server_hostname", "$@33", "dns_server_ip_address", "$@34",
2766 "dns_server_port", "tsig_keys", "$@35", "sub_tsig_keys", "$@36",
2767 "tsig_keys_list", "not_empty_tsig_keys_list", "tsig_key", "$@37",
2768 "sub_tsig_key", "$@38", "tsig_key_params", "tsig_key_param",
2769 "tsig_key_name", "$@39", "tsig_key_algorithm", "$@40",
2770 "tsig_key_digest_bits", "tsig_key_secret", "$@41", "control_socket",
2771 "$@42", "control_socket_params", "control_socket_param",
2772 "control_socket_type", "$@43", "control_socket_name", "$@44",
2773 "hooks_libraries", "$@45", "hooks_libraries_list",
2774 "not_empty_hooks_libraries_list", "hooks_library", "$@46",
2775 "sub_hooks_library", "$@47", "hooks_params", "hooks_param", "library",
2776 "$@48", "parameters", "$@49", "loggers", "$@50", "loggers_entries",
2777 "logger_entry", "$@51", "logger_params", "logger_param", "name", "$@52",
2778 "debuglevel", "severity", "$@53", "output_options_list", "$@54",
2779 "output_options_list_content", "output_entry", "$@55",
2780 "output_params_list", "output_params", "output", "$@56", "flush",
2781 "maxsize", "maxver", "pattern", "$@57", YY_NULLPTR
2782 };
2783#endif
2784
2785
2786#if D2_PARSER_DEBUG
2787 const short
2788 D2Parser::yyrline_[] =
2789 {
2790 0, 125, 125, 125, 126, 126, 127, 127, 128, 128,
2791 129, 129, 130, 130, 131, 131, 132, 132, 133, 133,
2792 134, 134, 142, 143, 144, 145, 146, 147, 148, 151,
2793 156, 156, 167, 170, 171, 174, 179, 185, 190, 190,
2794 197, 198, 201, 205, 209, 219, 228, 228, 241, 241,
2795 251, 254, 258, 258, 266, 267, 268, 274, 275, 276,
2796 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
2797 287, 290, 290, 299, 308, 318, 318, 327, 328, 331,
2798 331, 340, 340, 365, 365, 392, 392, 403, 403, 414,
2799 415, 418, 419, 420, 425, 426, 431, 431, 442, 442,
2800 449, 450, 453, 454, 455, 460, 460, 468, 468, 475,
2801 476, 477, 482, 483, 484, 485, 486, 487, 491, 491,
2802 504, 504, 517, 517, 528, 528, 535, 536, 537, 542,
2803 542, 550, 550, 557, 558, 559, 564, 565, 566, 567,
2804 568, 569, 570, 573, 573, 586, 586, 595, 610, 610,
2805 621, 621, 628, 629, 632, 633, 634, 639, 639, 647,
2806 647, 656, 657, 658, 663, 664, 665, 666, 667, 668,
2807 669, 672, 672, 685, 685, 697, 706, 706, 723, 723,
2808 734, 735, 736, 741, 742, 743, 744, 745, 748, 748,
2809 757, 757, 768, 768, 779, 780, 783, 784, 785, 790,
2810 790, 800, 800, 810, 811, 812, 815, 818, 819, 822,
2811 822, 831, 831, 841, 841, 854, 855, 856, 862, 862,
2812 870, 871, 872, 877, 878, 879, 880, 881, 882, 883,
2813 886, 886, 895, 901, 901, 910, 910, 921, 922, 923,
2814 928, 928, 936, 937, 938, 943, 944, 945, 946, 947,
2815 950, 950, 959, 965, 971, 977, 977
2816 };
2817
2818 void
2819 D2Parser::yy_stack_print_ () const
2820 {
2821 *yycdebug_ << "Stack now";
2822 for (stack_type::const_iterator
2823 i = yystack_.begin (),
2824 i_end = yystack_.end ();
2825 i != i_end; ++i)
2826 *yycdebug_ << ' ' << int (i->state);
2827 *yycdebug_ << '\n';
2828 }
2829
2830 void
2831 D2Parser::yy_reduce_print_ (int yyrule) const
2832 {
2833 int yylno = yyrline_[yyrule];
2834 int yynrhs = yyr2_[yyrule];
2835 // Print the symbols being reduced, and their result.
2836 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
2837 << " (line " << yylno << "):\n";
2838 // The symbols being reduced.
2839 for (int yyi = 0; yyi < yynrhs; yyi++)
2840 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
2841 yystack_[(yynrhs) - (yyi + 1)]);
2842 }
2843#endif // D2_PARSER_DEBUG
2844
2845
2846#line 14 "d2_parser.yy"
2847} } // isc::d2
2848#line 2849 "d2_parser.cc"
2849
2850#line 986 "d2_parser.yy"
2851
2852
2853void
2855 const std::string& what)
2856{
2857 ctx.error(loc, what);
2858}
#define YY_RVREF(Type)
Definition: agent_parser.h:85
#define YY_CAST(Type, Val)
Definition: agent_parser.h:177
#define YY_MOVE_REF(Type)
Definition: agent_parser.h:84
#define YY_NOEXCEPT
Definition: agent_parser.h:94
#define YY_MOVE
Definition: agent_parser.h:82
#define YY_NOTHROW
Definition: agent_parser.h:95
#define YY_USE(E)
Definition: agent_parser.h:130
Evaluation context, an interface to the expression evaluation.
@ DDNS_DOMAIN
Used while parsing a list of ddns-domains.
@ DNS_SERVERS
Used while parsing content of a control-socket.
@ DDNS_DOMAINS
Used while parsing content of a dns-server.
@ NCR_FORMAT
Used while parsing DhcpDdns/ncr-format.
@ NCR_PROTOCOL
Used while parsing DhcpDdns/ncr-protocol.
@ NO_KEYWORD
This one is used in pure JSON mode.
@ DHCPDDNS
Used while parsing content of a tsig-key.
@ OUTPUT_OPTIONS
Used while parsing DhcpDdns/loggers/output_options structures.
@ FORWARD_DDNS
Used while parsing content of DhcpDdns/reverse-ddns.
@ TSIG_KEY
Used while parsing a list of tsig-keys.
@ REVERSE_DDNS
Used while parsing content of a ddns-domain.
@ LOGGERS
Used while parsing DhcpDdns/loggers structures.
@ HOOKS_LIBRARIES
Used while parsing DhcpDdns/hooks-libraries.
@ TSIG_KEYS
Used while parsing content of DhcpDdns/tsig-keys/algorithm.
@ CONFIG
Used while parsing content of DhcpDdns.
const std::string contextName()
Get the syntax context name.
void leave()
Leave a syntactic context.
void warnAboutExtraCommas(const isc::d2::location &loc)
Warning for extra commas.
void unique(const std::string &name, isc::data::Element::Position loc)
Check if a parameter is already present.
ParserContext ctx_
Current syntactic context.
void require(const std::string &name, isc::data::Element::Position open_loc, isc::data::Element::Position close_loc)
Check if a required parameter is present.
std::vector< isc::data::ElementPtr > stack_
JSON elements being parsed.
void enter(const ParserContext &ctx)
Enter a new syntactic context.
isc::data::Element::Position loc2pos(isc::d2::location &loc)
Converts bison's position to one understood by isc::data::Element.
context(const D2Parser &yyparser, const symbol_type &yyla)
Definition: d2_parser.cc:2286
const symbol_type & lookahead() const YY_NOEXCEPT
Definition: d2_parser.h:2100
symbol_kind_type token() const YY_NOEXCEPT
Definition: d2_parser.h:2101
int expected_tokens(symbol_kind_type yyarg[], int yyargn) const
Put in YYARG at most YYARGN of the expected tokens, and return the number of tokens stored in YYARG.
Definition: d2_parser.cc:2292
Present a slice of the top of a stack.
Definition: d2_parser.h:2367
A Bison parser.
Definition: d2_parser.h:216
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition: d2_parser.h:789
virtual ~D2Parser()
Definition: d2_parser.cc:157
void set_debug_level(debug_level_type l)
Set the current debugging level.
Definition: d2_parser.cc:476
D2Parser(isc::d2::D2ParserContext &ctx_yyarg)
Build a parser object.
Definition: d2_parser.cc:147
location location_type
Symbol locations.
Definition: d2_parser.h:467
int debug_level_type
Type for debugging levels.
Definition: d2_parser.h:1159
debug_level_type debug_level() const YY_ATTRIBUTE_PURE
The current debugging level.
Definition: d2_parser.cc:470
void set_debug_stream(std::ostream &)
Set the current debugging stream.
Definition: d2_parser.cc:463
static const symbol_kind_type YYNTOKENS
The number of tokens.
Definition: d2_parser.h:792
virtual int parse()
Parse.
Definition: d2_parser.cc:511
std::ostream & debug_stream() const YY_ATTRIBUTE_PURE
The current debugging stream.
Definition: d2_parser.cc:457
static std::string symbol_name(symbol_kind_type yysymbol)
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
Definition: d2_parser.cc:2278
int operator()()
Parse.
Definition: d2_parser.cc:505
virtual void error(const location_type &loc, const std::string &msg)
Report a syntax error.
Definition: d2_parser.cc:2854
Notes: IntElement type is changed to int64_t.
Definition: data.h:590
#define YYCDEBUG
Definition: d2_parser.cc:101
#define YYABORT
Definition: d2_parser.cc:138
#define YYLLOC_DEFAULT(Current, Rhs, N)
Definition: d2_parser.cc:82
#define YY_REDUCE_PRINT(Rule)
Definition: d2_parser.cc:113
#define YY_SYMBOL_PRINT(Title, Symbol)
Definition: d2_parser.cc:103
#define yylex
Definition: d2_parser.cc:39
#define YYCASE_(N, S)
#define YY_STACK_PRINT()
Definition: d2_parser.cc:119
#define YY_(msgid)
Definition: d2_parser.cc:62
#define YYACCEPT
Definition: d2_parser.cc:137
#define YYERROR
Definition: d2_parser.cc:139
Define the isc::d2::parser class.
void merge(ElementPtr element, ConstElementPtr other)
Merges the data from other into element.
Definition: data.cc:1139
boost::shared_ptr< const Element > ConstElementPtr
Definition: data.h:27
boost::shared_ptr< Element > ElementPtr
Definition: data.h:24
Defines the logger used by the top-level component of kea-lfc.
bool empty() const YY_NOEXCEPT
Whether empty.
Definition: d2_parser.h:2539
location_type location
The location.
Definition: d2_parser.h:1008
void move(basic_symbol &s)
Destructive move, s is emptied into this.
Definition: d2_parser.h:2546
void clear() YY_NOEXCEPT
Destroy contents, and record that is empty.
Definition: d2_parser.h:945
"External" symbols: returned by the scanner.
Definition: d2_parser.h:1062
Syntax errors thrown from user actions.
Definition: d2_parser.h:471
~syntax_error() YY_NOEXCEPT YY_NOTHROW
Definition: d2_parser.cc:160