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