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