Kea 2.6.0
dhcp6_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 parser6_lex
40
41
42
43#include "dhcp6_parser.h"
44
45
46// Unqualified %code blocks.
47#line 34 "dhcp6_parser.yy"
48
50
51// Avoid warnings with the error counter.
52#if defined(__GNUC__) || defined(__clang__)
53#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
54#endif
55
56#line 57 "dhcp6_parser.cc"
57
58
59#ifndef YY_
60# if defined YYENABLE_NLS && YYENABLE_NLS
61# if ENABLE_NLS
62# include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
63# define YY_(msgid) dgettext ("bison-runtime", msgid)
64# endif
65# endif
66# ifndef YY_
67# define YY_(msgid) msgid
68# endif
69#endif
70
71
72// Whether we are compiled with exception support.
73#ifndef YY_EXCEPTIONS
74# if defined __GNUC__ && !defined __EXCEPTIONS
75# define YY_EXCEPTIONS 0
76# else
77# define YY_EXCEPTIONS 1
78# endif
79#endif
80
81#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
82/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
83 If N is 0, then set CURRENT to the empty location which ends
84 the previous symbol: RHS[0] (always defined). */
85
86# ifndef YYLLOC_DEFAULT
87# define YYLLOC_DEFAULT(Current, Rhs, N) \
88 do \
89 if (N) \
90 { \
91 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
92 (Current).end = YYRHSLOC (Rhs, N).end; \
93 } \
94 else \
95 { \
96 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
97 } \
98 while (false)
99# endif
100
101
102// Enable debugging if requested.
103#if PARSER6_DEBUG
104
105// A pseudo ostream that takes yydebug_ into account.
106# define YYCDEBUG if (yydebug_) (*yycdebug_)
107
108# define YY_SYMBOL_PRINT(Title, Symbol) \
109 do { \
110 if (yydebug_) \
111 { \
112 *yycdebug_ << Title << ' '; \
113 yy_print_ (*yycdebug_, Symbol); \
114 *yycdebug_ << '\n'; \
115 } \
116 } while (false)
117
118# define YY_REDUCE_PRINT(Rule) \
119 do { \
120 if (yydebug_) \
121 yy_reduce_print_ (Rule); \
122 } while (false)
123
124# define YY_STACK_PRINT() \
125 do { \
126 if (yydebug_) \
127 yy_stack_print_ (); \
128 } while (false)
129
130#else // !PARSER6_DEBUG
131
132# define YYCDEBUG if (false) std::cerr
133# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol)
134# define YY_REDUCE_PRINT(Rule) static_cast<void> (0)
135# define YY_STACK_PRINT() static_cast<void> (0)
136
137#endif // !PARSER6_DEBUG
138
139#define yyerrok (yyerrstatus_ = 0)
140#define yyclearin (yyla.clear ())
141
142#define YYACCEPT goto yyacceptlab
143#define YYABORT goto yyabortlab
144#define YYERROR goto yyerrorlab
145#define YYRECOVERING() (!!yyerrstatus_)
146
147#line 14 "dhcp6_parser.yy"
148namespace isc { namespace dhcp {
149#line 150 "dhcp6_parser.cc"
150
153#if PARSER6_DEBUG
154 : yydebug_ (false),
155 yycdebug_ (&std::cerr),
156#else
157 :
158#endif
159 ctx (ctx_yyarg)
160 {}
161
163 {}
164
166 {}
167
168 /*---------.
169 | symbol. |
170 `---------*/
171
172
173
174 // by_state.
175 Dhcp6Parser::by_state::by_state () YY_NOEXCEPT
176 : state (empty_state)
177 {}
178
179 Dhcp6Parser::by_state::by_state (const by_state& that) YY_NOEXCEPT
180 : state (that.state)
181 {}
182
183 void
184 Dhcp6Parser::by_state::clear () YY_NOEXCEPT
185 {
186 state = empty_state;
187 }
188
189 void
190 Dhcp6Parser::by_state::move (by_state& that)
191 {
192 state = that.state;
193 that.clear ();
194 }
195
196 Dhcp6Parser::by_state::by_state (state_type s) YY_NOEXCEPT
197 : state (s)
198 {}
199
201 Dhcp6Parser::by_state::kind () const YY_NOEXCEPT
202 {
203 if (state == empty_state)
205 else
206 return YY_CAST (symbol_kind_type, yystos_[+state]);
207 }
208
209 Dhcp6Parser::stack_symbol_type::stack_symbol_type ()
210 {}
211
212 Dhcp6Parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
213 : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
214 {
215 switch (that.kind ())
216 {
217 case symbol_kind::S_value: // value
218 case symbol_kind::S_map_value: // map_value
219 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
220 case symbol_kind::S_ddns_conflict_resolution_mode_value: // ddns_conflict_resolution_mode_value
221 case symbol_kind::S_db_type: // db_type
222 case symbol_kind::S_on_fail_mode: // on_fail_mode
223 case symbol_kind::S_duid_type: // duid_type
224 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
225 value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
226 break;
227
228 case symbol_kind::S_BOOLEAN: // "boolean"
229 value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
230 break;
231
232 case symbol_kind::S_FLOAT: // "floating point"
233 value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
234 break;
235
236 case symbol_kind::S_INTEGER: // "integer"
237 value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
238 break;
239
240 case symbol_kind::S_STRING: // "constant string"
241 value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
242 break;
243
244 default:
245 break;
246 }
247
248#if 201103L <= YY_CPLUSPLUS
249 // that is emptied.
250 that.state = empty_state;
251#endif
252 }
253
254 Dhcp6Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
255 : super_type (s, YY_MOVE (that.location))
256 {
257 switch (that.kind ())
258 {
259 case symbol_kind::S_value: // value
260 case symbol_kind::S_map_value: // map_value
261 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
262 case symbol_kind::S_ddns_conflict_resolution_mode_value: // ddns_conflict_resolution_mode_value
263 case symbol_kind::S_db_type: // db_type
264 case symbol_kind::S_on_fail_mode: // on_fail_mode
265 case symbol_kind::S_duid_type: // duid_type
266 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
267 value.move< ElementPtr > (YY_MOVE (that.value));
268 break;
269
270 case symbol_kind::S_BOOLEAN: // "boolean"
271 value.move< bool > (YY_MOVE (that.value));
272 break;
273
274 case symbol_kind::S_FLOAT: // "floating point"
275 value.move< double > (YY_MOVE (that.value));
276 break;
277
278 case symbol_kind::S_INTEGER: // "integer"
279 value.move< int64_t > (YY_MOVE (that.value));
280 break;
281
282 case symbol_kind::S_STRING: // "constant string"
283 value.move< std::string > (YY_MOVE (that.value));
284 break;
285
286 default:
287 break;
288 }
289
290 // that is emptied.
291 that.kind_ = symbol_kind::S_YYEMPTY;
292 }
293
294#if YY_CPLUSPLUS < 201103L
295 Dhcp6Parser::stack_symbol_type&
296 Dhcp6Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
297 {
298 state = that.state;
299 switch (that.kind ())
300 {
301 case symbol_kind::S_value: // value
302 case symbol_kind::S_map_value: // map_value
303 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
304 case symbol_kind::S_ddns_conflict_resolution_mode_value: // ddns_conflict_resolution_mode_value
305 case symbol_kind::S_db_type: // db_type
306 case symbol_kind::S_on_fail_mode: // on_fail_mode
307 case symbol_kind::S_duid_type: // duid_type
308 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
309 value.copy< ElementPtr > (that.value);
310 break;
311
312 case symbol_kind::S_BOOLEAN: // "boolean"
313 value.copy< bool > (that.value);
314 break;
315
316 case symbol_kind::S_FLOAT: // "floating point"
317 value.copy< double > (that.value);
318 break;
319
320 case symbol_kind::S_INTEGER: // "integer"
321 value.copy< int64_t > (that.value);
322 break;
323
324 case symbol_kind::S_STRING: // "constant string"
325 value.copy< std::string > (that.value);
326 break;
327
328 default:
329 break;
330 }
331
332 location = that.location;
333 return *this;
334 }
335
336 Dhcp6Parser::stack_symbol_type&
337 Dhcp6Parser::stack_symbol_type::operator= (stack_symbol_type& that)
338 {
339 state = that.state;
340 switch (that.kind ())
341 {
342 case symbol_kind::S_value: // value
343 case symbol_kind::S_map_value: // map_value
344 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
345 case symbol_kind::S_ddns_conflict_resolution_mode_value: // ddns_conflict_resolution_mode_value
346 case symbol_kind::S_db_type: // db_type
347 case symbol_kind::S_on_fail_mode: // on_fail_mode
348 case symbol_kind::S_duid_type: // duid_type
349 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
350 value.move< ElementPtr > (that.value);
351 break;
352
353 case symbol_kind::S_BOOLEAN: // "boolean"
354 value.move< bool > (that.value);
355 break;
356
357 case symbol_kind::S_FLOAT: // "floating point"
358 value.move< double > (that.value);
359 break;
360
361 case symbol_kind::S_INTEGER: // "integer"
362 value.move< int64_t > (that.value);
363 break;
364
365 case symbol_kind::S_STRING: // "constant string"
366 value.move< std::string > (that.value);
367 break;
368
369 default:
370 break;
371 }
372
373 location = that.location;
374 // that is emptied.
375 that.state = empty_state;
376 return *this;
377 }
378#endif
379
380 template <typename Base>
381 void
382 Dhcp6Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
383 {
384 if (yymsg)
385 YY_SYMBOL_PRINT (yymsg, yysym);
386 }
387
388#if PARSER6_DEBUG
389 template <typename Base>
390 void
391 Dhcp6Parser::yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const
392 {
393 std::ostream& yyoutput = yyo;
394 YY_USE (yyoutput);
395 if (yysym.empty ())
396 yyo << "empty symbol";
397 else
398 {
399 symbol_kind_type yykind = yysym.kind ();
400 yyo << (yykind < YYNTOKENS ? "token" : "nterm")
401 << ' ' << yysym.name () << " ("
402 << yysym.location << ": ";
403 switch (yykind)
404 {
405 case symbol_kind::S_STRING: // "constant string"
406#line 303 "dhcp6_parser.yy"
407 { yyoutput << yysym.value.template as < std::string > (); }
408#line 409 "dhcp6_parser.cc"
409 break;
410
411 case symbol_kind::S_INTEGER: // "integer"
412#line 303 "dhcp6_parser.yy"
413 { yyoutput << yysym.value.template as < int64_t > (); }
414#line 415 "dhcp6_parser.cc"
415 break;
416
417 case symbol_kind::S_FLOAT: // "floating point"
418#line 303 "dhcp6_parser.yy"
419 { yyoutput << yysym.value.template as < double > (); }
420#line 421 "dhcp6_parser.cc"
421 break;
422
423 case symbol_kind::S_BOOLEAN: // "boolean"
424#line 303 "dhcp6_parser.yy"
425 { yyoutput << yysym.value.template as < bool > (); }
426#line 427 "dhcp6_parser.cc"
427 break;
428
429 case symbol_kind::S_value: // value
430#line 303 "dhcp6_parser.yy"
431 { yyoutput << yysym.value.template as < ElementPtr > (); }
432#line 433 "dhcp6_parser.cc"
433 break;
434
435 case symbol_kind::S_map_value: // map_value
436#line 303 "dhcp6_parser.yy"
437 { yyoutput << yysym.value.template as < ElementPtr > (); }
438#line 439 "dhcp6_parser.cc"
439 break;
440
441 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
442#line 303 "dhcp6_parser.yy"
443 { yyoutput << yysym.value.template as < ElementPtr > (); }
444#line 445 "dhcp6_parser.cc"
445 break;
446
447 case symbol_kind::S_ddns_conflict_resolution_mode_value: // ddns_conflict_resolution_mode_value
448#line 303 "dhcp6_parser.yy"
449 { yyoutput << yysym.value.template as < ElementPtr > (); }
450#line 451 "dhcp6_parser.cc"
451 break;
452
453 case symbol_kind::S_db_type: // db_type
454#line 303 "dhcp6_parser.yy"
455 { yyoutput << yysym.value.template as < ElementPtr > (); }
456#line 457 "dhcp6_parser.cc"
457 break;
458
459 case symbol_kind::S_on_fail_mode: // on_fail_mode
460#line 303 "dhcp6_parser.yy"
461 { yyoutput << yysym.value.template as < ElementPtr > (); }
462#line 463 "dhcp6_parser.cc"
463 break;
464
465 case symbol_kind::S_duid_type: // duid_type
466#line 303 "dhcp6_parser.yy"
467 { yyoutput << yysym.value.template as < ElementPtr > (); }
468#line 469 "dhcp6_parser.cc"
469 break;
470
471 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
472#line 303 "dhcp6_parser.yy"
473 { yyoutput << yysym.value.template as < ElementPtr > (); }
474#line 475 "dhcp6_parser.cc"
475 break;
476
477 default:
478 break;
479 }
480 yyo << ')';
481 }
482 }
483#endif
484
485 void
486 Dhcp6Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
487 {
488 if (m)
489 YY_SYMBOL_PRINT (m, sym);
490 yystack_.push (YY_MOVE (sym));
491 }
492
493 void
494 Dhcp6Parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
495 {
496#if 201103L <= YY_CPLUSPLUS
497 yypush_ (m, stack_symbol_type (s, std::move (sym)));
498#else
499 stack_symbol_type ss (s, sym);
500 yypush_ (m, ss);
501#endif
502 }
503
504 void
505 Dhcp6Parser::yypop_ (int n) YY_NOEXCEPT
506 {
507 yystack_.pop (n);
508 }
509
510#if PARSER6_DEBUG
511 std::ostream&
512 Dhcp6Parser::debug_stream () const
513 {
514 return *yycdebug_;
515 }
516
517 void
518 Dhcp6Parser::set_debug_stream (std::ostream& o)
519 {
520 yycdebug_ = &o;
521 }
522
523
524 Dhcp6Parser::debug_level_type
525 Dhcp6Parser::debug_level () const
526 {
527 return yydebug_;
528 }
529
530 void
531 Dhcp6Parser::set_debug_level (debug_level_type l)
532 {
533 yydebug_ = l;
534 }
535#endif // PARSER6_DEBUG
536
537 Dhcp6Parser::state_type
538 Dhcp6Parser::yy_lr_goto_state_ (state_type yystate, int yysym)
539 {
540 int yyr = yypgoto_[yysym - YYNTOKENS] + yystate;
541 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
542 return yytable_[yyr];
543 else
544 return yydefgoto_[yysym - YYNTOKENS];
545 }
546
547 bool
548 Dhcp6Parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT
549 {
550 return yyvalue == yypact_ninf_;
551 }
552
553 bool
554 Dhcp6Parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT
555 {
556 return yyvalue == yytable_ninf_;
557 }
558
559 int
561 {
562 return parse ();
563 }
564
565 int
567 {
568 int yyn;
570 int yylen = 0;
571
572 // Error handling.
573 int yynerrs_ = 0;
574 int yyerrstatus_ = 0;
575
577 symbol_type yyla;
578
580 stack_symbol_type yyerror_range[3];
581
583 int yyresult;
584
585#if YY_EXCEPTIONS
586 try
587#endif // YY_EXCEPTIONS
588 {
589 YYCDEBUG << "Starting parse\n";
590
591
592 /* Initialize the stack. The initial state will be set in
593 yynewstate, since the latter expects the semantical and the
594 location values to have been already stored, initialize these
595 stacks with a primary value. */
596 yystack_.clear ();
597 yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
598
599 /*-----------------------------------------------.
600 | yynewstate -- push a new symbol on the stack. |
601 `-----------------------------------------------*/
602 yynewstate:
603 YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n';
605
606 // Accept?
607 if (yystack_[0].state == yyfinal_)
608 YYACCEPT;
609
610 goto yybackup;
611
612
613 /*-----------.
614 | yybackup. |
615 `-----------*/
616 yybackup:
617 // Try to take a decision without lookahead.
618 yyn = yypact_[+yystack_[0].state];
619 if (yy_pact_value_is_default_ (yyn))
620 goto yydefault;
621
622 // Read a lookahead token.
623 if (yyla.empty ())
624 {
625 YYCDEBUG << "Reading a token\n";
626#if YY_EXCEPTIONS
627 try
628#endif // YY_EXCEPTIONS
629 {
630 symbol_type yylookahead (yylex (ctx));
631 yyla.move (yylookahead);
632 }
633#if YY_EXCEPTIONS
634 catch (const syntax_error& yyexc)
635 {
636 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
637 error (yyexc);
638 goto yyerrlab1;
639 }
640#endif // YY_EXCEPTIONS
641 }
642 YY_SYMBOL_PRINT ("Next token is", yyla);
643
644 if (yyla.kind () == symbol_kind::S_YYerror)
645 {
646 // The scanner already issued an error message, process directly
647 // to error recovery. But do not keep the error token as
648 // lookahead, it is too special and may lead us to an endless
649 // loop in error recovery. */
650 yyla.kind_ = symbol_kind::S_YYUNDEF;
651 goto yyerrlab1;
652 }
653
654 /* If the proper action on seeing token YYLA.TYPE is to reduce or
655 to detect an error, take that action. */
656 yyn += yyla.kind ();
657 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ())
658 {
659 goto yydefault;
660 }
661
662 // Reduce or error.
663 yyn = yytable_[yyn];
664 if (yyn <= 0)
665 {
666 if (yy_table_value_is_error_ (yyn))
667 goto yyerrlab;
668 yyn = -yyn;
669 goto yyreduce;
670 }
671
672 // Count tokens shifted since error; after three, turn off error status.
673 if (yyerrstatus_)
674 --yyerrstatus_;
675
676 // Shift the lookahead token.
677 yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));
678 goto yynewstate;
679
680
681 /*-----------------------------------------------------------.
682 | yydefault -- do the default action for the current state. |
683 `-----------------------------------------------------------*/
684 yydefault:
685 yyn = yydefact_[+yystack_[0].state];
686 if (yyn == 0)
687 goto yyerrlab;
688 goto yyreduce;
689
690
691 /*-----------------------------.
692 | yyreduce -- do a reduction. |
693 `-----------------------------*/
694 yyreduce:
695 yylen = yyr2_[yyn];
696 {
697 stack_symbol_type yylhs;
698 yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
699 /* Variants are always initialized to an empty instance of the
700 correct type. The default '$$ = $1' action is NOT applied
701 when using variants. */
702 switch (yyr1_[yyn])
703 {
704 case symbol_kind::S_value: // value
705 case symbol_kind::S_map_value: // map_value
706 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
707 case symbol_kind::S_ddns_conflict_resolution_mode_value: // ddns_conflict_resolution_mode_value
708 case symbol_kind::S_db_type: // db_type
709 case symbol_kind::S_on_fail_mode: // on_fail_mode
710 case symbol_kind::S_duid_type: // duid_type
711 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
712 yylhs.value.emplace< ElementPtr > ();
713 break;
714
715 case symbol_kind::S_BOOLEAN: // "boolean"
716 yylhs.value.emplace< bool > ();
717 break;
718
719 case symbol_kind::S_FLOAT: // "floating point"
720 yylhs.value.emplace< double > ();
721 break;
722
723 case symbol_kind::S_INTEGER: // "integer"
724 yylhs.value.emplace< int64_t > ();
725 break;
726
727 case symbol_kind::S_STRING: // "constant string"
728 yylhs.value.emplace< std::string > ();
729 break;
730
731 default:
732 break;
733 }
734
735
736 // Default location.
737 {
738 stack_type::slice range (yystack_, yylen);
739 YYLLOC_DEFAULT (yylhs.location, range, yylen);
740 yyerror_range[1].location = yylhs.location;
741 }
742
743 // Perform the reduction.
744 YY_REDUCE_PRINT (yyn);
745#if YY_EXCEPTIONS
746 try
747#endif // YY_EXCEPTIONS
748 {
749 switch (yyn)
750 {
751 case 2: // $@1: %empty
752#line 312 "dhcp6_parser.yy"
753 { ctx.ctx_ = ctx.NO_KEYWORD; }
754#line 755 "dhcp6_parser.cc"
755 break;
756
757 case 4: // $@2: %empty
758#line 313 "dhcp6_parser.yy"
759 { ctx.ctx_ = ctx.CONFIG; }
760#line 761 "dhcp6_parser.cc"
761 break;
762
763 case 6: // $@3: %empty
764#line 314 "dhcp6_parser.yy"
765 { ctx.ctx_ = ctx.DHCP6; }
766#line 767 "dhcp6_parser.cc"
767 break;
768
769 case 8: // $@4: %empty
770#line 315 "dhcp6_parser.yy"
771 { ctx.ctx_ = ctx.INTERFACES_CONFIG; }
772#line 773 "dhcp6_parser.cc"
773 break;
774
775 case 10: // $@5: %empty
776#line 316 "dhcp6_parser.yy"
777 { ctx.ctx_ = ctx.SUBNET6; }
778#line 779 "dhcp6_parser.cc"
779 break;
780
781 case 12: // $@6: %empty
782#line 317 "dhcp6_parser.yy"
783 { ctx.ctx_ = ctx.POOLS; }
784#line 785 "dhcp6_parser.cc"
785 break;
786
787 case 14: // $@7: %empty
788#line 318 "dhcp6_parser.yy"
789 { ctx.ctx_ = ctx.PD_POOLS; }
790#line 791 "dhcp6_parser.cc"
791 break;
792
793 case 16: // $@8: %empty
794#line 319 "dhcp6_parser.yy"
795 { ctx.ctx_ = ctx.RESERVATIONS; }
796#line 797 "dhcp6_parser.cc"
797 break;
798
799 case 18: // $@9: %empty
800#line 320 "dhcp6_parser.yy"
801 { ctx.ctx_ = ctx.DHCP6; }
802#line 803 "dhcp6_parser.cc"
803 break;
804
805 case 20: // $@10: %empty
806#line 321 "dhcp6_parser.yy"
807 { ctx.ctx_ = ctx.OPTION_DEF; }
808#line 809 "dhcp6_parser.cc"
809 break;
810
811 case 22: // $@11: %empty
812#line 322 "dhcp6_parser.yy"
813 { ctx.ctx_ = ctx.OPTION_DATA; }
814#line 815 "dhcp6_parser.cc"
815 break;
816
817 case 24: // $@12: %empty
818#line 323 "dhcp6_parser.yy"
819 { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
820#line 821 "dhcp6_parser.cc"
821 break;
822
823 case 26: // $@13: %empty
824#line 324 "dhcp6_parser.yy"
825 { ctx.ctx_ = ctx.DHCP_DDNS; }
826#line 827 "dhcp6_parser.cc"
827 break;
828
829 case 28: // $@14: %empty
830#line 325 "dhcp6_parser.yy"
831 { ctx.ctx_ = ctx.CONFIG_CONTROL; }
832#line 833 "dhcp6_parser.cc"
833 break;
834
835 case 30: // value: "integer"
836#line 333 "dhcp6_parser.yy"
837 { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); }
838#line 839 "dhcp6_parser.cc"
839 break;
840
841 case 31: // value: "floating point"
842#line 334 "dhcp6_parser.yy"
843 { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); }
844#line 845 "dhcp6_parser.cc"
845 break;
846
847 case 32: // value: "boolean"
848#line 335 "dhcp6_parser.yy"
849 { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); }
850#line 851 "dhcp6_parser.cc"
851 break;
852
853 case 33: // value: "constant string"
854#line 336 "dhcp6_parser.yy"
855 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); }
856#line 857 "dhcp6_parser.cc"
857 break;
858
859 case 34: // value: "null"
860#line 337 "dhcp6_parser.yy"
861 { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
862#line 863 "dhcp6_parser.cc"
863 break;
864
865 case 35: // value: map2
866#line 338 "dhcp6_parser.yy"
867 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
868#line 869 "dhcp6_parser.cc"
869 break;
870
871 case 36: // value: list_generic
872#line 339 "dhcp6_parser.yy"
873 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
874#line 875 "dhcp6_parser.cc"
875 break;
876
877 case 37: // sub_json: value
878#line 342 "dhcp6_parser.yy"
879 {
880 // Push back the JSON value on the stack
881 ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ());
882}
883#line 884 "dhcp6_parser.cc"
884 break;
885
886 case 38: // $@15: %empty
887#line 347 "dhcp6_parser.yy"
888 {
889 // This code is executed when we're about to start parsing
890 // the content of the map
891 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
892 ctx.stack_.push_back(m);
893}
894#line 895 "dhcp6_parser.cc"
895 break;
896
897 case 39: // map2: "{" $@15 map_content "}"
898#line 352 "dhcp6_parser.yy"
899 {
900 // map parsing completed. If we ever want to do any wrap up
901 // (maybe some sanity checking), this would be the best place
902 // for it.
903}
904#line 905 "dhcp6_parser.cc"
905 break;
906
907 case 40: // map_value: map2
908#line 358 "dhcp6_parser.yy"
909 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
910#line 911 "dhcp6_parser.cc"
911 break;
912
913 case 43: // not_empty_map: "constant string" ":" value
914#line 365 "dhcp6_parser.yy"
915 {
916 // map containing a single entry
917 ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
918 ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
919 }
920#line 921 "dhcp6_parser.cc"
921 break;
922
923 case 44: // not_empty_map: not_empty_map "," "constant string" ":" value
924#line 370 "dhcp6_parser.yy"
925 {
926 // map consisting of a shorter map followed by
927 // comma and string:value
928 ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
929 ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
930 }
931#line 932 "dhcp6_parser.cc"
932 break;
933
934 case 45: // not_empty_map: not_empty_map ","
935#line 376 "dhcp6_parser.yy"
936 {
937 ctx.warnAboutExtraCommas(yystack_[0].location);
938 }
939#line 940 "dhcp6_parser.cc"
940 break;
941
942 case 46: // $@16: %empty
943#line 381 "dhcp6_parser.yy"
944 {
945 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
946 ctx.stack_.push_back(l);
947}
948#line 949 "dhcp6_parser.cc"
949 break;
950
951 case 47: // list_generic: "[" $@16 list_content "]"
952#line 384 "dhcp6_parser.yy"
953 {
954 // list parsing complete. Put any sanity checking here
955}
956#line 957 "dhcp6_parser.cc"
957 break;
958
959 case 50: // not_empty_list: value
960#line 392 "dhcp6_parser.yy"
961 {
962 // List consisting of a single element.
963 ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
964 }
965#line 966 "dhcp6_parser.cc"
966 break;
967
968 case 51: // not_empty_list: not_empty_list "," value
969#line 396 "dhcp6_parser.yy"
970 {
971 // List ending with , and a value.
972 ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
973 }
974#line 975 "dhcp6_parser.cc"
975 break;
976
977 case 52: // not_empty_list: not_empty_list ","
978#line 400 "dhcp6_parser.yy"
979 {
980 ctx.warnAboutExtraCommas(yystack_[0].location);
981 }
982#line 983 "dhcp6_parser.cc"
983 break;
984
985 case 53: // $@17: %empty
986#line 406 "dhcp6_parser.yy"
987 {
988 // List parsing about to start
989}
990#line 991 "dhcp6_parser.cc"
991 break;
992
993 case 54: // list_strings: "[" $@17 list_strings_content "]"
994#line 408 "dhcp6_parser.yy"
995 {
996 // list parsing complete. Put any sanity checking here
997 //ctx.stack_.pop_back();
998}
999#line 1000 "dhcp6_parser.cc"
1000 break;
1001
1002 case 57: // not_empty_list_strings: "constant string"
1003#line 417 "dhcp6_parser.yy"
1004 {
1005 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1006 ctx.stack_.back()->add(s);
1007 }
1008#line 1009 "dhcp6_parser.cc"
1009 break;
1010
1011 case 58: // not_empty_list_strings: not_empty_list_strings "," "constant string"
1012#line 421 "dhcp6_parser.yy"
1013 {
1014 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1015 ctx.stack_.back()->add(s);
1016 }
1017#line 1018 "dhcp6_parser.cc"
1018 break;
1019
1020 case 59: // not_empty_list_strings: not_empty_list_strings ","
1021#line 425 "dhcp6_parser.yy"
1022 {
1023 ctx.warnAboutExtraCommas(yystack_[0].location);
1024 }
1025#line 1026 "dhcp6_parser.cc"
1026 break;
1027
1028 case 60: // unknown_map_entry: "constant string" ":"
1029#line 435 "dhcp6_parser.yy"
1030 {
1031 const std::string& where = ctx.contextName();
1032 const std::string& keyword = yystack_[1].value.as < std::string > ();
1033 error(yystack_[1].location,
1034 "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
1035}
1036#line 1037 "dhcp6_parser.cc"
1037 break;
1038
1039 case 61: // $@18: %empty
1040#line 444 "dhcp6_parser.yy"
1041 {
1042 // This code is executed when we're about to start parsing
1043 // the content of the map
1044 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1045 ctx.stack_.push_back(m);
1046}
1047#line 1048 "dhcp6_parser.cc"
1048 break;
1049
1050 case 62: // syntax_map: "{" $@18 global_object "}"
1051#line 449 "dhcp6_parser.yy"
1052 {
1053 // map parsing completed. If we ever want to do any wrap up
1054 // (maybe some sanity checking), this would be the best place
1055 // for it.
1056
1057 // Dhcp6 is required
1058 ctx.require("Dhcp6", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
1059}
1060#line 1061 "dhcp6_parser.cc"
1061 break;
1062
1063 case 63: // $@19: %empty
1064#line 459 "dhcp6_parser.yy"
1065 {
1066 // This code is executed when we're about to start parsing
1067 // the content of the map
1068 // Prevent against duplicate.
1069 ctx.unique("Dhcp6", ctx.loc2pos(yystack_[0].location));
1070 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1071 ctx.stack_.back()->set("Dhcp6", m);
1072 ctx.stack_.push_back(m);
1073 ctx.enter(ctx.DHCP6);
1074}
1075#line 1076 "dhcp6_parser.cc"
1076 break;
1077
1078 case 64: // global_object: "Dhcp6" $@19 ":" "{" global_params "}"
1079#line 468 "dhcp6_parser.yy"
1080 {
1081 // No global parameter is required
1082 ctx.stack_.pop_back();
1083 ctx.leave();
1084}
1085#line 1086 "dhcp6_parser.cc"
1086 break;
1087
1088 case 66: // global_object_comma: global_object ","
1089#line 476 "dhcp6_parser.yy"
1090 {
1091 ctx.warnAboutExtraCommas(yystack_[0].location);
1092}
1093#line 1094 "dhcp6_parser.cc"
1094 break;
1095
1096 case 67: // $@20: %empty
1097#line 482 "dhcp6_parser.yy"
1098 {
1099 // Parse the Dhcp6 map
1100 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1101 ctx.stack_.push_back(m);
1102}
1103#line 1104 "dhcp6_parser.cc"
1104 break;
1105
1106 case 68: // sub_dhcp6: "{" $@20 global_params "}"
1107#line 486 "dhcp6_parser.yy"
1108 {
1109 // No global parameter is required
1110 // parsing completed
1111}
1112#line 1113 "dhcp6_parser.cc"
1113 break;
1114
1115 case 71: // global_params: global_params ","
1116#line 493 "dhcp6_parser.yy"
1117 {
1118 ctx.warnAboutExtraCommas(yystack_[0].location);
1119 }
1120#line 1121 "dhcp6_parser.cc"
1121 break;
1122
1123 case 140: // $@21: %empty
1124#line 570 "dhcp6_parser.yy"
1125 {
1126 ctx.unique("data-directory", ctx.loc2pos(yystack_[0].location));
1127 ctx.enter(ctx.NO_KEYWORD);
1128}
1129#line 1130 "dhcp6_parser.cc"
1130 break;
1131
1132 case 141: // data_directory: "data-directory" $@21 ":" "constant string"
1133#line 573 "dhcp6_parser.yy"
1134 {
1135 ElementPtr datadir(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1136 ctx.stack_.back()->set("data-directory", datadir);
1137 ctx.leave();
1138}
1139#line 1140 "dhcp6_parser.cc"
1140 break;
1141
1142 case 142: // preferred_lifetime: "preferred-lifetime" ":" "integer"
1143#line 579 "dhcp6_parser.yy"
1144 {
1145 ctx.unique("preferred-lifetime", ctx.loc2pos(yystack_[2].location));
1146 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1147 ctx.stack_.back()->set("preferred-lifetime", prf);
1148}
1149#line 1150 "dhcp6_parser.cc"
1150 break;
1151
1152 case 143: // min_preferred_lifetime: "min-preferred-lifetime" ":" "integer"
1153#line 585 "dhcp6_parser.yy"
1154 {
1155 ctx.unique("min-preferred-lifetime", ctx.loc2pos(yystack_[2].location));
1156 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1157 ctx.stack_.back()->set("min-preferred-lifetime", prf);
1158}
1159#line 1160 "dhcp6_parser.cc"
1160 break;
1161
1162 case 144: // max_preferred_lifetime: "max-preferred-lifetime" ":" "integer"
1163#line 591 "dhcp6_parser.yy"
1164 {
1165 ctx.unique("max-preferred-lifetime", ctx.loc2pos(yystack_[2].location));
1166 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1167 ctx.stack_.back()->set("max-preferred-lifetime", prf);
1168}
1169#line 1170 "dhcp6_parser.cc"
1170 break;
1171
1172 case 145: // valid_lifetime: "valid-lifetime" ":" "integer"
1173#line 597 "dhcp6_parser.yy"
1174 {
1175 ctx.unique("valid-lifetime", ctx.loc2pos(yystack_[2].location));
1176 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1177 ctx.stack_.back()->set("valid-lifetime", prf);
1178}
1179#line 1180 "dhcp6_parser.cc"
1180 break;
1181
1182 case 146: // min_valid_lifetime: "min-valid-lifetime" ":" "integer"
1183#line 603 "dhcp6_parser.yy"
1184 {
1185 ctx.unique("min-valid-lifetime", ctx.loc2pos(yystack_[2].location));
1186 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1187 ctx.stack_.back()->set("min-valid-lifetime", prf);
1188}
1189#line 1190 "dhcp6_parser.cc"
1190 break;
1191
1192 case 147: // max_valid_lifetime: "max-valid-lifetime" ":" "integer"
1193#line 609 "dhcp6_parser.yy"
1194 {
1195 ctx.unique("max-valid-lifetime", ctx.loc2pos(yystack_[2].location));
1196 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1197 ctx.stack_.back()->set("max-valid-lifetime", prf);
1198}
1199#line 1200 "dhcp6_parser.cc"
1200 break;
1201
1202 case 148: // renew_timer: "renew-timer" ":" "integer"
1203#line 615 "dhcp6_parser.yy"
1204 {
1205 ctx.unique("renew-timer", ctx.loc2pos(yystack_[2].location));
1206 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1207 ctx.stack_.back()->set("renew-timer", prf);
1208}
1209#line 1210 "dhcp6_parser.cc"
1210 break;
1211
1212 case 149: // rebind_timer: "rebind-timer" ":" "integer"
1213#line 621 "dhcp6_parser.yy"
1214 {
1215 ctx.unique("rebind-timer", ctx.loc2pos(yystack_[2].location));
1216 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1217 ctx.stack_.back()->set("rebind-timer", prf);
1218}
1219#line 1220 "dhcp6_parser.cc"
1220 break;
1221
1222 case 150: // calculate_tee_times: "calculate-tee-times" ":" "boolean"
1223#line 627 "dhcp6_parser.yy"
1224 {
1225 ctx.unique("calculate-tee-times", ctx.loc2pos(yystack_[2].location));
1226 ElementPtr ctt(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1227 ctx.stack_.back()->set("calculate-tee-times", ctt);
1228}
1229#line 1230 "dhcp6_parser.cc"
1230 break;
1231
1232 case 151: // t1_percent: "t1-percent" ":" "floating point"
1233#line 633 "dhcp6_parser.yy"
1234 {
1235 ctx.unique("t1-percent", ctx.loc2pos(yystack_[2].location));
1236 ElementPtr t1(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1237 ctx.stack_.back()->set("t1-percent", t1);
1238}
1239#line 1240 "dhcp6_parser.cc"
1240 break;
1241
1242 case 152: // t2_percent: "t2-percent" ":" "floating point"
1243#line 639 "dhcp6_parser.yy"
1244 {
1245 ctx.unique("t2-percent", ctx.loc2pos(yystack_[2].location));
1246 ElementPtr t2(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1247 ctx.stack_.back()->set("t2-percent", t2);
1248}
1249#line 1250 "dhcp6_parser.cc"
1250 break;
1251
1252 case 153: // cache_threshold: "cache-threshold" ":" "floating point"
1253#line 645 "dhcp6_parser.yy"
1254 {
1255 ctx.unique("cache-threshold", ctx.loc2pos(yystack_[2].location));
1256 ElementPtr ct(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1257 ctx.stack_.back()->set("cache-threshold", ct);
1258}
1259#line 1260 "dhcp6_parser.cc"
1260 break;
1261
1262 case 154: // cache_max_age: "cache-max-age" ":" "integer"
1263#line 651 "dhcp6_parser.yy"
1264 {
1265 ctx.unique("cache-max-age", ctx.loc2pos(yystack_[2].location));
1266 ElementPtr cm(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1267 ctx.stack_.back()->set("cache-max-age", cm);
1268}
1269#line 1270 "dhcp6_parser.cc"
1270 break;
1271
1272 case 155: // decline_probation_period: "decline-probation-period" ":" "integer"
1273#line 657 "dhcp6_parser.yy"
1274 {
1275 ctx.unique("decline-probation-period", ctx.loc2pos(yystack_[2].location));
1276 ElementPtr dpp(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1277 ctx.stack_.back()->set("decline-probation-period", dpp);
1278}
1279#line 1280 "dhcp6_parser.cc"
1280 break;
1281
1282 case 156: // ddns_send_updates: "ddns-send-updates" ":" "boolean"
1283#line 663 "dhcp6_parser.yy"
1284 {
1285 ctx.unique("ddns-send-updates", ctx.loc2pos(yystack_[2].location));
1286 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1287 ctx.stack_.back()->set("ddns-send-updates", b);
1288}
1289#line 1290 "dhcp6_parser.cc"
1290 break;
1291
1292 case 157: // ddns_override_no_update: "ddns-override-no-update" ":" "boolean"
1293#line 669 "dhcp6_parser.yy"
1294 {
1295 ctx.unique("ddns-override-no-update", ctx.loc2pos(yystack_[2].location));
1296 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1297 ctx.stack_.back()->set("ddns-override-no-update", b);
1298}
1299#line 1300 "dhcp6_parser.cc"
1300 break;
1301
1302 case 158: // ddns_override_client_update: "ddns-override-client-update" ":" "boolean"
1303#line 675 "dhcp6_parser.yy"
1304 {
1305 ctx.unique("ddns-override-client-update", ctx.loc2pos(yystack_[2].location));
1306 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1307 ctx.stack_.back()->set("ddns-override-client-update", b);
1308}
1309#line 1310 "dhcp6_parser.cc"
1310 break;
1311
1312 case 159: // $@22: %empty
1313#line 681 "dhcp6_parser.yy"
1314 {
1315 ctx.enter(ctx.REPLACE_CLIENT_NAME);
1316 ctx.unique("ddns-replace-client-name", ctx.loc2pos(yystack_[0].location));
1317}
1318#line 1319 "dhcp6_parser.cc"
1319 break;
1320
1321 case 160: // ddns_replace_client_name: "ddns-replace-client-name" $@22 ":" ddns_replace_client_name_value
1322#line 684 "dhcp6_parser.yy"
1323 {
1324 ctx.stack_.back()->set("ddns-replace-client-name", yystack_[0].value.as < ElementPtr > ());
1325 ctx.leave();
1326}
1327#line 1328 "dhcp6_parser.cc"
1328 break;
1329
1330 case 161: // ddns_replace_client_name_value: "when-present"
1331#line 690 "dhcp6_parser.yy"
1332 {
1333 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location)));
1334 }
1335#line 1336 "dhcp6_parser.cc"
1336 break;
1337
1338 case 162: // ddns_replace_client_name_value: "never"
1339#line 693 "dhcp6_parser.yy"
1340 {
1341 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location)));
1342 }
1343#line 1344 "dhcp6_parser.cc"
1344 break;
1345
1346 case 163: // ddns_replace_client_name_value: "always"
1347#line 696 "dhcp6_parser.yy"
1348 {
1349 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location)));
1350 }
1351#line 1352 "dhcp6_parser.cc"
1352 break;
1353
1354 case 164: // ddns_replace_client_name_value: "when-not-present"
1355#line 699 "dhcp6_parser.yy"
1356 {
1357 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location)));
1358 }
1359#line 1360 "dhcp6_parser.cc"
1360 break;
1361
1362 case 165: // ddns_replace_client_name_value: "boolean"
1363#line 702 "dhcp6_parser.yy"
1364 {
1365 error(yystack_[0].location, "boolean values for the ddns-replace-client-name are "
1366 "no longer supported");
1367 }
1368#line 1369 "dhcp6_parser.cc"
1369 break;
1370
1371 case 166: // $@23: %empty
1372#line 708 "dhcp6_parser.yy"
1373 {
1374 ctx.unique("ddns-generated-prefix", ctx.loc2pos(yystack_[0].location));
1375 ctx.enter(ctx.NO_KEYWORD);
1376}
1377#line 1378 "dhcp6_parser.cc"
1378 break;
1379
1380 case 167: // ddns_generated_prefix: "ddns-generated-prefix" $@23 ":" "constant string"
1381#line 711 "dhcp6_parser.yy"
1382 {
1383 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1384 ctx.stack_.back()->set("ddns-generated-prefix", s);
1385 ctx.leave();
1386}
1387#line 1388 "dhcp6_parser.cc"
1388 break;
1389
1390 case 168: // $@24: %empty
1391#line 717 "dhcp6_parser.yy"
1392 {
1393 ctx.unique("ddns-qualifying-suffix", ctx.loc2pos(yystack_[0].location));
1394 ctx.enter(ctx.NO_KEYWORD);
1395}
1396#line 1397 "dhcp6_parser.cc"
1397 break;
1398
1399 case 169: // ddns_qualifying_suffix: "ddns-qualifying-suffix" $@24 ":" "constant string"
1400#line 720 "dhcp6_parser.yy"
1401 {
1402 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1403 ctx.stack_.back()->set("ddns-qualifying-suffix", s);
1404 ctx.leave();
1405}
1406#line 1407 "dhcp6_parser.cc"
1407 break;
1408
1409 case 170: // ddns_update_on_renew: "ddns-update-on-renew" ":" "boolean"
1410#line 726 "dhcp6_parser.yy"
1411 {
1412 ctx.unique("ddns-update-on-renew", ctx.loc2pos(yystack_[2].location));
1413 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1414 ctx.stack_.back()->set("ddns-update-on-renew", b);
1415}
1416#line 1417 "dhcp6_parser.cc"
1417 break;
1418
1419 case 171: // ddns_use_conflict_resolution: "ddns-use-conflict-resolution" ":" "boolean"
1420#line 735 "dhcp6_parser.yy"
1421 {
1422 ctx.unique("ddns-use-conflict-resolution", ctx.loc2pos(yystack_[2].location));
1423 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1424 ctx.warning(yystack_[1].location, "ddns-use-conflict-resolution is deprecated. "
1425 "Substituting ddns-conflict-resolution-mode");
1426 ElementPtr mode(new StringElement(b->boolValue() ? "check-with-dhcid"
1427 : "no-check-with-dhcid"));
1428 ctx.stack_.back()->set("ddns-conflict-resolution-mode", mode);
1429}
1430#line 1431 "dhcp6_parser.cc"
1431 break;
1432
1433 case 172: // $@25: %empty
1434#line 745 "dhcp6_parser.yy"
1435 {
1436 ctx.unique("ddns-conflict-resolution-mode", ctx.loc2pos(yystack_[0].location));
1438}
1439#line 1440 "dhcp6_parser.cc"
1440 break;
1441
1442 case 173: // ddns_conflict_resolution_mode: "ddns-conflict-resolution-mode" $@25 ":" ddns_conflict_resolution_mode_value
1443#line 748 "dhcp6_parser.yy"
1444 {
1445 ctx.stack_.back()->set("ddns-conflict-resolution-mode", yystack_[0].value.as < ElementPtr > ());
1446 ctx.leave();
1447}
1448#line 1449 "dhcp6_parser.cc"
1449 break;
1450
1451 case 174: // ddns_conflict_resolution_mode_value: "check-with-dhcid"
1452#line 754 "dhcp6_parser.yy"
1453 {
1454 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("check-with-dhcid", ctx.loc2pos(yystack_[0].location)));
1455 }
1456#line 1457 "dhcp6_parser.cc"
1457 break;
1458
1459 case 175: // ddns_conflict_resolution_mode_value: "no-check-with-dhcid"
1460#line 757 "dhcp6_parser.yy"
1461 {
1462 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("no-check-with-dhcid", ctx.loc2pos(yystack_[0].location)));
1463 }
1464#line 1465 "dhcp6_parser.cc"
1465 break;
1466
1467 case 176: // ddns_conflict_resolution_mode_value: "check-exists-with-dhcid"
1468#line 760 "dhcp6_parser.yy"
1469 {
1470 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("check-exists-with-dhcid", ctx.loc2pos(yystack_[0].location)));
1471 }
1472#line 1473 "dhcp6_parser.cc"
1473 break;
1474
1475 case 177: // ddns_conflict_resolution_mode_value: "no-check-without-dhcid"
1476#line 763 "dhcp6_parser.yy"
1477 {
1478 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("no-check-without-dhcid", ctx.loc2pos(yystack_[0].location)));
1479 }
1480#line 1481 "dhcp6_parser.cc"
1481 break;
1482
1483 case 178: // ddns_ttl_percent: "ddns-ttl-percent" ":" "floating point"
1484#line 768 "dhcp6_parser.yy"
1485 {
1486 ctx.unique("ddns-ttl-percent", ctx.loc2pos(yystack_[2].location));
1487 ElementPtr ttl(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1488 ctx.stack_.back()->set("ddns-ttl-percent", ttl);
1489}
1490#line 1491 "dhcp6_parser.cc"
1491 break;
1492
1493 case 179: // $@26: %empty
1494#line 774 "dhcp6_parser.yy"
1495 {
1496 ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location));
1497 ctx.enter(ctx.NO_KEYWORD);
1498}
1499#line 1500 "dhcp6_parser.cc"
1500 break;
1501
1502 case 180: // hostname_char_set: "hostname-char-set" $@26 ":" "constant string"
1503#line 777 "dhcp6_parser.yy"
1504 {
1505 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1506 ctx.stack_.back()->set("hostname-char-set", s);
1507 ctx.leave();
1508}
1509#line 1510 "dhcp6_parser.cc"
1510 break;
1511
1512 case 181: // $@27: %empty
1513#line 783 "dhcp6_parser.yy"
1514 {
1515 ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location));
1516 ctx.enter(ctx.NO_KEYWORD);
1517}
1518#line 1519 "dhcp6_parser.cc"
1519 break;
1520
1521 case 182: // hostname_char_replacement: "hostname-char-replacement" $@27 ":" "constant string"
1522#line 786 "dhcp6_parser.yy"
1523 {
1524 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1525 ctx.stack_.back()->set("hostname-char-replacement", s);
1526 ctx.leave();
1527}
1528#line 1529 "dhcp6_parser.cc"
1529 break;
1530
1531 case 183: // store_extended_info: "store-extended-info" ":" "boolean"
1532#line 792 "dhcp6_parser.yy"
1533 {
1534 ctx.unique("store-extended-info", ctx.loc2pos(yystack_[2].location));
1535 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1536 ctx.stack_.back()->set("store-extended-info", b);
1537}
1538#line 1539 "dhcp6_parser.cc"
1539 break;
1540
1541 case 184: // statistic_default_sample_count: "statistic-default-sample-count" ":" "integer"
1542#line 798 "dhcp6_parser.yy"
1543 {
1544 ctx.unique("statistic-default-sample-count", ctx.loc2pos(yystack_[2].location));
1545 ElementPtr count(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1546 ctx.stack_.back()->set("statistic-default-sample-count", count);
1547}
1548#line 1549 "dhcp6_parser.cc"
1549 break;
1550
1551 case 185: // statistic_default_sample_age: "statistic-default-sample-age" ":" "integer"
1552#line 804 "dhcp6_parser.yy"
1553 {
1554 ctx.unique("statistic-default-sample-age", ctx.loc2pos(yystack_[2].location));
1555 ElementPtr age(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1556 ctx.stack_.back()->set("statistic-default-sample-age", age);
1557}
1558#line 1559 "dhcp6_parser.cc"
1559 break;
1560
1561 case 186: // $@28: %empty
1562#line 810 "dhcp6_parser.yy"
1563 {
1564 ctx.unique("server-tag", ctx.loc2pos(yystack_[0].location));
1565 ctx.enter(ctx.NO_KEYWORD);
1566}
1567#line 1568 "dhcp6_parser.cc"
1568 break;
1569
1570 case 187: // server_tag: "server-tag" $@28 ":" "constant string"
1571#line 813 "dhcp6_parser.yy"
1572 {
1573 ElementPtr stag(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1574 ctx.stack_.back()->set("server-tag", stag);
1575 ctx.leave();
1576}
1577#line 1578 "dhcp6_parser.cc"
1578 break;
1579
1580 case 188: // parked_packet_limit: "parked-packet-limit" ":" "integer"
1581#line 819 "dhcp6_parser.yy"
1582 {
1583 ctx.unique("parked-packet-limit", ctx.loc2pos(yystack_[2].location));
1584 ElementPtr ppl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1585 ctx.stack_.back()->set("parked-packet-limit", ppl);
1586}
1587#line 1588 "dhcp6_parser.cc"
1588 break;
1589
1590 case 189: // $@29: %empty
1591#line 825 "dhcp6_parser.yy"
1592 {
1593 ctx.unique("allocator", ctx.loc2pos(yystack_[0].location));
1594 ctx.enter(ctx.NO_KEYWORD);
1595}
1596#line 1597 "dhcp6_parser.cc"
1597 break;
1598
1599 case 190: // allocator: "allocator" $@29 ":" "constant string"
1600#line 828 "dhcp6_parser.yy"
1601 {
1602 ElementPtr al(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1603 ctx.stack_.back()->set("allocator", al);
1604 ctx.leave();
1605}
1606#line 1607 "dhcp6_parser.cc"
1607 break;
1608
1609 case 191: // $@30: %empty
1610#line 834 "dhcp6_parser.yy"
1611 {
1612 ctx.unique("pd-allocator", ctx.loc2pos(yystack_[0].location));
1613 ctx.enter(ctx.NO_KEYWORD);
1614}
1615#line 1616 "dhcp6_parser.cc"
1616 break;
1617
1618 case 192: // pd_allocator: "pd-allocator" $@30 ":" "constant string"
1619#line 837 "dhcp6_parser.yy"
1620 {
1621 ElementPtr al(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1622 ctx.stack_.back()->set("pd-allocator", al);
1623 ctx.leave();
1624}
1625#line 1626 "dhcp6_parser.cc"
1626 break;
1627
1628 case 193: // early_global_reservations_lookup: "early-global-reservations-lookup" ":" "boolean"
1629#line 843 "dhcp6_parser.yy"
1630 {
1631 ctx.unique("early-global-reservations-lookup", ctx.loc2pos(yystack_[2].location));
1632 ElementPtr early(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1633 ctx.stack_.back()->set("early-global-reservations-lookup", early);
1634}
1635#line 1636 "dhcp6_parser.cc"
1636 break;
1637
1638 case 194: // ip_reservations_unique: "ip-reservations-unique" ":" "boolean"
1639#line 849 "dhcp6_parser.yy"
1640 {
1641 ctx.unique("ip-reservations-unique", ctx.loc2pos(yystack_[2].location));
1642 ElementPtr unique(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1643 ctx.stack_.back()->set("ip-reservations-unique", unique);
1644}
1645#line 1646 "dhcp6_parser.cc"
1646 break;
1647
1648 case 195: // reservations_lookup_first: "reservations-lookup-first" ":" "boolean"
1649#line 855 "dhcp6_parser.yy"
1650 {
1651 ctx.unique("reservations-lookup-first", ctx.loc2pos(yystack_[2].location));
1652 ElementPtr first(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1653 ctx.stack_.back()->set("reservations-lookup-first", first);
1654}
1655#line 1656 "dhcp6_parser.cc"
1656 break;
1657
1658 case 196: // $@31: %empty
1659#line 861 "dhcp6_parser.yy"
1660 {
1661 ctx.unique("interfaces-config", ctx.loc2pos(yystack_[0].location));
1662 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
1663 ctx.stack_.back()->set("interfaces-config", i);
1664 ctx.stack_.push_back(i);
1665 ctx.enter(ctx.INTERFACES_CONFIG);
1666}
1667#line 1668 "dhcp6_parser.cc"
1668 break;
1669
1670 case 197: // interfaces_config: "interfaces-config" $@31 ":" "{" interfaces_config_params "}"
1671#line 867 "dhcp6_parser.yy"
1672 {
1673 // No interfaces config param is required
1674 ctx.stack_.pop_back();
1675 ctx.leave();
1676}
1677#line 1678 "dhcp6_parser.cc"
1678 break;
1679
1680 case 198: // $@32: %empty
1681#line 873 "dhcp6_parser.yy"
1682 {
1683 // Parse the interfaces-config map
1684 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1685 ctx.stack_.push_back(m);
1686}
1687#line 1688 "dhcp6_parser.cc"
1688 break;
1689
1690 case 199: // sub_interfaces6: "{" $@32 interfaces_config_params "}"
1691#line 877 "dhcp6_parser.yy"
1692 {
1693 // No interfaces config param is required
1694 // parsing completed
1695}
1696#line 1697 "dhcp6_parser.cc"
1697 break;
1698
1699 case 202: // interfaces_config_params: interfaces_config_params ","
1700#line 884 "dhcp6_parser.yy"
1701 {
1702 ctx.warnAboutExtraCommas(yystack_[0].location);
1703 }
1704#line 1705 "dhcp6_parser.cc"
1705 break;
1706
1707 case 211: // $@33: %empty
1708#line 899 "dhcp6_parser.yy"
1709 {
1710 ctx.unique("interfaces", ctx.loc2pos(yystack_[0].location));
1711 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1712 ctx.stack_.back()->set("interfaces", l);
1713 ctx.stack_.push_back(l);
1714 ctx.enter(ctx.NO_KEYWORD);
1715}
1716#line 1717 "dhcp6_parser.cc"
1717 break;
1718
1719 case 212: // interfaces_list: "interfaces" $@33 ":" list_strings
1720#line 905 "dhcp6_parser.yy"
1721 {
1722 ctx.stack_.pop_back();
1723 ctx.leave();
1724}
1725#line 1726 "dhcp6_parser.cc"
1726 break;
1727
1728 case 213: // re_detect: "re-detect" ":" "boolean"
1729#line 910 "dhcp6_parser.yy"
1730 {
1731 ctx.unique("re-detect", ctx.loc2pos(yystack_[2].location));
1732 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1733 ctx.stack_.back()->set("re-detect", b);
1734}
1735#line 1736 "dhcp6_parser.cc"
1736 break;
1737
1738 case 214: // service_sockets_require_all: "service-sockets-require-all" ":" "boolean"
1739#line 916 "dhcp6_parser.yy"
1740 {
1741 ctx.unique("service-sockets-require-all", ctx.loc2pos(yystack_[2].location));
1742 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1743 ctx.stack_.back()->set("service-sockets-require-all", b);
1744}
1745#line 1746 "dhcp6_parser.cc"
1746 break;
1747
1748 case 215: // service_sockets_retry_wait_time: "service-sockets-retry-wait-time" ":" "integer"
1749#line 922 "dhcp6_parser.yy"
1750 {
1751 ctx.unique("service-sockets-retry-wait-time", ctx.loc2pos(yystack_[2].location));
1752 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1753 ctx.stack_.back()->set("service-sockets-retry-wait-time", n);
1754}
1755#line 1756 "dhcp6_parser.cc"
1756 break;
1757
1758 case 216: // service_sockets_max_retries: "service-sockets-max-retries" ":" "integer"
1759#line 928 "dhcp6_parser.yy"
1760 {
1761 ctx.unique("service-sockets-max-retries", ctx.loc2pos(yystack_[2].location));
1762 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1763 ctx.stack_.back()->set("service-sockets-max-retries", n);
1764}
1765#line 1766 "dhcp6_parser.cc"
1766 break;
1767
1768 case 217: // $@34: %empty
1769#line 934 "dhcp6_parser.yy"
1770 {
1771 ctx.unique("lease-database", ctx.loc2pos(yystack_[0].location));
1772 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
1773 ctx.stack_.back()->set("lease-database", i);
1774 ctx.stack_.push_back(i);
1775 ctx.enter(ctx.LEASE_DATABASE);
1776}
1777#line 1778 "dhcp6_parser.cc"
1778 break;
1779
1780 case 218: // lease_database: "lease-database" $@34 ":" "{" database_map_params "}"
1781#line 940 "dhcp6_parser.yy"
1782 {
1783 // The type parameter is required
1784 ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
1785 ctx.stack_.pop_back();
1786 ctx.leave();
1787}
1788#line 1789 "dhcp6_parser.cc"
1789 break;
1790
1791 case 219: // $@35: %empty
1792#line 947 "dhcp6_parser.yy"
1793 {
1794 ctx.unique("hosts-database", ctx.loc2pos(yystack_[0].location));
1795 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
1796 ctx.stack_.back()->set("hosts-database", i);
1797 ctx.stack_.push_back(i);
1798 ctx.enter(ctx.HOSTS_DATABASE);
1799}
1800#line 1801 "dhcp6_parser.cc"
1801 break;
1802
1803 case 220: // hosts_database: "hosts-database" $@35 ":" "{" database_map_params "}"
1804#line 953 "dhcp6_parser.yy"
1805 {
1806 // The type parameter is required
1807 ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
1808 ctx.stack_.pop_back();
1809 ctx.leave();
1810}
1811#line 1812 "dhcp6_parser.cc"
1812 break;
1813
1814 case 221: // $@36: %empty
1815#line 960 "dhcp6_parser.yy"
1816 {
1817 ctx.unique("hosts-databases", ctx.loc2pos(yystack_[0].location));
1818 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1819 ctx.stack_.back()->set("hosts-databases", l);
1820 ctx.stack_.push_back(l);
1821 ctx.enter(ctx.HOSTS_DATABASE);
1822}
1823#line 1824 "dhcp6_parser.cc"
1824 break;
1825
1826 case 222: // hosts_databases: "hosts-databases" $@36 ":" "[" database_list "]"
1827#line 966 "dhcp6_parser.yy"
1828 {
1829 ctx.stack_.pop_back();
1830 ctx.leave();
1831}
1832#line 1833 "dhcp6_parser.cc"
1833 break;
1834
1835 case 227: // not_empty_database_list: not_empty_database_list ","
1836#line 977 "dhcp6_parser.yy"
1837 {
1838 ctx.warnAboutExtraCommas(yystack_[0].location);
1839 }
1840#line 1841 "dhcp6_parser.cc"
1841 break;
1842
1843 case 228: // $@37: %empty
1844#line 982 "dhcp6_parser.yy"
1845 {
1846 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1847 ctx.stack_.back()->add(m);
1848 ctx.stack_.push_back(m);
1849}
1850#line 1851 "dhcp6_parser.cc"
1851 break;
1852
1853 case 229: // database: "{" $@37 database_map_params "}"
1854#line 986 "dhcp6_parser.yy"
1855 {
1856 // The type parameter is required
1857 ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
1858 ctx.stack_.pop_back();
1859}
1860#line 1861 "dhcp6_parser.cc"
1861 break;
1862
1863 case 232: // database_map_params: database_map_params ","
1864#line 994 "dhcp6_parser.yy"
1865 {
1866 ctx.warnAboutExtraCommas(yystack_[0].location);
1867 }
1868#line 1869 "dhcp6_parser.cc"
1869 break;
1870
1871 case 256: // $@38: %empty
1872#line 1024 "dhcp6_parser.yy"
1873 {
1874 ctx.unique("type", ctx.loc2pos(yystack_[0].location));
1875 ctx.enter(ctx.DATABASE_TYPE);
1876}
1877#line 1878 "dhcp6_parser.cc"
1878 break;
1879
1880 case 257: // database_type: "type" $@38 ":" db_type
1881#line 1027 "dhcp6_parser.yy"
1882 {
1883 ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ());
1884 ctx.leave();
1885}
1886#line 1887 "dhcp6_parser.cc"
1887 break;
1888
1889 case 258: // db_type: "memfile"
1890#line 1032 "dhcp6_parser.yy"
1891 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); }
1892#line 1893 "dhcp6_parser.cc"
1893 break;
1894
1895 case 259: // db_type: "mysql"
1896#line 1033 "dhcp6_parser.yy"
1897 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); }
1898#line 1899 "dhcp6_parser.cc"
1899 break;
1900
1901 case 260: // db_type: "postgresql"
1902#line 1034 "dhcp6_parser.yy"
1903 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); }
1904#line 1905 "dhcp6_parser.cc"
1905 break;
1906
1907 case 261: // $@39: %empty
1908#line 1037 "dhcp6_parser.yy"
1909 {
1910 ctx.unique("user", ctx.loc2pos(yystack_[0].location));
1911 ctx.enter(ctx.NO_KEYWORD);
1912}
1913#line 1914 "dhcp6_parser.cc"
1914 break;
1915
1916 case 262: // user: "user" $@39 ":" "constant string"
1917#line 1040 "dhcp6_parser.yy"
1918 {
1919 ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1920 ctx.stack_.back()->set("user", user);
1921 ctx.leave();
1922}
1923#line 1924 "dhcp6_parser.cc"
1924 break;
1925
1926 case 263: // $@40: %empty
1927#line 1046 "dhcp6_parser.yy"
1928 {
1929 ctx.unique("password", ctx.loc2pos(yystack_[0].location));
1930 ctx.enter(ctx.NO_KEYWORD);
1931}
1932#line 1933 "dhcp6_parser.cc"
1933 break;
1934
1935 case 264: // password: "password" $@40 ":" "constant string"
1936#line 1049 "dhcp6_parser.yy"
1937 {
1938 ElementPtr pwd(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1939 ctx.stack_.back()->set("password", pwd);
1940 ctx.leave();
1941}
1942#line 1943 "dhcp6_parser.cc"
1943 break;
1944
1945 case 265: // $@41: %empty
1946#line 1055 "dhcp6_parser.yy"
1947 {
1948 ctx.unique("host", ctx.loc2pos(yystack_[0].location));
1949 ctx.enter(ctx.NO_KEYWORD);
1950}
1951#line 1952 "dhcp6_parser.cc"
1952 break;
1953
1954 case 266: // host: "host" $@41 ":" "constant string"
1955#line 1058 "dhcp6_parser.yy"
1956 {
1957 ElementPtr h(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1958 ctx.stack_.back()->set("host", h);
1959 ctx.leave();
1960}
1961#line 1962 "dhcp6_parser.cc"
1962 break;
1963
1964 case 267: // port: "port" ":" "integer"
1965#line 1064 "dhcp6_parser.yy"
1966 {
1967 ctx.unique("port", ctx.loc2pos(yystack_[2].location));
1968 ElementPtr p(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1969 ctx.stack_.back()->set("port", p);
1970}
1971#line 1972 "dhcp6_parser.cc"
1972 break;
1973
1974 case 268: // $@42: %empty
1975#line 1070 "dhcp6_parser.yy"
1976 {
1977 ctx.unique("name", ctx.loc2pos(yystack_[0].location));
1978 ctx.enter(ctx.NO_KEYWORD);
1979}
1980#line 1981 "dhcp6_parser.cc"
1981 break;
1982
1983 case 269: // name: "name" $@42 ":" "constant string"
1984#line 1073 "dhcp6_parser.yy"
1985 {
1986 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1987 ctx.stack_.back()->set("name", name);
1988 ctx.leave();
1989}
1990#line 1991 "dhcp6_parser.cc"
1991 break;
1992
1993 case 270: // persist: "persist" ":" "boolean"
1994#line 1079 "dhcp6_parser.yy"
1995 {
1996 ctx.unique("persist", ctx.loc2pos(yystack_[2].location));
1997 ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1998 ctx.stack_.back()->set("persist", n);
1999}
2000#line 2001 "dhcp6_parser.cc"
2001 break;
2002
2003 case 271: // lfc_interval: "lfc-interval" ":" "integer"
2004#line 1085 "dhcp6_parser.yy"
2005 {
2006 ctx.unique("lfc-interval", ctx.loc2pos(yystack_[2].location));
2007 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2008 ctx.stack_.back()->set("lfc-interval", n);
2009}
2010#line 2011 "dhcp6_parser.cc"
2011 break;
2012
2013 case 272: // readonly: "readonly" ":" "boolean"
2014#line 1091 "dhcp6_parser.yy"
2015 {
2016 ctx.unique("readonly", ctx.loc2pos(yystack_[2].location));
2017 ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2018 ctx.stack_.back()->set("readonly", n);
2019}
2020#line 2021 "dhcp6_parser.cc"
2021 break;
2022
2023 case 273: // connect_timeout: "connect-timeout" ":" "integer"
2024#line 1097 "dhcp6_parser.yy"
2025 {
2026 ctx.unique("connect-timeout", ctx.loc2pos(yystack_[2].location));
2027 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2028 ctx.stack_.back()->set("connect-timeout", n);
2029}
2030#line 2031 "dhcp6_parser.cc"
2031 break;
2032
2033 case 274: // read_timeout: "read-timeout" ":" "integer"
2034#line 1103 "dhcp6_parser.yy"
2035 {
2036 ctx.unique("read-timeout", ctx.loc2pos(yystack_[2].location));
2037 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2038 ctx.stack_.back()->set("read-timeout", n);
2039}
2040#line 2041 "dhcp6_parser.cc"
2041 break;
2042
2043 case 275: // write_timeout: "write-timeout" ":" "integer"
2044#line 1109 "dhcp6_parser.yy"
2045 {
2046 ctx.unique("write-timeout", ctx.loc2pos(yystack_[2].location));
2047 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2048 ctx.stack_.back()->set("write-timeout", n);
2049}
2050#line 2051 "dhcp6_parser.cc"
2051 break;
2052
2053 case 276: // tcp_user_timeout: "tcp-user-timeout" ":" "integer"
2054#line 1115 "dhcp6_parser.yy"
2055 {
2056 ctx.unique("tcp-user-timeout", ctx.loc2pos(yystack_[2].location));
2057 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2058 ctx.stack_.back()->set("tcp-user-timeout", n);
2059}
2060#line 2061 "dhcp6_parser.cc"
2061 break;
2062
2063 case 277: // reconnect_wait_time: "reconnect-wait-time" ":" "integer"
2064#line 1122 "dhcp6_parser.yy"
2065 {
2066 ctx.unique("reconnect-wait-time", ctx.loc2pos(yystack_[2].location));
2067 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2068 ctx.stack_.back()->set("reconnect-wait-time", n);
2069}
2070#line 2071 "dhcp6_parser.cc"
2071 break;
2072
2073 case 278: // $@43: %empty
2074#line 1128 "dhcp6_parser.yy"
2075 {
2076 ctx.unique("on-fail", ctx.loc2pos(yystack_[0].location));
2077 ctx.enter(ctx.DATABASE_ON_FAIL);
2078}
2079#line 2080 "dhcp6_parser.cc"
2080 break;
2081
2082 case 279: // on_fail: "on-fail" $@43 ":" on_fail_mode
2083#line 1131 "dhcp6_parser.yy"
2084 {
2085 ctx.stack_.back()->set("on-fail", yystack_[0].value.as < ElementPtr > ());
2086 ctx.leave();
2087}
2088#line 2089 "dhcp6_parser.cc"
2089 break;
2090
2091 case 280: // on_fail_mode: "stop-retry-exit"
2092#line 1136 "dhcp6_parser.yy"
2093 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("stop-retry-exit", ctx.loc2pos(yystack_[0].location))); }
2094#line 2095 "dhcp6_parser.cc"
2095 break;
2096
2097 case 281: // on_fail_mode: "serve-retry-exit"
2098#line 1137 "dhcp6_parser.yy"
2099 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-exit", ctx.loc2pos(yystack_[0].location))); }
2100#line 2101 "dhcp6_parser.cc"
2101 break;
2102
2103 case 282: // on_fail_mode: "serve-retry-continue"
2104#line 1138 "dhcp6_parser.yy"
2105 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-continue", ctx.loc2pos(yystack_[0].location))); }
2106#line 2107 "dhcp6_parser.cc"
2107 break;
2108
2109 case 283: // retry_on_startup: "retry-on-startup" ":" "boolean"
2110#line 1141 "dhcp6_parser.yy"
2111 {
2112 ctx.unique("retry-on-startup", ctx.loc2pos(yystack_[2].location));
2113 ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2114 ctx.stack_.back()->set("retry-on-startup", n);
2115}
2116#line 2117 "dhcp6_parser.cc"
2117 break;
2118
2119 case 284: // max_row_errors: "max-row-errors" ":" "integer"
2120#line 1147 "dhcp6_parser.yy"
2121 {
2122 ctx.unique("max-row-errors", ctx.loc2pos(yystack_[2].location));
2123 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2124 ctx.stack_.back()->set("max-row-errors", n);
2125}
2126#line 2127 "dhcp6_parser.cc"
2127 break;
2128
2129 case 285: // max_reconnect_tries: "max-reconnect-tries" ":" "integer"
2130#line 1153 "dhcp6_parser.yy"
2131 {
2132 ctx.unique("max-reconnect-tries", ctx.loc2pos(yystack_[2].location));
2133 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2134 ctx.stack_.back()->set("max-reconnect-tries", n);
2135}
2136#line 2137 "dhcp6_parser.cc"
2137 break;
2138
2139 case 286: // $@44: %empty
2140#line 1159 "dhcp6_parser.yy"
2141 {
2142 ctx.unique("trust-anchor", ctx.loc2pos(yystack_[0].location));
2143 ctx.enter(ctx.NO_KEYWORD);
2144}
2145#line 2146 "dhcp6_parser.cc"
2146 break;
2147
2148 case 287: // trust_anchor: "trust-anchor" $@44 ":" "constant string"
2149#line 1162 "dhcp6_parser.yy"
2150 {
2151 ElementPtr ca(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2152 ctx.stack_.back()->set("trust-anchor", ca);
2153 ctx.leave();
2154}
2155#line 2156 "dhcp6_parser.cc"
2156 break;
2157
2158 case 288: // $@45: %empty
2159#line 1168 "dhcp6_parser.yy"
2160 {
2161 ctx.unique("cert-file", ctx.loc2pos(yystack_[0].location));
2162 ctx.enter(ctx.NO_KEYWORD);
2163}
2164#line 2165 "dhcp6_parser.cc"
2165 break;
2166
2167 case 289: // cert_file: "cert-file" $@45 ":" "constant string"
2168#line 1171 "dhcp6_parser.yy"
2169 {
2170 ElementPtr cert(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2171 ctx.stack_.back()->set("cert-file", cert);
2172 ctx.leave();
2173}
2174#line 2175 "dhcp6_parser.cc"
2175 break;
2176
2177 case 290: // $@46: %empty
2178#line 1177 "dhcp6_parser.yy"
2179 {
2180 ctx.unique("key-file", ctx.loc2pos(yystack_[0].location));
2181 ctx.enter(ctx.NO_KEYWORD);
2182}
2183#line 2184 "dhcp6_parser.cc"
2184 break;
2185
2186 case 291: // key_file: "key-file" $@46 ":" "constant string"
2187#line 1180 "dhcp6_parser.yy"
2188 {
2189 ElementPtr key(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2190 ctx.stack_.back()->set("key-file", key);
2191 ctx.leave();
2192}
2193#line 2194 "dhcp6_parser.cc"
2194 break;
2195
2196 case 292: // $@47: %empty
2197#line 1186 "dhcp6_parser.yy"
2198 {
2199 ctx.unique("cipher-list", ctx.loc2pos(yystack_[0].location));
2200 ctx.enter(ctx.NO_KEYWORD);
2201}
2202#line 2203 "dhcp6_parser.cc"
2203 break;
2204
2205 case 293: // cipher_list: "cipher-list" $@47 ":" "constant string"
2206#line 1189 "dhcp6_parser.yy"
2207 {
2208 ElementPtr cl(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2209 ctx.stack_.back()->set("cipher-list", cl);
2210 ctx.leave();
2211}
2212#line 2213 "dhcp6_parser.cc"
2213 break;
2214
2215 case 294: // $@48: %empty
2216#line 1195 "dhcp6_parser.yy"
2217 {
2218 ctx.unique("sanity-checks", ctx.loc2pos(yystack_[0].location));
2219 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2220 ctx.stack_.back()->set("sanity-checks", m);
2221 ctx.stack_.push_back(m);
2222 ctx.enter(ctx.SANITY_CHECKS);
2223}
2224#line 2225 "dhcp6_parser.cc"
2225 break;
2226
2227 case 295: // sanity_checks: "sanity-checks" $@48 ":" "{" sanity_checks_params "}"
2228#line 1201 "dhcp6_parser.yy"
2229 {
2230 ctx.stack_.pop_back();
2231 ctx.leave();
2232}
2233#line 2234 "dhcp6_parser.cc"
2234 break;
2235
2236 case 298: // sanity_checks_params: sanity_checks_params ","
2237#line 1208 "dhcp6_parser.yy"
2238 {
2239 ctx.warnAboutExtraCommas(yystack_[0].location);
2240 }
2241#line 2242 "dhcp6_parser.cc"
2242 break;
2243
2244 case 301: // $@49: %empty
2245#line 1217 "dhcp6_parser.yy"
2246 {
2247 ctx.unique("lease-checks", ctx.loc2pos(yystack_[0].location));
2248 ctx.enter(ctx.NO_KEYWORD);
2249}
2250#line 2251 "dhcp6_parser.cc"
2251 break;
2252
2253 case 302: // lease_checks: "lease-checks" $@49 ":" "constant string"
2254#line 1220 "dhcp6_parser.yy"
2255 {
2256
2257 if ( (string(yystack_[0].value.as < std::string > ()) == "none") ||
2258 (string(yystack_[0].value.as < std::string > ()) == "warn") ||
2259 (string(yystack_[0].value.as < std::string > ()) == "fix") ||
2260 (string(yystack_[0].value.as < std::string > ()) == "fix-del") ||
2261 (string(yystack_[0].value.as < std::string > ()) == "del")) {
2262 ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2263 ctx.stack_.back()->set("lease-checks", user);
2264 ctx.leave();
2265 } else {
2266 error(yystack_[0].location, "Unsupported 'lease-checks value: " + string(yystack_[0].value.as < std::string > ()) +
2267 ", supported values are: none, warn, fix, fix-del, del");
2268 }
2269}
2270#line 2271 "dhcp6_parser.cc"
2271 break;
2272
2273 case 303: // $@50: %empty
2274#line 1236 "dhcp6_parser.yy"
2275 {
2276 ctx.unique("extended-info-checks", ctx.loc2pos(yystack_[0].location));
2277 ctx.enter(ctx.NO_KEYWORD);
2278}
2279#line 2280 "dhcp6_parser.cc"
2280 break;
2281
2282 case 304: // extended_info_checks: "extended-info-checks" $@50 ":" "constant string"
2283#line 1239 "dhcp6_parser.yy"
2284 {
2285
2286 if ( (string(yystack_[0].value.as < std::string > ()) == "none") ||
2287 (string(yystack_[0].value.as < std::string > ()) == "fix") ||
2288 (string(yystack_[0].value.as < std::string > ()) == "strict") ||
2289 (string(yystack_[0].value.as < std::string > ()) == "pedantic")) {
2290 ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2291 ctx.stack_.back()->set("extended-info-checks", user);
2292 ctx.leave();
2293 } else {
2294 error(yystack_[0].location, "Unsupported 'extended-info-checks value: " + string(yystack_[0].value.as < std::string > ()) +
2295 ", supported values are: none, fix, strict, pedantic");
2296 }
2297}
2298#line 2299 "dhcp6_parser.cc"
2299 break;
2300
2301 case 305: // $@51: %empty
2302#line 1254 "dhcp6_parser.yy"
2303 {
2304 ctx.unique("mac-sources", ctx.loc2pos(yystack_[0].location));
2305 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2306 ctx.stack_.back()->set("mac-sources", l);
2307 ctx.stack_.push_back(l);
2308 ctx.enter(ctx.MAC_SOURCES);
2309}
2310#line 2311 "dhcp6_parser.cc"
2311 break;
2312
2313 case 306: // mac_sources: "mac-sources" $@51 ":" "[" mac_sources_list "]"
2314#line 1260 "dhcp6_parser.yy"
2315 {
2316 ctx.stack_.pop_back();
2317 ctx.leave();
2318}
2319#line 2320 "dhcp6_parser.cc"
2320 break;
2321
2322 case 309: // mac_sources_list: mac_sources_list ","
2323#line 1267 "dhcp6_parser.yy"
2324 {
2325 ctx.warnAboutExtraCommas(yystack_[0].location);
2326 }
2327#line 2328 "dhcp6_parser.cc"
2328 break;
2329
2330 case 312: // duid_id: "duid"
2331#line 1276 "dhcp6_parser.yy"
2332 {
2333 ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location)));
2334 ctx.stack_.back()->add(duid);
2335}
2336#line 2337 "dhcp6_parser.cc"
2337 break;
2338
2339 case 313: // string_id: "constant string"
2340#line 1281 "dhcp6_parser.yy"
2341 {
2342 ElementPtr duid(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2343 ctx.stack_.back()->add(duid);
2344}
2345#line 2346 "dhcp6_parser.cc"
2346 break;
2347
2348 case 314: // $@52: %empty
2349#line 1286 "dhcp6_parser.yy"
2350 {
2351 ctx.unique("host-reservation-identifiers", ctx.loc2pos(yystack_[0].location));
2352 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2353 ctx.stack_.back()->set("host-reservation-identifiers", l);
2354 ctx.stack_.push_back(l);
2356}
2357#line 2358 "dhcp6_parser.cc"
2358 break;
2359
2360 case 315: // host_reservation_identifiers: "host-reservation-identifiers" $@52 ":" "[" host_reservation_identifiers_list "]"
2361#line 1292 "dhcp6_parser.yy"
2362 {
2363 ctx.stack_.pop_back();
2364 ctx.leave();
2365}
2366#line 2367 "dhcp6_parser.cc"
2367 break;
2368
2369 case 318: // host_reservation_identifiers_list: host_reservation_identifiers_list ","
2370#line 1299 "dhcp6_parser.yy"
2371 {
2372 ctx.warnAboutExtraCommas(yystack_[0].location);
2373 }
2374#line 2375 "dhcp6_parser.cc"
2375 break;
2376
2377 case 322: // hw_address_id: "hw-address"
2378#line 1309 "dhcp6_parser.yy"
2379 {
2380 ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location)));
2381 ctx.stack_.back()->add(hwaddr);
2382}
2383#line 2384 "dhcp6_parser.cc"
2384 break;
2385
2386 case 323: // flex_id: "flex-id"
2387#line 1314 "dhcp6_parser.yy"
2388 {
2389 ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location)));
2390 ctx.stack_.back()->add(flex_id);
2391}
2392#line 2393 "dhcp6_parser.cc"
2393 break;
2394
2395 case 324: // $@53: %empty
2396#line 1321 "dhcp6_parser.yy"
2397 {
2398 ctx.unique("relay-supplied-options", ctx.loc2pos(yystack_[0].location));
2399 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2400 ctx.stack_.back()->set("relay-supplied-options", l);
2401 ctx.stack_.push_back(l);
2402 ctx.enter(ctx.NO_KEYWORD);
2403}
2404#line 2405 "dhcp6_parser.cc"
2405 break;
2406
2407 case 325: // relay_supplied_options: "relay-supplied-options" $@53 ":" "[" list_content "]"
2408#line 1327 "dhcp6_parser.yy"
2409 {
2410 ctx.stack_.pop_back();
2411 ctx.leave();
2412}
2413#line 2414 "dhcp6_parser.cc"
2414 break;
2415
2416 case 326: // $@54: %empty
2417#line 1334 "dhcp6_parser.yy"
2418 {
2419 ctx.unique("multi-threading", ctx.loc2pos(yystack_[0].location));
2420 ElementPtr mt(new MapElement(ctx.loc2pos(yystack_[0].location)));
2421 ctx.stack_.back()->set("multi-threading", mt);
2422 ctx.stack_.push_back(mt);
2423 ctx.enter(ctx.DHCP_MULTI_THREADING);
2424}
2425#line 2426 "dhcp6_parser.cc"
2426 break;
2427
2428 case 327: // dhcp_multi_threading: "multi-threading" $@54 ":" "{" multi_threading_params "}"
2429#line 1340 "dhcp6_parser.yy"
2430 {
2431 // The enable parameter is required.
2432 ctx.require("enable-multi-threading", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
2433 ctx.stack_.pop_back();
2434 ctx.leave();
2435}
2436#line 2437 "dhcp6_parser.cc"
2437 break;
2438
2439 case 330: // multi_threading_params: multi_threading_params ","
2440#line 1349 "dhcp6_parser.yy"
2441 {
2442 ctx.warnAboutExtraCommas(yystack_[0].location);
2443 }
2444#line 2445 "dhcp6_parser.cc"
2445 break;
2446
2447 case 337: // enable_multi_threading: "enable-multi-threading" ":" "boolean"
2448#line 1362 "dhcp6_parser.yy"
2449 {
2450 ctx.unique("enable-multi-threading", ctx.loc2pos(yystack_[2].location));
2451 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2452 ctx.stack_.back()->set("enable-multi-threading", b);
2453}
2454#line 2455 "dhcp6_parser.cc"
2455 break;
2456
2457 case 338: // thread_pool_size: "thread-pool-size" ":" "integer"
2458#line 1368 "dhcp6_parser.yy"
2459 {
2460 ctx.unique("thread-pool-size", ctx.loc2pos(yystack_[2].location));
2461 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2462 ctx.stack_.back()->set("thread-pool-size", prf);
2463}
2464#line 2465 "dhcp6_parser.cc"
2465 break;
2466
2467 case 339: // packet_queue_size: "packet-queue-size" ":" "integer"
2468#line 1374 "dhcp6_parser.yy"
2469 {
2470 ctx.unique("packet-queue-size", ctx.loc2pos(yystack_[2].location));
2471 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2472 ctx.stack_.back()->set("packet-queue-size", prf);
2473}
2474#line 2475 "dhcp6_parser.cc"
2475 break;
2476
2477 case 340: // $@55: %empty
2478#line 1380 "dhcp6_parser.yy"
2479 {
2480 ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location));
2481 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2482 ctx.stack_.back()->set("hooks-libraries", l);
2483 ctx.stack_.push_back(l);
2484 ctx.enter(ctx.HOOKS_LIBRARIES);
2485}
2486#line 2487 "dhcp6_parser.cc"
2487 break;
2488
2489 case 341: // hooks_libraries: "hooks-libraries" $@55 ":" "[" hooks_libraries_list "]"
2490#line 1386 "dhcp6_parser.yy"
2491 {
2492 ctx.stack_.pop_back();
2493 ctx.leave();
2494}
2495#line 2496 "dhcp6_parser.cc"
2496 break;
2497
2498 case 346: // not_empty_hooks_libraries_list: not_empty_hooks_libraries_list ","
2499#line 1397 "dhcp6_parser.yy"
2500 {
2501 ctx.warnAboutExtraCommas(yystack_[0].location);
2502 }
2503#line 2504 "dhcp6_parser.cc"
2504 break;
2505
2506 case 347: // $@56: %empty
2507#line 1402 "dhcp6_parser.yy"
2508 {
2509 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2510 ctx.stack_.back()->add(m);
2511 ctx.stack_.push_back(m);
2512}
2513#line 2514 "dhcp6_parser.cc"
2514 break;
2515
2516 case 348: // hooks_library: "{" $@56 hooks_params "}"
2517#line 1406 "dhcp6_parser.yy"
2518 {
2519 // The library hooks parameter is required
2520 ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2521 ctx.stack_.pop_back();
2522}
2523#line 2524 "dhcp6_parser.cc"
2524 break;
2525
2526 case 349: // $@57: %empty
2527#line 1412 "dhcp6_parser.yy"
2528 {
2529 // Parse the hooks-libraries list entry map
2530 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2531 ctx.stack_.push_back(m);
2532}
2533#line 2534 "dhcp6_parser.cc"
2534 break;
2535
2536 case 350: // sub_hooks_library: "{" $@57 hooks_params "}"
2537#line 1416 "dhcp6_parser.yy"
2538 {
2539 // The library hooks parameter is required
2540 ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2541 // parsing completed
2542}
2543#line 2544 "dhcp6_parser.cc"
2544 break;
2545
2546 case 353: // hooks_params: hooks_params ","
2547#line 1424 "dhcp6_parser.yy"
2548 {
2549 ctx.warnAboutExtraCommas(yystack_[0].location);
2550 }
2551#line 2552 "dhcp6_parser.cc"
2552 break;
2553
2554 case 357: // $@58: %empty
2555#line 1434 "dhcp6_parser.yy"
2556 {
2557 ctx.unique("library", ctx.loc2pos(yystack_[0].location));
2558 ctx.enter(ctx.NO_KEYWORD);
2559}
2560#line 2561 "dhcp6_parser.cc"
2561 break;
2562
2563 case 358: // library: "library" $@58 ":" "constant string"
2564#line 1437 "dhcp6_parser.yy"
2565 {
2566 ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2567 ctx.stack_.back()->set("library", lib);
2568 ctx.leave();
2569}
2570#line 2571 "dhcp6_parser.cc"
2571 break;
2572
2573 case 359: // $@59: %empty
2574#line 1443 "dhcp6_parser.yy"
2575 {
2576 ctx.unique("parameters", ctx.loc2pos(yystack_[0].location));
2577 ctx.enter(ctx.NO_KEYWORD);
2578}
2579#line 2580 "dhcp6_parser.cc"
2580 break;
2581
2582 case 360: // parameters: "parameters" $@59 ":" map_value
2583#line 1446 "dhcp6_parser.yy"
2584 {
2585 ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ());
2586 ctx.leave();
2587}
2588#line 2589 "dhcp6_parser.cc"
2589 break;
2590
2591 case 361: // $@60: %empty
2592#line 1452 "dhcp6_parser.yy"
2593 {
2594 ctx.unique("expired-leases-processing", ctx.loc2pos(yystack_[0].location));
2595 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2596 ctx.stack_.back()->set("expired-leases-processing", m);
2597 ctx.stack_.push_back(m);
2599}
2600#line 2601 "dhcp6_parser.cc"
2601 break;
2602
2603 case 362: // expired_leases_processing: "expired-leases-processing" $@60 ":" "{" expired_leases_params "}"
2604#line 1458 "dhcp6_parser.yy"
2605 {
2606 // No expired lease parameter is required
2607 ctx.stack_.pop_back();
2608 ctx.leave();
2609}
2610#line 2611 "dhcp6_parser.cc"
2611 break;
2612
2613 case 365: // expired_leases_params: expired_leases_params ","
2614#line 1466 "dhcp6_parser.yy"
2615 {
2616 ctx.warnAboutExtraCommas(yystack_[0].location);
2617 }
2618#line 2619 "dhcp6_parser.cc"
2619 break;
2620
2621 case 372: // reclaim_timer_wait_time: "reclaim-timer-wait-time" ":" "integer"
2622#line 1479 "dhcp6_parser.yy"
2623 {
2624 ctx.unique("reclaim-timer-wait-time", ctx.loc2pos(yystack_[2].location));
2625 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2626 ctx.stack_.back()->set("reclaim-timer-wait-time", value);
2627}
2628#line 2629 "dhcp6_parser.cc"
2629 break;
2630
2631 case 373: // flush_reclaimed_timer_wait_time: "flush-reclaimed-timer-wait-time" ":" "integer"
2632#line 1485 "dhcp6_parser.yy"
2633 {
2634 ctx.unique("flush-reclaimed-timer-wait-time", ctx.loc2pos(yystack_[2].location));
2635 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2636 ctx.stack_.back()->set("flush-reclaimed-timer-wait-time", value);
2637}
2638#line 2639 "dhcp6_parser.cc"
2639 break;
2640
2641 case 374: // hold_reclaimed_time: "hold-reclaimed-time" ":" "integer"
2642#line 1491 "dhcp6_parser.yy"
2643 {
2644 ctx.unique("hold-reclaimed-time", ctx.loc2pos(yystack_[2].location));
2645 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2646 ctx.stack_.back()->set("hold-reclaimed-time", value);
2647}
2648#line 2649 "dhcp6_parser.cc"
2649 break;
2650
2651 case 375: // max_reclaim_leases: "max-reclaim-leases" ":" "integer"
2652#line 1497 "dhcp6_parser.yy"
2653 {
2654 ctx.unique("max-reclaim-leases", ctx.loc2pos(yystack_[2].location));
2655 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2656 ctx.stack_.back()->set("max-reclaim-leases", value);
2657}
2658#line 2659 "dhcp6_parser.cc"
2659 break;
2660
2661 case 376: // max_reclaim_time: "max-reclaim-time" ":" "integer"
2662#line 1503 "dhcp6_parser.yy"
2663 {
2664 ctx.unique("max-reclaim-time", ctx.loc2pos(yystack_[2].location));
2665 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2666 ctx.stack_.back()->set("max-reclaim-time", value);
2667}
2668#line 2669 "dhcp6_parser.cc"
2669 break;
2670
2671 case 377: // unwarned_reclaim_cycles: "unwarned-reclaim-cycles" ":" "integer"
2672#line 1509 "dhcp6_parser.yy"
2673 {
2674 ctx.unique("unwarned-reclaim-cycles", ctx.loc2pos(yystack_[2].location));
2675 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2676 ctx.stack_.back()->set("unwarned-reclaim-cycles", value);
2677}
2678#line 2679 "dhcp6_parser.cc"
2679 break;
2680
2681 case 378: // $@61: %empty
2682#line 1518 "dhcp6_parser.yy"
2683 {
2684 ctx.unique("subnet6", ctx.loc2pos(yystack_[0].location));
2685 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2686 ctx.stack_.back()->set("subnet6", l);
2687 ctx.stack_.push_back(l);
2688 ctx.enter(ctx.SUBNET6);
2689}
2690#line 2691 "dhcp6_parser.cc"
2691 break;
2692
2693 case 379: // subnet6_list: "subnet6" $@61 ":" "[" subnet6_list_content "]"
2694#line 1524 "dhcp6_parser.yy"
2695 {
2696 ctx.stack_.pop_back();
2697 ctx.leave();
2698}
2699#line 2700 "dhcp6_parser.cc"
2700 break;
2701
2702 case 384: // not_empty_subnet6_list: not_empty_subnet6_list ","
2703#line 1538 "dhcp6_parser.yy"
2704 {
2705 ctx.warnAboutExtraCommas(yystack_[0].location);
2706 }
2707#line 2708 "dhcp6_parser.cc"
2708 break;
2709
2710 case 385: // $@62: %empty
2711#line 1547 "dhcp6_parser.yy"
2712 {
2713 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2714 ctx.stack_.back()->add(m);
2715 ctx.stack_.push_back(m);
2716}
2717#line 2718 "dhcp6_parser.cc"
2718 break;
2719
2720 case 386: // subnet6: "{" $@62 subnet6_params "}"
2721#line 1551 "dhcp6_parser.yy"
2722 {
2723 // Once we reached this place, the subnet parsing is now complete.
2724 // If we want to, we can implement default values here.
2725 // In particular we can do things like this:
2726 // if (!ctx.stack_.back()->get("interface")) {
2727 // ctx.stack_.back()->set("interface", StringElement("loopback"));
2728 // }
2729 //
2730 // We can also stack up one level (Dhcp6) and copy over whatever
2731 // global parameters we want to:
2732 // if (!ctx.stack_.back()->get("renew-timer")) {
2733 // ElementPtr renew = ctx_stack_[...].get("renew-timer");
2734 // if (renew) {
2735 // ctx.stack_.back()->set("renew-timer", renew);
2736 // }
2737 // }
2738
2739 // The subnet subnet6 parameter is required
2740 ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2741 ctx.stack_.pop_back();
2742}
2743#line 2744 "dhcp6_parser.cc"
2744 break;
2745
2746 case 387: // $@63: %empty
2747#line 1573 "dhcp6_parser.yy"
2748 {
2749 // Parse the subnet6 list entry map
2750 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2751 ctx.stack_.push_back(m);
2752}
2753#line 2754 "dhcp6_parser.cc"
2754 break;
2755
2756 case 388: // sub_subnet6: "{" $@63 subnet6_params "}"
2757#line 1577 "dhcp6_parser.yy"
2758 {
2759 // The subnet subnet6 parameter is required
2760 ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2761 // parsing completed
2762}
2763#line 2764 "dhcp6_parser.cc"
2764 break;
2765
2766 case 391: // subnet6_params: subnet6_params ","
2767#line 1586 "dhcp6_parser.yy"
2768 {
2769 ctx.warnAboutExtraCommas(yystack_[0].location);
2770 }
2771#line 2772 "dhcp6_parser.cc"
2772 break;
2773
2774 case 438: // $@64: %empty
2775#line 1640 "dhcp6_parser.yy"
2776 {
2777 ctx.unique("subnet", ctx.loc2pos(yystack_[0].location));
2778 ctx.enter(ctx.NO_KEYWORD);
2779}
2780#line 2781 "dhcp6_parser.cc"
2781 break;
2782
2783 case 439: // subnet: "subnet" $@64 ":" "constant string"
2784#line 1643 "dhcp6_parser.yy"
2785 {
2786 ElementPtr subnet(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2787 ctx.stack_.back()->set("subnet", subnet);
2788 ctx.leave();
2789}
2790#line 2791 "dhcp6_parser.cc"
2791 break;
2792
2793 case 440: // $@65: %empty
2794#line 1649 "dhcp6_parser.yy"
2795 {
2796 ctx.unique("interface", ctx.loc2pos(yystack_[0].location));
2797 ctx.enter(ctx.NO_KEYWORD);
2798}
2799#line 2800 "dhcp6_parser.cc"
2800 break;
2801
2802 case 441: // interface: "interface" $@65 ":" "constant string"
2803#line 1652 "dhcp6_parser.yy"
2804 {
2805 ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2806 ctx.stack_.back()->set("interface", iface);
2807 ctx.leave();
2808}
2809#line 2810 "dhcp6_parser.cc"
2810 break;
2811
2812 case 442: // $@66: %empty
2813#line 1658 "dhcp6_parser.yy"
2814 {
2815 ctx.unique("interface-id", ctx.loc2pos(yystack_[0].location));
2816 ctx.enter(ctx.NO_KEYWORD);
2817}
2818#line 2819 "dhcp6_parser.cc"
2819 break;
2820
2821 case 443: // interface_id: "interface-id" $@66 ":" "constant string"
2822#line 1661 "dhcp6_parser.yy"
2823 {
2824 ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2825 ctx.stack_.back()->set("interface-id", iface);
2826 ctx.leave();
2827}
2828#line 2829 "dhcp6_parser.cc"
2829 break;
2830
2831 case 444: // $@67: %empty
2832#line 1667 "dhcp6_parser.yy"
2833 {
2834 ctx.unique("client-class", ctx.loc2pos(yystack_[0].location));
2835 ctx.enter(ctx.NO_KEYWORD);
2836}
2837#line 2838 "dhcp6_parser.cc"
2838 break;
2839
2840 case 445: // client_class: "client-class" $@67 ":" "constant string"
2841#line 1670 "dhcp6_parser.yy"
2842 {
2843 ElementPtr cls(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2844 ctx.stack_.back()->set("client-class", cls);
2845 ctx.leave();
2846}
2847#line 2848 "dhcp6_parser.cc"
2848 break;
2849
2850 case 446: // $@68: %empty
2851#line 1676 "dhcp6_parser.yy"
2852 {
2853 ctx.unique("require-client-classes", ctx.loc2pos(yystack_[0].location));
2854 ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
2855 ctx.stack_.back()->set("require-client-classes", c);
2856 ctx.stack_.push_back(c);
2857 ctx.enter(ctx.NO_KEYWORD);
2858}
2859#line 2860 "dhcp6_parser.cc"
2860 break;
2861
2862 case 447: // require_client_classes: "require-client-classes" $@68 ":" list_strings
2863#line 1682 "dhcp6_parser.yy"
2864 {
2865 ctx.stack_.pop_back();
2866 ctx.leave();
2867}
2868#line 2869 "dhcp6_parser.cc"
2869 break;
2870
2871 case 448: // reservations_global: "reservations-global" ":" "boolean"
2872#line 1687 "dhcp6_parser.yy"
2873 {
2874 ctx.unique("reservations-global", ctx.loc2pos(yystack_[2].location));
2875 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2876 ctx.stack_.back()->set("reservations-global", b);
2877}
2878#line 2879 "dhcp6_parser.cc"
2879 break;
2880
2881 case 449: // reservations_in_subnet: "reservations-in-subnet" ":" "boolean"
2882#line 1693 "dhcp6_parser.yy"
2883 {
2884 ctx.unique("reservations-in-subnet", ctx.loc2pos(yystack_[2].location));
2885 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2886 ctx.stack_.back()->set("reservations-in-subnet", b);
2887}
2888#line 2889 "dhcp6_parser.cc"
2889 break;
2890
2891 case 450: // reservations_out_of_pool: "reservations-out-of-pool" ":" "boolean"
2892#line 1699 "dhcp6_parser.yy"
2893 {
2894 ctx.unique("reservations-out-of-pool", ctx.loc2pos(yystack_[2].location));
2895 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2896 ctx.stack_.back()->set("reservations-out-of-pool", b);
2897}
2898#line 2899 "dhcp6_parser.cc"
2899 break;
2900
2901 case 451: // id: "id" ":" "integer"
2902#line 1705 "dhcp6_parser.yy"
2903 {
2904 ctx.unique("id", ctx.loc2pos(yystack_[2].location));
2905 ElementPtr id(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2906 ctx.stack_.back()->set("id", id);
2907}
2908#line 2909 "dhcp6_parser.cc"
2909 break;
2910
2911 case 452: // rapid_commit: "rapid-commit" ":" "boolean"
2912#line 1711 "dhcp6_parser.yy"
2913 {
2914 ctx.unique("rapid-commit", ctx.loc2pos(yystack_[2].location));
2915 ElementPtr rc(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2916 ctx.stack_.back()->set("rapid-commit", rc);
2917}
2918#line 2919 "dhcp6_parser.cc"
2919 break;
2920
2921 case 453: // $@69: %empty
2922#line 1719 "dhcp6_parser.yy"
2923 {
2924 ctx.unique("shared-networks", ctx.loc2pos(yystack_[0].location));
2925 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2926 ctx.stack_.back()->set("shared-networks", l);
2927 ctx.stack_.push_back(l);
2928 ctx.enter(ctx.SHARED_NETWORK);
2929}
2930#line 2931 "dhcp6_parser.cc"
2931 break;
2932
2933 case 454: // shared_networks: "shared-networks" $@69 ":" "[" shared_networks_content "]"
2934#line 1725 "dhcp6_parser.yy"
2935 {
2936 ctx.stack_.pop_back();
2937 ctx.leave();
2938}
2939#line 2940 "dhcp6_parser.cc"
2940 break;
2941
2942 case 459: // shared_networks_list: shared_networks_list ","
2943#line 1738 "dhcp6_parser.yy"
2944 {
2945 ctx.warnAboutExtraCommas(yystack_[0].location);
2946 }
2947#line 2948 "dhcp6_parser.cc"
2948 break;
2949
2950 case 460: // $@70: %empty
2951#line 1743 "dhcp6_parser.yy"
2952 {
2953 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2954 ctx.stack_.back()->add(m);
2955 ctx.stack_.push_back(m);
2956}
2957#line 2958 "dhcp6_parser.cc"
2958 break;
2959
2960 case 461: // shared_network: "{" $@70 shared_network_params "}"
2961#line 1747 "dhcp6_parser.yy"
2962 {
2963 ctx.stack_.pop_back();
2964}
2965#line 2966 "dhcp6_parser.cc"
2966 break;
2967
2968 case 464: // shared_network_params: shared_network_params ","
2969#line 1753 "dhcp6_parser.yy"
2970 {
2971 ctx.warnAboutExtraCommas(yystack_[0].location);
2972 }
2973#line 2974 "dhcp6_parser.cc"
2974 break;
2975
2976 case 508: // $@71: %empty
2977#line 1807 "dhcp6_parser.yy"
2978 {
2979 ctx.unique("option-def", ctx.loc2pos(yystack_[0].location));
2980 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2981 ctx.stack_.back()->set("option-def", l);
2982 ctx.stack_.push_back(l);
2983 ctx.enter(ctx.OPTION_DEF);
2984}
2985#line 2986 "dhcp6_parser.cc"
2986 break;
2987
2988 case 509: // option_def_list: "option-def" $@71 ":" "[" option_def_list_content "]"
2989#line 1813 "dhcp6_parser.yy"
2990 {
2991 ctx.stack_.pop_back();
2992 ctx.leave();
2993}
2994#line 2995 "dhcp6_parser.cc"
2995 break;
2996
2997 case 510: // $@72: %empty
2998#line 1821 "dhcp6_parser.yy"
2999 {
3000 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3001 ctx.stack_.push_back(m);
3002}
3003#line 3004 "dhcp6_parser.cc"
3004 break;
3005
3006 case 511: // sub_option_def_list: "{" $@72 option_def_list "}"
3007#line 1824 "dhcp6_parser.yy"
3008 {
3009 // parsing completed
3010}
3011#line 3012 "dhcp6_parser.cc"
3012 break;
3013
3014 case 516: // not_empty_option_def_list: not_empty_option_def_list ","
3015#line 1836 "dhcp6_parser.yy"
3016 {
3017 ctx.warnAboutExtraCommas(yystack_[0].location);
3018 }
3019#line 3020 "dhcp6_parser.cc"
3020 break;
3021
3022 case 517: // $@73: %empty
3023#line 1843 "dhcp6_parser.yy"
3024 {
3025 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3026 ctx.stack_.back()->add(m);
3027 ctx.stack_.push_back(m);
3028}
3029#line 3030 "dhcp6_parser.cc"
3030 break;
3031
3032 case 518: // option_def_entry: "{" $@73 option_def_params "}"
3033#line 1847 "dhcp6_parser.yy"
3034 {
3035 // The name, code and type option def parameters are required.
3036 ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3037 ctx.require("code", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3038 ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3039 ctx.stack_.pop_back();
3040}
3041#line 3042 "dhcp6_parser.cc"
3042 break;
3043
3044 case 519: // $@74: %empty
3045#line 1858 "dhcp6_parser.yy"
3046 {
3047 // Parse the option-def list entry map
3048 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3049 ctx.stack_.push_back(m);
3050}
3051#line 3052 "dhcp6_parser.cc"
3052 break;
3053
3054 case 520: // sub_option_def: "{" $@74 option_def_params "}"
3055#line 1862 "dhcp6_parser.yy"
3056 {
3057 // The name, code and type option def parameters are required.
3058 ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3059 ctx.require("code", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3060 ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3061 // parsing completed
3062}
3063#line 3064 "dhcp6_parser.cc"
3064 break;
3065
3066 case 525: // not_empty_option_def_params: not_empty_option_def_params ","
3067#line 1878 "dhcp6_parser.yy"
3068 {
3069 ctx.warnAboutExtraCommas(yystack_[0].location);
3070 }
3071#line 3072 "dhcp6_parser.cc"
3072 break;
3073
3074 case 537: // code: "code" ":" "integer"
3075#line 1897 "dhcp6_parser.yy"
3076 {
3077 ctx.unique("code", ctx.loc2pos(yystack_[2].location));
3078 ElementPtr code(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3079 ctx.stack_.back()->set("code", code);
3080}
3081#line 3082 "dhcp6_parser.cc"
3082 break;
3083
3084 case 539: // $@75: %empty
3085#line 1905 "dhcp6_parser.yy"
3086 {
3087 ctx.unique("type", ctx.loc2pos(yystack_[0].location));
3088 ctx.enter(ctx.NO_KEYWORD);
3089}
3090#line 3091 "dhcp6_parser.cc"
3091 break;
3092
3093 case 540: // option_def_type: "type" $@75 ":" "constant string"
3094#line 1908 "dhcp6_parser.yy"
3095 {
3096 ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3097 ctx.stack_.back()->set("type", prf);
3098 ctx.leave();
3099}
3100#line 3101 "dhcp6_parser.cc"
3101 break;
3102
3103 case 541: // $@76: %empty
3104#line 1914 "dhcp6_parser.yy"
3105 {
3106 ctx.unique("record-types", ctx.loc2pos(yystack_[0].location));
3107 ctx.enter(ctx.NO_KEYWORD);
3108}
3109#line 3110 "dhcp6_parser.cc"
3110 break;
3111
3112 case 542: // option_def_record_types: "record-types" $@76 ":" "constant string"
3113#line 1917 "dhcp6_parser.yy"
3114 {
3115 ElementPtr rtypes(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3116 ctx.stack_.back()->set("record-types", rtypes);
3117 ctx.leave();
3118}
3119#line 3120 "dhcp6_parser.cc"
3120 break;
3121
3122 case 543: // $@77: %empty
3123#line 1923 "dhcp6_parser.yy"
3124 {
3125 ctx.unique("space", ctx.loc2pos(yystack_[0].location));
3126 ctx.enter(ctx.NO_KEYWORD);
3127}
3128#line 3129 "dhcp6_parser.cc"
3129 break;
3130
3131 case 544: // space: "space" $@77 ":" "constant string"
3132#line 1926 "dhcp6_parser.yy"
3133 {
3134 ElementPtr space(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3135 ctx.stack_.back()->set("space", space);
3136 ctx.leave();
3137}
3138#line 3139 "dhcp6_parser.cc"
3139 break;
3140
3141 case 546: // $@78: %empty
3142#line 1934 "dhcp6_parser.yy"
3143 {
3144 ctx.unique("encapsulate", ctx.loc2pos(yystack_[0].location));
3145 ctx.enter(ctx.NO_KEYWORD);
3146}
3147#line 3148 "dhcp6_parser.cc"
3148 break;
3149
3150 case 547: // option_def_encapsulate: "encapsulate" $@78 ":" "constant string"
3151#line 1937 "dhcp6_parser.yy"
3152 {
3153 ElementPtr encap(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3154 ctx.stack_.back()->set("encapsulate", encap);
3155 ctx.leave();
3156}
3157#line 3158 "dhcp6_parser.cc"
3158 break;
3159
3160 case 548: // option_def_array: "array" ":" "boolean"
3161#line 1943 "dhcp6_parser.yy"
3162 {
3163 ctx.unique("array", ctx.loc2pos(yystack_[2].location));
3164 ElementPtr array(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3165 ctx.stack_.back()->set("array", array);
3166}
3167#line 3168 "dhcp6_parser.cc"
3168 break;
3169
3170 case 549: // $@79: %empty
3171#line 1953 "dhcp6_parser.yy"
3172 {
3173 ctx.unique("option-data", ctx.loc2pos(yystack_[0].location));
3174 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3175 ctx.stack_.back()->set("option-data", l);
3176 ctx.stack_.push_back(l);
3177 ctx.enter(ctx.OPTION_DATA);
3178}
3179#line 3180 "dhcp6_parser.cc"
3180 break;
3181
3182 case 550: // option_data_list: "option-data" $@79 ":" "[" option_data_list_content "]"
3183#line 1959 "dhcp6_parser.yy"
3184 {
3185 ctx.stack_.pop_back();
3186 ctx.leave();
3187}
3188#line 3189 "dhcp6_parser.cc"
3189 break;
3190
3191 case 555: // not_empty_option_data_list: not_empty_option_data_list ","
3192#line 1974 "dhcp6_parser.yy"
3193 {
3194 ctx.warnAboutExtraCommas(yystack_[0].location);
3195 }
3196#line 3197 "dhcp6_parser.cc"
3197 break;
3198
3199 case 556: // $@80: %empty
3200#line 1981 "dhcp6_parser.yy"
3201 {
3202 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3203 ctx.stack_.back()->add(m);
3204 ctx.stack_.push_back(m);
3205}
3206#line 3207 "dhcp6_parser.cc"
3207 break;
3208
3209 case 557: // option_data_entry: "{" $@80 option_data_params "}"
3210#line 1985 "dhcp6_parser.yy"
3211 {
3213 ctx.stack_.pop_back();
3214}
3215#line 3216 "dhcp6_parser.cc"
3216 break;
3217
3218 case 558: // $@81: %empty
3219#line 1993 "dhcp6_parser.yy"
3220 {
3221 // Parse the option-data list entry map
3222 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3223 ctx.stack_.push_back(m);
3224}
3225#line 3226 "dhcp6_parser.cc"
3226 break;
3227
3228 case 559: // sub_option_data: "{" $@81 option_data_params "}"
3229#line 1997 "dhcp6_parser.yy"
3230 {
3232 // parsing completed
3233}
3234#line 3235 "dhcp6_parser.cc"
3235 break;
3236
3237 case 564: // not_empty_option_data_params: not_empty_option_data_params ","
3238#line 2013 "dhcp6_parser.yy"
3239 {
3240 ctx.warnAboutExtraCommas(yystack_[0].location);
3241 }
3242#line 3243 "dhcp6_parser.cc"
3243 break;
3244
3245 case 576: // $@82: %empty
3246#line 2034 "dhcp6_parser.yy"
3247 {
3248 ctx.unique("data", ctx.loc2pos(yystack_[0].location));
3249 ctx.enter(ctx.NO_KEYWORD);
3250}
3251#line 3252 "dhcp6_parser.cc"
3252 break;
3253
3254 case 577: // option_data_data: "data" $@82 ":" "constant string"
3255#line 2037 "dhcp6_parser.yy"
3256 {
3257 ElementPtr data(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3258 ctx.stack_.back()->set("data", data);
3259 ctx.leave();
3260}
3261#line 3262 "dhcp6_parser.cc"
3262 break;
3263
3264 case 580: // option_data_csv_format: "csv-format" ":" "boolean"
3265#line 2047 "dhcp6_parser.yy"
3266 {
3267 ctx.unique("csv-format", ctx.loc2pos(yystack_[2].location));
3268 ElementPtr csv(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3269 ctx.stack_.back()->set("csv-format", csv);
3270}
3271#line 3272 "dhcp6_parser.cc"
3272 break;
3273
3274 case 581: // option_data_always_send: "always-send" ":" "boolean"
3275#line 2053 "dhcp6_parser.yy"
3276 {
3277 ctx.unique("always-send", ctx.loc2pos(yystack_[2].location));
3278 ElementPtr persist(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3279 ctx.stack_.back()->set("always-send", persist);
3280}
3281#line 3282 "dhcp6_parser.cc"
3282 break;
3283
3284 case 582: // option_data_never_send: "never-send" ":" "boolean"
3285#line 2059 "dhcp6_parser.yy"
3286 {
3287 ctx.unique("never-send", ctx.loc2pos(yystack_[2].location));
3288 ElementPtr cancel(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3289 ctx.stack_.back()->set("never-send", cancel);
3290}
3291#line 3292 "dhcp6_parser.cc"
3292 break;
3293
3294 case 583: // $@83: %empty
3295#line 2068 "dhcp6_parser.yy"
3296 {
3297 ctx.unique("pools", ctx.loc2pos(yystack_[0].location));
3298 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3299 ctx.stack_.back()->set("pools", l);
3300 ctx.stack_.push_back(l);
3301 ctx.enter(ctx.POOLS);
3302}
3303#line 3304 "dhcp6_parser.cc"
3304 break;
3305
3306 case 584: // pools_list: "pools" $@83 ":" "[" pools_list_content "]"
3307#line 2074 "dhcp6_parser.yy"
3308 {
3309 ctx.stack_.pop_back();
3310 ctx.leave();
3311}
3312#line 3313 "dhcp6_parser.cc"
3313 break;
3314
3315 case 589: // not_empty_pools_list: not_empty_pools_list ","
3316#line 2087 "dhcp6_parser.yy"
3317 {
3318 ctx.warnAboutExtraCommas(yystack_[0].location);
3319 }
3320#line 3321 "dhcp6_parser.cc"
3321 break;
3322
3323 case 590: // $@84: %empty
3324#line 2092 "dhcp6_parser.yy"
3325 {
3326 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3327 ctx.stack_.back()->add(m);
3328 ctx.stack_.push_back(m);
3329}
3330#line 3331 "dhcp6_parser.cc"
3331 break;
3332
3333 case 591: // pool_list_entry: "{" $@84 pool_params "}"
3334#line 2096 "dhcp6_parser.yy"
3335 {
3336 // The pool parameter is required.
3337 ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3338 ctx.stack_.pop_back();
3339}
3340#line 3341 "dhcp6_parser.cc"
3341 break;
3342
3343 case 592: // $@85: %empty
3344#line 2102 "dhcp6_parser.yy"
3345 {
3346 // Parse the pool list entry map
3347 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3348 ctx.stack_.push_back(m);
3349}
3350#line 3351 "dhcp6_parser.cc"
3351 break;
3352
3353 case 593: // sub_pool6: "{" $@85 pool_params "}"
3354#line 2106 "dhcp6_parser.yy"
3355 {
3356 // The pool parameter is required.
3357 ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3358 // parsing completed
3359}
3360#line 3361 "dhcp6_parser.cc"
3361 break;
3362
3363 case 596: // pool_params: pool_params ","
3364#line 2114 "dhcp6_parser.yy"
3365 {
3366 ctx.warnAboutExtraCommas(yystack_[0].location);
3367 }
3368#line 3369 "dhcp6_parser.cc"
3369 break;
3370
3371 case 605: // $@86: %empty
3372#line 2129 "dhcp6_parser.yy"
3373 {
3374 ctx.unique("pool", ctx.loc2pos(yystack_[0].location));
3375 ctx.enter(ctx.NO_KEYWORD);
3376}
3377#line 3378 "dhcp6_parser.cc"
3378 break;
3379
3380 case 606: // pool_entry: "pool" $@86 ":" "constant string"
3381#line 2132 "dhcp6_parser.yy"
3382 {
3383 ElementPtr pool(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3384 ctx.stack_.back()->set("pool", pool);
3385 ctx.leave();
3386}
3387#line 3388 "dhcp6_parser.cc"
3388 break;
3389
3390 case 607: // pool_id: "pool-id" ":" "integer"
3391#line 2138 "dhcp6_parser.yy"
3392 {
3393 ctx.unique("pool-id", ctx.loc2pos(yystack_[2].location));
3394 ElementPtr id(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3395 ctx.stack_.back()->set("pool-id", id);
3396}
3397#line 3398 "dhcp6_parser.cc"
3398 break;
3399
3400 case 608: // $@87: %empty
3401#line 2144 "dhcp6_parser.yy"
3402 {
3403 ctx.enter(ctx.NO_KEYWORD);
3404}
3405#line 3406 "dhcp6_parser.cc"
3406 break;
3407
3408 case 609: // user_context: "user-context" $@87 ":" map_value
3409#line 2146 "dhcp6_parser.yy"
3410 {
3411 ElementPtr parent = ctx.stack_.back();
3412 ElementPtr user_context = yystack_[0].value.as < ElementPtr > ();
3413 ConstElementPtr old = parent->get("user-context");
3414
3415 // Handle already existing user context
3416 if (old) {
3417 // Check if it was a comment or a duplicate
3418 if ((old->size() != 1) || !old->contains("comment")) {
3419 std::stringstream msg;
3420 msg << "duplicate user-context entries (previous at "
3421 << old->getPosition().str() << ")";
3422 error(yystack_[3].location, msg.str());
3423 }
3424 // Merge the comment
3425 user_context->set("comment", old->get("comment"));
3426 }
3427
3428 // Set the user context
3429 parent->set("user-context", user_context);
3430 ctx.leave();
3431}
3432#line 3433 "dhcp6_parser.cc"
3433 break;
3434
3435 case 610: // $@88: %empty
3436#line 2169 "dhcp6_parser.yy"
3437 {
3438 ctx.enter(ctx.NO_KEYWORD);
3439}
3440#line 3441 "dhcp6_parser.cc"
3441 break;
3442
3443 case 611: // comment: "comment" $@88 ":" "constant string"
3444#line 2171 "dhcp6_parser.yy"
3445 {
3446 ElementPtr parent = ctx.stack_.back();
3447 ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
3448 ElementPtr comment(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3449 user_context->set("comment", comment);
3450
3451 // Handle already existing user context
3452 ConstElementPtr old = parent->get("user-context");
3453 if (old) {
3454 // Check for duplicate comment
3455 if (old->contains("comment")) {
3456 std::stringstream msg;
3457 msg << "duplicate user-context/comment entries (previous at "
3458 << old->getPosition().str() << ")";
3459 error(yystack_[3].location, msg.str());
3460 }
3461 // Merge the user context in the comment
3462 merge(user_context, old);
3463 }
3464
3465 // Set the user context
3466 parent->set("user-context", user_context);
3467 ctx.leave();
3468}
3469#line 3470 "dhcp6_parser.cc"
3470 break;
3471
3472 case 612: // $@89: %empty
3473#line 2199 "dhcp6_parser.yy"
3474 {
3475 ctx.unique("pd-pools", ctx.loc2pos(yystack_[0].location));
3476 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3477 ctx.stack_.back()->set("pd-pools", l);
3478 ctx.stack_.push_back(l);
3479 ctx.enter(ctx.PD_POOLS);
3480}
3481#line 3482 "dhcp6_parser.cc"
3482 break;
3483
3484 case 613: // pd_pools_list: "pd-pools" $@89 ":" "[" pd_pools_list_content "]"
3485#line 2205 "dhcp6_parser.yy"
3486 {
3487 ctx.stack_.pop_back();
3488 ctx.leave();
3489}
3490#line 3491 "dhcp6_parser.cc"
3491 break;
3492
3493 case 618: // not_empty_pd_pools_list: not_empty_pd_pools_list ","
3494#line 2218 "dhcp6_parser.yy"
3495 {
3496 ctx.warnAboutExtraCommas(yystack_[0].location);
3497 }
3498#line 3499 "dhcp6_parser.cc"
3499 break;
3500
3501 case 619: // $@90: %empty
3502#line 2223 "dhcp6_parser.yy"
3503 {
3504 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3505 ctx.stack_.back()->add(m);
3506 ctx.stack_.push_back(m);
3507}
3508#line 3509 "dhcp6_parser.cc"
3509 break;
3510
3511 case 620: // pd_pool_entry: "{" $@90 pd_pool_params "}"
3512#line 2227 "dhcp6_parser.yy"
3513 {
3514 // The prefix, prefix len and delegated len parameters are required.
3515 ctx.require("prefix", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3516 ctx.require("prefix-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3517 ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3518 ctx.stack_.pop_back();
3519}
3520#line 3521 "dhcp6_parser.cc"
3521 break;
3522
3523 case 621: // $@91: %empty
3524#line 2235 "dhcp6_parser.yy"
3525 {
3526 // Parse the pd-pool list entry map
3527 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3528 ctx.stack_.push_back(m);
3529}
3530#line 3531 "dhcp6_parser.cc"
3531 break;
3532
3533 case 622: // sub_pd_pool: "{" $@91 pd_pool_params "}"
3534#line 2239 "dhcp6_parser.yy"
3535 {
3536 // The prefix, prefix len and delegated len parameters are required.
3537 ctx.require("prefix", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3538 ctx.require("prefix-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3539 ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3540 // parsing completed
3541}
3542#line 3543 "dhcp6_parser.cc"
3543 break;
3544
3545 case 625: // pd_pool_params: pd_pool_params ","
3546#line 2249 "dhcp6_parser.yy"
3547 {
3548 ctx.warnAboutExtraCommas(yystack_[0].location);
3549 }
3550#line 3551 "dhcp6_parser.cc"
3551 break;
3552
3553 case 638: // $@92: %empty
3554#line 2268 "dhcp6_parser.yy"
3555 {
3556 ctx.unique("prefix", ctx.loc2pos(yystack_[0].location));
3557 ctx.enter(ctx.NO_KEYWORD);
3558}
3559#line 3560 "dhcp6_parser.cc"
3560 break;
3561
3562 case 639: // pd_prefix: "prefix" $@92 ":" "constant string"
3563#line 2271 "dhcp6_parser.yy"
3564 {
3565 ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3566 ctx.stack_.back()->set("prefix", prf);
3567 ctx.leave();
3568}
3569#line 3570 "dhcp6_parser.cc"
3570 break;
3571
3572 case 640: // pd_prefix_len: "prefix-len" ":" "integer"
3573#line 2277 "dhcp6_parser.yy"
3574 {
3575 ctx.unique("prefix-len", ctx.loc2pos(yystack_[2].location));
3576 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3577 ctx.stack_.back()->set("prefix-len", prf);
3578}
3579#line 3580 "dhcp6_parser.cc"
3580 break;
3581
3582 case 641: // $@93: %empty
3583#line 2283 "dhcp6_parser.yy"
3584 {
3585 ctx.unique("excluded-prefix", ctx.loc2pos(yystack_[0].location));
3586 ctx.enter(ctx.NO_KEYWORD);
3587}
3588#line 3589 "dhcp6_parser.cc"
3589 break;
3590
3591 case 642: // excluded_prefix: "excluded-prefix" $@93 ":" "constant string"
3592#line 2286 "dhcp6_parser.yy"
3593 {
3594 ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3595 ctx.stack_.back()->set("excluded-prefix", prf);
3596 ctx.leave();
3597}
3598#line 3599 "dhcp6_parser.cc"
3599 break;
3600
3601 case 643: // excluded_prefix_len: "excluded-prefix-len" ":" "integer"
3602#line 2292 "dhcp6_parser.yy"
3603 {
3604 ctx.unique("excluded-prefix-len", ctx.loc2pos(yystack_[2].location));
3605 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3606 ctx.stack_.back()->set("excluded-prefix-len", prf);
3607}
3608#line 3609 "dhcp6_parser.cc"
3609 break;
3610
3611 case 644: // pd_delegated_len: "delegated-len" ":" "integer"
3612#line 2298 "dhcp6_parser.yy"
3613 {
3614 ctx.unique("delegated-len", ctx.loc2pos(yystack_[2].location));
3615 ElementPtr deleg(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3616 ctx.stack_.back()->set("delegated-len", deleg);
3617}
3618#line 3619 "dhcp6_parser.cc"
3619 break;
3620
3621 case 645: // $@94: %empty
3622#line 2307 "dhcp6_parser.yy"
3623 {
3624 ctx.unique("reservations", ctx.loc2pos(yystack_[0].location));
3625 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3626 ctx.stack_.back()->set("reservations", l);
3627 ctx.stack_.push_back(l);
3628 ctx.enter(ctx.RESERVATIONS);
3629}
3630#line 3631 "dhcp6_parser.cc"
3631 break;
3632
3633 case 646: // reservations: "reservations" $@94 ":" "[" reservations_list "]"
3634#line 2313 "dhcp6_parser.yy"
3635 {
3636 ctx.stack_.pop_back();
3637 ctx.leave();
3638}
3639#line 3640 "dhcp6_parser.cc"
3640 break;
3641
3642 case 651: // not_empty_reservations_list: not_empty_reservations_list ","
3643#line 2324 "dhcp6_parser.yy"
3644 {
3645 ctx.warnAboutExtraCommas(yystack_[0].location);
3646 }
3647#line 3648 "dhcp6_parser.cc"
3648 break;
3649
3650 case 652: // $@95: %empty
3651#line 2329 "dhcp6_parser.yy"
3652 {
3653 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3654 ctx.stack_.back()->add(m);
3655 ctx.stack_.push_back(m);
3656}
3657#line 3658 "dhcp6_parser.cc"
3658 break;
3659
3660 case 653: // reservation: "{" $@95 reservation_params "}"
3661#line 2333 "dhcp6_parser.yy"
3662 {
3664 ctx.stack_.pop_back();
3665}
3666#line 3667 "dhcp6_parser.cc"
3667 break;
3668
3669 case 654: // $@96: %empty
3670#line 2338 "dhcp6_parser.yy"
3671 {
3672 // Parse the reservations list entry map
3673 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3674 ctx.stack_.push_back(m);
3675}
3676#line 3677 "dhcp6_parser.cc"
3677 break;
3678
3679 case 655: // sub_reservation: "{" $@96 reservation_params "}"
3680#line 2342 "dhcp6_parser.yy"
3681 {
3683 // parsing completed
3684}
3685#line 3686 "dhcp6_parser.cc"
3686 break;
3687
3688 case 660: // not_empty_reservation_params: not_empty_reservation_params ","
3689#line 2353 "dhcp6_parser.yy"
3690 {
3691 ctx.warnAboutExtraCommas(yystack_[0].location);
3692 }
3693#line 3694 "dhcp6_parser.cc"
3694 break;
3695
3696 case 672: // $@97: %empty
3697#line 2372 "dhcp6_parser.yy"
3698 {
3699 ctx.unique("ip-addresses", ctx.loc2pos(yystack_[0].location));
3700 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3701 ctx.stack_.back()->set("ip-addresses", l);
3702 ctx.stack_.push_back(l);
3703 ctx.enter(ctx.NO_KEYWORD);
3704}
3705#line 3706 "dhcp6_parser.cc"
3706 break;
3707
3708 case 673: // ip_addresses: "ip-addresses" $@97 ":" list_strings
3709#line 2378 "dhcp6_parser.yy"
3710 {
3711 ctx.stack_.pop_back();
3712 ctx.leave();
3713}
3714#line 3715 "dhcp6_parser.cc"
3715 break;
3716
3717 case 674: // $@98: %empty
3718#line 2383 "dhcp6_parser.yy"
3719 {
3720 ctx.unique("prefixes", ctx.loc2pos(yystack_[0].location));
3721 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3722 ctx.stack_.back()->set("prefixes", l);
3723 ctx.stack_.push_back(l);
3724 ctx.enter(ctx.NO_KEYWORD);
3725}
3726#line 3727 "dhcp6_parser.cc"
3727 break;
3728
3729 case 675: // prefixes: "prefixes" $@98 ":" list_strings
3730#line 2389 "dhcp6_parser.yy"
3731 {
3732 ctx.stack_.pop_back();
3733 ctx.leave();
3734}
3735#line 3736 "dhcp6_parser.cc"
3736 break;
3737
3738 case 676: // $@99: %empty
3739#line 2394 "dhcp6_parser.yy"
3740 {
3741 ctx.unique("duid", ctx.loc2pos(yystack_[0].location));
3742 ctx.enter(ctx.NO_KEYWORD);
3743}
3744#line 3745 "dhcp6_parser.cc"
3745 break;
3746
3747 case 677: // duid: "duid" $@99 ":" "constant string"
3748#line 2397 "dhcp6_parser.yy"
3749 {
3750 ElementPtr d(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3751 ctx.stack_.back()->set("duid", d);
3752 ctx.leave();
3753}
3754#line 3755 "dhcp6_parser.cc"
3755 break;
3756
3757 case 678: // $@100: %empty
3758#line 2403 "dhcp6_parser.yy"
3759 {
3760 ctx.unique("hw-address", ctx.loc2pos(yystack_[0].location));
3761 ctx.enter(ctx.NO_KEYWORD);
3762}
3763#line 3764 "dhcp6_parser.cc"
3764 break;
3765
3766 case 679: // hw_address: "hw-address" $@100 ":" "constant string"
3767#line 2406 "dhcp6_parser.yy"
3768 {
3769 ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3770 ctx.stack_.back()->set("hw-address", hw);
3771 ctx.leave();
3772}
3773#line 3774 "dhcp6_parser.cc"
3774 break;
3775
3776 case 680: // $@101: %empty
3777#line 2412 "dhcp6_parser.yy"
3778 {
3779 ctx.unique("hostname", ctx.loc2pos(yystack_[0].location));
3780 ctx.enter(ctx.NO_KEYWORD);
3781}
3782#line 3783 "dhcp6_parser.cc"
3783 break;
3784
3785 case 681: // hostname: "hostname" $@101 ":" "constant string"
3786#line 2415 "dhcp6_parser.yy"
3787 {
3788 ElementPtr host(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3789 ctx.stack_.back()->set("hostname", host);
3790 ctx.leave();
3791}
3792#line 3793 "dhcp6_parser.cc"
3793 break;
3794
3795 case 682: // $@102: %empty
3796#line 2421 "dhcp6_parser.yy"
3797 {
3798 ctx.unique("flex-id", ctx.loc2pos(yystack_[0].location));
3799 ctx.enter(ctx.NO_KEYWORD);
3800}
3801#line 3802 "dhcp6_parser.cc"
3802 break;
3803
3804 case 683: // flex_id_value: "flex-id" $@102 ":" "constant string"
3805#line 2424 "dhcp6_parser.yy"
3806 {
3807 ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3808 ctx.stack_.back()->set("flex-id", hw);
3809 ctx.leave();
3810}
3811#line 3812 "dhcp6_parser.cc"
3812 break;
3813
3814 case 684: // $@103: %empty
3815#line 2430 "dhcp6_parser.yy"
3816 {
3817 ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location));
3818 ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
3819 ctx.stack_.back()->set("client-classes", c);
3820 ctx.stack_.push_back(c);
3821 ctx.enter(ctx.NO_KEYWORD);
3822}
3823#line 3824 "dhcp6_parser.cc"
3824 break;
3825
3826 case 685: // reservation_client_classes: "client-classes" $@103 ":" list_strings
3827#line 2436 "dhcp6_parser.yy"
3828 {
3829 ctx.stack_.pop_back();
3830 ctx.leave();
3831}
3832#line 3833 "dhcp6_parser.cc"
3833 break;
3834
3835 case 686: // $@104: %empty
3836#line 2444 "dhcp6_parser.yy"
3837 {
3838 ctx.unique("relay", ctx.loc2pos(yystack_[0].location));
3839 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3840 ctx.stack_.back()->set("relay", m);
3841 ctx.stack_.push_back(m);
3842 ctx.enter(ctx.RELAY);
3843}
3844#line 3845 "dhcp6_parser.cc"
3845 break;
3846
3847 case 687: // relay: "relay" $@104 ":" "{" relay_map "}"
3848#line 2450 "dhcp6_parser.yy"
3849 {
3850 ctx.stack_.pop_back();
3851 ctx.leave();
3852}
3853#line 3854 "dhcp6_parser.cc"
3854 break;
3855
3856 case 689: // $@105: %empty
3857#line 2461 "dhcp6_parser.yy"
3858 {
3859 ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location));
3860 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3861 ctx.stack_.back()->set("client-classes", l);
3862 ctx.stack_.push_back(l);
3863 ctx.enter(ctx.CLIENT_CLASSES);
3864}
3865#line 3866 "dhcp6_parser.cc"
3866 break;
3867
3868 case 690: // client_classes: "client-classes" $@105 ":" "[" client_classes_list "]"
3869#line 2467 "dhcp6_parser.yy"
3870 {
3871 ctx.stack_.pop_back();
3872 ctx.leave();
3873}
3874#line 3875 "dhcp6_parser.cc"
3875 break;
3876
3877 case 693: // client_classes_list: client_classes_list ","
3878#line 2474 "dhcp6_parser.yy"
3879 {
3880 ctx.warnAboutExtraCommas(yystack_[0].location);
3881 }
3882#line 3883 "dhcp6_parser.cc"
3883 break;
3884
3885 case 694: // $@106: %empty
3886#line 2479 "dhcp6_parser.yy"
3887 {
3888 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3889 ctx.stack_.back()->add(m);
3890 ctx.stack_.push_back(m);
3891}
3892#line 3893 "dhcp6_parser.cc"
3893 break;
3894
3895 case 695: // client_class_entry: "{" $@106 client_class_params "}"
3896#line 2483 "dhcp6_parser.yy"
3897 {
3898 // The name client class parameter is required.
3899 ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3900 ctx.stack_.pop_back();
3901}
3902#line 3903 "dhcp6_parser.cc"
3903 break;
3904
3905 case 700: // not_empty_client_class_params: not_empty_client_class_params ","
3906#line 2495 "dhcp6_parser.yy"
3907 {
3908 ctx.warnAboutExtraCommas(yystack_[0].location);
3909 }
3910#line 3911 "dhcp6_parser.cc"
3911 break;
3912
3913 case 716: // $@107: %empty
3914#line 2518 "dhcp6_parser.yy"
3915 {
3916 ctx.unique("test", ctx.loc2pos(yystack_[0].location));
3917 ctx.enter(ctx.NO_KEYWORD);
3918}
3919#line 3920 "dhcp6_parser.cc"
3920 break;
3921
3922 case 717: // client_class_test: "test" $@107 ":" "constant string"
3923#line 2521 "dhcp6_parser.yy"
3924 {
3925 ElementPtr test(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3926 ctx.stack_.back()->set("test", test);
3927 ctx.leave();
3928}
3929#line 3930 "dhcp6_parser.cc"
3930 break;
3931
3932 case 718: // $@108: %empty
3933#line 2527 "dhcp6_parser.yy"
3934 {
3935 ctx.unique("template-test", ctx.loc2pos(yystack_[0].location));
3936 ctx.enter(ctx.NO_KEYWORD);
3937}
3938#line 3939 "dhcp6_parser.cc"
3939 break;
3940
3941 case 719: // client_class_template_test: "template-test" $@108 ":" "constant string"
3942#line 2530 "dhcp6_parser.yy"
3943 {
3944 ElementPtr template_test(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3945 ctx.stack_.back()->set("template-test", template_test);
3946 ctx.leave();
3947}
3948#line 3949 "dhcp6_parser.cc"
3949 break;
3950
3951 case 720: // only_if_required: "only-if-required" ":" "boolean"
3952#line 2536 "dhcp6_parser.yy"
3953 {
3954 ctx.unique("only-if-required", ctx.loc2pos(yystack_[2].location));
3955 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3956 ctx.stack_.back()->set("only-if-required", b);
3957}
3958#line 3959 "dhcp6_parser.cc"
3959 break;
3960
3961 case 721: // $@109: %empty
3962#line 2545 "dhcp6_parser.yy"
3963 {
3964 ctx.unique("server-id", ctx.loc2pos(yystack_[0].location));
3965 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3966 ctx.stack_.back()->set("server-id", m);
3967 ctx.stack_.push_back(m);
3968 ctx.enter(ctx.SERVER_ID);
3969}
3970#line 3971 "dhcp6_parser.cc"
3971 break;
3972
3973 case 722: // server_id: "server-id" $@109 ":" "{" server_id_params "}"
3974#line 2551 "dhcp6_parser.yy"
3975 {
3976 // The type parameter is required.
3977 ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
3978 ctx.stack_.pop_back();
3979 ctx.leave();
3980}
3981#line 3982 "dhcp6_parser.cc"
3982 break;
3983
3984 case 725: // server_id_params: server_id_params ","
3985#line 2560 "dhcp6_parser.yy"
3986 {
3987 ctx.warnAboutExtraCommas(yystack_[0].location);
3988 }
3989#line 3990 "dhcp6_parser.cc"
3990 break;
3991
3992 case 735: // $@110: %empty
3993#line 2576 "dhcp6_parser.yy"
3994 {
3995 ctx.unique("type", ctx.loc2pos(yystack_[0].location));
3996 ctx.enter(ctx.DUID_TYPE);
3997}
3998#line 3999 "dhcp6_parser.cc"
3999 break;
4000
4001 case 736: // server_id_type: "type" $@110 ":" duid_type
4002#line 2579 "dhcp6_parser.yy"
4003 {
4004 ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ());
4005 ctx.leave();
4006}
4007#line 4008 "dhcp6_parser.cc"
4008 break;
4009
4010 case 737: // duid_type: "LLT"
4011#line 2584 "dhcp6_parser.yy"
4012 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("LLT", ctx.loc2pos(yystack_[0].location))); }
4013#line 4014 "dhcp6_parser.cc"
4014 break;
4015
4016 case 738: // duid_type: "EN"
4017#line 2585 "dhcp6_parser.yy"
4018 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("EN", ctx.loc2pos(yystack_[0].location))); }
4019#line 4020 "dhcp6_parser.cc"
4020 break;
4021
4022 case 739: // duid_type: "LL"
4023#line 2586 "dhcp6_parser.yy"
4024 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("LL", ctx.loc2pos(yystack_[0].location))); }
4025#line 4026 "dhcp6_parser.cc"
4026 break;
4027
4028 case 740: // htype: "htype" ":" "integer"
4029#line 2589 "dhcp6_parser.yy"
4030 {
4031 ctx.unique("htype", ctx.loc2pos(yystack_[2].location));
4032 ElementPtr htype(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4033 ctx.stack_.back()->set("htype", htype);
4034}
4035#line 4036 "dhcp6_parser.cc"
4036 break;
4037
4038 case 741: // $@111: %empty
4039#line 2595 "dhcp6_parser.yy"
4040 {
4041 ctx.unique("identifier", ctx.loc2pos(yystack_[0].location));
4042 ctx.enter(ctx.NO_KEYWORD);
4043}
4044#line 4045 "dhcp6_parser.cc"
4045 break;
4046
4047 case 742: // identifier: "identifier" $@111 ":" "constant string"
4048#line 2598 "dhcp6_parser.yy"
4049 {
4050 ElementPtr id(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4051 ctx.stack_.back()->set("identifier", id);
4052 ctx.leave();
4053}
4054#line 4055 "dhcp6_parser.cc"
4055 break;
4056
4057 case 743: // time: "time" ":" "integer"
4058#line 2604 "dhcp6_parser.yy"
4059 {
4060 ctx.unique("time", ctx.loc2pos(yystack_[2].location));
4061 ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4062 ctx.stack_.back()->set("time", time);
4063}
4064#line 4065 "dhcp6_parser.cc"
4065 break;
4066
4067 case 744: // enterprise_id: "enterprise-id" ":" "integer"
4068#line 2610 "dhcp6_parser.yy"
4069 {
4070 ctx.unique("enterprise-id", ctx.loc2pos(yystack_[2].location));
4071 ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4072 ctx.stack_.back()->set("enterprise-id", time);
4073}
4074#line 4075 "dhcp6_parser.cc"
4075 break;
4076
4077 case 745: // dhcp4o6_port: "dhcp4o6-port" ":" "integer"
4078#line 2618 "dhcp6_parser.yy"
4079 {
4080 ctx.unique("dhcp4o6-port", ctx.loc2pos(yystack_[2].location));
4081 ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4082 ctx.stack_.back()->set("dhcp4o6-port", time);
4083}
4084#line 4085 "dhcp6_parser.cc"
4085 break;
4086
4087 case 746: // $@112: %empty
4088#line 2626 "dhcp6_parser.yy"
4089 {
4090 ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location));
4091 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
4092 ctx.stack_.back()->set("control-socket", m);
4093 ctx.stack_.push_back(m);
4094 ctx.enter(ctx.CONTROL_SOCKET);
4095}
4096#line 4097 "dhcp6_parser.cc"
4097 break;
4098
4099 case 747: // control_socket: "control-socket" $@112 ":" "{" control_socket_params "}"
4100#line 2632 "dhcp6_parser.yy"
4101 {
4102 ctx.stack_.pop_back();
4103 ctx.leave();
4104}
4105#line 4106 "dhcp6_parser.cc"
4106 break;
4107
4108 case 750: // control_socket_params: control_socket_params ","
4109#line 2639 "dhcp6_parser.yy"
4110 {
4111 ctx.warnAboutExtraCommas(yystack_[0].location);
4112 }
4113#line 4114 "dhcp6_parser.cc"
4114 break;
4115
4116 case 756: // $@113: %empty
4117#line 2651 "dhcp6_parser.yy"
4118 {
4119 ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location));
4120 ctx.enter(ctx.NO_KEYWORD);
4121}
4122#line 4123 "dhcp6_parser.cc"
4123 break;
4124
4125 case 757: // socket_type: "socket-type" $@113 ":" "constant string"
4126#line 2654 "dhcp6_parser.yy"
4127 {
4128 ElementPtr stype(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4129 ctx.stack_.back()->set("socket-type", stype);
4130 ctx.leave();
4131}
4132#line 4133 "dhcp6_parser.cc"
4133 break;
4134
4135 case 758: // $@114: %empty
4136#line 2660 "dhcp6_parser.yy"
4137 {
4138 ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location));
4139 ctx.enter(ctx.NO_KEYWORD);
4140}
4141#line 4142 "dhcp6_parser.cc"
4142 break;
4143
4144 case 759: // socket_name: "socket-name" $@114 ":" "constant string"
4145#line 2663 "dhcp6_parser.yy"
4146 {
4147 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4148 ctx.stack_.back()->set("socket-name", name);
4149 ctx.leave();
4150}
4151#line 4152 "dhcp6_parser.cc"
4152 break;
4153
4154 case 760: // $@115: %empty
4155#line 2672 "dhcp6_parser.yy"
4156 {
4157 ctx.unique("dhcp-queue-control", ctx.loc2pos(yystack_[0].location));
4158 ElementPtr qc(new MapElement(ctx.loc2pos(yystack_[0].location)));
4159 ctx.stack_.back()->set("dhcp-queue-control", qc);
4160 ctx.stack_.push_back(qc);
4161 ctx.enter(ctx.DHCP_QUEUE_CONTROL);
4162}
4163#line 4164 "dhcp6_parser.cc"
4164 break;
4165
4166 case 761: // dhcp_queue_control: "dhcp-queue-control" $@115 ":" "{" queue_control_params "}"
4167#line 2678 "dhcp6_parser.yy"
4168 {
4169 // The enable queue parameter is required.
4170 ctx.require("enable-queue", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
4171 ctx.stack_.pop_back();
4172 ctx.leave();
4173}
4174#line 4175 "dhcp6_parser.cc"
4175 break;
4176
4177 case 764: // queue_control_params: queue_control_params ","
4178#line 2687 "dhcp6_parser.yy"
4179 {
4180 ctx.warnAboutExtraCommas(yystack_[0].location);
4181 }
4182#line 4183 "dhcp6_parser.cc"
4183 break;
4184
4185 case 771: // enable_queue: "enable-queue" ":" "boolean"
4186#line 2700 "dhcp6_parser.yy"
4187 {
4188 ctx.unique("enable-queue", ctx.loc2pos(yystack_[2].location));
4189 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
4190 ctx.stack_.back()->set("enable-queue", b);
4191}
4192#line 4193 "dhcp6_parser.cc"
4193 break;
4194
4195 case 772: // $@116: %empty
4196#line 2706 "dhcp6_parser.yy"
4197 {
4198 ctx.unique("queue-type", ctx.loc2pos(yystack_[0].location));
4199 ctx.enter(ctx.NO_KEYWORD);
4200}
4201#line 4202 "dhcp6_parser.cc"
4202 break;
4203
4204 case 773: // queue_type: "queue-type" $@116 ":" "constant string"
4205#line 2709 "dhcp6_parser.yy"
4206 {
4207 ElementPtr qt(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4208 ctx.stack_.back()->set("queue-type", qt);
4209 ctx.leave();
4210}
4211#line 4212 "dhcp6_parser.cc"
4212 break;
4213
4214 case 774: // capacity: "capacity" ":" "integer"
4215#line 2715 "dhcp6_parser.yy"
4216 {
4217 ctx.unique("capacity", ctx.loc2pos(yystack_[2].location));
4218 ElementPtr c(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4219 ctx.stack_.back()->set("capacity", c);
4220}
4221#line 4222 "dhcp6_parser.cc"
4222 break;
4223
4224 case 775: // $@117: %empty
4225#line 2721 "dhcp6_parser.yy"
4226 {
4227 ctx.unique(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location));
4228 ctx.enter(ctx.NO_KEYWORD);
4229}
4230#line 4231 "dhcp6_parser.cc"
4231 break;
4232
4233 case 776: // arbitrary_map_entry: "constant string" $@117 ":" value
4234#line 2724 "dhcp6_parser.yy"
4235 {
4236 ctx.stack_.back()->set(yystack_[3].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
4237 ctx.leave();
4238}
4239#line 4240 "dhcp6_parser.cc"
4240 break;
4241
4242 case 777: // $@118: %empty
4243#line 2731 "dhcp6_parser.yy"
4244 {
4245 ctx.unique("dhcp-ddns", ctx.loc2pos(yystack_[0].location));
4246 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
4247 ctx.stack_.back()->set("dhcp-ddns", m);
4248 ctx.stack_.push_back(m);
4249 ctx.enter(ctx.DHCP_DDNS);
4250}
4251#line 4252 "dhcp6_parser.cc"
4252 break;
4253
4254 case 778: // dhcp_ddns: "dhcp-ddns" $@118 ":" "{" dhcp_ddns_params "}"
4255#line 2737 "dhcp6_parser.yy"
4256 {
4257 // The enable updates DHCP DDNS parameter is required.
4258 ctx.require("enable-updates", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
4259 ctx.stack_.pop_back();
4260 ctx.leave();
4261}
4262#line 4263 "dhcp6_parser.cc"
4263 break;
4264
4265 case 779: // $@119: %empty
4266#line 2744 "dhcp6_parser.yy"
4267 {
4268 // Parse the dhcp-ddns map
4269 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
4270 ctx.stack_.push_back(m);
4271}
4272#line 4273 "dhcp6_parser.cc"
4273 break;
4274
4275 case 780: // sub_dhcp_ddns: "{" $@119 dhcp_ddns_params "}"
4276#line 2748 "dhcp6_parser.yy"
4277 {
4278 // The enable updates DHCP DDNS parameter is required.
4279 ctx.require("enable-updates", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
4280 // parsing completed
4281}
4282#line 4283 "dhcp6_parser.cc"
4283 break;
4284
4285 case 783: // dhcp_ddns_params: dhcp_ddns_params ","
4286#line 2756 "dhcp6_parser.yy"
4287 {
4288 ctx.warnAboutExtraCommas(yystack_[0].location);
4289 }
4290#line 4291 "dhcp6_parser.cc"
4291 break;
4292
4293 case 795: // enable_updates: "enable-updates" ":" "boolean"
4294#line 2774 "dhcp6_parser.yy"
4295 {
4296 ctx.unique("enable-updates", ctx.loc2pos(yystack_[2].location));
4297 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
4298 ctx.stack_.back()->set("enable-updates", b);
4299}
4300#line 4301 "dhcp6_parser.cc"
4301 break;
4302
4303 case 796: // $@120: %empty
4304#line 2780 "dhcp6_parser.yy"
4305 {
4306 ctx.unique("server-ip", ctx.loc2pos(yystack_[0].location));
4307 ctx.enter(ctx.NO_KEYWORD);
4308}
4309#line 4310 "dhcp6_parser.cc"
4310 break;
4311
4312 case 797: // server_ip: "server-ip" $@120 ":" "constant string"
4313#line 2783 "dhcp6_parser.yy"
4314 {
4315 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4316 ctx.stack_.back()->set("server-ip", s);
4317 ctx.leave();
4318}
4319#line 4320 "dhcp6_parser.cc"
4320 break;
4321
4322 case 798: // server_port: "server-port" ":" "integer"
4323#line 2789 "dhcp6_parser.yy"
4324 {
4325 ctx.unique("server-port", ctx.loc2pos(yystack_[2].location));
4326 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4327 ctx.stack_.back()->set("server-port", i);
4328}
4329#line 4330 "dhcp6_parser.cc"
4330 break;
4331
4332 case 799: // $@121: %empty
4333#line 2795 "dhcp6_parser.yy"
4334 {
4335 ctx.unique("sender-ip", ctx.loc2pos(yystack_[0].location));
4336 ctx.enter(ctx.NO_KEYWORD);
4337}
4338#line 4339 "dhcp6_parser.cc"
4339 break;
4340
4341 case 800: // sender_ip: "sender-ip" $@121 ":" "constant string"
4342#line 2798 "dhcp6_parser.yy"
4343 {
4344 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4345 ctx.stack_.back()->set("sender-ip", s);
4346 ctx.leave();
4347}
4348#line 4349 "dhcp6_parser.cc"
4349 break;
4350
4351 case 801: // sender_port: "sender-port" ":" "integer"
4352#line 2804 "dhcp6_parser.yy"
4353 {
4354 ctx.unique("sender-port", ctx.loc2pos(yystack_[2].location));
4355 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4356 ctx.stack_.back()->set("sender-port", i);
4357}
4358#line 4359 "dhcp6_parser.cc"
4359 break;
4360
4361 case 802: // max_queue_size: "max-queue-size" ":" "integer"
4362#line 2810 "dhcp6_parser.yy"
4363 {
4364 ctx.unique("max-queue-size", ctx.loc2pos(yystack_[2].location));
4365 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4366 ctx.stack_.back()->set("max-queue-size", i);
4367}
4368#line 4369 "dhcp6_parser.cc"
4369 break;
4370
4371 case 803: // $@122: %empty
4372#line 2816 "dhcp6_parser.yy"
4373 {
4374 ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location));
4375 ctx.enter(ctx.NCR_PROTOCOL);
4376}
4377#line 4378 "dhcp6_parser.cc"
4378 break;
4379
4380 case 804: // ncr_protocol: "ncr-protocol" $@122 ":" ncr_protocol_value
4381#line 2819 "dhcp6_parser.yy"
4382 {
4383 ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ());
4384 ctx.leave();
4385}
4386#line 4387 "dhcp6_parser.cc"
4387 break;
4388
4389 case 805: // ncr_protocol_value: "UDP"
4390#line 2825 "dhcp6_parser.yy"
4391 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
4392#line 4393 "dhcp6_parser.cc"
4393 break;
4394
4395 case 806: // ncr_protocol_value: "TCP"
4396#line 2826 "dhcp6_parser.yy"
4397 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
4398#line 4399 "dhcp6_parser.cc"
4399 break;
4400
4401 case 807: // $@123: %empty
4402#line 2829 "dhcp6_parser.yy"
4403 {
4404 ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location));
4405 ctx.enter(ctx.NCR_FORMAT);
4406}
4407#line 4408 "dhcp6_parser.cc"
4408 break;
4409
4410 case 808: // ncr_format: "ncr-format" $@123 ":" "JSON"
4411#line 2832 "dhcp6_parser.yy"
4412 {
4413 ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
4414 ctx.stack_.back()->set("ncr-format", json);
4415 ctx.leave();
4416}
4417#line 4418 "dhcp6_parser.cc"
4418 break;
4419
4420 case 809: // $@124: %empty
4421#line 2840 "dhcp6_parser.yy"
4422 {
4423 ctx.unique("config-control", ctx.loc2pos(yystack_[0].location));
4424 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
4425 ctx.stack_.back()->set("config-control", i);
4426 ctx.stack_.push_back(i);
4427 ctx.enter(ctx.CONFIG_CONTROL);
4428}
4429#line 4430 "dhcp6_parser.cc"
4430 break;
4431
4432 case 810: // config_control: "config-control" $@124 ":" "{" config_control_params "}"
4433#line 2846 "dhcp6_parser.yy"
4434 {
4435 // No config control params are required
4436 ctx.stack_.pop_back();
4437 ctx.leave();
4438}
4439#line 4440 "dhcp6_parser.cc"
4440 break;
4441
4442 case 811: // $@125: %empty
4443#line 2852 "dhcp6_parser.yy"
4444 {
4445 // Parse the config-control map
4446 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
4447 ctx.stack_.push_back(m);
4448}
4449#line 4450 "dhcp6_parser.cc"
4450 break;
4451
4452 case 812: // sub_config_control: "{" $@125 config_control_params "}"
4453#line 2856 "dhcp6_parser.yy"
4454 {
4455 // No config_control params are required
4456 // parsing completed
4457}
4458#line 4459 "dhcp6_parser.cc"
4459 break;
4460
4461 case 815: // config_control_params: config_control_params ","
4462#line 2864 "dhcp6_parser.yy"
4463 {
4464 ctx.warnAboutExtraCommas(yystack_[0].location);
4465 }
4466#line 4467 "dhcp6_parser.cc"
4467 break;
4468
4469 case 818: // $@126: %empty
4470#line 2874 "dhcp6_parser.yy"
4471 {
4472 ctx.unique("config-databases", ctx.loc2pos(yystack_[0].location));
4473 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
4474 ctx.stack_.back()->set("config-databases", l);
4475 ctx.stack_.push_back(l);
4476 ctx.enter(ctx.CONFIG_DATABASE);
4477}
4478#line 4479 "dhcp6_parser.cc"
4479 break;
4480
4481 case 819: // config_databases: "config-databases" $@126 ":" "[" database_list "]"
4482#line 2880 "dhcp6_parser.yy"
4483 {
4484 ctx.stack_.pop_back();
4485 ctx.leave();
4486}
4487#line 4488 "dhcp6_parser.cc"
4488 break;
4489
4490 case 820: // config_fetch_wait_time: "config-fetch-wait-time" ":" "integer"
4491#line 2885 "dhcp6_parser.yy"
4492 {
4493 ctx.unique("config-fetch-wait-time", ctx.loc2pos(yystack_[2].location));
4494 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4495 ctx.stack_.back()->set("config-fetch-wait-time", value);
4496}
4497#line 4498 "dhcp6_parser.cc"
4498 break;
4499
4500 case 821: // $@127: %empty
4501#line 2893 "dhcp6_parser.yy"
4502 {
4503 ctx.unique("loggers", ctx.loc2pos(yystack_[0].location));
4504 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
4505 ctx.stack_.back()->set("loggers", l);
4506 ctx.stack_.push_back(l);
4507 ctx.enter(ctx.LOGGERS);
4508}
4509#line 4510 "dhcp6_parser.cc"
4510 break;
4511
4512 case 822: // loggers: "loggers" $@127 ":" "[" loggers_entries "]"
4513#line 2899 "dhcp6_parser.yy"
4514 {
4515 ctx.stack_.pop_back();
4516 ctx.leave();
4517}
4518#line 4519 "dhcp6_parser.cc"
4519 break;
4520
4521 case 825: // loggers_entries: loggers_entries ","
4522#line 2908 "dhcp6_parser.yy"
4523 {
4524 ctx.warnAboutExtraCommas(yystack_[0].location);
4525 }
4526#line 4527 "dhcp6_parser.cc"
4527 break;
4528
4529 case 826: // $@128: %empty
4530#line 2914 "dhcp6_parser.yy"
4531 {
4532 ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
4533 ctx.stack_.back()->add(l);
4534 ctx.stack_.push_back(l);
4535}
4536#line 4537 "dhcp6_parser.cc"
4537 break;
4538
4539 case 827: // logger_entry: "{" $@128 logger_params "}"
4540#line 2918 "dhcp6_parser.yy"
4541 {
4542 ctx.stack_.pop_back();
4543}
4544#line 4545 "dhcp6_parser.cc"
4545 break;
4546
4547 case 830: // logger_params: logger_params ","
4548#line 2924 "dhcp6_parser.yy"
4549 {
4550 ctx.warnAboutExtraCommas(yystack_[0].location);
4551 }
4552#line 4553 "dhcp6_parser.cc"
4553 break;
4554
4555 case 838: // debuglevel: "debuglevel" ":" "integer"
4556#line 2938 "dhcp6_parser.yy"
4557 {
4558 ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location));
4559 ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4560 ctx.stack_.back()->set("debuglevel", dl);
4561}
4562#line 4563 "dhcp6_parser.cc"
4563 break;
4564
4565 case 839: // $@129: %empty
4566#line 2944 "dhcp6_parser.yy"
4567 {
4568 ctx.unique("severity", ctx.loc2pos(yystack_[0].location));
4569 ctx.enter(ctx.NO_KEYWORD);
4570}
4571#line 4572 "dhcp6_parser.cc"
4572 break;
4573
4574 case 840: // severity: "severity" $@129 ":" "constant string"
4575#line 2947 "dhcp6_parser.yy"
4576 {
4577 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4578 ctx.stack_.back()->set("severity", sev);
4579 ctx.leave();
4580}
4581#line 4582 "dhcp6_parser.cc"
4582 break;
4583
4584 case 841: // $@130: %empty
4585#line 2953 "dhcp6_parser.yy"
4586 {
4587 ctx.unique("output-options", ctx.loc2pos(yystack_[0].location));
4588 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
4589 ctx.stack_.back()->set("output-options", l);
4590 ctx.stack_.push_back(l);
4591 ctx.enter(ctx.OUTPUT_OPTIONS);
4592}
4593#line 4594 "dhcp6_parser.cc"
4594 break;
4595
4596 case 842: // output_options_list: "output-options" $@130 ":" "[" output_options_list_content "]"
4597#line 2959 "dhcp6_parser.yy"
4598 {
4599 ctx.stack_.pop_back();
4600 ctx.leave();
4601}
4602#line 4603 "dhcp6_parser.cc"
4603 break;
4604
4605 case 845: // output_options_list_content: output_options_list_content ","
4606#line 2966 "dhcp6_parser.yy"
4607 {
4608 ctx.warnAboutExtraCommas(yystack_[0].location);
4609 }
4610#line 4611 "dhcp6_parser.cc"
4611 break;
4612
4613 case 846: // $@131: %empty
4614#line 2971 "dhcp6_parser.yy"
4615 {
4616 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
4617 ctx.stack_.back()->add(m);
4618 ctx.stack_.push_back(m);
4619}
4620#line 4621 "dhcp6_parser.cc"
4621 break;
4622
4623 case 847: // output_entry: "{" $@131 output_params_list "}"
4624#line 2975 "dhcp6_parser.yy"
4625 {
4626 ctx.stack_.pop_back();
4627}
4628#line 4629 "dhcp6_parser.cc"
4629 break;
4630
4631 case 850: // output_params_list: output_params_list ","
4632#line 2981 "dhcp6_parser.yy"
4633 {
4634 ctx.warnAboutExtraCommas(yystack_[0].location);
4635 }
4636#line 4637 "dhcp6_parser.cc"
4637 break;
4638
4639 case 856: // $@132: %empty
4640#line 2993 "dhcp6_parser.yy"
4641 {
4642 ctx.unique("output", ctx.loc2pos(yystack_[0].location));
4643 ctx.enter(ctx.NO_KEYWORD);
4644}
4645#line 4646 "dhcp6_parser.cc"
4646 break;
4647
4648 case 857: // output: "output" $@132 ":" "constant string"
4649#line 2996 "dhcp6_parser.yy"
4650 {
4651 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4652 ctx.stack_.back()->set("output", sev);
4653 ctx.leave();
4654}
4655#line 4656 "dhcp6_parser.cc"
4656 break;
4657
4658 case 858: // flush: "flush" ":" "boolean"
4659#line 3002 "dhcp6_parser.yy"
4660 {
4661 ctx.unique("flush", ctx.loc2pos(yystack_[2].location));
4662 ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
4663 ctx.stack_.back()->set("flush", flush);
4664}
4665#line 4666 "dhcp6_parser.cc"
4666 break;
4667
4668 case 859: // maxsize: "maxsize" ":" "integer"
4669#line 3008 "dhcp6_parser.yy"
4670 {
4671 ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location));
4672 ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4673 ctx.stack_.back()->set("maxsize", maxsize);
4674}
4675#line 4676 "dhcp6_parser.cc"
4676 break;
4677
4678 case 860: // maxver: "maxver" ":" "integer"
4679#line 3014 "dhcp6_parser.yy"
4680 {
4681 ctx.unique("maxver", ctx.loc2pos(yystack_[2].location));
4682 ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4683 ctx.stack_.back()->set("maxver", maxver);
4684}
4685#line 4686 "dhcp6_parser.cc"
4686 break;
4687
4688 case 861: // $@133: %empty
4689#line 3020 "dhcp6_parser.yy"
4690 {
4691 ctx.unique("pattern", ctx.loc2pos(yystack_[0].location));
4692 ctx.enter(ctx.NO_KEYWORD);
4693}
4694#line 4695 "dhcp6_parser.cc"
4695 break;
4696
4697 case 862: // pattern: "pattern" $@133 ":" "constant string"
4698#line 3023 "dhcp6_parser.yy"
4699 {
4700 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4701 ctx.stack_.back()->set("pattern", sev);
4702 ctx.leave();
4703}
4704#line 4705 "dhcp6_parser.cc"
4705 break;
4706
4707 case 863: // $@134: %empty
4708#line 3029 "dhcp6_parser.yy"
4709 {
4710 ctx.unique("compatibility", ctx.loc2pos(yystack_[0].location));
4711 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
4712 ctx.stack_.back()->set("compatibility", i);
4713 ctx.stack_.push_back(i);
4714 ctx.enter(ctx.COMPATIBILITY);
4715}
4716#line 4717 "dhcp6_parser.cc"
4717 break;
4718
4719 case 864: // compatibility: "compatibility" $@134 ":" "{" compatibility_params "}"
4720#line 3035 "dhcp6_parser.yy"
4721 {
4722 ctx.stack_.pop_back();
4723 ctx.leave();
4724}
4725#line 4726 "dhcp6_parser.cc"
4726 break;
4727
4728 case 867: // compatibility_params: compatibility_params ","
4729#line 3042 "dhcp6_parser.yy"
4730 {
4731 ctx.warnAboutExtraCommas(yystack_[0].location);
4732 }
4733#line 4734 "dhcp6_parser.cc"
4734 break;
4735
4736 case 870: // lenient_option_parsing: "lenient-option-parsing" ":" "boolean"
4737#line 3051 "dhcp6_parser.yy"
4738 {
4739 ctx.unique("lenient-option-parsing", ctx.loc2pos(yystack_[2].location));
4740 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
4741 ctx.stack_.back()->set("lenient-option-parsing", b);
4742}
4743#line 4744 "dhcp6_parser.cc"
4744 break;
4745
4746
4747#line 4748 "dhcp6_parser.cc"
4748
4749 default:
4750 break;
4751 }
4752 }
4753#if YY_EXCEPTIONS
4754 catch (const syntax_error& yyexc)
4755 {
4756 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
4757 error (yyexc);
4758 YYERROR;
4759 }
4760#endif // YY_EXCEPTIONS
4761 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
4762 yypop_ (yylen);
4763 yylen = 0;
4764
4765 // Shift the result of the reduction.
4766 yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
4767 }
4768 goto yynewstate;
4769
4770
4771 /*--------------------------------------.
4772 | yyerrlab -- here on detecting error. |
4773 `--------------------------------------*/
4774 yyerrlab:
4775 // If not already recovering from an error, report this error.
4776 if (!yyerrstatus_)
4777 {
4778 ++yynerrs_;
4779 context yyctx (*this, yyla);
4780 std::string msg = yysyntax_error_ (yyctx);
4781 error (yyla.location, YY_MOVE (msg));
4782 }
4783
4784
4785 yyerror_range[1].location = yyla.location;
4786 if (yyerrstatus_ == 3)
4787 {
4788 /* If just tried and failed to reuse lookahead token after an
4789 error, discard it. */
4790
4791 // Return failure if at end of input.
4792 if (yyla.kind () == symbol_kind::S_YYEOF)
4793 YYABORT;
4794 else if (!yyla.empty ())
4795 {
4796 yy_destroy_ ("Error: discarding", yyla);
4797 yyla.clear ();
4798 }
4799 }
4800
4801 // Else will try to reuse lookahead token after shifting the error token.
4802 goto yyerrlab1;
4803
4804
4805 /*---------------------------------------------------.
4806 | yyerrorlab -- error raised explicitly by YYERROR. |
4807 `---------------------------------------------------*/
4808 yyerrorlab:
4809 /* Pacify compilers when the user code never invokes YYERROR and
4810 the label yyerrorlab therefore never appears in user code. */
4811 if (false)
4812 YYERROR;
4813
4814 /* Do not reclaim the symbols of the rule whose action triggered
4815 this YYERROR. */
4816 yypop_ (yylen);
4817 yylen = 0;
4818 YY_STACK_PRINT ();
4819 goto yyerrlab1;
4820
4821
4822 /*-------------------------------------------------------------.
4823 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4824 `-------------------------------------------------------------*/
4825 yyerrlab1:
4826 yyerrstatus_ = 3; // Each real token shifted decrements this.
4827 // Pop stack until we find a state that shifts the error token.
4828 for (;;)
4829 {
4830 yyn = yypact_[+yystack_[0].state];
4831 if (!yy_pact_value_is_default_ (yyn))
4832 {
4834 if (0 <= yyn && yyn <= yylast_
4835 && yycheck_[yyn] == symbol_kind::S_YYerror)
4836 {
4837 yyn = yytable_[yyn];
4838 if (0 < yyn)
4839 break;
4840 }
4841 }
4842
4843 // Pop the current state because it cannot handle the error token.
4844 if (yystack_.size () == 1)
4845 YYABORT;
4846
4847 yyerror_range[1].location = yystack_[0].location;
4848 yy_destroy_ ("Error: popping", yystack_[0]);
4849 yypop_ ();
4850 YY_STACK_PRINT ();
4851 }
4852 {
4853 stack_symbol_type error_token;
4854
4855 yyerror_range[2].location = yyla.location;
4856 YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
4857
4858 // Shift the error token.
4859 error_token.state = state_type (yyn);
4860 yypush_ ("Shifting", YY_MOVE (error_token));
4861 }
4862 goto yynewstate;
4863
4864
4865 /*-------------------------------------.
4866 | yyacceptlab -- YYACCEPT comes here. |
4867 `-------------------------------------*/
4868 yyacceptlab:
4869 yyresult = 0;
4870 goto yyreturn;
4871
4872
4873 /*-----------------------------------.
4874 | yyabortlab -- YYABORT comes here. |
4875 `-----------------------------------*/
4876 yyabortlab:
4877 yyresult = 1;
4878 goto yyreturn;
4879
4880
4881 /*-----------------------------------------------------.
4882 | yyreturn -- parsing is finished, return the result. |
4883 `-----------------------------------------------------*/
4884 yyreturn:
4885 if (!yyla.empty ())
4886 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
4887
4888 /* Do not reclaim the symbols of the rule whose action triggered
4889 this YYABORT or YYACCEPT. */
4890 yypop_ (yylen);
4891 YY_STACK_PRINT ();
4892 while (1 < yystack_.size ())
4893 {
4894 yy_destroy_ ("Cleanup: popping", yystack_[0]);
4895 yypop_ ();
4896 }
4897
4898 return yyresult;
4899 }
4900#if YY_EXCEPTIONS
4901 catch (...)
4902 {
4903 YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
4904 // Do not try to display the values of the reclaimed symbols,
4905 // as their printers might throw an exception.
4906 if (!yyla.empty ())
4907 yy_destroy_ (YY_NULLPTR, yyla);
4908
4909 while (1 < yystack_.size ())
4910 {
4911 yy_destroy_ (YY_NULLPTR, yystack_[0]);
4912 yypop_ ();
4913 }
4914 throw;
4915 }
4916#endif // YY_EXCEPTIONS
4917 }
4918
4919 void
4921 {
4922 error (yyexc.location, yyexc.what ());
4923 }
4924
4925 /* Return YYSTR after stripping away unnecessary quotes and
4926 backslashes, so that it's suitable for yyerror. The heuristic is
4927 that double-quoting is unnecessary unless the string contains an
4928 apostrophe, a comma, or backslash (other than backslash-backslash).
4929 YYSTR is taken from yytname. */
4930 std::string
4931 Dhcp6Parser::yytnamerr_ (const char *yystr)
4932 {
4933 if (*yystr == '"')
4934 {
4935 std::string yyr;
4936 char const *yyp = yystr;
4937
4938 for (;;)
4939 switch (*++yyp)
4940 {
4941 case '\'':
4942 case ',':
4943 goto do_not_strip_quotes;
4944
4945 case '\\':
4946 if (*++yyp != '\\')
4947 goto do_not_strip_quotes;
4948 else
4949 goto append;
4950
4951 append:
4952 default:
4953 yyr += *yyp;
4954 break;
4955
4956 case '"':
4957 return yyr;
4958 }
4959 do_not_strip_quotes: ;
4960 }
4961
4962 return yystr;
4963 }
4964
4965 std::string
4967 {
4968 return yytnamerr_ (yytname_[yysymbol]);
4969 }
4970
4971
4972
4973 // Dhcp6Parser::context.
4975 : yyparser_ (yyparser)
4976 , yyla_ (yyla)
4977 {}
4978
4979 int
4981 {
4982 // Actual number of expected tokens
4983 int yycount = 0;
4984
4985 const int yyn = yypact_[+yyparser_.yystack_[0].state];
4986 if (!yy_pact_value_is_default_ (yyn))
4987 {
4988 /* Start YYX at -YYN if negative to avoid negative indexes in
4989 YYCHECK. In other words, skip the first -YYN actions for
4990 this state because they are default actions. */
4991 const int yyxbegin = yyn < 0 ? -yyn : 0;
4992 // Stay within bounds of both yycheck and yytname.
4993 const int yychecklim = yylast_ - yyn + 1;
4994 const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4995 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
4996 if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror
4997 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
4998 {
4999 if (!yyarg)
5000 ++yycount;
5001 else if (yycount == yyargn)
5002 return 0;
5003 else
5004 yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx);
5005 }
5006 }
5007
5008 if (yyarg && yycount == 0 && 0 < yyargn)
5009 yyarg[0] = symbol_kind::S_YYEMPTY;
5010 return yycount;
5011 }
5012
5013
5014
5015
5016
5017
5018 int
5019 Dhcp6Parser::yy_syntax_error_arguments_ (const context& yyctx,
5020 symbol_kind_type yyarg[], int yyargn) const
5021 {
5022 /* There are many possibilities here to consider:
5023 - If this state is a consistent state with a default action, then
5024 the only way this function was invoked is if the default action
5025 is an error action. In that case, don't check for expected
5026 tokens because there are none.
5027 - The only way there can be no lookahead present (in yyla) is
5028 if this state is a consistent state with a default action.
5029 Thus, detecting the absence of a lookahead is sufficient to
5030 determine that there is no unexpected or expected token to
5031 report. In that case, just report a simple "syntax error".
5032 - Don't assume there isn't a lookahead just because this state is
5033 a consistent state with a default action. There might have
5034 been a previous inconsistent state, consistent state with a
5035 non-default action, or user semantic action that manipulated
5036 yyla. (However, yyla is currently not documented for users.)
5037 - Of course, the expected token list depends on states to have
5038 correct lookahead information, and it depends on the parser not
5039 to perform extra reductions after fetching a lookahead from the
5040 scanner and before detecting a syntax error. Thus, state merging
5041 (from LALR or IELR) and default reductions corrupt the expected
5042 token list. However, the list is correct for canonical LR with
5043 one exception: it will still contain any token that will not be
5044 accepted due to an error action in a later state.
5045 */
5046
5047 if (!yyctx.lookahead ().empty ())
5048 {
5049 if (yyarg)
5050 yyarg[0] = yyctx.token ();
5051 int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1);
5052 return yyn + 1;
5053 }
5054 return 0;
5055 }
5056
5057 // Generate an error message.
5058 std::string
5059 Dhcp6Parser::yysyntax_error_ (const context& yyctx) const
5060 {
5061 // Its maximum.
5062 enum { YYARGS_MAX = 5 };
5063 // Arguments of yyformat.
5064 symbol_kind_type yyarg[YYARGS_MAX];
5065 int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX);
5066
5067 char const* yyformat = YY_NULLPTR;
5068 switch (yycount)
5069 {
5070#define YYCASE_(N, S) \
5071 case N: \
5072 yyformat = S; \
5073 break
5074 default: // Avoid compiler warnings.
5075 YYCASE_ (0, YY_("syntax error"));
5076 YYCASE_ (1, YY_("syntax error, unexpected %s"));
5077 YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
5078 YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
5079 YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
5080 YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
5081#undef YYCASE_
5082 }
5083
5084 std::string yyres;
5085 // Argument number.
5086 std::ptrdiff_t yyi = 0;
5087 for (char const* yyp = yyformat; *yyp; ++yyp)
5088 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
5089 {
5090 yyres += symbol_name (yyarg[yyi++]);
5091 ++yyp;
5092 }
5093 else
5094 yyres += *yyp;
5095 return yyres;
5096 }
5097
5098
5099 const short Dhcp6Parser::yypact_ninf_ = -1000;
5100
5101 const signed char Dhcp6Parser::yytable_ninf_ = -1;
5102
5103 const short
5104 Dhcp6Parser::yypact_[] =
5105 {
5106 432, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5107 -1000, -1000, -1000, -1000, -1000, 35, 34, 70, 82, 89,
5108 115, 121, 123, 131, 133, 139, 141, 147, 156, 163,
5109 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5110 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5111 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5112 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 34, -175,
5113 99, 167, 75, 669, 322, 214, 282, -35, 77, 313,
5114 -94, 455, 54, -1000, 55, 174, 183, 185, 188, -1000,
5115 96, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 196, 211,
5116 267, 285, 289, 303, 307, 330, 336, 337, 347, 354,
5117 377, 379, -1000, 388, 389, 397, 403, 409, -1000, -1000,
5118 -1000, 422, 436, 442, 449, -1000, -1000, -1000, 450, -1000,
5119 -1000, -1000, -1000, -1000, -1000, 452, 456, 462, -1000, -1000,
5120 -1000, -1000, -1000, -1000, -1000, -1000, -1000, 465, -1000, -1000,
5121 -1000, -1000, -1000, -1000, 466, 472, 480, -1000, -1000, 482,
5122 -1000, 154, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5123 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5124 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5125 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5126 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5127 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5128 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5129 -1000, 483, 486, 487, 489, -1000, 161, -1000, -1000, -1000,
5130 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5131 491, 492, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5132 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5133 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5134 -1000, -1000, -1000, -1000, 172, -1000, -1000, -1000, -1000, -1000,
5135 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5136 -1000, -1000, -1000, -1000, 494, -1000, -1000, -1000, -1000, 173,
5137 -1000, -1000, -1000, -1000, -1000, -1000, 495, -1000, 497, 499,
5138 -1000, -1000, -1000, -1000, -1000, -1000, -1000, 191, -1000, -1000,
5139 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5140 -1000, -1000, -1000, -1000, -1000, 255, 301, -1000, -1000, -1000,
5141 -1000, -1000, -1000, -1000, -1000, 323, -1000, -1000, 501, -1000,
5142 -1000, -1000, 505, -1000, -1000, 353, 335, -1000, -1000, -1000,
5143 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5144 506, 510, 511, -1000, -1000, -1000, -1000, 396, 425, -1000,
5145 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5146 -1000, -1000, 198, -1000, -1000, -1000, 515, -1000, 516, -1000,
5147 518, 522, -1000, -1000, -1000, -1000, -1000, 199, -1000, -1000,
5148 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 523, 209,
5149 -1000, -1000, -1000, -1000, 34, 34, -1000, 220, 530, -1000,
5150 -1000, 531, 535, 536, 537, 540, 543, 242, 332, 333,
5151 343, 350, 351, 352, 358, 355, 338, 359, 363, 365,
5152 366, 546, 369, 370, 371, 375, 381, 547, 548, 565,
5153 382, 383, 378, 385, 579, 583, 584, 390, 594, 601,
5154 605, 606, 607, 608, 398, 399, 401, 610, 611, 614,
5155 617, 618, 619, 620, 643, 645, 437, 646, 648, 650,
5156 651, 652, 653, 443, 444, 445, 654, 655, -1000, 167,
5157 -1000, 656, 446, 448, 451, 453, 75, -1000, 664, 667,
5158 668, 670, 671, 457, 458, 673, 674, 675, 669, -1000,
5159 676, 467, 322, -1000, 677, 468, 678, 469, 473, 214,
5160 -1000, 687, 688, 689, 691, 692, 693, 694, -1000, 282,
5161 -1000, 695, 701, 490, 703, 705, 706, 493, -1000, 77,
5162 708, 496, 498, 500, -1000, 313, 709, 711, 137, -1000,
5163 517, 713, 520, 729, 532, 534, 730, 743, 455, -1000,
5164 747, 544, 54, -1000, -1000, -1000, 748, 746, 549, 752,
5165 758, 759, 760, 763, -1000, -1000, -1000, -1000, -1000, -1000,
5166 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 555, -1000,
5167 -1000, -1000, -1000, -1000, -50, 557, 558, -1000, -1000, -1000,
5168 -1000, 769, 770, 771, -1000, 572, 573, 367, 784, 783,
5169 576, -1000, -1000, -1000, 787, 788, 790, 789, 792, 794,
5170 796, 795, 797, -1000, 798, 799, 801, 802, 588, 595,
5171 -1000, -1000, -1000, 806, 805, -1000, 808, -1000, -1000, -1000,
5172 -1000, -1000, 809, 823, 615, 616, 628, -1000, -1000, 808,
5173 631, 822, -1000, 632, -1000, -1000, 633, -1000, 634, -1000,
5174 -1000, -1000, 808, 808, 808, 635, 636, 637, 638, -1000,
5175 644, 647, -1000, 649, 659, 662, -1000, -1000, 672, -1000,
5176 -1000, -1000, -1000, 679, 783, -1000, -1000, 680, -1000, 681,
5177 -1000, -1000, 102, 683, -1000, 855, -1000, -1000, 34, 167,
5178 -1000, 54, 75, 339, 339, 854, -1000, -1000, -1000, -1000,
5179 -1000, -1000, -1000, -1000, -1000, 858, 859, 860, -1000, -1000,
5180 -1000, -1000, -1000, -1000, -1000, 861, -1000, -1000, -1000, -101,
5181 34, -53, 192, 862, 863, 864, 202, 42, 95, -44,
5182 -23, 455, -1000, -1000, 875, -152, -1000, -1000, 876, 878,
5183 -1000, -1000, -1000, -1000, -1000, 754, -1000, -1000, -1000, -1000,
5184 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5185 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5186 854, -1000, 245, 261, 271, -1000, -1000, -1000, -1000, 884,
5187 886, 887, 888, 893, 894, 895, 896, 897, 899, -1000,
5188 900, 901, -1000, -1000, -1000, -1000, -1000, 292, -1000, -1000,
5189 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5190 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5191 -1000, 293, -1000, 902, 903, -1000, -1000, 904, 906, -1000,
5192 -1000, 905, 909, -1000, -1000, 907, 911, -1000, -1000, 910,
5193 912, -1000, -1000, -1000, 39, -1000, -1000, -1000, 913, -1000,
5194 -1000, -1000, 94, -1000, -1000, -1000, -1000, -1000, 294, -1000,
5195 -1000, -1000, -1000, 112, -1000, -1000, 914, 915, -1000, -1000,
5196 916, 918, -1000, 919, 920, 921, 922, 923, 924, 300,
5197 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 925,
5198 926, 927, -1000, -1000, -1000, -1000, 325, -1000, -1000, -1000,
5199 -1000, -1000, -1000, 928, 929, 930, -1000, 327, -1000, -1000,
5200 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 334,
5201 -1000, -1000, -1000, 931, -1000, 932, -1000, -1000, -1000, 356,
5202 -1000, -1000, -1000, -1000, -1000, 357, -1000, 210, -1000, 933,
5203 -1000, 400, -1000, -1000, 702, -1000, 934, 935, -1000, -1000,
5204 936, 938, -1000, -1000, 939, 937, -1000, -1000, -1000, 940,
5205 942, 948, 949, 723, 738, 742, 749, 744, 745, 773,
5206 774, 775, 779, 966, 756, 807, 971, 981, 983, 999,
5207 339, -1000, -1000, 339, -1000, 854, 669, -1000, 858, 77,
5208 -1000, 859, 313, -1000, 860, 764, -1000, 861, -101, -1000,
5209 -1000, -53, -1000, 1000, 1008, 192, -1000, -1, 862, -1000,
5210 282, -1000, 863, -94, -1000, 864, 812, 827, 828, 848,
5211 881, 882, 202, -1000, 1021, 1034, 891, 892, 898, 42,
5212 -1000, 885, 917, 941, 95, -1000, 1073, 1096, -44, -1000,
5213 908, 1098, 943, 1105, -23, -1000, -1000, 218, 875, -1000,
5214 944, -152, -1000, -1000, 1104, 1108, 322, -1000, 876, 214,
5215 -1000, 878, -1000, -1000, 454, 945, 946, 950, -1000, -1000,
5216 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 430, -1000,
5217 -1000, 951, 953, 954, 956, -1000, 402, -1000, 424, -1000,
5218 1107, -1000, 1109, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5219 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5220 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5221 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5222 -1000, -1000, -1000, 431, -1000, -1000, -1000, -1000, -1000, -1000,
5223 -1000, -1000, 957, 958, -1000, -1000, -1000, 1112, -1000, -1000,
5224 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1110,
5225 1116, -1000, -1000, -1000, -1000, -1000, -1000, 1113, -1000, 433,
5226 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 380, 959,
5227 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 960, 961,
5228 -1000, -1000, 962, -1000, 34, -1000, -1000, 1118, -1000, -1000,
5229 -1000, -1000, -1000, 434, -1000, -1000, -1000, -1000, -1000, -1000,
5230 -1000, -1000, 963, 440, -1000, 441, -1000, -1000, -1000, -1000,
5231 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
5232 -1000, -1000, -1000, -1000, -1000, -1000, 764, -1000, -1000, -1000,
5233 1119, 1121, 964, -1000, -1, -1000, -1000, -1000, -1000, -1000,
5234 -1000, -1000, -1000, -1000, -1000, -1000, 1124, 947, 1125, 218,
5235 -1000, -1000, -1000, -1000, -1000, 965, 968, -1000, -1000, 1115,
5236 -1000, 969, -1000, -1000, -1000, 1106, -1000, -1000, 259, -1000,
5237 13, 1106, -1000, -1000, 1126, 1127, 1128, -1000, 447, -1000,
5238 -1000, -1000, -1000, -1000, -1000, -1000, 1130, 967, 970, 972,
5239 1131, 13, -1000, 974, -1000, -1000, -1000, 975, -1000, -1000,
5240 -1000
5241 };
5242
5243 const short
5244 Dhcp6Parser::yydefact_[] =
5245 {
5246 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
5247 20, 22, 24, 26, 28, 0, 0, 0, 0, 0,
5248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5249 1, 46, 38, 34, 33, 30, 31, 32, 37, 3,
5250 35, 36, 61, 5, 67, 7, 198, 9, 387, 11,
5251 592, 13, 621, 15, 654, 17, 510, 19, 519, 21,
5252 558, 23, 349, 25, 779, 27, 811, 29, 48, 41,
5253 0, 0, 0, 0, 0, 0, 656, 0, 521, 560,
5254 0, 0, 0, 50, 0, 49, 0, 0, 42, 63,
5255 0, 65, 140, 809, 196, 217, 219, 221, 0, 0,
5256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5257 0, 0, 186, 0, 0, 0, 0, 0, 159, 166,
5258 168, 0, 0, 0, 0, 378, 508, 549, 0, 189,
5259 191, 172, 453, 608, 610, 0, 0, 0, 305, 324,
5260 314, 294, 689, 645, 340, 361, 721, 0, 326, 746,
5261 760, 777, 179, 181, 0, 0, 0, 821, 863, 0,
5262 139, 0, 69, 72, 73, 74, 75, 76, 77, 78,
5263 79, 80, 110, 111, 112, 113, 114, 81, 118, 119,
5264 120, 121, 122, 123, 124, 125, 126, 127, 116, 117,
5265 128, 129, 130, 106, 136, 137, 138, 132, 133, 134,
5266 84, 85, 86, 87, 103, 88, 90, 89, 131, 94,
5267 95, 82, 107, 108, 109, 83, 92, 93, 101, 102,
5268 104, 91, 96, 97, 98, 99, 100, 105, 115, 135,
5269 211, 0, 0, 0, 0, 210, 0, 200, 203, 204,
5270 205, 206, 207, 208, 209, 583, 612, 438, 440, 442,
5271 0, 0, 446, 444, 686, 437, 392, 393, 394, 395,
5272 396, 397, 398, 399, 417, 418, 419, 420, 421, 424,
5273 425, 426, 427, 428, 429, 430, 431, 432, 433, 422,
5274 423, 434, 435, 436, 0, 389, 403, 404, 405, 408,
5275 409, 411, 412, 413, 406, 407, 400, 401, 415, 416,
5276 402, 410, 414, 605, 0, 604, 600, 601, 599, 0,
5277 594,