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