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