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