[#260,!120] Packet queueing is now optional

src/bin/dhcp<4/6>/ctrl_dhcp<4/6>_srv.cc
    ControlledDhcpv<4/6>Srv::processConfig() - now calls
        IfaceMgr::configureDHCPPacketQueue

src/bin/dhcp<4/6>/dhcp<4/6>_parser.yy
    dhpc-queue-control parsing updated to enforce
    enable-queue/queue-type rules

src/bin/dhcp<4/6>/tests/config_parser_unittest.cc
    TEST_F(Dhcp<4/6>ParserTest, dhcpQueueControl)
    TEST_F(Dhcp<4/6>ParserTest, dhcpQueueControlInvalid)

src/lib/dhcp/iface_mgr.*
    IfaceMgr
    - closeSockets()  - now calls stopDHCPReceiver

    - openSockets<4/6>() -  now calls startDHCPReceiver

    - receive<4/6>Indirect() - new function which monitors receiver
    thread watch sockets, reads DHCP packets from queue

    - receive<4/6>Direct() - new function which monitors and reads DHCP
    packets from interface sockets directly

    - receive<4/6>() - rewritten to call receive<4/6>Indirect
    if receiver thread is running, otherwise it calls receive<4/6>Direct

    - configureDHCPPacketQueue() - new function which either enables queuing
    by creating a new packet queue, or disables it by destroying the
    existing queue

src/lib/dhcp/packet_queue_mgr.h
    PacketQueue::destroyPacketQueue() - new function

src/lib/dhcp/packet_queue_mgr<4/6>.cc
    PacketQueueMgr<4/6>::PacketQueueMgr<4/6>() - no longer creates a
    default packet queue

src/lib/dhcpsrv/cfg_iface.cc
    CfgIface::closeSockets() - removed call to stopDHCPReceiver
    CfgIface::openSockets() - removed call to startDHCPReceiver

src/lib/dhcpsrv/parsers/dhcp_queue_control_parser.*
    DHCPQueueControlParser
    - removed unused family_ member
    - parse() - added support for enable-queue

src/lib/dhcpsrv/tests/dhcp_queue_control_parser_unittest.cc
    - new file

11 files changed, 4099 insertions, 4403 deletions

diff --git a/src/bin/dhcp4/dhcp4_lexer.cc b/src/bin/dhcp4/dhcp4_lexer.cc
index ccd6b950ae..bb902728c9 100644
--- a/src/bin/dhcp4/dhcp4_lexer.cc
+++ b/src/bin/dhcp4/dhcp4_lexer.cc
@@ -1,6 +1,6 @@
-#line 1 "dhcp4_lexer.cc"
+#line 2 "dhcp4_lexer.cc"
 
-#line 3 "dhcp4_lexer.cc"
+#line 4 "dhcp4_lexer.cc"
 
 #define  YY_INT_ALIGNED short int
 
@@ -1748,7 +1748,7 @@ using namespace isc::dhcp;
 
 /* To avoid the call to exit... oops! */
 #define YY_FATAL_ERROR(msg) isc::dhcp::Parser4Context::fatal(msg)
-#line 1751 "dhcp4_lexer.cc"
+#line 1752 "dhcp4_lexer.cc"
 /* noyywrap disables automatic rewinding for the next file to parse. Since we
    always parse only a single string, there's no need to do any wraps. And
    using yywrap requires linking with -lfl, which provides the default yywrap
@@ -1774,8 +1774,8 @@ using namespace isc::dhcp;
    by moving it ahead by yyleng bytes. yyleng specifies the length of the
    currently matched token. */
 #define YY_USER_ACTION  driver.loc_.columns(yyleng);
-#line 1777 "dhcp4_lexer.cc"
 #line 1778 "dhcp4_lexer.cc"
+#line 1779 "dhcp4_lexer.cc"
 
 #define INITIAL 0
 #define COMMENT 1
@@ -2103,7 +2103,7 @@ YY_DECL
     }
 
 
-#line 2106 "dhcp4_lexer.cc"
+#line 2107 "dhcp4_lexer.cc"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -4385,7 +4385,7 @@ YY_RULE_SETUP
 #line 1807 "dhcp4_lexer.ll"
 ECHO;
 	YY_BREAK
-#line 4388 "dhcp4_lexer.cc"
+#line 4389 "dhcp4_lexer.cc"
 
 	case YY_END_OF_BUFFER:
 		{
diff --git a/src/bin/dhcp4/dhcp4_parser.cc b/src/bin/dhcp4/dhcp4_parser.cc
index 4874ba3b30..bb8ef6705d 100644
--- a/src/bin/dhcp4/dhcp4_parser.cc
+++ b/src/bin/dhcp4/dhcp4_parser.cc
@@ -1,8 +1,8 @@
-// A Bison parser, made by GNU Bison 3.2.1.
+// A Bison parser, made by GNU Bison 3.0.4.
 
 // Skeleton implementation for Bison LALR(1) parsers in C++
 
-// Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -30,24 +30,32 @@
 // This special exception was added by the Free Software Foundation in
 // version 2.2 of Bison.
 
-// Undocumented macros, especially those whose name start with YY_,
-// are private implementation details.  Do not rely on them.
-
-
 // Take the name prefix into account.
 #define yylex   parser4_lex
 
+// First part of user declarations.
+
+#line 39 "dhcp4_parser.cc" // lalr1.cc:404
 
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
 
 #include "dhcp4_parser.h"
 
+// User implementation prologue.
 
+#line 53 "dhcp4_parser.cc" // lalr1.cc:412
 // Unqualified %code blocks.
-#line 34 "dhcp4_parser.yy" // lalr1.cc:438
+#line 34 "dhcp4_parser.yy" // lalr1.cc:413
 
 #include <dhcp4/parser_context.h>
 
-#line 51 "dhcp4_parser.cc" // lalr1.cc:438
+#line 59 "dhcp4_parser.cc" // lalr1.cc:413
 
 
 #ifndef YY_
@@ -62,15 +70,6 @@
 # endif
 #endif
 
-// Whether we are compiled with exception support.
-#ifndef YY_EXCEPTIONS
-# if defined __GNUC__ && !defined __EXCEPTIONS
-#  define YY_EXCEPTIONS 0
-# else
-#  define YY_EXCEPTIONS 1
-# endif
-#endif
-
 #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    If N is 0, then set CURRENT to the empty location which ends
@@ -107,7 +106,7 @@
     {                                           \
       *yycdebug_ << Title << ' ';               \
       yy_print_ (*yycdebug_, Symbol);           \
-      *yycdebug_ << '\n';                       \
+      *yycdebug_ << std::endl;                  \
     }                                           \
   } while (false)
 
@@ -126,9 +125,9 @@
 #else // !PARSER4_DEBUG
 
 # define YYCDEBUG if (false) std::cerr
-# define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE (Symbol)
-# define YY_REDUCE_PRINT(Rule)           static_cast<void> (0)
-# define YY_STACK_PRINT()                static_cast<void> (0)
+# define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE(Symbol)
+# define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
+# define YY_STACK_PRINT()                static_cast<void>(0)
 
 #endif // !PARSER4_DEBUG
 
@@ -140,9 +139,9 @@
 #define YYERROR         goto yyerrorlab
 #define YYRECOVERING()  (!!yyerrstatus_)
 
-#line 14 "dhcp4_parser.yy" // lalr1.cc:513
+#line 14 "dhcp4_parser.yy" // lalr1.cc:479
 namespace isc { namespace dhcp {
-#line 146 "dhcp4_parser.cc" // lalr1.cc:513
+#line 145 "dhcp4_parser.cc" // lalr1.cc:479
 
   /* Return YYSTR after stripping away unnecessary quotes and
      backslashes, so that it's suitable for yyerror.  The heuristic is
@@ -203,20 +202,24 @@ namespace isc { namespace dhcp {
 
 
   // by_state.
+  inline
   Dhcp4Parser::by_state::by_state ()
     : state (empty_state)
   {}
 
+  inline
   Dhcp4Parser::by_state::by_state (const by_state& other)
     : state (other.state)
   {}
 
+  inline
   void
   Dhcp4Parser::by_state::clear ()
   {
     state = empty_state;
   }
 
+  inline
   void
   Dhcp4Parser::by_state::move (by_state& that)
   {
@@ -224,10 +227,12 @@ namespace isc { namespace dhcp {
     that.clear ();
   }
 
+  inline
   Dhcp4Parser::by_state::by_state (state_type s)
     : state (s)
   {}
 
+  inline
   Dhcp4Parser::symbol_number_type
   Dhcp4Parser::by_state::type_get () const
   {
@@ -237,55 +242,16 @@ namespace isc { namespace dhcp {
       return yystos_[state];
   }
 
+  inline
   Dhcp4Parser::stack_symbol_type::stack_symbol_type ()
   {}
 
-  Dhcp4Parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
-    : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
-  {
-    switch (that.type_get ())
-    {
-      case 185: // value
-      case 189: // map_value
-      case 230: // socket_type
-      case 233: // outbound_interface_value
-      case 255: // db_type
-      case 337: // hr_mode
-      case 486: // ncr_protocol_value
-      case 493: // replace_client_name_value
-        value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
-        break;
-
-      case 168: // "boolean"
-        value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
-        break;
-
-      case 167: // "floating point"
-        value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
-        break;
-
-      case 166: // "integer"
-        value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
-        break;
-
-      case 165: // "constant string"
-        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
-        break;
-
-      default:
-        break;
-    }
-
-#if defined __cplusplus && 201103L <= __cplusplus
-    // that is emptied.
-    that.state = empty_state;
-#endif
-  }
 
-  Dhcp4Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
-    : super_type (s, YY_MOVE (that.location))
+  inline
+  Dhcp4Parser::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that)
+    : super_type (s, that.location)
   {
-    switch (that.type_get ())
+      switch (that.type_get ())
     {
       case 185: // value
       case 189: // map_value
@@ -295,23 +261,23 @@ namespace isc { namespace dhcp {
       case 337: // hr_mode
       case 486: // ncr_protocol_value
       case 493: // replace_client_name_value
-        value.move< ElementPtr > (YY_MOVE (that.value));
+        value.move< ElementPtr > (that.value);
         break;
 
       case 168: // "boolean"
-        value.move< bool > (YY_MOVE (that.value));
+        value.move< bool > (that.value);
         break;
 
       case 167: // "floating point"
-        value.move< double > (YY_MOVE (that.value));
+        value.move< double > (that.value);
         break;
 
       case 166: // "integer"
-        value.move< int64_t > (YY_MOVE (that.value));
+        value.move< int64_t > (that.value);
         break;
 
       case 165: // "constant string"
-        value.move< std::string > (YY_MOVE (that.value));
+        value.move< std::string > (that.value);
         break;
 
       default:
@@ -322,12 +288,12 @@ namespace isc { namespace dhcp {
     that.type = empty_symbol;
   }
 
-#if !defined __cplusplus || __cplusplus < 201103L
+  inline
   Dhcp4Parser::stack_symbol_type&
-  Dhcp4Parser::stack_symbol_type::operator= (stack_symbol_type& that)
+  Dhcp4Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
   {
     state = that.state;
-    switch (that.type_get ())
+      switch (that.type_get ())
     {
       case 185: // value
       case 189: // map_value
@@ -337,23 +303,23 @@ namespace isc { namespace dhcp {
       case 337: // hr_mode
       case 486: // ncr_protocol_value
       case 493: // replace_client_name_value
-        value.move< ElementPtr > (that.value);
+        value.copy< ElementPtr > (that.value);
         break;
 
       case 168: // "boolean"
-        value.move< bool > (that.value);
+        value.copy< bool > (that.value);
         break;
 
       case 167: // "floating point"
-        value.move< double > (that.value);
+        value.copy< double > (that.value);
         break;
 
       case 166: // "integer"
-        value.move< int64_t > (that.value);
+        value.copy< int64_t > (that.value);
         break;
 
       case 165: // "constant string"
-        value.move< std::string > (that.value);
+        value.copy< std::string > (that.value);
         break;
 
       default:
@@ -361,13 +327,12 @@ namespace isc { namespace dhcp {
     }
 
     location = that.location;
-    // that is emptied.
-    that.state = empty_state;
     return *this;
   }
-#endif
+
 
   template <typename Base>
+  inline
   void
   Dhcp4Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
   {
@@ -395,86 +360,86 @@ namespace isc { namespace dhcp {
     {
             case 165: // "constant string"
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< std::string > (); }
-#line 401 "dhcp4_parser.cc" // lalr1.cc:672
+#line 366 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 166: // "integer"
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< int64_t > (); }
-#line 408 "dhcp4_parser.cc" // lalr1.cc:672
+#line 373 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 167: // "floating point"
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< double > (); }
-#line 415 "dhcp4_parser.cc" // lalr1.cc:672
+#line 380 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 168: // "boolean"
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< bool > (); }
-#line 422 "dhcp4_parser.cc" // lalr1.cc:672
+#line 387 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 185: // value
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 429 "dhcp4_parser.cc" // lalr1.cc:672
+#line 394 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 189: // map_value
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 436 "dhcp4_parser.cc" // lalr1.cc:672
+#line 401 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 230: // socket_type
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 443 "dhcp4_parser.cc" // lalr1.cc:672
+#line 408 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 233: // outbound_interface_value
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 450 "dhcp4_parser.cc" // lalr1.cc:672
+#line 415 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 255: // db_type
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 457 "dhcp4_parser.cc" // lalr1.cc:672
+#line 422 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 337: // hr_mode
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 464 "dhcp4_parser.cc" // lalr1.cc:672
+#line 429 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 486: // ncr_protocol_value
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 471 "dhcp4_parser.cc" // lalr1.cc:672
+#line 436 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
       case 493: // replace_client_name_value
 
-#line 245 "dhcp4_parser.yy" // lalr1.cc:672
+#line 245 "dhcp4_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 478 "dhcp4_parser.cc" // lalr1.cc:672
+#line 443 "dhcp4_parser.cc" // lalr1.cc:636
         break;
 
 
@@ -485,27 +450,26 @@ namespace isc { namespace dhcp {
   }
 #endif
 
+  inline
   void
-  Dhcp4Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
+  Dhcp4Parser::yypush_ (const char* m, state_type s, symbol_type& sym)
   {
-    if (m)
-      YY_SYMBOL_PRINT (m, sym);
-    yystack_.push (YY_MOVE (sym));
+    stack_symbol_type t (s, sym);
+    yypush_ (m, t);
   }
 
+  inline
   void
-  Dhcp4Parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
+  Dhcp4Parser::yypush_ (const char* m, stack_symbol_type& s)
   {
-#if defined __cplusplus && 201103L <= __cplusplus
-    yypush_ (m, stack_symbol_type (s, std::move (sym)));
-#else
-    stack_symbol_type ss (s, sym);
-    yypush_ (m, ss);
-#endif
+    if (m)
+      YY_SYMBOL_PRINT (m, s);
+    yystack_.push (s);
   }
 
+  inline
   void
-  Dhcp4Parser::yypop_ (int n)
+  Dhcp4Parser::yypop_ (unsigned int n)
   {
     yystack_.pop (n);
   }
@@ -537,7 +501,7 @@ namespace isc { namespace dhcp {
   }
 #endif // PARSER4_DEBUG
 
-  Dhcp4Parser::state_type
+  inline Dhcp4Parser::state_type
   Dhcp4Parser::yy_lr_goto_state_ (state_type yystate, int yysym)
   {
     int yyr = yypgoto_[yysym - yyntokens_] + yystate;
@@ -547,25 +511,19 @@ namespace isc { namespace dhcp {
       return yydefgoto_[yysym - yyntokens_];
   }
 
-  bool
+  inline bool
   Dhcp4Parser::yy_pact_value_is_default_ (int yyvalue)
   {
     return yyvalue == yypact_ninf_;
   }
 
-  bool
+  inline bool
   Dhcp4Parser::yy_table_value_is_error_ (int yyvalue)
   {
     return yyvalue == yytable_ninf_;
   }
 
   int
-  Dhcp4Parser::operator() ()
-  {
-    return parse ();
-  }
-
-  int
   Dhcp4Parser::parse ()
   {
     // State.
@@ -586,11 +544,11 @@ namespace isc { namespace dhcp {
     /// The return value of parse ().
     int yyresult;
 
-#if YY_EXCEPTIONS
+    // FIXME: This shoud be completely indented.  It is not yet to
+    // avoid gratuitous conflicts when merging into the master branch.
     try
-#endif // YY_EXCEPTIONS
       {
-    YYCDEBUG << "Starting parse\n";
+    YYCDEBUG << "Starting parse" << std::endl;
 
 
     /* Initialize the stack.  The initial state will be set in
@@ -598,11 +556,11 @@ namespace isc { namespace dhcp {
        location values to have been already stored, initialize these
        stacks with a primary value.  */
     yystack_.clear ();
-    yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
+    yypush_ (YY_NULLPTR, 0, yyla);
 
     // A new symbol was pushed on the stack.
   yynewstate:
-    YYCDEBUG << "Entering state " << yystack_[0].state << '\n';
+    YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
 
     // Accept?
     if (yystack_[0].state == yyfinal_)
@@ -612,6 +570,7 @@ namespace isc { namespace dhcp {
 
     // Backup.
   yybackup:
+
     // Try to take a decision without lookahead.
     yyn = yypact_[yystack_[0].state];
     if (yy_pact_value_is_default_ (yyn))
@@ -621,20 +580,16 @@ namespace isc { namespace dhcp {
     if (yyla.empty ())
       {
         YYCDEBUG << "Reading a token: ";
-#if YY_EXCEPTIONS
         try
-#endif // YY_EXCEPTIONS
           {
             symbol_type yylookahead (yylex (ctx));
             yyla.move (yylookahead);
           }
-#if YY_EXCEPTIONS
         catch (const syntax_error& yyexc)
           {
             error (yyexc);
             goto yyerrlab1;
           }
-#endif // YY_EXCEPTIONS
       }
     YY_SYMBOL_PRINT ("Next token is", yyla);
 
@@ -659,7 +614,7 @@ namespace isc { namespace dhcp {
       --yyerrstatus_;
 
     // Shift the lookahead token.
-    yypush_ ("Shifting", yyn, YY_MOVE (yyla));
+    yypush_ ("Shifting", yyn, yyla);
     goto yynewstate;
 
   /*-----------------------------------------------------------.
@@ -678,11 +633,11 @@ namespace isc { namespace dhcp {
     yylen = yyr2_[yyn];
     {
       stack_symbol_type yylhs;
-      yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
+      yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);
       /* Variants are always initialized to an empty instance of the
          correct type. The default '$$ = $1' action is NOT applied
          when using variants.  */
-      switch (yyr1_[yyn])
+        switch (yyr1_[yyn])
     {
       case 185: // value
       case 189: // map_value
@@ -692,23 +647,23 @@ namespace isc { namespace dhcp {
       case 337: // hr_mode
       case 486: // ncr_protocol_value
       case 493: // replace_client_name_value
-        yylhs.value.emplace< ElementPtr > ();
+        yylhs.value.build< ElementPtr > ();
         break;
 
       case 168: // "boolean"
-        yylhs.value.emplace< bool > ();
+        yylhs.value.build< bool > ();
         break;
 
       case 167: // "floating point"
-        yylhs.value.emplace< double > ();
+        yylhs.value.build< double > ();
         break;
 
       case 166: // "integer"
-        yylhs.value.emplace< int64_t > ();
+        yylhs.value.build< int64_t > ();
         break;
 
       case 165: // "constant string"
-        yylhs.value.emplace< std::string > ();
+        yylhs.value.build< std::string > ();
         break;
 
       default:
@@ -716,296 +671,293 @@ namespace isc { namespace dhcp {
     }
 
 
-      // Default location.
+      // Compute the default @$.
       {
         slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
         YYLLOC_DEFAULT (yylhs.location, slice, yylen);
-        yyerror_range[1].location = yylhs.location;
       }
 
       // Perform the reduction.
       YY_REDUCE_PRINT (yyn);
-#if YY_EXCEPTIONS
       try
-#endif // YY_EXCEPTIONS
         {
           switch (yyn)
             {
   case 2:
-#line 254 "dhcp4_parser.yy" // lalr1.cc:907
+#line 254 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.NO_KEYWORD; }
-#line 738 "dhcp4_parser.cc" // lalr1.cc:907
+#line 690 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 4:
-#line 255 "dhcp4_parser.yy" // lalr1.cc:907
+#line 255 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.CONFIG; }
-#line 744 "dhcp4_parser.cc" // lalr1.cc:907
+#line 696 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 6:
-#line 256 "dhcp4_parser.yy" // lalr1.cc:907
+#line 256 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.DHCP4; }
-#line 750 "dhcp4_parser.cc" // lalr1.cc:907
+#line 702 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 8:
-#line 257 "dhcp4_parser.yy" // lalr1.cc:907
+#line 257 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.INTERFACES_CONFIG; }
-#line 756 "dhcp4_parser.cc" // lalr1.cc:907
+#line 708 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 10:
-#line 258 "dhcp4_parser.yy" // lalr1.cc:907
+#line 258 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.SUBNET4; }
-#line 762 "dhcp4_parser.cc" // lalr1.cc:907
+#line 714 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 12:
-#line 259 "dhcp4_parser.yy" // lalr1.cc:907
+#line 259 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.POOLS; }
-#line 768 "dhcp4_parser.cc" // lalr1.cc:907
+#line 720 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 14:
-#line 260 "dhcp4_parser.yy" // lalr1.cc:907
+#line 260 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.RESERVATIONS; }
-#line 774 "dhcp4_parser.cc" // lalr1.cc:907
+#line 726 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 16:
-#line 261 "dhcp4_parser.yy" // lalr1.cc:907
+#line 261 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.DHCP4; }
-#line 780 "dhcp4_parser.cc" // lalr1.cc:907
+#line 732 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 18:
-#line 262 "dhcp4_parser.yy" // lalr1.cc:907
+#line 262 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.OPTION_DEF; }
-#line 786 "dhcp4_parser.cc" // lalr1.cc:907
+#line 738 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 20:
-#line 263 "dhcp4_parser.yy" // lalr1.cc:907
+#line 263 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.OPTION_DATA; }
-#line 792 "dhcp4_parser.cc" // lalr1.cc:907
+#line 744 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 22:
-#line 264 "dhcp4_parser.yy" // lalr1.cc:907
+#line 264 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
-#line 798 "dhcp4_parser.cc" // lalr1.cc:907
+#line 750 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 24:
-#line 265 "dhcp4_parser.yy" // lalr1.cc:907
+#line 265 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.DHCP_DDNS; }
-#line 804 "dhcp4_parser.cc" // lalr1.cc:907
+#line 756 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 26:
-#line 266 "dhcp4_parser.yy" // lalr1.cc:907
+#line 266 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.LOGGING; }
-#line 810 "dhcp4_parser.cc" // lalr1.cc:907
+#line 762 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 28:
-#line 267 "dhcp4_parser.yy" // lalr1.cc:907
+#line 267 "dhcp4_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.CONFIG_CONTROL; }
-#line 816 "dhcp4_parser.cc" // lalr1.cc:907
+#line 768 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 30:
-#line 275 "dhcp4_parser.yy" // lalr1.cc:907
+#line 275 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location))); }
-#line 822 "dhcp4_parser.cc" // lalr1.cc:907
+#line 774 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 31:
-#line 276 "dhcp4_parser.yy" // lalr1.cc:907
+#line 276 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as< double > (), ctx.loc2pos(yystack_[0].location))); }
-#line 828 "dhcp4_parser.cc" // lalr1.cc:907
+#line 780 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 32:
-#line 277 "dhcp4_parser.yy" // lalr1.cc:907
+#line 277 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location))); }
-#line 834 "dhcp4_parser.cc" // lalr1.cc:907
+#line 786 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 33:
-#line 278 "dhcp4_parser.yy" // lalr1.cc:907
+#line 278 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location))); }
-#line 840 "dhcp4_parser.cc" // lalr1.cc:907
+#line 792 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 34:
-#line 279 "dhcp4_parser.yy" // lalr1.cc:907
+#line 279 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
-#line 846 "dhcp4_parser.cc" // lalr1.cc:907
+#line 798 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 35:
-#line 280 "dhcp4_parser.yy" // lalr1.cc:907
+#line 280 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
-#line 852 "dhcp4_parser.cc" // lalr1.cc:907
+#line 804 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 36:
-#line 281 "dhcp4_parser.yy" // lalr1.cc:907
+#line 281 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
-#line 858 "dhcp4_parser.cc" // lalr1.cc:907
+#line 810 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 37:
-#line 284 "dhcp4_parser.yy" // lalr1.cc:907
+#line 284 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Push back the JSON value on the stack
     ctx.stack_.push_back(yystack_[0].value.as< ElementPtr > ());
 }
-#line 867 "dhcp4_parser.cc" // lalr1.cc:907
+#line 819 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 38:
-#line 289 "dhcp4_parser.yy" // lalr1.cc:907
+#line 289 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // This code is executed when we're about to start parsing
     // the content of the map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 878 "dhcp4_parser.cc" // lalr1.cc:907
+#line 830 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 39:
-#line 294 "dhcp4_parser.yy" // lalr1.cc:907
+#line 294 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // map parsing completed. If we ever want to do any wrap up
     // (maybe some sanity checking), this would be the best place
     // for it.
 }
-#line 888 "dhcp4_parser.cc" // lalr1.cc:907
+#line 840 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 40:
-#line 300 "dhcp4_parser.yy" // lalr1.cc:907
+#line 300 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
-#line 894 "dhcp4_parser.cc" // lalr1.cc:907
+#line 846 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 43:
-#line 307 "dhcp4_parser.yy" // lalr1.cc:907
+#line 307 "dhcp4_parser.yy" // lalr1.cc:859
     {
                   // map containing a single entry
                   ctx.stack_.back()->set(yystack_[2].value.as< std::string > (), yystack_[0].value.as< ElementPtr > ());
                   }
-#line 903 "dhcp4_parser.cc" // lalr1.cc:907
+#line 855 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 44:
-#line 311 "dhcp4_parser.yy" // lalr1.cc:907
+#line 311 "dhcp4_parser.yy" // lalr1.cc:859
     {
                   // map consisting of a shorter map followed by
                   // comma and string:value
                   ctx.stack_.back()->set(yystack_[2].value.as< std::string > (), yystack_[0].value.as< ElementPtr > ());
                   }
-#line 913 "dhcp4_parser.cc" // lalr1.cc:907
+#line 865 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 45:
-#line 318 "dhcp4_parser.yy" // lalr1.cc:907
+#line 318 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(l);
 }
-#line 922 "dhcp4_parser.cc" // lalr1.cc:907
+#line 874 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 46:
-#line 321 "dhcp4_parser.yy" // lalr1.cc:907
+#line 321 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // list parsing complete. Put any sanity checking here
 }
-#line 930 "dhcp4_parser.cc" // lalr1.cc:907
+#line 882 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 49:
-#line 329 "dhcp4_parser.yy" // lalr1.cc:907
+#line 329 "dhcp4_parser.yy" // lalr1.cc:859
     {
                   // List consisting of a single element.
                   ctx.stack_.back()->add(yystack_[0].value.as< ElementPtr > ());
                   }
-#line 939 "dhcp4_parser.cc" // lalr1.cc:907
+#line 891 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 50:
-#line 333 "dhcp4_parser.yy" // lalr1.cc:907
+#line 333 "dhcp4_parser.yy" // lalr1.cc:859
     {
                   // List ending with , and a value.
                   ctx.stack_.back()->add(yystack_[0].value.as< ElementPtr > ());
                   }
-#line 948 "dhcp4_parser.cc" // lalr1.cc:907
+#line 900 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 51:
-#line 340 "dhcp4_parser.yy" // lalr1.cc:907
+#line 340 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // List parsing about to start
 }
-#line 956 "dhcp4_parser.cc" // lalr1.cc:907
+#line 908 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 52:
-#line 342 "dhcp4_parser.yy" // lalr1.cc:907
+#line 342 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // list parsing complete. Put any sanity checking here
     //ctx.stack_.pop_back();
 }
-#line 965 "dhcp4_parser.cc" // lalr1.cc:907
+#line 917 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 55:
-#line 351 "dhcp4_parser.yy" // lalr1.cc:907
+#line 351 "dhcp4_parser.yy" // lalr1.cc:859
     {
                           ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
                           ctx.stack_.back()->add(s);
                           }
-#line 974 "dhcp4_parser.cc" // lalr1.cc:907
+#line 926 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 56:
-#line 355 "dhcp4_parser.yy" // lalr1.cc:907
+#line 355 "dhcp4_parser.yy" // lalr1.cc:859
     {
                           ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
                           ctx.stack_.back()->add(s);
                           }
-#line 983 "dhcp4_parser.cc" // lalr1.cc:907
+#line 935 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 57:
-#line 366 "dhcp4_parser.yy" // lalr1.cc:907
+#line 366 "dhcp4_parser.yy" // lalr1.cc:859
     {
     const std::string& where = ctx.contextName();
     const std::string& keyword = yystack_[1].value.as< std::string > ();
     error(yystack_[1].location,
           "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
 }
-#line 994 "dhcp4_parser.cc" // lalr1.cc:907
+#line 946 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 58:
-#line 376 "dhcp4_parser.yy" // lalr1.cc:907
+#line 376 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // This code is executed when we're about to start parsing
     // the content of the map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1005 "dhcp4_parser.cc" // lalr1.cc:907
+#line 957 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 59:
-#line 381 "dhcp4_parser.yy" // lalr1.cc:907
+#line 381 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // map parsing completed. If we ever want to do any wrap up
     // (maybe some sanity checking), this would be the best place
@@ -1014,11 +966,11 @@ namespace isc { namespace dhcp {
     // Dhcp4 is required
     ctx.require("Dhcp4", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
 }
-#line 1018 "dhcp4_parser.cc" // lalr1.cc:907
+#line 970 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 68:
-#line 405 "dhcp4_parser.yy" // lalr1.cc:907
+#line 405 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // This code is executed when we're about to start parsing
     // the content of the map
@@ -1027,302 +979,302 @@ namespace isc { namespace dhcp {
     ctx.stack_.push_back(m);
     ctx.enter(ctx.DHCP4);
 }
-#line 1031 "dhcp4_parser.cc" // lalr1.cc:907
+#line 983 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 69:
-#line 412 "dhcp4_parser.yy" // lalr1.cc:907
+#line 412 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No global parameter is required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1041 "dhcp4_parser.cc" // lalr1.cc:907
+#line 993 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 70:
-#line 420 "dhcp4_parser.yy" // lalr1.cc:907
+#line 420 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the Dhcp4 map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1051 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1003 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 71:
-#line 424 "dhcp4_parser.yy" // lalr1.cc:907
+#line 424 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No global parameter is required
     // parsing completed
 }
-#line 1060 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1012 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 108:
-#line 471 "dhcp4_parser.yy" // lalr1.cc:907
+#line 471 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("valid-lifetime", prf);
 }
-#line 1069 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1021 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 109:
-#line 476 "dhcp4_parser.yy" // lalr1.cc:907
+#line 476 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("renew-timer", prf);
 }
-#line 1078 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1030 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 110:
-#line 481 "dhcp4_parser.yy" // lalr1.cc:907
+#line 481 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("rebind-timer", prf);
 }
-#line 1087 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1039 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 111:
-#line 486 "dhcp4_parser.yy" // lalr1.cc:907
+#line 486 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr dpp(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("decline-probation-period", dpp);
 }
-#line 1096 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1048 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 112:
-#line 491 "dhcp4_parser.yy" // lalr1.cc:907
+#line 491 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1104 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1056 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 113:
-#line 493 "dhcp4_parser.yy" // lalr1.cc:907
+#line 493 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr stag(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-tag", stag);
     ctx.leave();
 }
-#line 1114 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1066 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 114:
-#line 499 "dhcp4_parser.yy" // lalr1.cc:907
+#line 499 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr echo(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("echo-client-id", echo);
 }
-#line 1123 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1075 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 115:
-#line 504 "dhcp4_parser.yy" // lalr1.cc:907
+#line 504 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr match(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("match-client-id", match);
 }
-#line 1132 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1084 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 116:
-#line 509 "dhcp4_parser.yy" // lalr1.cc:907
+#line 509 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("authoritative", prf);
 }
-#line 1141 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1093 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 117:
-#line 515 "dhcp4_parser.yy" // lalr1.cc:907
+#line 515 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interfaces-config", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.INTERFACES_CONFIG);
 }
-#line 1152 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1104 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 118:
-#line 520 "dhcp4_parser.yy" // lalr1.cc:907
+#line 520 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No interfaces config param is required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1162 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1114 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 128:
-#line 539 "dhcp4_parser.yy" // lalr1.cc:907
+#line 539 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the interfaces-config map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1172 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1124 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 129:
-#line 543 "dhcp4_parser.yy" // lalr1.cc:907
+#line 543 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No interfaces config param is required
     // parsing completed
 }
-#line 1181 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1133 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 130:
-#line 548 "dhcp4_parser.yy" // lalr1.cc:907
+#line 548 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interfaces", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1192 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1144 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 131:
-#line 553 "dhcp4_parser.yy" // lalr1.cc:907
+#line 553 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1201 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1153 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 132:
-#line 558 "dhcp4_parser.yy" // lalr1.cc:907
+#line 558 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.DHCP_SOCKET_TYPE);
 }
-#line 1209 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1161 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 133:
-#line 560 "dhcp4_parser.yy" // lalr1.cc:907
+#line 560 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("dhcp-socket-type", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 1218 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1170 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 134:
-#line 565 "dhcp4_parser.yy" // lalr1.cc:907
+#line 565 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("raw", ctx.loc2pos(yystack_[0].location))); }
-#line 1224 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1176 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 135:
-#line 566 "dhcp4_parser.yy" // lalr1.cc:907
+#line 566 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("udp", ctx.loc2pos(yystack_[0].location))); }
-#line 1230 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1182 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 136:
-#line 569 "dhcp4_parser.yy" // lalr1.cc:907
+#line 569 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.OUTBOUND_INTERFACE);
 }
-#line 1238 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1190 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 137:
-#line 571 "dhcp4_parser.yy" // lalr1.cc:907
+#line 571 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("outbound-interface", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 1247 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1199 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 138:
-#line 576 "dhcp4_parser.yy" // lalr1.cc:907
+#line 576 "dhcp4_parser.yy" // lalr1.cc:859
     {
     yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("same-as-inbound", ctx.loc2pos(yystack_[0].location)));
 }
-#line 1255 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1207 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 139:
-#line 578 "dhcp4_parser.yy" // lalr1.cc:907
+#line 578 "dhcp4_parser.yy" // lalr1.cc:859
     {
     yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("use-routing", ctx.loc2pos(yystack_[0].location)));
     }
-#line 1263 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1215 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 140:
-#line 582 "dhcp4_parser.yy" // lalr1.cc:907
+#line 582 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("re-detect", b);
 }
-#line 1272 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1224 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 141:
-#line 588 "dhcp4_parser.yy" // lalr1.cc:907
+#line 588 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("lease-database", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.LEASE_DATABASE);
 }
-#line 1283 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1235 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 142:
-#line 593 "dhcp4_parser.yy" // lalr1.cc:907
+#line 593 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required
     ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1294 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1246 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 143:
-#line 600 "dhcp4_parser.yy" // lalr1.cc:907
+#line 600 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("sanity-checks", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.SANITY_CHECKS);
 }
-#line 1305 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1257 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 144:
-#line 605 "dhcp4_parser.yy" // lalr1.cc:907
+#line 605 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1314 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1266 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 148:
-#line 615 "dhcp4_parser.yy" // lalr1.cc:907
+#line 615 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1322 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1274 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 149:
-#line 617 "dhcp4_parser.yy" // lalr1.cc:907
+#line 617 "dhcp4_parser.yy" // lalr1.cc:859
     {
 
     if ( (string(yystack_[0].value.as< std::string > ()) == "none") ||
@@ -1338,577 +1290,577 @@ namespace isc { namespace dhcp {
               ", supported values are: none, warn, fix, fix-del, del");
     }
 }
-#line 1342 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1294 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 150:
-#line 633 "dhcp4_parser.yy" // lalr1.cc:907
+#line 633 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hosts-database", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.HOSTS_DATABASE);
 }
-#line 1353 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1305 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 151:
-#line 638 "dhcp4_parser.yy" // lalr1.cc:907
+#line 638 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required
     ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1364 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1316 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 152:
-#line 645 "dhcp4_parser.yy" // lalr1.cc:907
+#line 645 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hosts-databases", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.HOSTS_DATABASE);
 }
-#line 1375 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1327 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 153:
-#line 650 "dhcp4_parser.yy" // lalr1.cc:907
+#line 650 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1384 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1336 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 158:
-#line 663 "dhcp4_parser.yy" // lalr1.cc:907
+#line 663 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 1394 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1346 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 159:
-#line 667 "dhcp4_parser.yy" // lalr1.cc:907
+#line 667 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required
     ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 1404 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1356 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 180:
-#line 697 "dhcp4_parser.yy" // lalr1.cc:907
+#line 697 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.DATABASE_TYPE);
 }
-#line 1412 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1364 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 181:
-#line 699 "dhcp4_parser.yy" // lalr1.cc:907
+#line 699 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("type", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 1421 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1373 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 182:
-#line 704 "dhcp4_parser.yy" // lalr1.cc:907
+#line 704 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); }
-#line 1427 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1379 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 183:
-#line 705 "dhcp4_parser.yy" // lalr1.cc:907
+#line 705 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); }
-#line 1433 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1385 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 184:
-#line 706 "dhcp4_parser.yy" // lalr1.cc:907
+#line 706 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); }
-#line 1439 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1391 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 185:
-#line 707 "dhcp4_parser.yy" // lalr1.cc:907
+#line 707 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("cql", ctx.loc2pos(yystack_[0].location))); }
-#line 1445 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1397 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 186:
-#line 710 "dhcp4_parser.yy" // lalr1.cc:907
+#line 710 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1453 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1405 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 187:
-#line 712 "dhcp4_parser.yy" // lalr1.cc:907
+#line 712 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr user(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("user", user);
     ctx.leave();
 }
-#line 1463 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1415 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 188:
-#line 718 "dhcp4_parser.yy" // lalr1.cc:907
+#line 718 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1471 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1423 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 189:
-#line 720 "dhcp4_parser.yy" // lalr1.cc:907
+#line 720 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr pwd(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("password", pwd);
     ctx.leave();
 }
-#line 1481 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1433 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 190:
-#line 726 "dhcp4_parser.yy" // lalr1.cc:907
+#line 726 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1489 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1441 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 191:
-#line 728 "dhcp4_parser.yy" // lalr1.cc:907
+#line 728 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr h(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("host", h);
     ctx.leave();
 }
-#line 1499 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1451 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 192:
-#line 734 "dhcp4_parser.yy" // lalr1.cc:907
+#line 734 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr p(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("port", p);
 }
-#line 1508 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1460 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 193:
-#line 739 "dhcp4_parser.yy" // lalr1.cc:907
+#line 739 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1516 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1468 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 194:
-#line 741 "dhcp4_parser.yy" // lalr1.cc:907
+#line 741 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr name(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("name", name);
     ctx.leave();
 }
-#line 1526 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1478 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 195:
-#line 747 "dhcp4_parser.yy" // lalr1.cc:907
+#line 747 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("persist", n);
 }
-#line 1535 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1487 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 196:
-#line 752 "dhcp4_parser.yy" // lalr1.cc:907
+#line 752 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("lfc-interval", n);
 }
-#line 1544 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1496 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 197:
-#line 757 "dhcp4_parser.yy" // lalr1.cc:907
+#line 757 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("readonly", n);
 }
-#line 1553 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1505 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 198:
-#line 762 "dhcp4_parser.yy" // lalr1.cc:907
+#line 762 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("connect-timeout", n);
 }
-#line 1562 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1514 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 199:
-#line 767 "dhcp4_parser.yy" // lalr1.cc:907
+#line 767 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("request-timeout", n);
 }
-#line 1571 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1523 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 200:
-#line 772 "dhcp4_parser.yy" // lalr1.cc:907
+#line 772 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("tcp-keepalive", n);
 }
-#line 1580 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1532 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 201:
-#line 777 "dhcp4_parser.yy" // lalr1.cc:907
+#line 777 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("tcp-nodelay", n);
 }
-#line 1589 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1541 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 202:
-#line 782 "dhcp4_parser.yy" // lalr1.cc:907
+#line 782 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1597 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1549 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 203:
-#line 784 "dhcp4_parser.yy" // lalr1.cc:907
+#line 784 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr cp(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("contact-points", cp);
     ctx.leave();
 }
-#line 1607 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1559 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 204:
-#line 790 "dhcp4_parser.yy" // lalr1.cc:907
+#line 790 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1615 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1567 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 205:
-#line 792 "dhcp4_parser.yy" // lalr1.cc:907
+#line 792 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr ks(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("keyspace", ks);
     ctx.leave();
 }
-#line 1625 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1577 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 206:
-#line 798 "dhcp4_parser.yy" // lalr1.cc:907
+#line 798 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-reconnect-tries", n);
 }
-#line 1634 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1586 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 207:
-#line 803 "dhcp4_parser.yy" // lalr1.cc:907
+#line 803 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("reconnect-wait-time", n);
 }
-#line 1643 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1595 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 208:
-#line 808 "dhcp4_parser.yy" // lalr1.cc:907
+#line 808 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("host-reservation-identifiers", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.HOST_RESERVATION_IDENTIFIERS);
 }
-#line 1654 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1606 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 209:
-#line 813 "dhcp4_parser.yy" // lalr1.cc:907
+#line 813 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1663 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1615 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 217:
-#line 829 "dhcp4_parser.yy" // lalr1.cc:907
+#line 829 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(duid);
 }
-#line 1672 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1624 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 218:
-#line 834 "dhcp4_parser.yy" // lalr1.cc:907
+#line 834 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(hwaddr);
 }
-#line 1681 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1633 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 219:
-#line 839 "dhcp4_parser.yy" // lalr1.cc:907
+#line 839 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr circuit(new StringElement("circuit-id", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(circuit);
 }
-#line 1690 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1642 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 220:
-#line 844 "dhcp4_parser.yy" // lalr1.cc:907
+#line 844 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr client(new StringElement("client-id", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(client);
 }
-#line 1699 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1651 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 221:
-#line 849 "dhcp4_parser.yy" // lalr1.cc:907
+#line 849 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(flex_id);
 }
-#line 1708 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1660 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 222:
-#line 854 "dhcp4_parser.yy" // lalr1.cc:907
+#line 854 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hooks-libraries", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.HOOKS_LIBRARIES);
 }
-#line 1719 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1671 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 223:
-#line 859 "dhcp4_parser.yy" // lalr1.cc:907
+#line 859 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1728 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1680 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 228:
-#line 872 "dhcp4_parser.yy" // lalr1.cc:907
+#line 872 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 1738 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1690 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 229:
-#line 876 "dhcp4_parser.yy" // lalr1.cc:907
+#line 876 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The library hooks parameter is required
     ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 1748 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1700 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 230:
-#line 882 "dhcp4_parser.yy" // lalr1.cc:907
+#line 882 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the hooks-libraries list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1758 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1710 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 231:
-#line 886 "dhcp4_parser.yy" // lalr1.cc:907
+#line 886 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The library hooks parameter is required
     ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 1768 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1720 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 237:
-#line 901 "dhcp4_parser.yy" // lalr1.cc:907
+#line 901 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1776 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1728 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 238:
-#line 903 "dhcp4_parser.yy" // lalr1.cc:907
+#line 903 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr lib(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("library", lib);
     ctx.leave();
 }
-#line 1786 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1738 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 239:
-#line 909 "dhcp4_parser.yy" // lalr1.cc:907
+#line 909 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1794 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1746 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 240:
-#line 911 "dhcp4_parser.yy" // lalr1.cc:907
+#line 911 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("parameters", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 1803 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1755 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 241:
-#line 917 "dhcp4_parser.yy" // lalr1.cc:907
+#line 917 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("expired-leases-processing", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.EXPIRED_LEASES_PROCESSING);
 }
-#line 1814 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1766 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 242:
-#line 922 "dhcp4_parser.yy" // lalr1.cc:907
+#line 922 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No expired lease parameter is required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1824 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1776 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 251:
-#line 940 "dhcp4_parser.yy" // lalr1.cc:907
+#line 940 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("reclaim-timer-wait-time", value);
 }
-#line 1833 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1785 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 252:
-#line 945 "dhcp4_parser.yy" // lalr1.cc:907
+#line 945 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("flush-reclaimed-timer-wait-time", value);
 }
-#line 1842 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1794 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 253:
-#line 950 "dhcp4_parser.yy" // lalr1.cc:907
+#line 950 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hold-reclaimed-time", value);
 }
-#line 1851 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1803 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 254:
-#line 955 "dhcp4_parser.yy" // lalr1.cc:907
+#line 955 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-reclaim-leases", value);
 }
-#line 1860 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1812 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 255:
-#line 960 "dhcp4_parser.yy" // lalr1.cc:907
+#line 960 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-reclaim-time", value);
 }
-#line 1869 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1821 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 256:
-#line 965 "dhcp4_parser.yy" // lalr1.cc:907
+#line 965 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("unwarned-reclaim-cycles", value);
 }
-#line 1878 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1830 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 257:
-#line 973 "dhcp4_parser.yy" // lalr1.cc:907
+#line 973 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("subnet4", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.SUBNET4);
 }
-#line 1889 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1841 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 258:
-#line 978 "dhcp4_parser.yy" // lalr1.cc:907
+#line 978 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1898 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1850 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 263:
-#line 998 "dhcp4_parser.yy" // lalr1.cc:907
+#line 998 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 1908 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1860 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 264:
-#line 1002 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1002 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Once we reached this place, the subnet parsing is now complete.
     // If we want to, we can implement default values here.
@@ -1930,294 +1882,294 @@ namespace isc { namespace dhcp {
     ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 1934 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1886 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 265:
-#line 1024 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1024 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the subnet4 list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1944 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1896 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 266:
-#line 1028 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1028 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The subnet subnet4 parameter is required
     ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 1954 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1906 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 293:
-#line 1066 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1066 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1962 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1914 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 294:
-#line 1068 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1068 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr subnet(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("subnet", subnet);
     ctx.leave();
 }
-#line 1972 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1924 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 295:
-#line 1074 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1074 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1980 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1932 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 296:
-#line 1076 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1076 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr iface(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("4o6-interface", iface);
     ctx.leave();
 }
-#line 1990 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1942 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 297:
-#line 1082 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1082 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1998 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1950 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 298:
-#line 1084 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1084 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr iface(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("4o6-interface-id", iface);
     ctx.leave();
 }
-#line 2008 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1960 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 299:
-#line 1090 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1090 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2016 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1968 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 300:
-#line 1092 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1092 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr iface(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("4o6-subnet", iface);
     ctx.leave();
 }
-#line 2026 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1978 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 301:
-#line 1098 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1098 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2034 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1986 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 302:
-#line 1100 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1100 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr iface(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interface", iface);
     ctx.leave();
 }
-#line 2044 "dhcp4_parser.cc" // lalr1.cc:907
+#line 1996 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 303:
-#line 1106 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1106 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2052 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2004 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 304:
-#line 1108 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1108 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr cls(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-class", cls);
     ctx.leave();
 }
-#line 2062 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2014 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 305:
-#line 1114 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1114 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("require-client-classes", c);
     ctx.stack_.push_back(c);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2073 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2025 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 306:
-#line 1119 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1119 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2082 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2034 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 307:
-#line 1124 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1124 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.RESERVATION_MODE);
 }
-#line 2090 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2042 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 308:
-#line 1126 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1126 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("reservation-mode", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 2099 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2051 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 309:
-#line 1131 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1131 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("disabled", ctx.loc2pos(yystack_[0].location))); }
-#line 2105 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2057 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 310:
-#line 1132 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1132 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("out-of-pool", ctx.loc2pos(yystack_[0].location))); }
-#line 2111 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2063 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 311:
-#line 1133 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1133 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("global", ctx.loc2pos(yystack_[0].location))); }
-#line 2117 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2069 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 312:
-#line 1134 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1134 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("all", ctx.loc2pos(yystack_[0].location))); }
-#line 2123 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2075 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 313:
-#line 1137 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1137 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr id(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("id", id);
 }
-#line 2132 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2084 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 314:
-#line 1144 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1144 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("shared-networks", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.SHARED_NETWORK);
 }
-#line 2143 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2095 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 315:
-#line 1149 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1149 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2152 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2104 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 320:
-#line 1164 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1164 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2162 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2114 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 321:
-#line 1168 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1168 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 2170 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2122 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 343:
-#line 1201 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1201 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("option-def", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.OPTION_DEF);
 }
-#line 2181 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2133 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 344:
-#line 1206 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1206 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2190 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2142 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 345:
-#line 1214 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1214 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2199 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2151 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 346:
-#line 1217 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1217 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // parsing completed
 }
-#line 2207 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2159 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 351:
-#line 1233 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1233 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2217 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2169 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 352:
-#line 1237 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1237 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The name, code and type option def parameters are required.
     ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
@@ -2225,21 +2177,21 @@ namespace isc { namespace dhcp {
     ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2229 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2181 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 353:
-#line 1248 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1248 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the option-def list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2239 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2191 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 354:
-#line 1252 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1252 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The name, code and type option def parameters are required.
     ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
@@ -2247,281 +2199,281 @@ namespace isc { namespace dhcp {
     ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 2251 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2203 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 370:
-#line 1284 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1284 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr code(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("code", code);
 }
-#line 2260 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2212 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 372:
-#line 1291 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1291 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2268 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2220 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 373:
-#line 1293 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1293 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("type", prf);
     ctx.leave();
 }
-#line 2278 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2230 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 374:
-#line 1299 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1299 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2286 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2238 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 375:
-#line 1301 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1301 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr rtypes(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("record-types", rtypes);
     ctx.leave();
 }
-#line 2296 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2248 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 376:
-#line 1307 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1307 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2304 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2256 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 377:
-#line 1309 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1309 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr space(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("space", space);
     ctx.leave();
 }
-#line 2314 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2266 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 379:
-#line 1317 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1317 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2322 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2274 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 380:
-#line 1319 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1319 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr encap(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("encapsulate", encap);
     ctx.leave();
 }
-#line 2332 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2284 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 381:
-#line 1325 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1325 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr array(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("array", array);
 }
-#line 2341 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2293 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 382:
-#line 1334 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1334 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("option-data", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.OPTION_DATA);
 }
-#line 2352 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2304 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 383:
-#line 1339 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1339 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2361 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2313 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 388:
-#line 1358 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1358 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2371 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2323 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 389:
-#line 1362 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1362 "dhcp4_parser.yy" // lalr1.cc:859
     {
     /// @todo: the code or name parameters are required.
     ctx.stack_.pop_back();
 }
-#line 2380 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2332 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 390:
-#line 1370 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1370 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the option-data list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2390 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2342 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 391:
-#line 1374 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1374 "dhcp4_parser.yy" // lalr1.cc:859
     {
     /// @todo: the code or name parameters are required.
     // parsing completed
 }
-#line 2399 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2351 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 406:
-#line 1407 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1407 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2407 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2359 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 407:
-#line 1409 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1409 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr data(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("data", data);
     ctx.leave();
 }
-#line 2417 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2369 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 410:
-#line 1419 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1419 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr space(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("csv-format", space);
 }
-#line 2426 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2378 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 411:
-#line 1424 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1424 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr persist(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("always-send", persist);
 }
-#line 2435 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2387 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 412:
-#line 1432 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1432 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("pools", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.POOLS);
 }
-#line 2446 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2398 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 413:
-#line 1437 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1437 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2455 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2407 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 418:
-#line 1452 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1452 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2465 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2417 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 419:
-#line 1456 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1456 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The pool parameter is required.
     ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2475 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2427 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 420:
-#line 1462 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1462 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the pool list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2485 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2437 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 421:
-#line 1466 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1466 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The pool parameter is required.
     ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 2495 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2447 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 431:
-#line 1485 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1485 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2503 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2455 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 432:
-#line 1487 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1487 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr pool(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("pool", pool);
     ctx.leave();
 }
-#line 2513 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2465 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 433:
-#line 1493 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1493 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2521 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2473 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 434:
-#line 1495 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1495 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr parent = ctx.stack_.back();
     ElementPtr user_context = yystack_[0].value.as< ElementPtr > ();
@@ -2544,19 +2496,19 @@ namespace isc { namespace dhcp {
     parent->set("user-context", user_context);
     ctx.leave();
 }
-#line 2548 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2500 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 435:
-#line 1518 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1518 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2556 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2508 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 436:
-#line 1520 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1520 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr parent = ctx.stack_.back();
     ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
@@ -2581,1109 +2533,1134 @@ namespace isc { namespace dhcp {
     parent->set("user-context", user_context);
     ctx.leave();
 }
-#line 2585 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2537 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 437:
-#line 1548 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1548 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("reservations", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.RESERVATIONS);
 }
-#line 2596 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2548 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 438:
-#line 1553 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1553 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2605 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2557 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 443:
-#line 1566 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1566 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2615 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2567 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 444:
-#line 1570 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1570 "dhcp4_parser.yy" // lalr1.cc:859
     {
     /// @todo: an identifier parameter is required.
     ctx.stack_.pop_back();
 }
-#line 2624 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2576 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 445:
-#line 1575 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1575 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the reservations list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2634 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2586 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 446:
-#line 1579 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1579 "dhcp4_parser.yy" // lalr1.cc:859
     {
     /// @todo: an identifier parameter is required.
     // parsing completed
 }
-#line 2643 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2595 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 466:
-#line 1610 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1610 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2651 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2603 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 467:
-#line 1612 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1612 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr next_server(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("next-server", next_server);
     ctx.leave();
 }
-#line 2661 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2613 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 468:
-#line 1618 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1618 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2669 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2621 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 469:
-#line 1620 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1620 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr srv(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-hostname", srv);
     ctx.leave();
 }
-#line 2679 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2631 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 470:
-#line 1626 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1626 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2687 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2639 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 471:
-#line 1628 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1628 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr bootfile(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("boot-file-name", bootfile);
     ctx.leave();
 }
-#line 2697 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2649 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 472:
-#line 1634 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1634 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2705 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2657 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 473:
-#line 1636 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1636 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr addr(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("ip-address", addr);
     ctx.leave();
 }
-#line 2715 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2667 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 474:
-#line 1642 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1642 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("ip-addresses", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2726 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2678 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 475:
-#line 1647 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1647 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2735 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2687 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 476:
-#line 1652 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1652 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2743 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2695 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 477:
-#line 1654 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1654 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr d(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("duid", d);
     ctx.leave();
 }
-#line 2753 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2705 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 478:
-#line 1660 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1660 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2761 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2713 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 479:
-#line 1662 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1662 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr hw(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hw-address", hw);
     ctx.leave();
 }
-#line 2771 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2723 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 480:
-#line 1668 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1668 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2779 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2731 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 481:
-#line 1670 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1670 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr hw(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-id", hw);
     ctx.leave();
 }
-#line 2789 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2741 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 482:
-#line 1676 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1676 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2797 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2749 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 483:
-#line 1678 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1678 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr hw(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("circuit-id", hw);
     ctx.leave();
 }
-#line 2807 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2759 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 484:
-#line 1684 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1684 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2815 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2767 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 485:
-#line 1686 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1686 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr hw(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("flex-id", hw);
     ctx.leave();
 }
-#line 2825 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2777 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 486:
-#line 1692 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1692 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2833 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2785 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 487:
-#line 1694 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1694 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr host(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hostname", host);
     ctx.leave();
 }
-#line 2843 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2795 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 488:
-#line 1700 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1700 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-classes", c);
     ctx.stack_.push_back(c);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2854 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2806 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 489:
-#line 1705 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1705 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2863 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2815 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 490:
-#line 1713 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1713 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("relay", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.RELAY);
 }
-#line 2874 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2826 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 491:
-#line 1718 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1718 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2883 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2835 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 494:
-#line 1730 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1730 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-classes", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.CLIENT_CLASSES);
 }
-#line 2894 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2846 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 495:
-#line 1735 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1735 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2903 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2855 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 498:
-#line 1744 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1744 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2913 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2865 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 499:
-#line 1748 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1748 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The name client class parameter is required.
     ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2923 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2875 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 516:
-#line 1777 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1777 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2931 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2883 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 517:
-#line 1779 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1779 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr test(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("test", test);
     ctx.leave();
 }
-#line 2941 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2893 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 518:
-#line 1785 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1785 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("only-if-required", b);
 }
-#line 2950 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2902 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 519:
-#line 1794 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1794 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr time(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("dhcp4o6-port", time);
 }
-#line 2959 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2911 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 520:
-#line 1801 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1801 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("control-socket", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.CONTROL_SOCKET);
 }
-#line 2970 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2922 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 521:
-#line 1806 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1806 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2979 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2931 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 529:
-#line 1822 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1822 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2987 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2939 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 530:
-#line 1824 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1824 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr stype(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("socket-type", stype);
     ctx.leave();
 }
-#line 2997 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2949 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 531:
-#line 1830 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1830 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3005 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2957 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 532:
-#line 1832 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1832 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr name(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("socket-name", name);
     ctx.leave();
 }
-#line 3015 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2967 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 533:
-#line 1841 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1841 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3023 "dhcp4_parser.cc" // lalr1.cc:907
+#line 2975 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 534:
-#line 1843 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1843 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr qc = yystack_[0].value.as< ElementPtr > ();
     ctx.stack_.back()->set("dhcp-queue-control", qc);
 
-    if (!qc->contains("queue-type")) {
+    // Doing this manually, because dhcp-queue-control
+    // content is otherwise arbitrary
+    if (!qc->contains("enable-queue")) {
         std::stringstream msg;
-        msg << "'queue-type' is required: ";
+        msg << "'enable-queue' is required: ";
         msg  << qc->getPosition().str() << ")";
         error(yystack_[3].location, msg.str());
     }
 
+     ConstElementPtr enable_queue = qc->get("enable-queue");
+     if (enable_queue->getType() != Element::boolean) {
+        std::stringstream msg;
+        msg << "'enable-queue' must be boolean: ";
+        msg  << qc->getPosition().str() << ")";
+        error(yystack_[3].location, msg.str());
+     }
+
+    if (enable_queue->boolValue()) {
+        if (!qc->contains("queue-type")) {
+            std::stringstream msg;
+            msg << "'queue-type' is required, when 'enable-queue' is true: ";
+            msg  << qc->getPosition().str() << ")";
+            error(yystack_[3].location, msg.str());
+        }
+
+        ConstElementPtr queue_type = qc->get("queue-type");
+        if (queue_type->getType() != Element::string) {
+            std::stringstream msg;
+            msg << "'queue-type' must be a string: ";
+            msg  << qc->getPosition().str() << ")";
+            error(yystack_[3].location, msg.str());
+        }
+     }
+
     ctx.leave();
 }
-#line 3041 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3020 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 535:
-#line 1859 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1886 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("dhcp-ddns", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.DHCP_DDNS);
 }
-#line 3052 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3031 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 536:
-#line 1864 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1891 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The enable updates DHCP DDNS parameter is required.
     ctx.require("enable-updates", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3063 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3042 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 537:
-#line 1871 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1898 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the dhcp-ddns map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 3073 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3052 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 538:
-#line 1875 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1902 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // The enable updates DHCP DDNS parameter is required.
     ctx.require("enable-updates", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 3083 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3062 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 559:
-#line 1905 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1932 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("enable-updates", b);
 }
-#line 3092 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3071 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 560:
-#line 1910 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1937 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3100 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3079 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 561:
-#line 1912 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1939 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("qualifying-suffix", s);
     ctx.leave();
 }
-#line 3110 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3089 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 562:
-#line 1918 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1945 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3118 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3097 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 563:
-#line 1920 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1947 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-ip", s);
     ctx.leave();
 }
-#line 3128 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3107 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 564:
-#line 1926 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1953 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-port", i);
 }
-#line 3137 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3116 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 565:
-#line 1931 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1958 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3145 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3124 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 566:
-#line 1933 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1960 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("sender-ip", s);
     ctx.leave();
 }
-#line 3155 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3134 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 567:
-#line 1939 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1966 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("sender-port", i);
 }
-#line 3164 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3143 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 568:
-#line 1944 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1971 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-queue-size", i);
 }
-#line 3173 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3152 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 569:
-#line 1949 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1976 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NCR_PROTOCOL);
 }
-#line 3181 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3160 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 570:
-#line 1951 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1978 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3190 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3169 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 571:
-#line 1957 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1984 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
-#line 3196 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3175 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 572:
-#line 1958 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1985 "dhcp4_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
-#line 3202 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3181 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 573:
-#line 1961 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1988 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NCR_FORMAT);
 }
-#line 3210 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3189 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 574:
-#line 1963 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1990 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("ncr-format", json);
     ctx.leave();
 }
-#line 3220 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3199 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 575:
-#line 1969 "dhcp4_parser.yy" // lalr1.cc:907
+#line 1996 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("override-no-update", b);
 }
-#line 3229 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3208 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 576:
-#line 1974 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2001 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("override-client-update", b);
 }
-#line 3238 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3217 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 577:
-#line 1979 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2006 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.REPLACE_CLIENT_NAME);
 }
-#line 3246 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3225 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 578:
-#line 1981 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2008 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("replace-client-name", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3255 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3234 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 579:
-#line 1987 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2014 "dhcp4_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3263 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3242 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 580:
-#line 1990 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2017 "dhcp4_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3271 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3250 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 581:
-#line 1993 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2020 "dhcp4_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3279 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3258 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 582:
-#line 1996 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2023 "dhcp4_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3287 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3266 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 583:
-#line 1999 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2026 "dhcp4_parser.yy" // lalr1.cc:859
     {
       error(yystack_[0].location, "boolean values for the replace-client-name are "
                 "no longer supported");
       }
-#line 3296 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3275 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 584:
-#line 2005 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2032 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3304 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3283 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 585:
-#line 2007 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2034 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("generated-prefix", s);
     ctx.leave();
 }
-#line 3314 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3293 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 586:
-#line 2013 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2040 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3322 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3301 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 587:
-#line 2015 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2042 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hostname-char-set", s);
     ctx.leave();
 }
-#line 3332 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3311 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 588:
-#line 2021 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2048 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3340 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3319 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 589:
-#line 2023 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2050 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hostname-char-replacement", s);
     ctx.leave();
 }
-#line 3350 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3329 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 590:
-#line 2032 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2059 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3358 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3337 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 591:
-#line 2034 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2061 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("Dhcp6", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3367 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3346 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 592:
-#line 2039 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2066 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3375 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3354 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 593:
-#line 2041 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2068 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("DhcpDdns", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3384 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3363 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 594:
-#line 2046 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2073 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3392 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3371 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 595:
-#line 2048 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2075 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("Control-agent", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3401 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3380 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 596:
-#line 2053 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2080 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 3411 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3390 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 597:
-#line 2057 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2084 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 3419 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3398 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 598:
-#line 2062 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2089 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("config-control", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.CONFIG_CONTROL);
 }
-#line 3430 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3409 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 599:
-#line 2067 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2094 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No config control params are required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3440 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3419 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 600:
-#line 2073 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2100 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the config-control map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 3450 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3429 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 601:
-#line 2077 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2104 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // No config_control params are required
     // parsing completed
 }
-#line 3459 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3438 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 606:
-#line 2092 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2119 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("config-databases", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.CONFIG_DATABASE);
 }
-#line 3470 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3449 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 607:
-#line 2097 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2124 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3479 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3458 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 608:
-#line 2107 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2134 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("Logging", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.LOGGING);
 }
-#line 3490 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3469 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 609:
-#line 2112 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2139 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3499 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3478 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 610:
-#line 2117 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2144 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // Parse the Logging map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 3509 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3488 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 611:
-#line 2121 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2148 "dhcp4_parser.yy" // lalr1.cc:859
     {
     // parsing completed
 }
-#line 3517 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3496 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 615:
-#line 2137 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2164 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("loggers", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.LOGGERS);
 }
-#line 3528 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3507 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 616:
-#line 2142 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2169 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3537 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3516 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 619:
-#line 2154 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2181 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(l);
     ctx.stack_.push_back(l);
 }
-#line 3547 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3526 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 620:
-#line 2158 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2185 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 3555 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3534 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 630:
-#line 2175 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2202 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr dl(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("debuglevel", dl);
 }
-#line 3564 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3543 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 631:
-#line 2180 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2207 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3572 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3551 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 632:
-#line 2182 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2209 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr sev(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("severity", sev);
     ctx.leave();
 }
-#line 3582 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3561 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 633:
-#line 2188 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2215 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("output_options", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.OUTPUT_OPTIONS);
 }
-#line 3593 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3572 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 634:
-#line 2193 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2220 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3602 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3581 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 637:
-#line 2202 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2229 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 3612 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3591 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 638:
-#line 2206 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2233 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 3620 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3599 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 645:
-#line 2220 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2247 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3628 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3607 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 646:
-#line 2222 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2249 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr sev(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("output", sev);
     ctx.leave();
 }
-#line 3638 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3617 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 647:
-#line 2228 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2255 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr flush(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("flush", flush);
 }
-#line 3647 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3626 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 648:
-#line 2233 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2260 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr maxsize(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("maxsize", maxsize);
 }
-#line 3656 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3635 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
   case 649:
-#line 2238 "dhcp4_parser.yy" // lalr1.cc:907
+#line 2265 "dhcp4_parser.yy" // lalr1.cc:859
     {
     ElementPtr maxver(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("maxver", maxver);
 }
-#line 3665 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3644 "dhcp4_parser.cc" // lalr1.cc:859
     break;
 
 
-#line 3669 "dhcp4_parser.cc" // lalr1.cc:907
+#line 3648 "dhcp4_parser.cc" // lalr1.cc:859
             default:
               break;
             }
         }
-#if YY_EXCEPTIONS
       catch (const syntax_error& yyexc)
         {
           error (yyexc);
           YYERROR;
         }
-#endif // YY_EXCEPTIONS
       YY_SYMBOL_PRINT ("-> $$ =", yylhs);
       yypop_ (yylen);
       yylen = 0;
       YY_STACK_PRINT ();
 
       // Shift the result of the reduction.
-      yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
+      yypush_ (YY_NULLPTR, yylhs);
     }
     goto yynewstate;
 
@@ -3729,6 +3706,7 @@ namespace isc { namespace dhcp {
        code.  */
     if (false)
       goto yyerrorlab;
+    yyerror_range[1].location = yystack_[yylen - 1].location;
     /* Do not reclaim the symbols of the rule whose action triggered
        this YYERROR.  */
     yypop_ (yylen);
@@ -3771,7 +3749,7 @@ namespace isc { namespace dhcp {
 
       // Shift the error token.
       error_token.state = yyn;
-      yypush_ ("Shifting", YY_MOVE (error_token));
+      yypush_ ("Shifting", error_token);
     }
     goto yynewstate;
 
@@ -3800,12 +3778,12 @@ namespace isc { namespace dhcp {
 
     return yyresult;
   }
-#if YY_EXCEPTIONS
     catch (...)
       {
-        YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
+        YYCDEBUG << "Exception caught: cleaning lookahead and stack"
+                 << std::endl;
         // Do not try to display the values of the reclaimed symbols,
-        // as their printers might throw an exception.
+        // as their printer might throw an exception.
         if (!yyla.empty ())
           yy_destroy_ (YY_NULLPTR, yyla);
 
@@ -3816,13 +3794,12 @@ namespace isc { namespace dhcp {
           }
         throw;
       }
-#endif // YY_EXCEPTIONS
   }
 
   void
   Dhcp4Parser::error (const syntax_error& yyexc)
   {
-    error (yyexc.location, yyexc.what ());
+    error (yyexc.location, yyexc.what());
   }
 
   // Generate an error message.
@@ -3898,13 +3875,12 @@ namespace isc { namespace dhcp {
         case N:                               \
           yyformat = S;                       \
         break
-      default: // Avoid compiler warnings.
-        YYCASE_ (0, YY_("syntax error"));
-        YYCASE_ (1, YY_("syntax error, unexpected %s"));
-        YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
-        YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-        YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-        YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+        YYCASE_(0, YY_("syntax error"));
+        YYCASE_(1, YY_("syntax error, unexpected %s"));
+        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 #undef YYCASE_
       }
 
@@ -3923,11 +3899,11 @@ namespace isc { namespace dhcp {
   }
 
 
-  const short Dhcp4Parser::yypact_ninf_ = -796;
+  const short int Dhcp4Parser::yypact_ninf_ = -796;
 
   const signed char Dhcp4Parser::yytable_ninf_ = -1;
 
-  const short
+  const short int
   Dhcp4Parser::yypact_[] =
   {
      343,  -796,  -796,  -796,  -796,  -796,  -796,  -796,  -796,  -796,
@@ -4037,7 +4013,7 @@ namespace isc { namespace dhcp {
     -796,  -796,  -796,  -796
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp4Parser::yydefact_[] =
   {
        0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
@@ -4147,7 +4123,7 @@ namespace isc { namespace dhcp {
      648,   649,   640,   646
   };
 
-  const short
+  const short int
   Dhcp4Parser::yypgoto_[] =
   {
     -796,  -796,  -796,  -796,  -796,  -796,  -796,  -796,  -796,  -796,
@@ -4190,7 +4166,7 @@ namespace isc { namespace dhcp {
     -796,  -796,  -796,  -796
   };
 
-  const short
+  const short int
   Dhcp4Parser::yydefgoto_[] =
   {
       -1,    15,    16,    17,    18,    19,    20,    21,    22,    23,
@@ -4233,7 +4209,7 @@ namespace isc { namespace dhcp {
     1032,  1028,  1029,  1030
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp4Parser::yytable_[] =
   {
       95,   137,   177,   196,   223,   240,   224,   266,   285,   302,
@@ -4339,7 +4315,7 @@ namespace isc { namespace dhcp {
        0,   903,     0,     0,     0,   909
   };
 
-  const short
+  const short int
   Dhcp4Parser::yycheck_[] =
   {
       70,    71,    72,    73,    74,    75,    74,    77,    78,    79,
@@ -4445,7 +4421,7 @@ namespace isc { namespace dhcp {
       -1,   986,    -1,    -1,    -1,   986
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp4Parser::yystos_[] =
   {
        0,   151,   152,   153,   154,   155,   156,   157,   158,   159,
@@ -4555,7 +4531,7 @@ namespace isc { namespace dhcp {
      166,   166,   537,   165
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp4Parser::yyr1_[] =
   {
        0,   169,   171,   170,   172,   170,   173,   170,   174,   170,
@@ -4842,7 +4818,7 @@ namespace isc { namespace dhcp {
   };
 
 #if PARSER4_DEBUG
-  const unsigned short
+  const unsigned short int
   Dhcp4Parser::yyrline_[] =
   {
        0,   254,   254,   254,   255,   255,   256,   256,   257,   257,
@@ -4898,18 +4874,18 @@ namespace isc { namespace dhcp {
     1754,  1755,  1758,  1759,  1762,  1763,  1764,  1765,  1766,  1767,
     1768,  1769,  1770,  1771,  1772,  1775,  1777,  1777,  1785,  1794,
     1801,  1801,  1811,  1812,  1815,  1816,  1817,  1818,  1819,  1822,
-    1822,  1830,  1830,  1841,  1841,  1859,  1859,  1871,  1871,  1881,
-    1882,  1885,  1886,  1887,  1888,  1889,  1890,  1891,  1892,  1893,
-    1894,  1895,  1896,  1897,  1898,  1899,  1900,  1901,  1902,  1905,
-    1910,  1910,  1918,  1918,  1926,  1931,  1931,  1939,  1944,  1949,
-    1949,  1957,  1958,  1961,  1961,  1969,  1974,  1979,  1979,  1987,
-    1990,  1993,  1996,  1999,  2005,  2005,  2013,  2013,  2021,  2021,
-    2032,  2032,  2039,  2039,  2046,  2046,  2053,  2053,  2062,  2062,
-    2073,  2073,  2083,  2084,  2088,  2089,  2092,  2092,  2107,  2107,
-    2117,  2117,  2128,  2129,  2133,  2137,  2137,  2149,  2150,  2154,
-    2154,  2162,  2163,  2166,  2167,  2168,  2169,  2170,  2171,  2172,
-    2175,  2180,  2180,  2188,  2188,  2198,  2199,  2202,  2202,  2210,
-    2211,  2214,  2215,  2216,  2217,  2220,  2220,  2228,  2233,  2238
+    1822,  1830,  1830,  1841,  1841,  1886,  1886,  1898,  1898,  1908,
+    1909,  1912,  1913,  1914,  1915,  1916,  1917,  1918,  1919,  1920,
+    1921,  1922,  1923,  1924,  1925,  1926,  1927,  1928,  1929,  1932,
+    1937,  1937,  1945,  1945,  1953,  1958,  1958,  1966,  1971,  1976,
+    1976,  1984,  1985,  1988,  1988,  1996,  2001,  2006,  2006,  2014,
+    2017,  2020,  2023,  2026,  2032,  2032,  2040,  2040,  2048,  2048,
+    2059,  2059,  2066,  2066,  2073,  2073,  2080,  2080,  2089,  2089,
+    2100,  2100,  2110,  2111,  2115,  2116,  2119,  2119,  2134,  2134,
+    2144,  2144,  2155,  2156,  2160,  2164,  2164,  2176,  2177,  2181,
+    2181,  2189,  2190,  2193,  2194,  2195,  2196,  2197,  2198,  2199,
+    2202,  2207,  2207,  2215,  2215,  2225,  2226,  2229,  2229,  2237,
+    2238,  2241,  2242,  2243,  2244,  2247,  2247,  2255,  2260,  2265
   };
 
   // Print the state stack on the debug stream.
@@ -4922,18 +4898,18 @@ namespace isc { namespace dhcp {
            i_end = yystack_.end ();
          i != i_end; ++i)
       *yycdebug_ << ' ' << i->state;
-    *yycdebug_ << '\n';
+    *yycdebug_ << std::endl;
   }
 
   // Report on the debug stream that the rule \a yyrule is going to be reduced.
   void
   Dhcp4Parser::yy_reduce_print_ (int yyrule)
   {
-    unsigned yylno = yyrline_[yyrule];
+    unsigned int yylno = yyrline_[yyrule];
     int yynrhs = yyr2_[yyrule];
     // Print the symbols being reduced, and their result.
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
-               << " (line " << yylno << "):\n";
+               << " (line " << yylno << "):" << std::endl;
     // The symbols being reduced.
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
@@ -4942,10 +4918,10 @@ namespace isc { namespace dhcp {
 #endif // PARSER4_DEBUG
 
 
-#line 14 "dhcp4_parser.yy" // lalr1.cc:1218
+#line 14 "dhcp4_parser.yy" // lalr1.cc:1167
 } } // isc::dhcp
-#line 4948 "dhcp4_parser.cc" // lalr1.cc:1218
-#line 2243 "dhcp4_parser.yy" // lalr1.cc:1219
+#line 4924 "dhcp4_parser.cc" // lalr1.cc:1167
+#line 2270 "dhcp4_parser.yy" // lalr1.cc:1168
 
 
 void
diff --git a/src/bin/dhcp4/dhcp4_parser.h b/src/bin/dhcp4/dhcp4_parser.h
index f3905efaef..88e4ae3635 100644
--- a/src/bin/dhcp4/dhcp4_parser.h
+++ b/src/bin/dhcp4/dhcp4_parser.h
@@ -1,8 +1,8 @@
-// A Bison parser, made by GNU Bison 3.2.1.
+// A Bison parser, made by GNU Bison 3.0.4.
 
 // Skeleton interface for Bison LALR(1) parsers in C++
 
-// Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -30,7 +30,6 @@
 // This special exception was added by the Free Software Foundation in
 // version 2.2 of Bison.
 
-
 /**
  ** \file dhcp4_parser.h
  ** Define the isc::dhcp::parser class.
@@ -38,13 +37,10 @@
 
 // C++ LALR(1) parser skeleton written by Akim Demaille.
 
-// Undocumented macros, especially those whose name start with YY_,
-// are private implementation details.  Do not rely on them.
-
 #ifndef YY_PARSER4_DHCP4_PARSER_H_INCLUDED
 # define YY_PARSER4_DHCP4_PARSER_H_INCLUDED
 // //                    "%code requires" blocks.
-#line 17 "dhcp4_parser.yy" // lalr1.cc:404
+#line 17 "dhcp4_parser.yy" // lalr1.cc:377
 
 #include <string>
 #include <cc/data.h>
@@ -56,7 +52,7 @@ using namespace isc::dhcp;
 using namespace isc::data;
 using namespace std;
 
-#line 60 "dhcp4_parser.h" // lalr1.cc:404
+#line 56 "dhcp4_parser.h" // lalr1.cc:377
 
 # include <cassert>
 # include <cstdlib> // std::abort
@@ -64,21 +60,7 @@ using namespace std;
 # include <stdexcept>
 # include <string>
 # include <vector>
-
-// Support move semantics when possible.
-#if defined __cplusplus && 201103L <= __cplusplus
-# define YY_MOVE           std::move
-# define YY_MOVE_OR_COPY   move
-# define YY_MOVE_REF(Type) Type&&
-# define YY_RVREF(Type)    Type&&
-# define YY_COPY(Type)     Type
-#else
-# define YY_MOVE
-# define YY_MOVE_OR_COPY   copy
-# define YY_MOVE_REF(Type) Type&
-# define YY_RVREF(Type)    const Type&
-# define YY_COPY(Type)     const Type&
-#endif
+# include "stack.hh"
 # include "location.hh"
 #include <typeinfo>
 #ifndef YYASSERT
@@ -105,6 +87,15 @@ using namespace std;
 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 #endif
 
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
@@ -112,7 +103,7 @@ using namespace std;
 # define YYUSE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
@@ -131,18 +122,6 @@ using namespace std;
 # define YY_INITIAL_VALUE(Value) /* Nothing. */
 #endif
 
-# ifndef YY_NULLPTR
-#  if defined __cplusplus
-#   if 201103L <= __cplusplus
-#    define YY_NULLPTR nullptr
-#   else
-#    define YY_NULLPTR 0
-#   endif
-#  else
-#   define YY_NULLPTR ((void*)0)
-#  endif
-# endif
-
 /* Debug traces.  */
 #ifndef PARSER4_DEBUG
 # if defined YYDEBUG
@@ -156,128 +135,9 @@ using namespace std;
 # endif /* ! defined YYDEBUG */
 #endif  /* ! defined PARSER4_DEBUG */
 
-#line 14 "dhcp4_parser.yy" // lalr1.cc:404
+#line 14 "dhcp4_parser.yy" // lalr1.cc:377
 namespace isc { namespace dhcp {
-#line 162 "dhcp4_parser.h" // lalr1.cc:404
-
-  /// A stack with random access from its top.
-  template <typename T, typename S = std::vector<T> >
-  class stack
-  {
-  public:
-    // Hide our reversed order.
-    typedef typename S::reverse_iterator iterator;
-    typedef typename S::const_reverse_iterator const_iterator;
-    typedef typename S::size_type size_type;
-
-    stack (size_type n = 200)
-      : seq_ (n)
-    {}
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    T&
-    operator[] (size_type i)
-    {
-      return seq_[size () - 1 - i];
-    }
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    T&
-    operator[] (int i)
-    {
-      return operator[] (size_type (i));
-    }
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    const T&
-    operator[] (size_type i) const
-    {
-      return seq_[size () - 1 - i];
-    }
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    const T&
-    operator[] (int i) const
-    {
-      return operator[] (size_type (i));
-    }
-
-    /// Steal the contents of \a t.
-    ///
-    /// Close to move-semantics.
-    void
-    push (YY_MOVE_REF (T) t)
-    {
-      seq_.push_back (T ());
-      operator[](0).move (t);
-    }
-
-    void
-    pop (int n = 1)
-    {
-      for (; 0 < n; --n)
-        seq_.pop_back ();
-    }
-
-    void
-    clear ()
-    {
-      seq_.clear ();
-    }
-
-    size_type
-    size () const
-    {
-      return seq_.size ();
-    }
-
-    const_iterator
-    begin () const
-    {
-      return seq_.rbegin ();
-    }
-
-    const_iterator
-    end () const
-    {
-      return seq_.rend ();
-    }
-
-  private:
-    stack (const stack&);
-    stack& operator= (const stack&);
-    /// The wrapped container.
-    S seq_;
-  };
-
-  /// Present a slice of the top of a stack.
-  template <typename T, typename S = stack<T> >
-  class slice
-  {
-  public:
-    slice (const S& stack, int range)
-      : stack_ (stack)
-      , range_ (range)
-    {}
-
-    const T&
-    operator[] (int i) const
-    {
-      return stack_[range_ - i];
-    }
-
-  private:
-    const S& stack_;
-    int range_;
-  };
+#line 141 "dhcp4_parser.h" // lalr1.cc:377
 
 
 
@@ -294,17 +154,16 @@ namespace isc { namespace dhcp {
 
     /// Empty construction.
     variant ()
-      : yybuffer_ ()
-      , yytypeid_ (YY_NULLPTR)
+      : yytypeid_ (YY_NULLPTR)
     {}
 
     /// Construct and fill.
     template <typename T>
-    variant (YY_RVREF (T) t)
+    variant (const T& t)
       : yytypeid_ (&typeid (T))
     {
       YYASSERT (sizeof (T) <= S);
-      new (yyas_<T> ()) T (YY_MOVE (t));
+      new (yyas_<T> ()) T (t);
     }
 
     /// Destruction, allowed only if empty.
@@ -316,62 +175,30 @@ namespace isc { namespace dhcp {
     /// Instantiate an empty \a T in here.
     template <typename T>
     T&
-    emplace ()
+    build ()
     {
       YYASSERT (!yytypeid_);
       YYASSERT (sizeof (T) <= S);
       yytypeid_ = & typeid (T);
-      return *new (yyas_<T> ()) T ();
+      return *new (yyas_<T> ()) T;
     }
 
-# if defined __cplusplus && 201103L <= __cplusplus
-    /// Instantiate a \a T in here from \a t.
-    template <typename T, typename U>
-    T&
-    emplace (U&& u)
-    {
-      YYASSERT (!yytypeid_);
-      YYASSERT (sizeof (T) <= S);
-      yytypeid_ = & typeid (T);
-      return *new (yyas_<T> ()) T (std::forward <U>(u));
-    }
-# else
     /// Instantiate a \a T in here from \a t.
     template <typename T>
     T&
-    emplace (const T& t)
+    build (const T& t)
     {
       YYASSERT (!yytypeid_);
       YYASSERT (sizeof (T) <= S);
       yytypeid_ = & typeid (T);
       return *new (yyas_<T> ()) T (t);
     }
-# endif
-
-    /// Instantiate an empty \a T in here.
-    /// Obsolete, use emplace.
-    template <typename T>
-    T&
-    build ()
-    {
-      return emplace<T> ();
-    }
-
-    /// Instantiate a \a T in here from \a t.
-    /// Obsolete, use emplace.
-    template <typename T>
-    T&
-    build (const T& t)
-    {
-      return emplace<T> (t);
-    }
 
     /// Accessor to a built \a T.
     template <typename T>
     T&
     as ()
     {
-      YYASSERT (yytypeid_);
       YYASSERT (*yytypeid_ == typeid (T));
       YYASSERT (sizeof (T) <= S);
       return *yyas_<T> ();
@@ -382,7 +209,6 @@ namespace isc { namespace dhcp {
     const T&
     as () const
     {
-      YYASSERT (yytypeid_);
       YYASSERT (*yytypeid_ == typeid (T));
       YYASSERT (sizeof (T) <= S);
       return *yyas_<T> ();
@@ -393,7 +219,7 @@ namespace isc { namespace dhcp {
     /// Both variants must be built beforehand, because swapping the actual
     /// data requires reading it (with as()), and this is not possible on
     /// unconstructed variants: it would require some dynamic testing, which
-    /// should not be the variant's responsibility.
+    /// should not be the variant's responsability.
     /// Swapping between built and (possibly) non-built is done with
     /// variant::move ().
     template <typename T>
@@ -412,32 +238,17 @@ namespace isc { namespace dhcp {
     void
     move (self_type& other)
     {
-# if defined __cplusplus && 201103L <= __cplusplus
-      emplace<T> (std::move (other.as<T> ()));
-# else
-      emplace<T> ();
+      build<T> ();
       swap<T> (other);
-# endif
       other.destroy<T> ();
     }
 
-# if defined __cplusplus && 201103L <= __cplusplus
-    /// Move the content of \a other to this.
-    template <typename T>
-    void
-    move (self_type&& other)
-    {
-      emplace<T> (std::move (other.as<T> ()));
-      other.destroy<T> ();
-    }
-#endif
-
     /// Copy the content of \a other to this.
     template <typename T>
     void
     copy (const self_type& other)
     {
-      emplace<T> (other.as<T> ());
+      build<T> (other.as<T> ());
     }
 
     /// Destroy the stored \a T.
@@ -451,7 +262,7 @@ namespace isc { namespace dhcp {
 
   private:
     /// Prohibit blind copies.
-    self_type& operator= (const self_type&);
+    self_type& operator=(const self_type&);
     variant (const self_type&);
 
     /// Accessor to raw memory as \a T.
@@ -501,23 +312,23 @@ namespace isc { namespace dhcp {
       // hr_mode
       // ncr_protocol_value
       // replace_client_name_value
-      char dummy1[sizeof (ElementPtr)];
+      char dummy1[sizeof(ElementPtr)];
 
       // "boolean"
-      char dummy2[sizeof (bool)];
+      char dummy2[sizeof(bool)];
 
       // "floating point"
-      char dummy3[sizeof (double)];
+      char dummy3[sizeof(double)];
 
       // "integer"
-      char dummy4[sizeof (int64_t)];
+      char dummy4[sizeof(int64_t)];
 
       // "constant string"
-      char dummy5[sizeof (std::string)];
+      char dummy5[sizeof(std::string)];
 };
 
     /// Symbol semantic values.
-    typedef variant<sizeof (union_type)> semantic_type;
+    typedef variant<sizeof(union_type)> semantic_type;
 #else
     typedef PARSER4_STYPE semantic_type;
 #endif
@@ -721,7 +532,7 @@ namespace isc { namespace dhcp {
     /// A complete symbol.
     ///
     /// Expects its Base type to provide access to the symbol type
-    /// via type_get ().
+    /// via type_get().
     ///
     /// Provide access to semantic value and location.
     template <typename Base>
@@ -733,18 +544,28 @@ namespace isc { namespace dhcp {
       /// Default constructor.
       basic_symbol ();
 
-      /// Move or copy constructor.
-      basic_symbol (YY_RVREF (basic_symbol) other);
-
+      /// Copy constructor.
+      basic_symbol (const basic_symbol& other);
 
       /// Constructor for valueless symbols, and symbols from each type.
-      basic_symbol (typename Base::kind_type t, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (ElementPtr) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (bool) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (double) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (int64_t) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (std::string) v, YY_RVREF (location_type) l);
 
+  basic_symbol (typename Base::kind_type t, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const ElementPtr v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const bool v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const double v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const int64_t v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const std::string v, const location_type& l);
+
+
+      /// Constructor for symbols with semantic value.
+      basic_symbol (typename Base::kind_type t,
+                    const semantic_type& v,
+                    const location_type& l);
 
       /// Destroy the symbol.
       ~basic_symbol ();
@@ -765,10 +586,8 @@ namespace isc { namespace dhcp {
       location_type location;
 
     private:
-#if !defined __cplusplus || __cplusplus < 201103L
       /// Assignment operator.
       basic_symbol& operator= (const basic_symbol& other);
-#endif
     };
 
     /// Type access provider for token (enum) based symbols.
@@ -808,710 +627,705 @@ namespace isc { namespace dhcp {
     /// "External" symbols: returned by the scanner.
     typedef basic_symbol<by_type> symbol_type;
 
-    /// Build a parser object.
-    Dhcp4Parser (isc::dhcp::Parser4Context& ctx_yyarg);
-    virtual ~Dhcp4Parser ();
-
-    /// Parse.  An alias for parse ().
-    /// \returns  0 iff parsing succeeded.
-    int operator() ();
-
-    /// Parse.
-    /// \returns  0 iff parsing succeeded.
-    virtual int parse ();
-
-#if PARSER4_DEBUG
-    /// The current debugging stream.
-    std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
-    /// Set the current debugging stream.
-    void set_debug_stream (std::ostream &);
-
-    /// Type for debugging levels.
-    typedef int debug_level_type;
-    /// The current debugging level.
-    debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
-    /// Set the current debugging level.
-    void set_debug_level (debug_level_type l);
-#endif
-
-    /// Report a syntax error.
-    /// \param loc    where the syntax error is found.
-    /// \param msg    a description of the syntax error.
-    virtual void error (const location_type& loc, const std::string& msg);
-
-    /// Report a syntax error.
-    void error (const syntax_error& err);
-
     // Symbol constructors declarations.
-    static
+    static inline
     symbol_type
-    make_END (YY_COPY (location_type) l);
+    make_END (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_COMMA (YY_COPY (location_type) l);
+    make_COMMA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_COLON (YY_COPY (location_type) l);
+    make_COLON (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LSQUARE_BRACKET (YY_COPY (location_type) l);
+    make_LSQUARE_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RSQUARE_BRACKET (YY_COPY (location_type) l);
+    make_RSQUARE_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LCURLY_BRACKET (YY_COPY (location_type) l);
+    make_LCURLY_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RCURLY_BRACKET (YY_COPY (location_type) l);
+    make_RCURLY_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NULL_TYPE (YY_COPY (location_type) l);
+    make_NULL_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP4 (YY_COPY (location_type) l);
+    make_DHCP4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONFIG_CONTROL (YY_COPY (location_type) l);
+    make_CONFIG_CONTROL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONFIG_DATABASES (YY_COPY (location_type) l);
+    make_CONFIG_DATABASES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACES_CONFIG (YY_COPY (location_type) l);
+    make_INTERFACES_CONFIG (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACES (YY_COPY (location_type) l);
+    make_INTERFACES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP_SOCKET_TYPE (YY_COPY (location_type) l);
+    make_DHCP_SOCKET_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RAW (YY_COPY (location_type) l);
+    make_RAW (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_UDP (YY_COPY (location_type) l);
+    make_UDP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUTBOUND_INTERFACE (YY_COPY (location_type) l);
+    make_OUTBOUND_INTERFACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SAME_AS_INBOUND (YY_COPY (location_type) l);
+    make_SAME_AS_INBOUND (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_USE_ROUTING (YY_COPY (location_type) l);
+    make_USE_ROUTING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RE_DETECT (YY_COPY (location_type) l);
+    make_RE_DETECT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SANITY_CHECKS (YY_COPY (location_type) l);
+    make_SANITY_CHECKS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LEASE_CHECKS (YY_COPY (location_type) l);
+    make_LEASE_CHECKS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ECHO_CLIENT_ID (YY_COPY (location_type) l);
+    make_ECHO_CLIENT_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MATCH_CLIENT_ID (YY_COPY (location_type) l);
+    make_MATCH_CLIENT_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_AUTHORITATIVE (YY_COPY (location_type) l);
+    make_AUTHORITATIVE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NEXT_SERVER (YY_COPY (location_type) l);
+    make_NEXT_SERVER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_HOSTNAME (YY_COPY (location_type) l);
+    make_SERVER_HOSTNAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_BOOT_FILE_NAME (YY_COPY (location_type) l);
+    make_BOOT_FILE_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LEASE_DATABASE (YY_COPY (location_type) l);
+    make_LEASE_DATABASE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTS_DATABASE (YY_COPY (location_type) l);
+    make_HOSTS_DATABASE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTS_DATABASES (YY_COPY (location_type) l);
+    make_HOSTS_DATABASES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TYPE (YY_COPY (location_type) l);
+    make_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MEMFILE (YY_COPY (location_type) l);
+    make_MEMFILE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MYSQL (YY_COPY (location_type) l);
+    make_MYSQL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_POSTGRESQL (YY_COPY (location_type) l);
+    make_POSTGRESQL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CQL (YY_COPY (location_type) l);
+    make_CQL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_USER (YY_COPY (location_type) l);
+    make_USER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PASSWORD (YY_COPY (location_type) l);
+    make_PASSWORD (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOST (YY_COPY (location_type) l);
+    make_HOST (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PORT (YY_COPY (location_type) l);
+    make_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PERSIST (YY_COPY (location_type) l);
+    make_PERSIST (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LFC_INTERVAL (YY_COPY (location_type) l);
+    make_LFC_INTERVAL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_READONLY (YY_COPY (location_type) l);
+    make_READONLY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONNECT_TIMEOUT (YY_COPY (location_type) l);
+    make_CONNECT_TIMEOUT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONTACT_POINTS (YY_COPY (location_type) l);
+    make_CONTACT_POINTS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_KEYSPACE (YY_COPY (location_type) l);
+    make_KEYSPACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_RECONNECT_TRIES (YY_COPY (location_type) l);
+    make_MAX_RECONNECT_TRIES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RECONNECT_WAIT_TIME (YY_COPY (location_type) l);
+    make_RECONNECT_WAIT_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REQUEST_TIMEOUT (YY_COPY (location_type) l);
+    make_REQUEST_TIMEOUT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TCP_KEEPALIVE (YY_COPY (location_type) l);
+    make_TCP_KEEPALIVE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TCP_NODELAY (YY_COPY (location_type) l);
+    make_TCP_NODELAY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_VALID_LIFETIME (YY_COPY (location_type) l);
+    make_VALID_LIFETIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RENEW_TIMER (YY_COPY (location_type) l);
+    make_RENEW_TIMER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REBIND_TIMER (YY_COPY (location_type) l);
+    make_REBIND_TIMER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DECLINE_PROBATION_PERIOD (YY_COPY (location_type) l);
+    make_DECLINE_PROBATION_PERIOD (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_TAG (YY_COPY (location_type) l);
+    make_SERVER_TAG (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET4 (YY_COPY (location_type) l);
+    make_SUBNET4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET_4O6_INTERFACE (YY_COPY (location_type) l);
+    make_SUBNET_4O6_INTERFACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET_4O6_INTERFACE_ID (YY_COPY (location_type) l);
+    make_SUBNET_4O6_INTERFACE_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET_4O6_SUBNET (YY_COPY (location_type) l);
+    make_SUBNET_4O6_SUBNET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OPTION_DEF (YY_COPY (location_type) l);
+    make_OPTION_DEF (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OPTION_DATA (YY_COPY (location_type) l);
+    make_OPTION_DATA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NAME (YY_COPY (location_type) l);
+    make_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DATA (YY_COPY (location_type) l);
+    make_DATA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CODE (YY_COPY (location_type) l);
+    make_CODE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SPACE (YY_COPY (location_type) l);
+    make_SPACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CSV_FORMAT (YY_COPY (location_type) l);
+    make_CSV_FORMAT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ALWAYS_SEND (YY_COPY (location_type) l);
+    make_ALWAYS_SEND (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RECORD_TYPES (YY_COPY (location_type) l);
+    make_RECORD_TYPES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ENCAPSULATE (YY_COPY (location_type) l);
+    make_ENCAPSULATE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ARRAY (YY_COPY (location_type) l);
+    make_ARRAY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SHARED_NETWORKS (YY_COPY (location_type) l);
+    make_SHARED_NETWORKS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_POOLS (YY_COPY (location_type) l);
+    make_POOLS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_POOL (YY_COPY (location_type) l);
+    make_POOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_USER_CONTEXT (YY_COPY (location_type) l);
+    make_USER_CONTEXT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_COMMENT (YY_COPY (location_type) l);
+    make_COMMENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET (YY_COPY (location_type) l);
+    make_SUBNET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACE (YY_COPY (location_type) l);
+    make_INTERFACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ID (YY_COPY (location_type) l);
+    make_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RESERVATION_MODE (YY_COPY (location_type) l);
+    make_RESERVATION_MODE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DISABLED (YY_COPY (location_type) l);
+    make_DISABLED (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUT_OF_POOL (YY_COPY (location_type) l);
+    make_OUT_OF_POOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_GLOBAL (YY_COPY (location_type) l);
+    make_GLOBAL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ALL (YY_COPY (location_type) l);
+    make_ALL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOST_RESERVATION_IDENTIFIERS (YY_COPY (location_type) l);
+    make_HOST_RESERVATION_IDENTIFIERS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CLIENT_CLASSES (YY_COPY (location_type) l);
+    make_CLIENT_CLASSES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REQUIRE_CLIENT_CLASSES (YY_COPY (location_type) l);
+    make_REQUIRE_CLIENT_CLASSES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TEST (YY_COPY (location_type) l);
+    make_TEST (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ONLY_IF_REQUIRED (YY_COPY (location_type) l);
+    make_ONLY_IF_REQUIRED (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CLIENT_CLASS (YY_COPY (location_type) l);
+    make_CLIENT_CLASS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RESERVATIONS (YY_COPY (location_type) l);
+    make_RESERVATIONS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DUID (YY_COPY (location_type) l);
+    make_DUID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HW_ADDRESS (YY_COPY (location_type) l);
+    make_HW_ADDRESS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CIRCUIT_ID (YY_COPY (location_type) l);
+    make_CIRCUIT_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CLIENT_ID (YY_COPY (location_type) l);
+    make_CLIENT_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTNAME (YY_COPY (location_type) l);
+    make_HOSTNAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLEX_ID (YY_COPY (location_type) l);
+    make_FLEX_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RELAY (YY_COPY (location_type) l);
+    make_RELAY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_IP_ADDRESS (YY_COPY (location_type) l);
+    make_IP_ADDRESS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_IP_ADDRESSES (YY_COPY (location_type) l);
+    make_IP_ADDRESSES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOOKS_LIBRARIES (YY_COPY (location_type) l);
+    make_HOOKS_LIBRARIES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LIBRARY (YY_COPY (location_type) l);
+    make_LIBRARY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PARAMETERS (YY_COPY (location_type) l);
+    make_PARAMETERS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_EXPIRED_LEASES_PROCESSING (YY_COPY (location_type) l);
+    make_EXPIRED_LEASES_PROCESSING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RECLAIM_TIMER_WAIT_TIME (YY_COPY (location_type) l);
+    make_RECLAIM_TIMER_WAIT_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (YY_COPY (location_type) l);
+    make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOLD_RECLAIMED_TIME (YY_COPY (location_type) l);
+    make_HOLD_RECLAIMED_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_RECLAIM_LEASES (YY_COPY (location_type) l);
+    make_MAX_RECLAIM_LEASES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_RECLAIM_TIME (YY_COPY (location_type) l);
+    make_MAX_RECLAIM_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_UNWARNED_RECLAIM_CYCLES (YY_COPY (location_type) l);
+    make_UNWARNED_RECLAIM_CYCLES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP4O6_PORT (YY_COPY (location_type) l);
+    make_DHCP4O6_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONTROL_SOCKET (YY_COPY (location_type) l);
+    make_CONTROL_SOCKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SOCKET_TYPE (YY_COPY (location_type) l);
+    make_SOCKET_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SOCKET_NAME (YY_COPY (location_type) l);
+    make_SOCKET_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP_QUEUE_CONTROL (YY_COPY (location_type) l);
+    make_DHCP_QUEUE_CONTROL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP_DDNS (YY_COPY (location_type) l);
+    make_DHCP_DDNS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ENABLE_UPDATES (YY_COPY (location_type) l);
+    make_ENABLE_UPDATES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_QUALIFYING_SUFFIX (YY_COPY (location_type) l);
+    make_QUALIFYING_SUFFIX (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_IP (YY_COPY (location_type) l);
+    make_SERVER_IP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_PORT (YY_COPY (location_type) l);
+    make_SERVER_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SENDER_IP (YY_COPY (location_type) l);
+    make_SENDER_IP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SENDER_PORT (YY_COPY (location_type) l);
+    make_SENDER_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_QUEUE_SIZE (YY_COPY (location_type) l);
+    make_MAX_QUEUE_SIZE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NCR_PROTOCOL (YY_COPY (location_type) l);
+    make_NCR_PROTOCOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NCR_FORMAT (YY_COPY (location_type) l);
+    make_NCR_FORMAT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OVERRIDE_NO_UPDATE (YY_COPY (location_type) l);
+    make_OVERRIDE_NO_UPDATE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OVERRIDE_CLIENT_UPDATE (YY_COPY (location_type) l);
+    make_OVERRIDE_CLIENT_UPDATE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REPLACE_CLIENT_NAME (YY_COPY (location_type) l);
+    make_REPLACE_CLIENT_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_GENERATED_PREFIX (YY_COPY (location_type) l);
+    make_GENERATED_PREFIX (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TCP (YY_COPY (location_type) l);
+    make_TCP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_JSON (YY_COPY (location_type) l);
+    make_JSON (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_WHEN_PRESENT (YY_COPY (location_type) l);
+    make_WHEN_PRESENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NEVER (YY_COPY (location_type) l);
+    make_NEVER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ALWAYS (YY_COPY (location_type) l);
+    make_ALWAYS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_WHEN_NOT_PRESENT (YY_COPY (location_type) l);
+    make_WHEN_NOT_PRESENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTNAME_CHAR_SET (YY_COPY (location_type) l);
+    make_HOSTNAME_CHAR_SET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTNAME_CHAR_REPLACEMENT (YY_COPY (location_type) l);
+    make_HOSTNAME_CHAR_REPLACEMENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LOGGING (YY_COPY (location_type) l);
+    make_LOGGING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LOGGERS (YY_COPY (location_type) l);
+    make_LOGGERS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUTPUT_OPTIONS (YY_COPY (location_type) l);
+    make_OUTPUT_OPTIONS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUTPUT (YY_COPY (location_type) l);
+    make_OUTPUT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DEBUGLEVEL (YY_COPY (location_type) l);
+    make_DEBUGLEVEL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SEVERITY (YY_COPY (location_type) l);
+    make_SEVERITY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLUSH (YY_COPY (location_type) l);
+    make_FLUSH (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAXSIZE (YY_COPY (location_type) l);
+    make_MAXSIZE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAXVER (YY_COPY (location_type) l);
+    make_MAXVER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP6 (YY_COPY (location_type) l);
+    make_DHCP6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCPDDNS (YY_COPY (location_type) l);
+    make_DHCPDDNS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONTROL_AGENT (YY_COPY (location_type) l);
+    make_CONTROL_AGENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TOPLEVEL_JSON (YY_COPY (location_type) l);
+    make_TOPLEVEL_JSON (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TOPLEVEL_DHCP4 (YY_COPY (location_type) l);
+    make_TOPLEVEL_DHCP4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_DHCP4 (YY_COPY (location_type) l);
+    make_SUB_DHCP4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_INTERFACES4 (YY_COPY (location_type) l);
+    make_SUB_INTERFACES4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_SUBNET4 (YY_COPY (location_type) l);
+    make_SUB_SUBNET4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_POOL4 (YY_COPY (location_type) l);
+    make_SUB_POOL4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_RESERVATION (YY_COPY (location_type) l);
+    make_SUB_RESERVATION (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_OPTION_DEFS (YY_COPY (location_type) l);
+    make_SUB_OPTION_DEFS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_OPTION_DEF (YY_COPY (location_type) l);
+    make_SUB_OPTION_DEF (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_OPTION_DATA (YY_COPY (location_type) l);
+    make_SUB_OPTION_DATA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_HOOKS_LIBRARY (YY_COPY (location_type) l);
+    make_SUB_HOOKS_LIBRARY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_DHCP_DDNS (YY_COPY (location_type) l);
+    make_SUB_DHCP_DDNS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_LOGGING (YY_COPY (location_type) l);
+    make_SUB_LOGGING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_CONFIG_CONTROL (YY_COPY (location_type) l);
+    make_SUB_CONFIG_CONTROL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_STRING (YY_COPY (std::string) v, YY_COPY (location_type) l);
+    make_STRING (const std::string& v, const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTEGER (YY_COPY (int64_t) v, YY_COPY (location_type) l);
+    make_INTEGER (const int64_t& v, const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLOAT (YY_COPY (double) v, YY_COPY (location_type) l);
+    make_FLOAT (const double& v, const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_BOOLEAN (YY_COPY (bool) v, YY_COPY (location_type) l);
+    make_BOOLEAN (const bool& v, const location_type& l);
 
 
+    /// Build a parser object.
+    Dhcp4Parser (isc::dhcp::Parser4Context& ctx_yyarg);
+    virtual ~Dhcp4Parser ();
+
+    /// Parse.
+    /// \returns  0 iff parsing succeeded.
+    virtual int parse ();
+
+#if PARSER4_DEBUG
+    /// The current debugging stream.
+    std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
+    /// Set the current debugging stream.
+    void set_debug_stream (std::ostream &);
+
+    /// Type for debugging levels.
+    typedef int debug_level_type;
+    /// The current debugging level.
+    debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
+    /// Set the current debugging level.
+    void set_debug_level (debug_level_type l);
+#endif
+
+    /// Report a syntax error.
+    /// \param loc    where the syntax error is found.
+    /// \param msg    a description of the syntax error.
+    virtual void error (const location_type& loc, const std::string& msg);
+
+    /// Report a syntax error.
+    void error (const syntax_error& err);
 
   private:
     /// This class is not copyable.
@@ -1540,7 +1354,7 @@ namespace isc { namespace dhcp {
     /// \param yyvalue   the value to check
     static bool yy_table_value_is_error_ (int yyvalue);
 
-    static const short yypact_ninf_;
+    static const short int yypact_ninf_;
     static const signed char yytable_ninf_;
 
     /// Convert a scanner token number \a t to a symbol number.
@@ -1549,32 +1363,32 @@ namespace isc { namespace dhcp {
     // Tables.
   // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   // STATE-NUM.
-  static const short yypact_[];
+  static const short int yypact_[];
 
   // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
   // Performed when YYTABLE does not specify something else to do.  Zero
   // means the default is an error.
-  static const unsigned short yydefact_[];
+  static const unsigned short int yydefact_[];
 
   // YYPGOTO[NTERM-NUM].
-  static const short yypgoto_[];
+  static const short int yypgoto_[];
 
   // YYDEFGOTO[NTERM-NUM].
-  static const short yydefgoto_[];
+  static const short int yydefgoto_[];
 
   // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
   // positive, shift that token.  If negative, reduce the rule whose
   // number is the opposite.  If YYTABLE_NINF, syntax error.
-  static const unsigned short yytable_[];
+  static const unsigned short int yytable_[];
 
-  static const short yycheck_[];
+  static const short int yycheck_[];
 
   // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   // symbol of state STATE-NUM.
-  static const unsigned short yystos_[];
+  static const unsigned short int yystos_[];
 
   // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
-  static const unsigned short yyr1_[];
+  static const unsigned short int yyr1_[];
 
   // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
   static const unsigned char yyr2_[];
@@ -1588,15 +1402,14 @@ namespace isc { namespace dhcp {
     static const char* const yytname_[];
 #if PARSER4_DEBUG
   // YYRLINE[YYN] -- Source line where rule number YYN was defined.
-  static const unsigned short yyrline_[];
+  static const unsigned short int yyrline_[];
     /// Report on the debug stream that the rule \a r is going to be reduced.
     virtual void yy_reduce_print_ (int r);
     /// Print the state stack on the debug stream.
     virtual void yystack_print_ ();
 
-    /// Debugging level.
+    // Debugging.
     int yydebug_;
-    /// Debug stream.
     std::ostream* yycdebug_;
 
     /// \brief Display a symbol type, value and location.
@@ -1654,15 +1467,10 @@ namespace isc { namespace dhcp {
       typedef basic_symbol<by_state> super_type;
       /// Construct an empty symbol.
       stack_symbol_type ();
-      /// Move or copy construction.
-      stack_symbol_type (YY_RVREF (stack_symbol_type) that);
       /// Steal the contents from \a sym to build this.
-      stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
-#if !defined __cplusplus || __cplusplus < 201103L
-      /// Assignment, needed by push_back by some old implementations.
-      /// Moves the contents of that.
-      stack_symbol_type& operator= (stack_symbol_type& that);
-#endif
+      stack_symbol_type (state_type s, symbol_type& sym);
+      /// Assignment, needed by push_back.
+      stack_symbol_type& operator= (const stack_symbol_type& that);
     };
 
     /// Stack type.
@@ -1674,20 +1482,20 @@ namespace isc { namespace dhcp {
     /// Push a new state on the stack.
     /// \param m    a debug message to display
     ///             if null, no trace is output.
-    /// \param sym  the symbol
+    /// \param s    the symbol
     /// \warning the contents of \a s.value is stolen.
-    void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
+    void yypush_ (const char* m, stack_symbol_type& s);
 
     /// Push a new look ahead token on the state on the stack.
     /// \param m    a debug message to display
     ///             if null, no trace is output.
     /// \param s    the state
     /// \param sym  the symbol (for its value and location).
-    /// \warning the contents of \a sym.value is stolen.
-    void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
+    /// \warning the contents of \a s.value is stolen.
+    void yypush_ (const char* m, state_type s, symbol_type& sym);
 
-    /// Pop \a n symbols from the stack.
-    void yypop_ (int n = 1);
+    /// Pop \a n symbols the three stacks.
+    void yypop_ (unsigned int n = 1);
 
     /// Constants.
     enum
@@ -1759,12 +1567,12 @@ namespace isc { namespace dhcp {
      155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
      165,   166,   167,   168
     };
-    const unsigned user_token_number_max_ = 423;
+    const unsigned int user_token_number_max_ = 423;
     const token_number_type undef_token_ = 2;
 
-    if (static_cast<int> (t) <= yyeof_)
+    if (static_cast<int>(t) <= yyeof_)
       return yyeof_;
-    else if (static_cast<unsigned> (t) <= user_token_number_max_)
+    else if (static_cast<unsigned int> (t) <= user_token_number_max_)
       return translate_table[t];
     else
       return undef_token_;
@@ -1778,18 +1586,19 @@ namespace isc { namespace dhcp {
 
   // basic_symbol.
   template <typename Base>
+  inline
   Dhcp4Parser::basic_symbol<Base>::basic_symbol ()
     : value ()
-    , location ()
   {}
 
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (YY_RVREF (basic_symbol) other)
-    : Base (YY_MOVE (other))
+  inline
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
+    : Base (other)
     , value ()
-    , location (YY_MOVE (other.location))
+    , location (other.location)
   {
-    switch (other.type_get ())
+      switch (other.type_get ())
     {
       case 185: // value
       case 189: // map_value
@@ -1799,23 +1608,23 @@ namespace isc { namespace dhcp {
       case 337: // hr_mode
       case 486: // ncr_protocol_value
       case 493: // replace_client_name_value
-        value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (other.value));
+        value.copy< ElementPtr > (other.value);
         break;
 
       case 168: // "boolean"
-        value.YY_MOVE_OR_COPY< bool > (YY_MOVE (other.value));
+        value.copy< bool > (other.value);
         break;
 
       case 167: // "floating point"
-        value.YY_MOVE_OR_COPY< double > (YY_MOVE (other.value));
+        value.copy< double > (other.value);
         break;
 
       case 166: // "integer"
-        value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (other.value));
+        value.copy< int64_t > (other.value);
         break;
 
       case 165: // "constant string"
-        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (other.value));
+        value.copy< std::string > (other.value);
         break;
 
       default:
@@ -1825,57 +1634,103 @@ namespace isc { namespace dhcp {
   }
 
 
+  template <typename Base>
+  inline
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const semantic_type& v, const location_type& l)
+    : Base (t)
+    , value ()
+    , location (l)
+  {
+    (void) v;
+      switch (this->type_get ())
+    {
+      case 185: // value
+      case 189: // map_value
+      case 230: // socket_type
+      case 233: // outbound_interface_value
+      case 255: // db_type
+      case 337: // hr_mode
+      case 486: // ncr_protocol_value
+      case 493: // replace_client_name_value
+        value.copy< ElementPtr > (v);
+        break;
+
+      case 168: // "boolean"
+        value.copy< bool > (v);
+        break;
+
+      case 167: // "floating point"
+        value.copy< double > (v);
+        break;
+
+      case 166: // "integer"
+        value.copy< int64_t > (v);
+        break;
+
+      case 165: // "constant string"
+        value.copy< std::string > (v);
+        break;
+
+      default:
+        break;
+    }
+}
+
+
   // Implementation of basic_symbol constructor for each type.
+
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (location_type) l)
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const location_type& l)
     : Base (t)
-    , location (YY_MOVE (l))
+    , value ()
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (ElementPtr) v, YY_RVREF (location_type) l)
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const ElementPtr v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (bool) v, YY_RVREF (location_type) l)
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const bool v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (double) v, YY_RVREF (location_type) l)
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const double v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (int64_t) v, YY_RVREF (location_type) l)
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const int64_t v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (std::string) v, YY_RVREF (location_type) l)
+  Dhcp4Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::string v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
 
-
   template <typename Base>
+  inline
   Dhcp4Parser::basic_symbol<Base>::~basic_symbol ()
   {
     clear ();
   }
 
   template <typename Base>
+  inline
   void
   Dhcp4Parser::basic_symbol<Base>::clear ()
   {
@@ -1890,7 +1745,7 @@ namespace isc { namespace dhcp {
     }
 
     // Type destructor.
-  switch (yytype)
+    switch (yytype)
     {
       case 185: // value
       case 189: // map_value
@@ -1927,6 +1782,7 @@ namespace isc { namespace dhcp {
   }
 
   template <typename Base>
+  inline
   bool
   Dhcp4Parser::basic_symbol<Base>::empty () const
   {
@@ -1934,11 +1790,12 @@ namespace isc { namespace dhcp {
   }
 
   template <typename Base>
+  inline
   void
   Dhcp4Parser::basic_symbol<Base>::move (basic_symbol& s)
   {
-    super_type::move (s);
-    switch (this->type_get ())
+    super_type::move(s);
+      switch (this->type_get ())
     {
       case 185: // value
       case 189: // map_value
@@ -1948,30 +1805,30 @@ namespace isc { namespace dhcp {
       case 337: // hr_mode
       case 486: // ncr_protocol_value
       case 493: // replace_client_name_value
-        value.move< ElementPtr > (YY_MOVE (s.value));
+        value.move< ElementPtr > (s.value);
         break;
 
       case 168: // "boolean"
-        value.move< bool > (YY_MOVE (s.value));
+        value.move< bool > (s.value);
         break;
 
       case 167: // "floating point"
-        value.move< double > (YY_MOVE (s.value));
+        value.move< double > (s.value);
         break;
 
       case 166: // "integer"
-        value.move< int64_t > (YY_MOVE (s.value));
+        value.move< int64_t > (s.value);
         break;
 
       case 165: // "constant string"
-        value.move< std::string > (YY_MOVE (s.value));
+        value.move< std::string > (s.value);
         break;
 
       default:
         break;
     }
 
-    location = YY_MOVE (s.location);
+    location = s.location;
   }
 
   // by_type.
@@ -2019,7 +1876,7 @@ namespace isc { namespace dhcp {
     // YYTOKNUM[NUM] -- (External) token number corresponding to the
     // (internal) symbol number NUM (which must be that of a token).  */
     static
-    const unsigned short
+    const unsigned short int
     yytoken_number_[] =
     {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
@@ -2042,1181 +1899,1013 @@ namespace isc { namespace dhcp {
     };
     return static_cast<token_type> (yytoken_number_[type]);
   }
-
   // Implementation of make_symbol for each symbol type.
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_END (YY_COPY (location_type) l)
+  Dhcp4Parser::make_END (const location_type& l)
   {
-    return symbol_type (token::TOKEN_END, YY_MOVE (l));
+    return symbol_type (token::TOKEN_END, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_COMMA (YY_COPY (location_type) l)
+  Dhcp4Parser::make_COMMA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_COMMA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_COMMA, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_COLON (YY_COPY (location_type) l)
+  Dhcp4Parser::make_COLON (const location_type& l)
   {
-    return symbol_type (token::TOKEN_COLON, YY_MOVE (l));
+    return symbol_type (token::TOKEN_COLON, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LSQUARE_BRACKET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LSQUARE_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LSQUARE_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LSQUARE_BRACKET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RSQUARE_BRACKET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RSQUARE_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RSQUARE_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RSQUARE_BRACKET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LCURLY_BRACKET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LCURLY_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LCURLY_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LCURLY_BRACKET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RCURLY_BRACKET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RCURLY_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RCURLY_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RCURLY_BRACKET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_NULL_TYPE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_NULL_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NULL_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NULL_TYPE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCP4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCP4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CONFIG_CONTROL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CONFIG_CONTROL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONFIG_CONTROL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONFIG_CONTROL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CONFIG_DATABASES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CONFIG_DATABASES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONFIG_DATABASES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONFIG_DATABASES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_INTERFACES_CONFIG (YY_COPY (location_type) l)
+  Dhcp4Parser::make_INTERFACES_CONFIG (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACES_CONFIG, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACES_CONFIG, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_INTERFACES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_INTERFACES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCP_SOCKET_TYPE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCP_SOCKET_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP_SOCKET_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP_SOCKET_TYPE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RAW (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RAW (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RAW, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RAW, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_UDP (YY_COPY (location_type) l)
+  Dhcp4Parser::make_UDP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_UDP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_UDP, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OUTBOUND_INTERFACE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OUTBOUND_INTERFACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUTBOUND_INTERFACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUTBOUND_INTERFACE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SAME_AS_INBOUND (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SAME_AS_INBOUND (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SAME_AS_INBOUND, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SAME_AS_INBOUND, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_USE_ROUTING (YY_COPY (location_type) l)
+  Dhcp4Parser::make_USE_ROUTING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_USE_ROUTING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_USE_ROUTING, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RE_DETECT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RE_DETECT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RE_DETECT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RE_DETECT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SANITY_CHECKS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SANITY_CHECKS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SANITY_CHECKS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SANITY_CHECKS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LEASE_CHECKS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LEASE_CHECKS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LEASE_CHECKS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LEASE_CHECKS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ECHO_CLIENT_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ECHO_CLIENT_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ECHO_CLIENT_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ECHO_CLIENT_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MATCH_CLIENT_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MATCH_CLIENT_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MATCH_CLIENT_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MATCH_CLIENT_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_AUTHORITATIVE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_AUTHORITATIVE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_AUTHORITATIVE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_AUTHORITATIVE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_NEXT_SERVER (YY_COPY (location_type) l)
+  Dhcp4Parser::make_NEXT_SERVER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NEXT_SERVER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NEXT_SERVER, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SERVER_HOSTNAME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SERVER_HOSTNAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_HOSTNAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_HOSTNAME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_BOOT_FILE_NAME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_BOOT_FILE_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_BOOT_FILE_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_BOOT_FILE_NAME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LEASE_DATABASE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LEASE_DATABASE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LEASE_DATABASE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LEASE_DATABASE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOSTS_DATABASE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOSTS_DATABASE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTS_DATABASE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTS_DATABASE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOSTS_DATABASES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOSTS_DATABASES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTS_DATABASES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTS_DATABASES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TYPE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TYPE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MEMFILE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MEMFILE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MEMFILE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MEMFILE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MYSQL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MYSQL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MYSQL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MYSQL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_POSTGRESQL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_POSTGRESQL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_POSTGRESQL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_POSTGRESQL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CQL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CQL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CQL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CQL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_USER (YY_COPY (location_type) l)
+  Dhcp4Parser::make_USER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_USER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_USER, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_PASSWORD (YY_COPY (location_type) l)
+  Dhcp4Parser::make_PASSWORD (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PASSWORD, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PASSWORD, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOST (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOST (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOST, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOST, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_PORT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PORT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_PERSIST (YY_COPY (location_type) l)
+  Dhcp4Parser::make_PERSIST (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PERSIST, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PERSIST, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LFC_INTERVAL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LFC_INTERVAL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LFC_INTERVAL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LFC_INTERVAL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_READONLY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_READONLY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_READONLY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_READONLY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CONNECT_TIMEOUT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CONNECT_TIMEOUT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONNECT_TIMEOUT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONNECT_TIMEOUT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CONTACT_POINTS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CONTACT_POINTS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONTACT_POINTS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONTACT_POINTS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_KEYSPACE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_KEYSPACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_KEYSPACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_KEYSPACE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MAX_RECONNECT_TRIES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MAX_RECONNECT_TRIES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RECONNECT_WAIT_TIME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RECONNECT_WAIT_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_REQUEST_TIMEOUT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_REQUEST_TIMEOUT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REQUEST_TIMEOUT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REQUEST_TIMEOUT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TCP_KEEPALIVE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TCP_KEEPALIVE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TCP_KEEPALIVE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TCP_KEEPALIVE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TCP_NODELAY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TCP_NODELAY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TCP_NODELAY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TCP_NODELAY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_VALID_LIFETIME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_VALID_LIFETIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_VALID_LIFETIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_VALID_LIFETIME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RENEW_TIMER (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RENEW_TIMER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RENEW_TIMER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RENEW_TIMER, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_REBIND_TIMER (YY_COPY (location_type) l)
+  Dhcp4Parser::make_REBIND_TIMER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REBIND_TIMER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REBIND_TIMER, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DECLINE_PROBATION_PERIOD (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DECLINE_PROBATION_PERIOD (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SERVER_TAG (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SERVER_TAG (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_TAG, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_TAG, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUBNET4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUBNET4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUBNET_4O6_INTERFACE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUBNET_4O6_INTERFACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUBNET_4O6_INTERFACE_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUBNET_4O6_INTERFACE_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUBNET_4O6_SUBNET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUBNET_4O6_SUBNET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET_4O6_SUBNET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET_4O6_SUBNET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OPTION_DEF (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OPTION_DEF (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OPTION_DEF, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OPTION_DEF, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OPTION_DATA (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OPTION_DATA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OPTION_DATA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OPTION_DATA, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_NAME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NAME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DATA (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DATA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DATA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DATA, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CODE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CODE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CODE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CODE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SPACE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SPACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SPACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SPACE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CSV_FORMAT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CSV_FORMAT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CSV_FORMAT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CSV_FORMAT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ALWAYS_SEND (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ALWAYS_SEND (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ALWAYS_SEND, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ALWAYS_SEND, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RECORD_TYPES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RECORD_TYPES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RECORD_TYPES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RECORD_TYPES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ENCAPSULATE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ENCAPSULATE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ENCAPSULATE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ENCAPSULATE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ARRAY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ARRAY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ARRAY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ARRAY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SHARED_NETWORKS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SHARED_NETWORKS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SHARED_NETWORKS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SHARED_NETWORKS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_POOLS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_POOLS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_POOLS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_POOLS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_POOL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_POOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_POOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_POOL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_USER_CONTEXT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_USER_CONTEXT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_USER_CONTEXT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_USER_CONTEXT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_COMMENT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_COMMENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_COMMENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_COMMENT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUBNET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUBNET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_INTERFACE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_INTERFACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RESERVATION_MODE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RESERVATION_MODE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RESERVATION_MODE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RESERVATION_MODE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DISABLED (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DISABLED (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DISABLED, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DISABLED, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OUT_OF_POOL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OUT_OF_POOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUT_OF_POOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUT_OF_POOL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_GLOBAL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_GLOBAL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_GLOBAL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_GLOBAL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ALL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ALL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ALL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ALL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOST_RESERVATION_IDENTIFIERS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOST_RESERVATION_IDENTIFIERS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CLIENT_CLASSES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CLIENT_CLASSES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CLIENT_CLASSES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CLIENT_CLASSES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_REQUIRE_CLIENT_CLASSES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_REQUIRE_CLIENT_CLASSES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TEST (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TEST (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TEST, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TEST, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ONLY_IF_REQUIRED (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ONLY_IF_REQUIRED (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CLIENT_CLASS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CLIENT_CLASS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CLIENT_CLASS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CLIENT_CLASS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RESERVATIONS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RESERVATIONS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RESERVATIONS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RESERVATIONS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DUID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DUID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DUID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DUID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HW_ADDRESS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HW_ADDRESS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HW_ADDRESS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HW_ADDRESS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CIRCUIT_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CIRCUIT_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CIRCUIT_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CIRCUIT_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CLIENT_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CLIENT_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CLIENT_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CLIENT_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOSTNAME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOSTNAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTNAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTNAME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_FLEX_ID (YY_COPY (location_type) l)
+  Dhcp4Parser::make_FLEX_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLEX_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLEX_ID, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RELAY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RELAY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RELAY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RELAY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_IP_ADDRESS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_IP_ADDRESS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_IP_ADDRESS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_IP_ADDRESS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_IP_ADDRESSES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_IP_ADDRESSES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_IP_ADDRESSES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_IP_ADDRESSES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOOKS_LIBRARIES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOOKS_LIBRARIES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOOKS_LIBRARIES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOOKS_LIBRARIES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LIBRARY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LIBRARY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LIBRARY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LIBRARY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_PARAMETERS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_PARAMETERS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PARAMETERS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PARAMETERS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_EXPIRED_LEASES_PROCESSING (YY_COPY (location_type) l)
+  Dhcp4Parser::make_EXPIRED_LEASES_PROCESSING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_RECLAIM_TIMER_WAIT_TIME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_RECLAIM_TIMER_WAIT_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOLD_RECLAIMED_TIME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOLD_RECLAIMED_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MAX_RECLAIM_LEASES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MAX_RECLAIM_LEASES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MAX_RECLAIM_TIME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MAX_RECLAIM_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_UNWARNED_RECLAIM_CYCLES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_UNWARNED_RECLAIM_CYCLES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCP4O6_PORT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCP4O6_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP4O6_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP4O6_PORT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CONTROL_SOCKET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CONTROL_SOCKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONTROL_SOCKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONTROL_SOCKET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SOCKET_TYPE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SOCKET_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SOCKET_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SOCKET_TYPE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SOCKET_NAME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SOCKET_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SOCKET_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SOCKET_NAME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCP_QUEUE_CONTROL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCP_QUEUE_CONTROL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCP_DDNS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCP_DDNS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP_DDNS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP_DDNS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ENABLE_UPDATES (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ENABLE_UPDATES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ENABLE_UPDATES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ENABLE_UPDATES, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_QUALIFYING_SUFFIX (YY_COPY (location_type) l)
+  Dhcp4Parser::make_QUALIFYING_SUFFIX (const location_type& l)
   {
-    return symbol_type (token::TOKEN_QUALIFYING_SUFFIX, YY_MOVE (l));
+    return symbol_type (token::TOKEN_QUALIFYING_SUFFIX, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SERVER_IP (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SERVER_IP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_IP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_IP, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SERVER_PORT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SERVER_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_PORT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SENDER_IP (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SENDER_IP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SENDER_IP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SENDER_IP, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SENDER_PORT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SENDER_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SENDER_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SENDER_PORT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MAX_QUEUE_SIZE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MAX_QUEUE_SIZE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_NCR_PROTOCOL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_NCR_PROTOCOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NCR_PROTOCOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NCR_PROTOCOL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_NCR_FORMAT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_NCR_FORMAT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NCR_FORMAT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NCR_FORMAT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OVERRIDE_NO_UPDATE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OVERRIDE_NO_UPDATE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OVERRIDE_NO_UPDATE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OVERRIDE_NO_UPDATE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OVERRIDE_CLIENT_UPDATE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OVERRIDE_CLIENT_UPDATE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OVERRIDE_CLIENT_UPDATE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OVERRIDE_CLIENT_UPDATE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_REPLACE_CLIENT_NAME (YY_COPY (location_type) l)
+  Dhcp4Parser::make_REPLACE_CLIENT_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REPLACE_CLIENT_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REPLACE_CLIENT_NAME, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_GENERATED_PREFIX (YY_COPY (location_type) l)
+  Dhcp4Parser::make_GENERATED_PREFIX (const location_type& l)
   {
-    return symbol_type (token::TOKEN_GENERATED_PREFIX, YY_MOVE (l));
+    return symbol_type (token::TOKEN_GENERATED_PREFIX, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TCP (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TCP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TCP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TCP, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_JSON (YY_COPY (location_type) l)
+  Dhcp4Parser::make_JSON (const location_type& l)
   {
-    return symbol_type (token::TOKEN_JSON, YY_MOVE (l));
+    return symbol_type (token::TOKEN_JSON, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_WHEN_PRESENT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_WHEN_PRESENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_WHEN_PRESENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_WHEN_PRESENT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_NEVER (YY_COPY (location_type) l)
+  Dhcp4Parser::make_NEVER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NEVER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NEVER, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_ALWAYS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_ALWAYS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ALWAYS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ALWAYS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_WHEN_NOT_PRESENT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_WHEN_NOT_PRESENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOSTNAME_CHAR_SET (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOSTNAME_CHAR_SET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_HOSTNAME_CHAR_REPLACEMENT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_HOSTNAME_CHAR_REPLACEMENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LOGGING (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LOGGING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LOGGING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LOGGING, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_LOGGERS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_LOGGERS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LOGGERS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LOGGERS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OUTPUT_OPTIONS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OUTPUT_OPTIONS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUTPUT_OPTIONS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUTPUT_OPTIONS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_OUTPUT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_OUTPUT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUTPUT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUTPUT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DEBUGLEVEL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DEBUGLEVEL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DEBUGLEVEL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DEBUGLEVEL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SEVERITY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SEVERITY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SEVERITY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SEVERITY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_FLUSH (YY_COPY (location_type) l)
+  Dhcp4Parser::make_FLUSH (const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLUSH, YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLUSH, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MAXSIZE (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MAXSIZE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAXSIZE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAXSIZE, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_MAXVER (YY_COPY (location_type) l)
+  Dhcp4Parser::make_MAXVER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAXVER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAXVER, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCP6 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCP6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP6, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_DHCPDDNS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_DHCPDDNS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCPDDNS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCPDDNS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_CONTROL_AGENT (YY_COPY (location_type) l)
+  Dhcp4Parser::make_CONTROL_AGENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONTROL_AGENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONTROL_AGENT, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TOPLEVEL_JSON (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TOPLEVEL_JSON (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TOPLEVEL_JSON, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TOPLEVEL_JSON, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_TOPLEVEL_DHCP4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_TOPLEVEL_DHCP4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TOPLEVEL_DHCP4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TOPLEVEL_DHCP4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_DHCP4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_DHCP4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_DHCP4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_DHCP4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_INTERFACES4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_INTERFACES4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_INTERFACES4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_INTERFACES4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_SUBNET4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_SUBNET4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_SUBNET4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_SUBNET4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_POOL4 (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_POOL4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_POOL4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_POOL4, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_RESERVATION (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_RESERVATION (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_RESERVATION, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_RESERVATION, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_OPTION_DEFS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_OPTION_DEFS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_OPTION_DEFS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_OPTION_DEFS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_OPTION_DEF (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_OPTION_DEF (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_OPTION_DEF, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_OPTION_DEF, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_OPTION_DATA (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_OPTION_DATA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_OPTION_DATA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_OPTION_DATA, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_HOOKS_LIBRARY (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_HOOKS_LIBRARY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_DHCP_DDNS (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_DHCP_DDNS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_DHCP_DDNS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_DHCP_DDNS, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_LOGGING (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_LOGGING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_LOGGING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_LOGGING, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_SUB_CONFIG_CONTROL (YY_COPY (location_type) l)
+  Dhcp4Parser::make_SUB_CONFIG_CONTROL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_STRING (YY_COPY (std::string) v, YY_COPY (location_type) l)
+  Dhcp4Parser::make_STRING (const std::string& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_STRING, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_STRING, v, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_INTEGER (YY_COPY (int64_t) v, YY_COPY (location_type) l)
+  Dhcp4Parser::make_INTEGER (const int64_t& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTEGER, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTEGER, v, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_FLOAT (YY_COPY (double) v, YY_COPY (location_type) l)
+  Dhcp4Parser::make_FLOAT (const double& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLOAT, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLOAT, v, l);
   }
 
-  inline
   Dhcp4Parser::symbol_type
-  Dhcp4Parser::make_BOOLEAN (YY_COPY (bool) v, YY_COPY (location_type) l)
+  Dhcp4Parser::make_BOOLEAN (const bool& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_BOOLEAN, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_BOOLEAN, v, l);
   }
 
 
-#line 14 "dhcp4_parser.yy" // lalr1.cc:404
+#line 14 "dhcp4_parser.yy" // lalr1.cc:377
 } } // isc::dhcp
-#line 3220 "dhcp4_parser.h" // lalr1.cc:404
+#line 2909 "dhcp4_parser.h" // lalr1.cc:377
 
 
 
diff --git a/src/bin/dhcp4/location.hh b/src/bin/dhcp4/location.hh
index bf20acebfc..7e23a2ccac 100644
--- a/src/bin/dhcp4/location.hh
+++ b/src/bin/dhcp4/location.hh
@@ -1,9 +1,8 @@
-// Generated 201811201411
-// A Bison parser, made by GNU Bison 3.2.1.
+// A Bison parser, made by GNU Bison 3.0.4.
 
 // Locations for Bison parsers in C++
 
-// Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -39,145 +38,12 @@
 #ifndef YY_PARSER4_LOCATION_HH_INCLUDED
 # define YY_PARSER4_LOCATION_HH_INCLUDED
 
-# include <algorithm> // std::max
-# include <iostream>
-# include <string>
+# include "position.hh"
 
-# ifndef YY_NULLPTR
-#  if defined __cplusplus
-#   if 201103L <= __cplusplus
-#    define YY_NULLPTR nullptr
-#   else
-#    define YY_NULLPTR 0
-#   endif
-#  else
-#   define YY_NULLPTR ((void*)0)
-#  endif
-# endif
-
-#line 14 "dhcp4_parser.yy" // location.cc:339
+#line 14 "dhcp4_parser.yy" // location.cc:296
 namespace isc { namespace dhcp {
-#line 60 "location.hh" // location.cc:339
-  /// A point in a source file.
-  class position
-  {
-  public:
-    /// Construct a position.
-    explicit position (std::string* f = YY_NULLPTR,
-                       unsigned l = 1u,
-                       unsigned c = 1u)
-      : filename (f)
-      , line (l)
-      , column (c)
-    {}
-
-
-    /// Initialization.
-    void initialize (std::string* fn = YY_NULLPTR,
-                     unsigned l = 1u,
-                     unsigned c = 1u)
-    {
-      filename = fn;
-      line = l;
-      column = c;
-    }
-
-    /** \name Line and Column related manipulators
-     ** \{ */
-    /// (line related) Advance to the COUNT next lines.
-    void lines (int count = 1)
-    {
-      if (count)
-        {
-          column = 1u;
-          line = add_ (line, count, 1);
-        }
-    }
-
-    /// (column related) Advance to the COUNT next columns.
-    void columns (int count = 1)
-    {
-      column = add_ (column, count, 1);
-    }
-    /** \} */
-
-    /// File name to which this position refers.
-    std::string* filename;
-    /// Current line number.
-    unsigned line;
-    /// Current column number.
-    unsigned column;
-
-  private:
-    /// Compute max (min, lhs+rhs).
-    static unsigned add_ (unsigned lhs, int rhs, int min)
-    {
-      return static_cast<unsigned> (std::max (min,
-                                              static_cast<int> (lhs) + rhs));
-    }
-  };
-
-  /// Add \a width columns, in place.
-  inline position&
-  operator+= (position& res, int width)
-  {
-    res.columns (width);
-    return res;
-  }
-
-  /// Add \a width columns.
-  inline position
-  operator+ (position res, int width)
-  {
-    return res += width;
-  }
-
-  /// Subtract \a width columns, in place.
-  inline position&
-  operator-= (position& res, int width)
-  {
-    return res += -width;
-  }
-
-  /// Subtract \a width columns.
-  inline position
-  operator- (position res, int width)
-  {
-    return res -= width;
-  }
-
-  /// Compare two position objects.
-  inline bool
-  operator== (const position& pos1, const position& pos2)
-  {
-    return (pos1.line == pos2.line
-            && pos1.column == pos2.column
-            && (pos1.filename == pos2.filename
-                || (pos1.filename && pos2.filename
-                    && *pos1.filename == *pos2.filename)));
-  }
-
-  /// Compare two position objects.
-  inline bool
-  operator!= (const position& pos1, const position& pos2)
-  {
-    return !(pos1 == pos2);
-  }
-
-  /** \brief Intercept output stream redirection.
-   ** \param ostr the destination output stream
-   ** \param pos a reference to the position to redirect
-   */
-  template <typename YYChar>
-  std::basic_ostream<YYChar>&
-  operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
-  {
-    if (pos.filename)
-      ostr << *pos.filename << ':';
-    return ostr << pos.line << '.' << pos.column;
-  }
-
-  /// Two points in a source file.
+#line 46 "location.hh" // location.cc:296
+  /// Abstract a location.
   class location
   {
   public:
@@ -186,27 +52,30 @@ namespace isc { namespace dhcp {
     location (const position& b, const position& e)
       : begin (b)
       , end (e)
-    {}
+    {
+    }
 
     /// Construct a 0-width location in \a p.
     explicit location (const position& p = position ())
       : begin (p)
       , end (p)
-    {}
+    {
+    }
 
     /// Construct a 0-width location in \a f, \a l, \a c.
     explicit location (std::string* f,
-                       unsigned l = 1u,
-                       unsigned c = 1u)
+                       unsigned int l = 1u,
+                       unsigned int c = 1u)
       : begin (f, l, c)
       , end (f, l, c)
-    {}
+    {
+    }
 
 
     /// Initialization.
     void initialize (std::string* f = YY_NULLPTR,
-                     unsigned l = 1u,
-                     unsigned c = 1u)
+                     unsigned int l = 1u,
+                     unsigned int c = 1u)
     {
       begin.initialize (f, l, c);
       end = begin;
@@ -301,10 +170,10 @@ namespace isc { namespace dhcp {
    ** Avoid duplicate information.
    */
   template <typename YYChar>
-  std::basic_ostream<YYChar>&
+  inline std::basic_ostream<YYChar>&
   operator<< (std::basic_ostream<YYChar>& ostr, const location& loc)
   {
-    unsigned end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
+    unsigned int end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
     ostr << loc.begin;
     if (loc.end.filename
         && (!loc.begin.filename
@@ -317,7 +186,7 @@ namespace isc { namespace dhcp {
     return ostr;
   }
 
-#line 14 "dhcp4_parser.yy" // location.cc:339
+#line 14 "dhcp4_parser.yy" // location.cc:296
 } } // isc::dhcp
-#line 322 "location.hh" // location.cc:339
+#line 192 "location.hh" // location.cc:296
 #endif // !YY_PARSER4_LOCATION_HH_INCLUDED
diff --git a/src/bin/dhcp4/position.hh b/src/bin/dhcp4/position.hh
index 4a9a456ce0..c60fabbdf8 100644
--- a/src/bin/dhcp4/position.hh
+++ b/src/bin/dhcp4/position.hh
@@ -1,12 +1,180 @@
-// Generated 201811201411
-// A Bison parser, made by GNU Bison 3.2.1.
-
-// Starting with Bison 3.2, this file is useless: the structure it
-// used to define is now defined in "location.hh".
-//
-// To get rid of this file:
-// 1. add 'require "3.2"' (or newer) to your grammar file
-// 2. remove references to this file from your build system
-// 3. if you used to include it, include "location.hh" instead.
-
-#include "location.hh"
+// A Bison parser, made by GNU Bison 3.0.4.
+
+// Positions for Bison parsers in C++
+
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file position.hh
+ ** Define the isc::dhcp::position class.
+ */
+
+#ifndef YY_PARSER4_POSITION_HH_INCLUDED
+# define YY_PARSER4_POSITION_HH_INCLUDED
+
+# include <algorithm> // std::max
+# include <iostream>
+# include <string>
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+#line 14 "dhcp4_parser.yy" // location.cc:296
+namespace isc { namespace dhcp {
+#line 56 "position.hh" // location.cc:296
+  /// Abstract a position.
+  class position
+  {
+  public:
+    /// Construct a position.
+    explicit position (std::string* f = YY_NULLPTR,
+                       unsigned int l = 1u,
+                       unsigned int c = 1u)
+      : filename (f)
+      , line (l)
+      , column (c)
+    {
+    }
+
+
+    /// Initialization.
+    void initialize (std::string* fn = YY_NULLPTR,
+                     unsigned int l = 1u,
+                     unsigned int c = 1u)
+    {
+      filename = fn;
+      line = l;
+      column = c;
+    }
+
+    /** \name Line and Column related manipulators
+     ** \{ */
+    /// (line related) Advance to the COUNT next lines.
+    void lines (int count = 1)
+    {
+      if (count)
+        {
+          column = 1u;
+          line = add_ (line, count, 1);
+        }
+    }
+
+    /// (column related) Advance to the COUNT next columns.
+    void columns (int count = 1)
+    {
+      column = add_ (column, count, 1);
+    }
+    /** \} */
+
+    /// File name to which this position refers.
+    std::string* filename;
+    /// Current line number.
+    unsigned int line;
+    /// Current column number.
+    unsigned int column;
+
+  private:
+    /// Compute max(min, lhs+rhs) (provided min <= lhs).
+    static unsigned int add_ (unsigned int lhs, int rhs, unsigned int min)
+    {
+      return (0 < rhs || -static_cast<unsigned int>(rhs) < lhs
+              ? rhs + lhs
+              : min);
+    }
+  };
+
+  /// Add \a width columns, in place.
+  inline position&
+  operator+= (position& res, int width)
+  {
+    res.columns (width);
+    return res;
+  }
+
+  /// Add \a width columns.
+  inline position
+  operator+ (position res, int width)
+  {
+    return res += width;
+  }
+
+  /// Subtract \a width columns, in place.
+  inline position&
+  operator-= (position& res, int width)
+  {
+    return res += -width;
+  }
+
+  /// Subtract \a width columns.
+  inline position
+  operator- (position res, int width)
+  {
+    return res -= width;
+  }
+
+  /// Compare two position objects.
+  inline bool
+  operator== (const position& pos1, const position& pos2)
+  {
+    return (pos1.line == pos2.line
+            && pos1.column == pos2.column
+            && (pos1.filename == pos2.filename
+                || (pos1.filename && pos2.filename
+                    && *pos1.filename == *pos2.filename)));
+  }
+
+  /// Compare two position objects.
+  inline bool
+  operator!= (const position& pos1, const position& pos2)
+  {
+    return !(pos1 == pos2);
+  }
+
+  /** \brief Intercept output stream redirection.
+   ** \param ostr the destination output stream
+   ** \param pos a reference to the position to redirect
+   */
+  template <typename YYChar>
+  inline std::basic_ostream<YYChar>&
+  operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
+  {
+    if (pos.filename)
+      ostr << *pos.filename << ':';
+    return ostr << pos.line << '.' << pos.column;
+  }
+
+#line 14 "dhcp4_parser.yy" // location.cc:296
+} } // isc::dhcp
+#line 180 "position.hh" // location.cc:296
+#endif // !YY_PARSER4_POSITION_HH_INCLUDED
diff --git a/src/bin/dhcp4/stack.hh b/src/bin/dhcp4/stack.hh
index 8d96cdf2b7..3dd2a2a393 100644
--- a/src/bin/dhcp4/stack.hh
+++ b/src/bin/dhcp4/stack.hh
@@ -1,9 +1,157 @@
-// Generated 201811201411
-// A Bison parser, made by GNU Bison 3.2.1.
-
-// Starting with Bison 3.2, this file is useless: the structure it
-// used to define is now defined with the parser itself.
-//
-// To get rid of this file:
-// 1. add 'require "3.2"' (or newer) to your grammar file
-// 2. remove references to this file from your build system.
+// A Bison parser, made by GNU Bison 3.0.4.
+
+// Stack handling for Bison parsers in C++
+
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file stack.hh
+ ** Define the isc::dhcp::stack class.
+ */
+
+#ifndef YY_PARSER4_STACK_HH_INCLUDED
+# define YY_PARSER4_STACK_HH_INCLUDED
+
+# include <vector>
+
+#line 14 "dhcp4_parser.yy" // stack.hh:132
+namespace isc { namespace dhcp {
+#line 46 "stack.hh" // stack.hh:132
+  template <class T, class S = std::vector<T> >
+  class stack
+  {
+  public:
+    // Hide our reversed order.
+    typedef typename S::reverse_iterator iterator;
+    typedef typename S::const_reverse_iterator const_iterator;
+
+    stack ()
+      : seq_ ()
+    {
+      seq_.reserve (200);
+    }
+
+    stack (unsigned int n)
+      : seq_ (n)
+    {}
+
+    inline
+    T&
+    operator[] (unsigned int i)
+    {
+      return seq_[seq_.size () - 1 - i];
+    }
+
+    inline
+    const T&
+    operator[] (unsigned int i) const
+    {
+      return seq_[seq_.size () - 1 - i];
+    }
+
+    /// Steal the contents of \a t.
+    ///
+    /// Close to move-semantics.
+    inline
+    void
+    push (T& t)
+    {
+      seq_.push_back (T());
+      operator[](0).move (t);
+    }
+
+    inline
+    void
+    pop (unsigned int n = 1)
+    {
+      for (; n; --n)
+        seq_.pop_back ();
+    }
+
+    void
+    clear ()
+    {
+      seq_.clear ();
+    }
+
+    inline
+    typename S::size_type
+    size () const
+    {
+      return seq_.size ();
+    }
+
+    inline
+    const_iterator
+    begin () const
+    {
+      return seq_.rbegin ();
+    }
+
+    inline
+    const_iterator
+    end () const
+    {
+      return seq_.rend ();
+    }
+
+  private:
+    stack (const stack&);
+    stack& operator= (const stack&);
+    /// The wrapped container.
+    S seq_;
+  };
+
+  /// Present a slice of the top of a stack.
+  template <class T, class S = stack<T> >
+  class slice
+  {
+  public:
+    slice (const S& stack, unsigned int range)
+      : stack_ (stack)
+      , range_ (range)
+    {}
+
+    inline
+    const T&
+    operator [] (unsigned int i) const
+    {
+      return stack_[range_ - i];
+    }
+
+  private:
+    const S& stack_;
+    unsigned int range_;
+  };
+
+#line 14 "dhcp4_parser.yy" // stack.hh:132
+} } // isc::dhcp
+#line 156 "stack.hh" // stack.hh:132
+
+#endif // !YY_PARSER4_STACK_HH_INCLUDED
diff --git a/src/bin/dhcp6/dhcp6_parser.cc b/src/bin/dhcp6/dhcp6_parser.cc
index a3cab1fd01..c4b6488949 100644
--- a/src/bin/dhcp6/dhcp6_parser.cc
+++ b/src/bin/dhcp6/dhcp6_parser.cc
@@ -1,8 +1,8 @@
-// A Bison parser, made by GNU Bison 3.2.1.
+// A Bison parser, made by GNU Bison 3.0.4.
 
 // Skeleton implementation for Bison LALR(1) parsers in C++
 
-// Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -30,24 +30,32 @@
 // This special exception was added by the Free Software Foundation in
 // version 2.2 of Bison.
 
-// Undocumented macros, especially those whose name start with YY_,
-// are private implementation details.  Do not rely on them.
-
-
 // Take the name prefix into account.
 #define yylex   parser6_lex
 
+// First part of user declarations.
+
+#line 39 "dhcp6_parser.cc" // lalr1.cc:404
 
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
 
 #include "dhcp6_parser.h"
 
+// User implementation prologue.
 
+#line 53 "dhcp6_parser.cc" // lalr1.cc:412
 // Unqualified %code blocks.
-#line 34 "dhcp6_parser.yy" // lalr1.cc:438
+#line 34 "dhcp6_parser.yy" // lalr1.cc:413
 
 #include <dhcp6/parser_context.h>
 
-#line 51 "dhcp6_parser.cc" // lalr1.cc:438
+#line 59 "dhcp6_parser.cc" // lalr1.cc:413
 
 
 #ifndef YY_
@@ -62,15 +70,6 @@
 # endif
 #endif
 
-// Whether we are compiled with exception support.
-#ifndef YY_EXCEPTIONS
-# if defined __GNUC__ && !defined __EXCEPTIONS
-#  define YY_EXCEPTIONS 0
-# else
-#  define YY_EXCEPTIONS 1
-# endif
-#endif
-
 #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    If N is 0, then set CURRENT to the empty location which ends
@@ -107,7 +106,7 @@
     {                                           \
       *yycdebug_ << Title << ' ';               \
       yy_print_ (*yycdebug_, Symbol);           \
-      *yycdebug_ << '\n';                       \
+      *yycdebug_ << std::endl;                  \
     }                                           \
   } while (false)
 
@@ -126,9 +125,9 @@
 #else // !PARSER6_DEBUG
 
 # define YYCDEBUG if (false) std::cerr
-# define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE (Symbol)
-# define YY_REDUCE_PRINT(Rule)           static_cast<void> (0)
-# define YY_STACK_PRINT()                static_cast<void> (0)
+# define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE(Symbol)
+# define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)
+# define YY_STACK_PRINT()                static_cast<void>(0)
 
 #endif // !PARSER6_DEBUG
 
@@ -140,9 +139,9 @@
 #define YYERROR         goto yyerrorlab
 #define YYRECOVERING()  (!!yyerrstatus_)
 
-#line 14 "dhcp6_parser.yy" // lalr1.cc:513
+#line 14 "dhcp6_parser.yy" // lalr1.cc:479
 namespace isc { namespace dhcp {
-#line 146 "dhcp6_parser.cc" // lalr1.cc:513
+#line 145 "dhcp6_parser.cc" // lalr1.cc:479
 
   /* Return YYSTR after stripping away unnecessary quotes and
      backslashes, so that it's suitable for yyerror.  The heuristic is
@@ -203,20 +202,24 @@ namespace isc { namespace dhcp {
 
 
   // by_state.
+  inline
   Dhcp6Parser::by_state::by_state ()
     : state (empty_state)
   {}
 
+  inline
   Dhcp6Parser::by_state::by_state (const by_state& other)
     : state (other.state)
   {}
 
+  inline
   void
   Dhcp6Parser::by_state::clear ()
   {
     state = empty_state;
   }
 
+  inline
   void
   Dhcp6Parser::by_state::move (by_state& that)
   {
@@ -224,10 +227,12 @@ namespace isc { namespace dhcp {
     that.clear ();
   }
 
+  inline
   Dhcp6Parser::by_state::by_state (state_type s)
     : state (s)
   {}
 
+  inline
   Dhcp6Parser::symbol_number_type
   Dhcp6Parser::by_state::type_get () const
   {
@@ -237,54 +242,16 @@ namespace isc { namespace dhcp {
       return yystos_[state];
   }
 
+  inline
   Dhcp6Parser::stack_symbol_type::stack_symbol_type ()
   {}
 
-  Dhcp6Parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
-    : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
-  {
-    switch (that.type_get ())
-    {
-      case 191: // value
-      case 195: // map_value
-      case 247: // db_type
-      case 336: // hr_mode
-      case 472: // duid_type
-      case 507: // ncr_protocol_value
-      case 514: // replace_client_name_value
-        value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
-        break;
-
-      case 173: // "boolean"
-        value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
-        break;
-
-      case 172: // "floating point"
-        value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
-        break;
-
-      case 171: // "integer"
-        value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
-        break;
-
-      case 170: // "constant string"
-        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
-        break;
-
-      default:
-        break;
-    }
-
-#if defined __cplusplus && 201103L <= __cplusplus
-    // that is emptied.
-    that.state = empty_state;
-#endif
-  }
 
-  Dhcp6Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
-    : super_type (s, YY_MOVE (that.location))
+  inline
+  Dhcp6Parser::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that)
+    : super_type (s, that.location)
   {
-    switch (that.type_get ())
+      switch (that.type_get ())
     {
       case 191: // value
       case 195: // map_value
@@ -293,23 +260,23 @@ namespace isc { namespace dhcp {
       case 472: // duid_type
       case 507: // ncr_protocol_value
       case 514: // replace_client_name_value
-        value.move< ElementPtr > (YY_MOVE (that.value));
+        value.move< ElementPtr > (that.value);
         break;
 
       case 173: // "boolean"
-        value.move< bool > (YY_MOVE (that.value));
+        value.move< bool > (that.value);
         break;
 
       case 172: // "floating point"
-        value.move< double > (YY_MOVE (that.value));
+        value.move< double > (that.value);
         break;
 
       case 171: // "integer"
-        value.move< int64_t > (YY_MOVE (that.value));
+        value.move< int64_t > (that.value);
         break;
 
       case 170: // "constant string"
-        value.move< std::string > (YY_MOVE (that.value));
+        value.move< std::string > (that.value);
         break;
 
       default:
@@ -320,12 +287,12 @@ namespace isc { namespace dhcp {
     that.type = empty_symbol;
   }
 
-#if !defined __cplusplus || __cplusplus < 201103L
+  inline
   Dhcp6Parser::stack_symbol_type&
-  Dhcp6Parser::stack_symbol_type::operator= (stack_symbol_type& that)
+  Dhcp6Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
   {
     state = that.state;
-    switch (that.type_get ())
+      switch (that.type_get ())
     {
       case 191: // value
       case 195: // map_value
@@ -334,23 +301,23 @@ namespace isc { namespace dhcp {
       case 472: // duid_type
       case 507: // ncr_protocol_value
       case 514: // replace_client_name_value
-        value.move< ElementPtr > (that.value);
+        value.copy< ElementPtr > (that.value);
         break;
 
       case 173: // "boolean"
-        value.move< bool > (that.value);
+        value.copy< bool > (that.value);
         break;
 
       case 172: // "floating point"
-        value.move< double > (that.value);
+        value.copy< double > (that.value);
         break;
 
       case 171: // "integer"
-        value.move< int64_t > (that.value);
+        value.copy< int64_t > (that.value);
         break;
 
       case 170: // "constant string"
-        value.move< std::string > (that.value);
+        value.copy< std::string > (that.value);
         break;
 
       default:
@@ -358,13 +325,12 @@ namespace isc { namespace dhcp {
     }
 
     location = that.location;
-    // that is emptied.
-    that.state = empty_state;
     return *this;
   }
-#endif
+
 
   template <typename Base>
+  inline
   void
   Dhcp6Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
   {
@@ -392,79 +358,79 @@ namespace isc { namespace dhcp {
     {
             case 170: // "constant string"
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< std::string > (); }
-#line 398 "dhcp6_parser.cc" // lalr1.cc:672
+#line 364 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 171: // "integer"
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< int64_t > (); }
-#line 405 "dhcp6_parser.cc" // lalr1.cc:672
+#line 371 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 172: // "floating point"
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< double > (); }
-#line 412 "dhcp6_parser.cc" // lalr1.cc:672
+#line 378 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 173: // "boolean"
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< bool > (); }
-#line 419 "dhcp6_parser.cc" // lalr1.cc:672
+#line 385 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 191: // value
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 426 "dhcp6_parser.cc" // lalr1.cc:672
+#line 392 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 195: // map_value
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 433 "dhcp6_parser.cc" // lalr1.cc:672
+#line 399 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 247: // db_type
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 440 "dhcp6_parser.cc" // lalr1.cc:672
+#line 406 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 336: // hr_mode
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 447 "dhcp6_parser.cc" // lalr1.cc:672
+#line 413 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 472: // duid_type
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 454 "dhcp6_parser.cc" // lalr1.cc:672
+#line 420 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 507: // ncr_protocol_value
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 461 "dhcp6_parser.cc" // lalr1.cc:672
+#line 427 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
       case 514: // replace_client_name_value
 
-#line 248 "dhcp6_parser.yy" // lalr1.cc:672
+#line 248 "dhcp6_parser.yy" // lalr1.cc:636
         { yyoutput << yysym.value.template as< ElementPtr > (); }
-#line 468 "dhcp6_parser.cc" // lalr1.cc:672
+#line 434 "dhcp6_parser.cc" // lalr1.cc:636
         break;
 
 
@@ -475,27 +441,26 @@ namespace isc { namespace dhcp {
   }
 #endif
 
+  inline
   void
-  Dhcp6Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
+  Dhcp6Parser::yypush_ (const char* m, state_type s, symbol_type& sym)
   {
-    if (m)
-      YY_SYMBOL_PRINT (m, sym);
-    yystack_.push (YY_MOVE (sym));
+    stack_symbol_type t (s, sym);
+    yypush_ (m, t);
   }
 
+  inline
   void
-  Dhcp6Parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
+  Dhcp6Parser::yypush_ (const char* m, stack_symbol_type& s)
   {
-#if defined __cplusplus && 201103L <= __cplusplus
-    yypush_ (m, stack_symbol_type (s, std::move (sym)));
-#else
-    stack_symbol_type ss (s, sym);
-    yypush_ (m, ss);
-#endif
+    if (m)
+      YY_SYMBOL_PRINT (m, s);
+    yystack_.push (s);
   }
 
+  inline
   void
-  Dhcp6Parser::yypop_ (int n)
+  Dhcp6Parser::yypop_ (unsigned int n)
   {
     yystack_.pop (n);
   }
@@ -527,7 +492,7 @@ namespace isc { namespace dhcp {
   }
 #endif // PARSER6_DEBUG
 
-  Dhcp6Parser::state_type
+  inline Dhcp6Parser::state_type
   Dhcp6Parser::yy_lr_goto_state_ (state_type yystate, int yysym)
   {
     int yyr = yypgoto_[yysym - yyntokens_] + yystate;
@@ -537,25 +502,19 @@ namespace isc { namespace dhcp {
       return yydefgoto_[yysym - yyntokens_];
   }
 
-  bool
+  inline bool
   Dhcp6Parser::yy_pact_value_is_default_ (int yyvalue)
   {
     return yyvalue == yypact_ninf_;
   }
 
-  bool
+  inline bool
   Dhcp6Parser::yy_table_value_is_error_ (int yyvalue)
   {
     return yyvalue == yytable_ninf_;
   }
 
   int
-  Dhcp6Parser::operator() ()
-  {
-    return parse ();
-  }
-
-  int
   Dhcp6Parser::parse ()
   {
     // State.
@@ -576,11 +535,11 @@ namespace isc { namespace dhcp {
     /// The return value of parse ().
     int yyresult;
 
-#if YY_EXCEPTIONS
+    // FIXME: This shoud be completely indented.  It is not yet to
+    // avoid gratuitous conflicts when merging into the master branch.
     try
-#endif // YY_EXCEPTIONS
       {
-    YYCDEBUG << "Starting parse\n";
+    YYCDEBUG << "Starting parse" << std::endl;
 
 
     /* Initialize the stack.  The initial state will be set in
@@ -588,11 +547,11 @@ namespace isc { namespace dhcp {
        location values to have been already stored, initialize these
        stacks with a primary value.  */
     yystack_.clear ();
-    yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
+    yypush_ (YY_NULLPTR, 0, yyla);
 
     // A new symbol was pushed on the stack.
   yynewstate:
-    YYCDEBUG << "Entering state " << yystack_[0].state << '\n';
+    YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;
 
     // Accept?
     if (yystack_[0].state == yyfinal_)
@@ -602,6 +561,7 @@ namespace isc { namespace dhcp {
 
     // Backup.
   yybackup:
+
     // Try to take a decision without lookahead.
     yyn = yypact_[yystack_[0].state];
     if (yy_pact_value_is_default_ (yyn))
@@ -611,20 +571,16 @@ namespace isc { namespace dhcp {
     if (yyla.empty ())
       {
         YYCDEBUG << "Reading a token: ";
-#if YY_EXCEPTIONS
         try
-#endif // YY_EXCEPTIONS
           {
             symbol_type yylookahead (yylex (ctx));
             yyla.move (yylookahead);
           }
-#if YY_EXCEPTIONS
         catch (const syntax_error& yyexc)
           {
             error (yyexc);
             goto yyerrlab1;
           }
-#endif // YY_EXCEPTIONS
       }
     YY_SYMBOL_PRINT ("Next token is", yyla);
 
@@ -649,7 +605,7 @@ namespace isc { namespace dhcp {
       --yyerrstatus_;
 
     // Shift the lookahead token.
-    yypush_ ("Shifting", yyn, YY_MOVE (yyla));
+    yypush_ ("Shifting", yyn, yyla);
     goto yynewstate;
 
   /*-----------------------------------------------------------.
@@ -668,11 +624,11 @@ namespace isc { namespace dhcp {
     yylen = yyr2_[yyn];
     {
       stack_symbol_type yylhs;
-      yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
+      yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);
       /* Variants are always initialized to an empty instance of the
          correct type. The default '$$ = $1' action is NOT applied
          when using variants.  */
-      switch (yyr1_[yyn])
+        switch (yyr1_[yyn])
     {
       case 191: // value
       case 195: // map_value
@@ -681,23 +637,23 @@ namespace isc { namespace dhcp {
       case 472: // duid_type
       case 507: // ncr_protocol_value
       case 514: // replace_client_name_value
-        yylhs.value.emplace< ElementPtr > ();
+        yylhs.value.build< ElementPtr > ();
         break;
 
       case 173: // "boolean"
-        yylhs.value.emplace< bool > ();
+        yylhs.value.build< bool > ();
         break;
 
       case 172: // "floating point"
-        yylhs.value.emplace< double > ();
+        yylhs.value.build< double > ();
         break;
 
       case 171: // "integer"
-        yylhs.value.emplace< int64_t > ();
+        yylhs.value.build< int64_t > ();
         break;
 
       case 170: // "constant string"
-        yylhs.value.emplace< std::string > ();
+        yylhs.value.build< std::string > ();
         break;
 
       default:
@@ -705,302 +661,299 @@ namespace isc { namespace dhcp {
     }
 
 
-      // Default location.
+      // Compute the default @$.
       {
         slice<stack_symbol_type, stack_type> slice (yystack_, yylen);
         YYLLOC_DEFAULT (yylhs.location, slice, yylen);
-        yyerror_range[1].location = yylhs.location;
       }
 
       // Perform the reduction.
       YY_REDUCE_PRINT (yyn);
-#if YY_EXCEPTIONS
       try
-#endif // YY_EXCEPTIONS
         {
           switch (yyn)
             {
   case 2:
-#line 257 "dhcp6_parser.yy" // lalr1.cc:907
+#line 257 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.NO_KEYWORD; }
-#line 727 "dhcp6_parser.cc" // lalr1.cc:907
+#line 680 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 4:
-#line 258 "dhcp6_parser.yy" // lalr1.cc:907
+#line 258 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.CONFIG; }
-#line 733 "dhcp6_parser.cc" // lalr1.cc:907
+#line 686 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 6:
-#line 259 "dhcp6_parser.yy" // lalr1.cc:907
+#line 259 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.DHCP6; }
-#line 739 "dhcp6_parser.cc" // lalr1.cc:907
+#line 692 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 8:
-#line 260 "dhcp6_parser.yy" // lalr1.cc:907
+#line 260 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.INTERFACES_CONFIG; }
-#line 745 "dhcp6_parser.cc" // lalr1.cc:907
+#line 698 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 10:
-#line 261 "dhcp6_parser.yy" // lalr1.cc:907
+#line 261 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.SUBNET6; }
-#line 751 "dhcp6_parser.cc" // lalr1.cc:907
+#line 704 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 12:
-#line 262 "dhcp6_parser.yy" // lalr1.cc:907
+#line 262 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.POOLS; }
-#line 757 "dhcp6_parser.cc" // lalr1.cc:907
+#line 710 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 14:
-#line 263 "dhcp6_parser.yy" // lalr1.cc:907
+#line 263 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.PD_POOLS; }
-#line 763 "dhcp6_parser.cc" // lalr1.cc:907
+#line 716 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 16:
-#line 264 "dhcp6_parser.yy" // lalr1.cc:907
+#line 264 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.RESERVATIONS; }
-#line 769 "dhcp6_parser.cc" // lalr1.cc:907
+#line 722 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 18:
-#line 265 "dhcp6_parser.yy" // lalr1.cc:907
+#line 265 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.DHCP6; }
-#line 775 "dhcp6_parser.cc" // lalr1.cc:907
+#line 728 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 20:
-#line 266 "dhcp6_parser.yy" // lalr1.cc:907
+#line 266 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.OPTION_DEF; }
-#line 781 "dhcp6_parser.cc" // lalr1.cc:907
+#line 734 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 22:
-#line 267 "dhcp6_parser.yy" // lalr1.cc:907
+#line 267 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.OPTION_DATA; }
-#line 787 "dhcp6_parser.cc" // lalr1.cc:907
+#line 740 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 24:
-#line 268 "dhcp6_parser.yy" // lalr1.cc:907
+#line 268 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
-#line 793 "dhcp6_parser.cc" // lalr1.cc:907
+#line 746 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 26:
-#line 269 "dhcp6_parser.yy" // lalr1.cc:907
+#line 269 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.DHCP_DDNS; }
-#line 799 "dhcp6_parser.cc" // lalr1.cc:907
+#line 752 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 28:
-#line 270 "dhcp6_parser.yy" // lalr1.cc:907
+#line 270 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.LOGGING; }
-#line 805 "dhcp6_parser.cc" // lalr1.cc:907
+#line 758 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 30:
-#line 271 "dhcp6_parser.yy" // lalr1.cc:907
+#line 271 "dhcp6_parser.yy" // lalr1.cc:859
     { ctx.ctx_ = ctx.CONFIG_CONTROL; }
-#line 811 "dhcp6_parser.cc" // lalr1.cc:907
+#line 764 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 32:
-#line 279 "dhcp6_parser.yy" // lalr1.cc:907
+#line 279 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location))); }
-#line 817 "dhcp6_parser.cc" // lalr1.cc:907
+#line 770 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 33:
-#line 280 "dhcp6_parser.yy" // lalr1.cc:907
+#line 280 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as< double > (), ctx.loc2pos(yystack_[0].location))); }
-#line 823 "dhcp6_parser.cc" // lalr1.cc:907
+#line 776 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 34:
-#line 281 "dhcp6_parser.yy" // lalr1.cc:907
+#line 281 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location))); }
-#line 829 "dhcp6_parser.cc" // lalr1.cc:907
+#line 782 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 35:
-#line 282 "dhcp6_parser.yy" // lalr1.cc:907
+#line 282 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location))); }
-#line 835 "dhcp6_parser.cc" // lalr1.cc:907
+#line 788 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 36:
-#line 283 "dhcp6_parser.yy" // lalr1.cc:907
+#line 283 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
-#line 841 "dhcp6_parser.cc" // lalr1.cc:907
+#line 794 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 37:
-#line 284 "dhcp6_parser.yy" // lalr1.cc:907
+#line 284 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
-#line 847 "dhcp6_parser.cc" // lalr1.cc:907
+#line 800 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 38:
-#line 285 "dhcp6_parser.yy" // lalr1.cc:907
+#line 285 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
-#line 853 "dhcp6_parser.cc" // lalr1.cc:907
+#line 806 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 39:
-#line 288 "dhcp6_parser.yy" // lalr1.cc:907
+#line 288 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Push back the JSON value on the stack
     ctx.stack_.push_back(yystack_[0].value.as< ElementPtr > ());
 }
-#line 862 "dhcp6_parser.cc" // lalr1.cc:907
+#line 815 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 40:
-#line 293 "dhcp6_parser.yy" // lalr1.cc:907
+#line 293 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // This code is executed when we're about to start parsing
     // the content of the map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 873 "dhcp6_parser.cc" // lalr1.cc:907
+#line 826 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 41:
-#line 298 "dhcp6_parser.yy" // lalr1.cc:907
+#line 298 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // map parsing completed. If we ever want to do any wrap up
     // (maybe some sanity checking), this would be the best place
     // for it.
 }
-#line 883 "dhcp6_parser.cc" // lalr1.cc:907
+#line 836 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 42:
-#line 304 "dhcp6_parser.yy" // lalr1.cc:907
+#line 304 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
-#line 889 "dhcp6_parser.cc" // lalr1.cc:907
+#line 842 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 45:
-#line 311 "dhcp6_parser.yy" // lalr1.cc:907
+#line 311 "dhcp6_parser.yy" // lalr1.cc:859
     {
                   // map containing a single entry
                   ctx.stack_.back()->set(yystack_[2].value.as< std::string > (), yystack_[0].value.as< ElementPtr > ());
                   }
-#line 898 "dhcp6_parser.cc" // lalr1.cc:907
+#line 851 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 46:
-#line 315 "dhcp6_parser.yy" // lalr1.cc:907
+#line 315 "dhcp6_parser.yy" // lalr1.cc:859
     {
                   // map consisting of a shorter map followed by
                   // comma and string:value
                   ctx.stack_.back()->set(yystack_[2].value.as< std::string > (), yystack_[0].value.as< ElementPtr > ());
                   }
-#line 908 "dhcp6_parser.cc" // lalr1.cc:907
+#line 861 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 47:
-#line 322 "dhcp6_parser.yy" // lalr1.cc:907
+#line 322 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(l);
 }
-#line 917 "dhcp6_parser.cc" // lalr1.cc:907
+#line 870 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 48:
-#line 325 "dhcp6_parser.yy" // lalr1.cc:907
+#line 325 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // list parsing complete. Put any sanity checking here
 }
-#line 925 "dhcp6_parser.cc" // lalr1.cc:907
+#line 878 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 51:
-#line 333 "dhcp6_parser.yy" // lalr1.cc:907
+#line 333 "dhcp6_parser.yy" // lalr1.cc:859
     {
                   // List consisting of a single element.
                   ctx.stack_.back()->add(yystack_[0].value.as< ElementPtr > ());
                   }
-#line 934 "dhcp6_parser.cc" // lalr1.cc:907
+#line 887 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 52:
-#line 337 "dhcp6_parser.yy" // lalr1.cc:907
+#line 337 "dhcp6_parser.yy" // lalr1.cc:859
     {
                   // List ending with , and a value.
                   ctx.stack_.back()->add(yystack_[0].value.as< ElementPtr > ());
                   }
-#line 943 "dhcp6_parser.cc" // lalr1.cc:907
+#line 896 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 53:
-#line 344 "dhcp6_parser.yy" // lalr1.cc:907
+#line 344 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // List parsing about to start
 }
-#line 951 "dhcp6_parser.cc" // lalr1.cc:907
+#line 904 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 54:
-#line 346 "dhcp6_parser.yy" // lalr1.cc:907
+#line 346 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // list parsing complete. Put any sanity checking here
     //ctx.stack_.pop_back();
 }
-#line 960 "dhcp6_parser.cc" // lalr1.cc:907
+#line 913 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 57:
-#line 355 "dhcp6_parser.yy" // lalr1.cc:907
+#line 355 "dhcp6_parser.yy" // lalr1.cc:859
     {
                           ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
                           ctx.stack_.back()->add(s);
                           }
-#line 969 "dhcp6_parser.cc" // lalr1.cc:907
+#line 922 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 58:
-#line 359 "dhcp6_parser.yy" // lalr1.cc:907
+#line 359 "dhcp6_parser.yy" // lalr1.cc:859
     {
                           ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
                           ctx.stack_.back()->add(s);
                           }
-#line 978 "dhcp6_parser.cc" // lalr1.cc:907
+#line 931 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 59:
-#line 370 "dhcp6_parser.yy" // lalr1.cc:907
+#line 370 "dhcp6_parser.yy" // lalr1.cc:859
     {
     const std::string& where = ctx.contextName();
     const std::string& keyword = yystack_[1].value.as< std::string > ();
     error(yystack_[1].location,
           "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
 }
-#line 989 "dhcp6_parser.cc" // lalr1.cc:907
+#line 942 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 60:
-#line 380 "dhcp6_parser.yy" // lalr1.cc:907
+#line 380 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // This code is executed when we're about to start parsing
     // the content of the map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1000 "dhcp6_parser.cc" // lalr1.cc:907
+#line 953 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 61:
-#line 385 "dhcp6_parser.yy" // lalr1.cc:907
+#line 385 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // map parsing completed. If we ever want to do any wrap up
     // (maybe some sanity checking), this would be the best place
@@ -1009,11 +962,11 @@ namespace isc { namespace dhcp {
     // Dhcp6 is required
     ctx.require("Dhcp6", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
 }
-#line 1013 "dhcp6_parser.cc" // lalr1.cc:907
+#line 966 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 70:
-#line 408 "dhcp6_parser.yy" // lalr1.cc:907
+#line 408 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // This code is executed when we're about to start parsing
     // the content of the map
@@ -1022,523 +975,523 @@ namespace isc { namespace dhcp {
     ctx.stack_.push_back(m);
     ctx.enter(ctx.DHCP6);
 }
-#line 1026 "dhcp6_parser.cc" // lalr1.cc:907
+#line 979 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 71:
-#line 415 "dhcp6_parser.yy" // lalr1.cc:907
+#line 415 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No global parameter is required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1036 "dhcp6_parser.cc" // lalr1.cc:907
+#line 989 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 72:
-#line 423 "dhcp6_parser.yy" // lalr1.cc:907
+#line 423 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the Dhcp6 map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1046 "dhcp6_parser.cc" // lalr1.cc:907
+#line 999 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 73:
-#line 427 "dhcp6_parser.yy" // lalr1.cc:907
+#line 427 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No global parameter is required
     // parsing completed
 }
-#line 1055 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1008 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 108:
-#line 472 "dhcp6_parser.yy" // lalr1.cc:907
+#line 472 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("preferred-lifetime", prf);
 }
-#line 1064 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1017 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 109:
-#line 477 "dhcp6_parser.yy" // lalr1.cc:907
+#line 477 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("valid-lifetime", prf);
 }
-#line 1073 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1026 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 110:
-#line 482 "dhcp6_parser.yy" // lalr1.cc:907
+#line 482 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("renew-timer", prf);
 }
-#line 1082 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1035 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 111:
-#line 487 "dhcp6_parser.yy" // lalr1.cc:907
+#line 487 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("rebind-timer", prf);
 }
-#line 1091 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1044 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 112:
-#line 492 "dhcp6_parser.yy" // lalr1.cc:907
+#line 492 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr dpp(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("decline-probation-period", dpp);
 }
-#line 1100 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1053 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 113:
-#line 497 "dhcp6_parser.yy" // lalr1.cc:907
+#line 497 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1108 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1061 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 114:
-#line 499 "dhcp6_parser.yy" // lalr1.cc:907
+#line 499 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr stag(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-tag", stag);
     ctx.leave();
 }
-#line 1118 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1071 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 115:
-#line 505 "dhcp6_parser.yy" // lalr1.cc:907
+#line 505 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interfaces-config", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.INTERFACES_CONFIG);
 }
-#line 1129 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1082 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 116:
-#line 510 "dhcp6_parser.yy" // lalr1.cc:907
+#line 510 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No interfaces config param is required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1139 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1092 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 117:
-#line 516 "dhcp6_parser.yy" // lalr1.cc:907
+#line 516 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the interfaces-config map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1149 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1102 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 118:
-#line 520 "dhcp6_parser.yy" // lalr1.cc:907
+#line 520 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No interfaces config param is required
     // parsing completed
 }
-#line 1158 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1111 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 126:
-#line 536 "dhcp6_parser.yy" // lalr1.cc:907
+#line 536 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interfaces", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1169 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1122 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 127:
-#line 541 "dhcp6_parser.yy" // lalr1.cc:907
+#line 541 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1178 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1131 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 128:
-#line 546 "dhcp6_parser.yy" // lalr1.cc:907
+#line 546 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("re-detect", b);
 }
-#line 1187 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1140 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 129:
-#line 552 "dhcp6_parser.yy" // lalr1.cc:907
+#line 552 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("lease-database", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.LEASE_DATABASE);
 }
-#line 1198 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1151 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 130:
-#line 557 "dhcp6_parser.yy" // lalr1.cc:907
+#line 557 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required
     ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1209 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1162 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 131:
-#line 564 "dhcp6_parser.yy" // lalr1.cc:907
+#line 564 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hosts-database", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.HOSTS_DATABASE);
 }
-#line 1220 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1173 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 132:
-#line 569 "dhcp6_parser.yy" // lalr1.cc:907
+#line 569 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required
     ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1231 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1184 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 133:
-#line 576 "dhcp6_parser.yy" // lalr1.cc:907
+#line 576 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hosts-databases", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.HOSTS_DATABASE);
 }
-#line 1242 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1195 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 134:
-#line 581 "dhcp6_parser.yy" // lalr1.cc:907
+#line 581 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1251 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1204 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 139:
-#line 594 "dhcp6_parser.yy" // lalr1.cc:907
+#line 594 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 1261 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1214 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 140:
-#line 598 "dhcp6_parser.yy" // lalr1.cc:907
+#line 598 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required
     ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 1271 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1224 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 161:
-#line 628 "dhcp6_parser.yy" // lalr1.cc:907
+#line 628 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.DATABASE_TYPE);
 }
-#line 1279 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1232 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 162:
-#line 630 "dhcp6_parser.yy" // lalr1.cc:907
+#line 630 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("type", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 1288 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1241 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 163:
-#line 635 "dhcp6_parser.yy" // lalr1.cc:907
+#line 635 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); }
-#line 1294 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1247 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 164:
-#line 636 "dhcp6_parser.yy" // lalr1.cc:907
+#line 636 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); }
-#line 1300 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1253 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 165:
-#line 637 "dhcp6_parser.yy" // lalr1.cc:907
+#line 637 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); }
-#line 1306 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1259 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 166:
-#line 638 "dhcp6_parser.yy" // lalr1.cc:907
+#line 638 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("cql", ctx.loc2pos(yystack_[0].location))); }
-#line 1312 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1265 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 167:
-#line 641 "dhcp6_parser.yy" // lalr1.cc:907
+#line 641 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1320 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1273 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 168:
-#line 643 "dhcp6_parser.yy" // lalr1.cc:907
+#line 643 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr user(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("user", user);
     ctx.leave();
 }
-#line 1330 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1283 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 169:
-#line 649 "dhcp6_parser.yy" // lalr1.cc:907
+#line 649 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1338 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1291 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 170:
-#line 651 "dhcp6_parser.yy" // lalr1.cc:907
+#line 651 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr pwd(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("password", pwd);
     ctx.leave();
 }
-#line 1348 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1301 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 171:
-#line 657 "dhcp6_parser.yy" // lalr1.cc:907
+#line 657 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1356 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1309 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 172:
-#line 659 "dhcp6_parser.yy" // lalr1.cc:907
+#line 659 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr h(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("host", h);
     ctx.leave();
 }
-#line 1366 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1319 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 173:
-#line 665 "dhcp6_parser.yy" // lalr1.cc:907
+#line 665 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr p(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("port", p);
 }
-#line 1375 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1328 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 174:
-#line 670 "dhcp6_parser.yy" // lalr1.cc:907
+#line 670 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1383 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1336 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 175:
-#line 672 "dhcp6_parser.yy" // lalr1.cc:907
+#line 672 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr name(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("name", name);
     ctx.leave();
 }
-#line 1393 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1346 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 176:
-#line 678 "dhcp6_parser.yy" // lalr1.cc:907
+#line 678 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("persist", n);
 }
-#line 1402 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1355 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 177:
-#line 683 "dhcp6_parser.yy" // lalr1.cc:907
+#line 683 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("lfc-interval", n);
 }
-#line 1411 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1364 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 178:
-#line 688 "dhcp6_parser.yy" // lalr1.cc:907
+#line 688 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("readonly", n);
 }
-#line 1420 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1373 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 179:
-#line 693 "dhcp6_parser.yy" // lalr1.cc:907
+#line 693 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("connect-timeout", n);
 }
-#line 1429 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1382 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 180:
-#line 698 "dhcp6_parser.yy" // lalr1.cc:907
+#line 698 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("reconnect-wait-time", n);
 }
-#line 1438 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1391 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 181:
-#line 703 "dhcp6_parser.yy" // lalr1.cc:907
+#line 703 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("request-timeout", n);
 }
-#line 1447 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1400 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 182:
-#line 708 "dhcp6_parser.yy" // lalr1.cc:907
+#line 708 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("tcp-keepalive", n);
 }
-#line 1456 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1409 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 183:
-#line 713 "dhcp6_parser.yy" // lalr1.cc:907
+#line 713 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("tcp-nodelay", n);
 }
-#line 1465 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1418 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 184:
-#line 718 "dhcp6_parser.yy" // lalr1.cc:907
+#line 718 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1473 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1426 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 185:
-#line 720 "dhcp6_parser.yy" // lalr1.cc:907
+#line 720 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr cp(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("contact-points", cp);
     ctx.leave();
 }
-#line 1483 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1436 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 186:
-#line 726 "dhcp6_parser.yy" // lalr1.cc:907
+#line 726 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr n(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-reconnect-tries", n);
 }
-#line 1492 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1445 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 187:
-#line 731 "dhcp6_parser.yy" // lalr1.cc:907
+#line 731 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1500 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1453 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 188:
-#line 733 "dhcp6_parser.yy" // lalr1.cc:907
+#line 733 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr ks(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("keyspace", ks);
     ctx.leave();
 }
-#line 1510 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1463 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 189:
-#line 739 "dhcp6_parser.yy" // lalr1.cc:907
+#line 739 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("sanity-checks", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.SANITY_CHECKS);
 }
-#line 1521 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1474 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 190:
-#line 744 "dhcp6_parser.yy" // lalr1.cc:907
+#line 744 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1530 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1483 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 194:
-#line 754 "dhcp6_parser.yy" // lalr1.cc:907
+#line 754 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1538 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1491 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 195:
-#line 756 "dhcp6_parser.yy" // lalr1.cc:907
+#line 756 "dhcp6_parser.yy" // lalr1.cc:859
     {
 
     if ( (string(yystack_[0].value.as< std::string > ()) == "none") ||
@@ -1554,307 +1507,307 @@ namespace isc { namespace dhcp {
               ", supported values are: none, warn, fix, fix-del, del");
     }
 }
-#line 1558 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1511 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 196:
-#line 772 "dhcp6_parser.yy" // lalr1.cc:907
+#line 772 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("mac-sources", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.MAC_SOURCES);
 }
-#line 1569 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1522 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 197:
-#line 777 "dhcp6_parser.yy" // lalr1.cc:907
+#line 777 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1578 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1531 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 202:
-#line 790 "dhcp6_parser.yy" // lalr1.cc:907
+#line 790 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(duid);
 }
-#line 1587 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1540 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 203:
-#line 795 "dhcp6_parser.yy" // lalr1.cc:907
+#line 795 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr duid(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(duid);
 }
-#line 1596 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1549 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 204:
-#line 800 "dhcp6_parser.yy" // lalr1.cc:907
+#line 800 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("host-reservation-identifiers", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.HOST_RESERVATION_IDENTIFIERS);
 }
-#line 1607 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1560 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 205:
-#line 805 "dhcp6_parser.yy" // lalr1.cc:907
+#line 805 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1616 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1569 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 211:
-#line 819 "dhcp6_parser.yy" // lalr1.cc:907
+#line 819 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(hwaddr);
 }
-#line 1625 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1578 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 212:
-#line 824 "dhcp6_parser.yy" // lalr1.cc:907
+#line 824 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(flex_id);
 }
-#line 1634 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1587 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 213:
-#line 831 "dhcp6_parser.yy" // lalr1.cc:907
+#line 831 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("relay-supplied-options", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1645 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1598 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 214:
-#line 836 "dhcp6_parser.yy" // lalr1.cc:907
+#line 836 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1654 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1607 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 215:
-#line 841 "dhcp6_parser.yy" // lalr1.cc:907
+#line 841 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hooks-libraries", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.HOOKS_LIBRARIES);
 }
-#line 1665 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1618 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 216:
-#line 846 "dhcp6_parser.yy" // lalr1.cc:907
+#line 846 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1674 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1627 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 221:
-#line 859 "dhcp6_parser.yy" // lalr1.cc:907
+#line 859 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 1684 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1637 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 222:
-#line 863 "dhcp6_parser.yy" // lalr1.cc:907
+#line 863 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The library hooks parameter is required
     ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 1694 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1647 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 223:
-#line 869 "dhcp6_parser.yy" // lalr1.cc:907
+#line 869 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the hooks-libraries list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1704 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1657 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 224:
-#line 873 "dhcp6_parser.yy" // lalr1.cc:907
+#line 873 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The library hooks parameter is required
     ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 1714 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1667 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 230:
-#line 888 "dhcp6_parser.yy" // lalr1.cc:907
+#line 888 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1722 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1675 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 231:
-#line 890 "dhcp6_parser.yy" // lalr1.cc:907
+#line 890 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr lib(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("library", lib);
     ctx.leave();
 }
-#line 1732 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1685 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 232:
-#line 896 "dhcp6_parser.yy" // lalr1.cc:907
+#line 896 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1740 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1693 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 233:
-#line 898 "dhcp6_parser.yy" // lalr1.cc:907
+#line 898 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("parameters", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 1749 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1702 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 234:
-#line 904 "dhcp6_parser.yy" // lalr1.cc:907
+#line 904 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("expired-leases-processing", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.EXPIRED_LEASES_PROCESSING);
 }
-#line 1760 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1713 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 235:
-#line 909 "dhcp6_parser.yy" // lalr1.cc:907
+#line 909 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No expired lease parameter is required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1770 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1723 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 244:
-#line 927 "dhcp6_parser.yy" // lalr1.cc:907
+#line 927 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("reclaim-timer-wait-time", value);
 }
-#line 1779 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1732 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 245:
-#line 932 "dhcp6_parser.yy" // lalr1.cc:907
+#line 932 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("flush-reclaimed-timer-wait-time", value);
 }
-#line 1788 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1741 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 246:
-#line 937 "dhcp6_parser.yy" // lalr1.cc:907
+#line 937 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hold-reclaimed-time", value);
 }
-#line 1797 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1750 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 247:
-#line 942 "dhcp6_parser.yy" // lalr1.cc:907
+#line 942 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-reclaim-leases", value);
 }
-#line 1806 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1759 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 248:
-#line 947 "dhcp6_parser.yy" // lalr1.cc:907
+#line 947 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-reclaim-time", value);
 }
-#line 1815 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1768 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 249:
-#line 952 "dhcp6_parser.yy" // lalr1.cc:907
+#line 952 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr value(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("unwarned-reclaim-cycles", value);
 }
-#line 1824 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1777 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 250:
-#line 960 "dhcp6_parser.yy" // lalr1.cc:907
+#line 960 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("subnet6", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.SUBNET6);
 }
-#line 1835 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1788 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 251:
-#line 965 "dhcp6_parser.yy" // lalr1.cc:907
+#line 965 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1844 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1797 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 256:
-#line 985 "dhcp6_parser.yy" // lalr1.cc:907
+#line 985 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 1854 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1807 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 257:
-#line 989 "dhcp6_parser.yy" // lalr1.cc:907
+#line 989 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Once we reached this place, the subnet parsing is now complete.
     // If we want to, we can implement default values here.
@@ -1876,267 +1829,267 @@ namespace isc { namespace dhcp {
     ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 1880 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1833 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 258:
-#line 1011 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1011 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the subnet6 list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 1890 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1843 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 259:
-#line 1015 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1015 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The subnet subnet6 parameter is required
     ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 1900 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1853 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 282:
-#line 1049 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1049 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1908 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1861 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 283:
-#line 1051 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1051 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr subnet(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("subnet", subnet);
     ctx.leave();
 }
-#line 1918 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1871 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 284:
-#line 1057 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1057 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1926 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1879 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 285:
-#line 1059 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1059 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr iface(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interface", iface);
     ctx.leave();
 }
-#line 1936 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1889 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 286:
-#line 1065 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1065 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1944 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1897 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 287:
-#line 1067 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1067 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr iface(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("interface-id", iface);
     ctx.leave();
 }
-#line 1954 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1907 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 288:
-#line 1073 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1073 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1962 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1915 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 289:
-#line 1075 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1075 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr cls(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-class", cls);
     ctx.leave();
 }
-#line 1972 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1925 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 290:
-#line 1081 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1081 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("require-client-classes", c);
     ctx.stack_.push_back(c);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 1983 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1936 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 291:
-#line 1086 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1086 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 1992 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1945 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 292:
-#line 1091 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1091 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.RESERVATION_MODE);
 }
-#line 2000 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1953 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 293:
-#line 1093 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1093 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("reservation-mode", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 2009 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1962 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 294:
-#line 1098 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1098 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("disabled", ctx.loc2pos(yystack_[0].location))); }
-#line 2015 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1968 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 295:
-#line 1099 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1099 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("out-of-pool", ctx.loc2pos(yystack_[0].location))); }
-#line 2021 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1974 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 296:
-#line 1100 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1100 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("global", ctx.loc2pos(yystack_[0].location))); }
-#line 2027 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1980 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 297:
-#line 1101 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1101 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("all", ctx.loc2pos(yystack_[0].location))); }
-#line 2033 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1986 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 298:
-#line 1104 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1104 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr id(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("id", id);
 }
-#line 2042 "dhcp6_parser.cc" // lalr1.cc:907
+#line 1995 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 299:
-#line 1109 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1109 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr rc(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("rapid-commit", rc);
 }
-#line 2051 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2004 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 300:
-#line 1117 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1117 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("shared-networks", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.SHARED_NETWORK);
 }
-#line 2062 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2015 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 301:
-#line 1122 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1122 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2071 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2024 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 306:
-#line 1137 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1137 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2081 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2034 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 307:
-#line 1141 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1141 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 2089 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2042 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 327:
-#line 1172 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1172 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("option-def", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.OPTION_DEF);
 }
-#line 2100 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2053 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 328:
-#line 1177 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1177 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2109 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2062 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 329:
-#line 1185 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1185 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2118 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2071 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 330:
-#line 1188 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1188 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // parsing completed
 }
-#line 2126 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2079 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 335:
-#line 1204 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1204 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2136 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2089 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 336:
-#line 1208 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1208 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The name, code and type option def parameters are required.
     ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
@@ -2144,21 +2097,21 @@ namespace isc { namespace dhcp {
     ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2148 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2101 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 337:
-#line 1219 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1219 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the option-def list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2158 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2111 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 338:
-#line 1223 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1223 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The name, code and type option def parameters are required.
     ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
@@ -2166,280 +2119,280 @@ namespace isc { namespace dhcp {
     ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 2170 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2123 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 354:
-#line 1255 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1255 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr code(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("code", code);
 }
-#line 2179 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2132 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 356:
-#line 1262 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1262 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2187 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2140 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 357:
-#line 1264 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1264 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("type", prf);
     ctx.leave();
 }
-#line 2197 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2150 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 358:
-#line 1270 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1270 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2205 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2158 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 359:
-#line 1272 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1272 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr rtypes(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("record-types", rtypes);
     ctx.leave();
 }
-#line 2215 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2168 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 360:
-#line 1278 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1278 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2223 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2176 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 361:
-#line 1280 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1280 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr space(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("space", space);
     ctx.leave();
 }
-#line 2233 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2186 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 363:
-#line 1288 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1288 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2241 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2194 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 364:
-#line 1290 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1290 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr encap(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("encapsulate", encap);
     ctx.leave();
 }
-#line 2251 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2204 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 365:
-#line 1296 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1296 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr array(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("array", array);
 }
-#line 2260 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2213 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 366:
-#line 1305 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1305 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("option-data", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.OPTION_DATA);
 }
-#line 2271 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2224 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 367:
-#line 1310 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1310 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2280 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2233 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 372:
-#line 1329 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1329 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2290 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2243 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 373:
-#line 1333 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1333 "dhcp6_parser.yy" // lalr1.cc:859
     {
     /// @todo: the code or name parameters are required.
     ctx.stack_.pop_back();
 }
-#line 2299 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2252 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 374:
-#line 1341 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1341 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the option-data list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2309 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2262 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 375:
-#line 1345 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1345 "dhcp6_parser.yy" // lalr1.cc:859
     {
     /// @todo: the code or name parameters are required.
     // parsing completed
 }
-#line 2318 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2271 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 390:
-#line 1378 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1378 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2326 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2279 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 391:
-#line 1380 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1380 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr data(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("data", data);
     ctx.leave();
 }
-#line 2336 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2289 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 394:
-#line 1390 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1390 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr space(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("csv-format", space);
 }
-#line 2345 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2298 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 395:
-#line 1395 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1395 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr persist(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("always-send", persist);
 }
-#line 2354 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2307 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 396:
-#line 1403 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1403 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("pools", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.POOLS);
 }
-#line 2365 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2318 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 397:
-#line 1408 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1408 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2374 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2327 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 402:
-#line 1423 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1423 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2384 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2337 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 403:
-#line 1427 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1427 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The pool parameter is required.
     ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2394 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2347 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 404:
-#line 1433 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1433 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the pool list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2404 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2357 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 405:
-#line 1437 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1437 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The pool parameter is required.
     ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
 }
-#line 2413 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2366 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 415:
-#line 1455 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1455 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2421 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2374 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 416:
-#line 1457 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1457 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr pool(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("pool", pool);
     ctx.leave();
 }
-#line 2431 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2384 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 417:
-#line 1463 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1463 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2439 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2392 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 418:
-#line 1465 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1465 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr parent = ctx.stack_.back();
     ElementPtr user_context = yystack_[0].value.as< ElementPtr > ();
@@ -2462,19 +2415,19 @@ namespace isc { namespace dhcp {
     parent->set("user-context", user_context);
     ctx.leave();
 }
-#line 2466 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2419 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 419:
-#line 1488 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1488 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2474 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2427 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 420:
-#line 1490 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1490 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr parent = ctx.stack_.back();
     ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
@@ -2499,41 +2452,41 @@ namespace isc { namespace dhcp {
     parent->set("user-context", user_context);
     ctx.leave();
 }
-#line 2503 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2456 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 421:
-#line 1518 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1518 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("pd-pools", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.PD_POOLS);
 }
-#line 2514 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2467 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 422:
-#line 1523 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1523 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2523 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2476 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 427:
-#line 1538 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1538 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2533 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2486 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 428:
-#line 1542 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1542 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The prefix, prefix len and delegated len parameters are required.
     ctx.require("prefix", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
@@ -2541,21 +2494,21 @@ namespace isc { namespace dhcp {
     ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2545 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2498 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 429:
-#line 1550 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1550 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the pd-pool list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2555 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2508 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 430:
-#line 1554 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1554 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The prefix, prefix len and delegated len parameters are required.
     ctx.require("prefix", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
@@ -2563,1204 +2516,1230 @@ namespace isc { namespace dhcp {
     ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 2567 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2520 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 444:
-#line 1579 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1579 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2575 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2528 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 445:
-#line 1581 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1581 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("prefix", prf);
     ctx.leave();
 }
-#line 2585 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2538 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 446:
-#line 1587 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1587 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("prefix-len", prf);
 }
-#line 2594 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2547 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 447:
-#line 1592 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1592 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2602 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2555 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 448:
-#line 1594 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1594 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("excluded-prefix", prf);
     ctx.leave();
 }
-#line 2612 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2565 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 449:
-#line 1600 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1600 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr prf(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("excluded-prefix-len", prf);
 }
-#line 2621 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2574 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 450:
-#line 1605 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1605 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr deleg(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("delegated-len", deleg);
 }
-#line 2630 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2583 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 451:
-#line 1613 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1613 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("reservations", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.RESERVATIONS);
 }
-#line 2641 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2594 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 452:
-#line 1618 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1618 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2650 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2603 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 457:
-#line 1631 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1631 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2660 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2613 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 458:
-#line 1635 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1635 "dhcp6_parser.yy" // lalr1.cc:859
     {
     /// @todo: an identifier parameter is required.
     ctx.stack_.pop_back();
 }
-#line 2669 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2622 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 459:
-#line 1640 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1640 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the reservations list entry map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 2679 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2632 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 460:
-#line 1644 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1644 "dhcp6_parser.yy" // lalr1.cc:859
     {
     /// @todo: an identifier parameter is required.
     // parsing completed
 }
-#line 2688 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2641 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 476:
-#line 1671 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1671 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("ip-addresses", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2699 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2652 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 477:
-#line 1676 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1676 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2708 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2661 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 478:
-#line 1681 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1681 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("prefixes", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2719 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2672 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 479:
-#line 1686 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1686 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2728 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2681 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 480:
-#line 1691 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1691 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2736 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2689 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 481:
-#line 1693 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1693 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr d(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("duid", d);
     ctx.leave();
 }
-#line 2746 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2699 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 482:
-#line 1699 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1699 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2754 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2707 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 483:
-#line 1701 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1701 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr hw(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hw-address", hw);
     ctx.leave();
 }
-#line 2764 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2717 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 484:
-#line 1707 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1707 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2772 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2725 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 485:
-#line 1709 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1709 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr host(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hostname", host);
     ctx.leave();
 }
-#line 2782 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2735 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 486:
-#line 1715 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1715 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2790 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2743 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 487:
-#line 1717 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1717 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr hw(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("flex-id", hw);
     ctx.leave();
 }
-#line 2800 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2753 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 488:
-#line 1723 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1723 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-classes", c);
     ctx.stack_.push_back(c);
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2811 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2764 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 489:
-#line 1728 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1728 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2820 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2773 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 490:
-#line 1736 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1736 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("relay", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.RELAY);
 }
-#line 2831 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2784 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 491:
-#line 1741 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1741 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2840 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2793 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 494:
-#line 1750 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1750 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2848 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2801 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 495:
-#line 1752 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1752 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr addr(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("ip-address", addr);
     ctx.leave();
 }
-#line 2858 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2811 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 496:
-#line 1761 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1761 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("client-classes", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.CLIENT_CLASSES);
 }
-#line 2869 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2822 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 497:
-#line 1766 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1766 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2878 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2831 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 500:
-#line 1775 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1775 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 2888 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2841 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 501:
-#line 1779 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1779 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The name client class parameter is required.
     ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
 }
-#line 2898 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2851 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 514:
-#line 1804 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1804 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2906 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2859 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 515:
-#line 1806 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1806 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr test(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("test", test);
     ctx.leave();
 }
-#line 2916 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2869 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 516:
-#line 1812 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1812 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("only-if-required", b);
 }
-#line 2925 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2878 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 517:
-#line 1820 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1820 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-id", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.SERVER_ID);
 }
-#line 2936 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2889 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 518:
-#line 1825 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1825 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The type parameter is required.
     ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 2947 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2900 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 530:
-#line 1847 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1847 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.DUID_TYPE);
 }
-#line 2955 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2908 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 531:
-#line 1849 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1849 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("type", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 2964 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2917 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 532:
-#line 1854 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1854 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("LLT", ctx.loc2pos(yystack_[0].location))); }
-#line 2970 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2923 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 533:
-#line 1855 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1855 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("EN", ctx.loc2pos(yystack_[0].location))); }
-#line 2976 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2929 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 534:
-#line 1856 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1856 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("LL", ctx.loc2pos(yystack_[0].location))); }
-#line 2982 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2935 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 535:
-#line 1859 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1859 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr htype(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("htype", htype);
 }
-#line 2991 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2944 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 536:
-#line 1864 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1864 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 2999 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2952 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 537:
-#line 1866 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1866 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr id(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("identifier", id);
     ctx.leave();
 }
-#line 3009 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2962 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 538:
-#line 1872 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1872 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr time(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("time", time);
 }
-#line 3018 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2971 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 539:
-#line 1877 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1877 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr time(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("enterprise-id", time);
 }
-#line 3027 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2980 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 540:
-#line 1884 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1884 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr time(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("dhcp4o6-port", time);
 }
-#line 3036 "dhcp6_parser.cc" // lalr1.cc:907
+#line 2989 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 541:
-#line 1891 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1891 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("control-socket", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.CONTROL_SOCKET);
 }
-#line 3047 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3000 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 542:
-#line 1896 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1896 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3056 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3009 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 550:
-#line 1912 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1912 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3064 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3017 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 551:
-#line 1914 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1914 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr stype(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("socket-type", stype);
     ctx.leave();
 }
-#line 3074 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3027 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 552:
-#line 1920 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1920 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3082 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3035 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 553:
-#line 1922 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1922 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr name(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("socket-name", name);
     ctx.leave();
 }
-#line 3092 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3045 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 554:
-#line 1930 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1930 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3100 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3053 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 555:
-#line 1932 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1932 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr qc = yystack_[0].value.as< ElementPtr > ();
     ctx.stack_.back()->set("dhcp-queue-control", qc);
 
-    if (!qc->contains("queue-type")) {
+    // Doing this manually, because dhcp-queue-control
+    // content is otherwise arbitrary
+    if (!qc->contains("enable-queue")) {
         std::stringstream msg;
-        msg << "'queue-type' is required: ";
+        msg << "'enable-queue' is required: ";
         msg  << qc->getPosition().str() << ")";
         error(yystack_[3].location, msg.str());
     }
 
+     ConstElementPtr enable_queue = qc->get("enable-queue");
+     if (enable_queue->getType() != Element::boolean) {
+        std::stringstream msg;
+        msg << "'enable-queue' must be boolean: ";
+        msg  << qc->getPosition().str() << ")";
+        error(yystack_[3].location, msg.str());
+     }
+
+    if (enable_queue->boolValue()) {
+        if (!qc->contains("queue-type")) {
+            std::stringstream msg;
+            msg << "'queue-type' is required, when 'enable-queue' is true: ";
+            msg  << qc->getPosition().str() << ")";
+            error(yystack_[3].location, msg.str());
+        }
+
+        ConstElementPtr queue_type = qc->get("queue-type");
+        if (queue_type->getType() != Element::string) {
+            std::stringstream msg;
+            msg << "'queue-type' must be a string: ";
+            msg  << qc->getPosition().str() << ")";
+            error(yystack_[3].location, msg.str());
+        }
+     }
+
+
     ctx.leave();
 }
-#line 3118 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3099 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 556:
-#line 1948 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1976 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("dhcp-ddns", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.DHCP_DDNS);
 }
-#line 3129 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3110 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 557:
-#line 1953 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1981 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The enable updates DHCP DDNS parameter is required.
     ctx.require("enable-updates", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3140 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3121 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 558:
-#line 1960 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1988 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the dhcp-ddns map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 3150 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3131 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 559:
-#line 1964 "dhcp6_parser.yy" // lalr1.cc:907
+#line 1992 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // The enable updates DHCP DDNS parameter is required.
     ctx.require("enable-updates", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
     // parsing completed
 }
-#line 3160 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3141 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 580:
-#line 1994 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2022 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("enable-updates", b);
 }
-#line 3169 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3150 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 581:
-#line 1999 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2027 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3177 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3158 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 582:
-#line 2001 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2029 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("qualifying-suffix", s);
     ctx.leave();
 }
-#line 3187 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3168 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 583:
-#line 2007 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2035 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3195 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3176 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 584:
-#line 2009 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2037 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-ip", s);
     ctx.leave();
 }
-#line 3205 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3186 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 585:
-#line 2015 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2043 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("server-port", i);
 }
-#line 3214 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3195 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 586:
-#line 2020 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2048 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3222 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3203 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 587:
-#line 2022 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2050 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("sender-ip", s);
     ctx.leave();
 }
-#line 3232 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3213 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 588:
-#line 2028 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2056 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("sender-port", i);
 }
-#line 3241 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3222 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 589:
-#line 2033 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2061 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("max-queue-size", i);
 }
-#line 3250 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3231 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 590:
-#line 2038 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2066 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NCR_PROTOCOL);
 }
-#line 3258 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3239 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 591:
-#line 2040 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2068 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3267 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3248 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 592:
-#line 2046 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2074 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
-#line 3273 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3254 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 593:
-#line 2047 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2075 "dhcp6_parser.yy" // lalr1.cc:859
     { yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
-#line 3279 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3260 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 594:
-#line 2050 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2078 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NCR_FORMAT);
 }
-#line 3287 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3268 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 595:
-#line 2052 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2080 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("ncr-format", json);
     ctx.leave();
 }
-#line 3297 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3278 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 596:
-#line 2058 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2086 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("override-no-update", b);
 }
-#line 3306 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3287 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 597:
-#line 2063 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2091 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr b(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("override-client-update", b);
 }
-#line 3315 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3296 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 598:
-#line 2068 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2096 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.REPLACE_CLIENT_NAME);
 }
-#line 3323 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3304 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 599:
-#line 2070 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2098 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("replace-client-name", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3332 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3313 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 600:
-#line 2076 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2104 "dhcp6_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3340 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3321 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 601:
-#line 2079 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2107 "dhcp6_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3348 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3329 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 602:
-#line 2082 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2110 "dhcp6_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3356 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3337 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 603:
-#line 2085 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2113 "dhcp6_parser.yy" // lalr1.cc:859
     {
       yylhs.value.as< ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location)));
       }
-#line 3364 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3345 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 604:
-#line 2088 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2116 "dhcp6_parser.yy" // lalr1.cc:859
     {
       error(yystack_[0].location, "boolean values for the replace-client-name are "
                 "no longer supported");
       }
-#line 3373 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3354 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 605:
-#line 2094 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2122 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3381 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3362 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 606:
-#line 2096 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2124 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("generated-prefix", s);
     ctx.leave();
 }
-#line 3391 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3372 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 607:
-#line 2102 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2130 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3399 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3380 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 608:
-#line 2104 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2132 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hostname-char-set", s);
     ctx.leave();
 }
-#line 3409 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3390 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 609:
-#line 2110 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2138 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3417 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3398 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 610:
-#line 2112 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2140 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr s(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("hostname-char-replacement", s);
     ctx.leave();
 }
-#line 3427 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3408 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 611:
-#line 2120 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2148 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3435 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3416 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 612:
-#line 2122 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2150 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("Dhcp4", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3444 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3425 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 613:
-#line 2127 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2155 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3452 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3433 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 614:
-#line 2129 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2157 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("DhcpDdns", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3461 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3442 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 615:
-#line 2134 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2162 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3469 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3450 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 616:
-#line 2136 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2164 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.back()->set("Control-agent", yystack_[0].value.as< ElementPtr > ());
     ctx.leave();
 }
-#line 3478 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3459 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 617:
-#line 2143 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2171 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 3488 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3469 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 618:
-#line 2147 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2175 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 3496 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3477 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 619:
-#line 2152 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2180 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("config-control", i);
     ctx.stack_.push_back(i);
     ctx.enter(ctx.CONFIG_CONTROL);
 }
-#line 3507 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3488 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 620:
-#line 2157 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2185 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No config control params are required
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3517 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3498 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 621:
-#line 2163 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2191 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the config-control map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 3527 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3508 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 622:
-#line 2167 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2195 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // No config_control params are required
     // parsing completed
 }
-#line 3536 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3517 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 627:
-#line 2182 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2210 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("config-databases", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.CONFIG_DATABASE);
 }
-#line 3547 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3528 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 628:
-#line 2187 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2215 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3556 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3537 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 629:
-#line 2197 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2225 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("Logging", m);
     ctx.stack_.push_back(m);
     ctx.enter(ctx.LOGGING);
 }
-#line 3567 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3548 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 630:
-#line 2202 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2230 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3576 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3557 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 631:
-#line 2207 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2235 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // Parse the Logging map
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.push_back(m);
 }
-#line 3586 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3567 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 632:
-#line 2211 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2239 "dhcp6_parser.yy" // lalr1.cc:859
     {
     // parsing completed
 }
-#line 3594 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3575 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 636:
-#line 2227 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2255 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("loggers", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.LOGGERS);
 }
-#line 3605 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3586 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 637:
-#line 2232 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2260 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3614 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3595 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 640:
-#line 2244 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2272 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(l);
     ctx.stack_.push_back(l);
 }
-#line 3624 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3605 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 641:
-#line 2248 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2276 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 3632 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3613 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 651:
-#line 2265 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2293 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr dl(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("debuglevel", dl);
 }
-#line 3641 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3622 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 652:
-#line 2270 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2298 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3649 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3630 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 653:
-#line 2272 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2300 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr sev(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("severity", sev);
     ctx.leave();
 }
-#line 3659 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3640 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 654:
-#line 2278 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2306 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("output_options", l);
     ctx.stack_.push_back(l);
     ctx.enter(ctx.OUTPUT_OPTIONS);
 }
-#line 3670 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3651 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 655:
-#line 2283 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2311 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
     ctx.leave();
 }
-#line 3679 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3660 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 658:
-#line 2292 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2320 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->add(m);
     ctx.stack_.push_back(m);
 }
-#line 3689 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3670 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 659:
-#line 2296 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2324 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.stack_.pop_back();
 }
-#line 3697 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3678 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 666:
-#line 2310 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2338 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ctx.enter(ctx.NO_KEYWORD);
 }
-#line 3705 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3686 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 667:
-#line 2312 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2340 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr sev(new StringElement(yystack_[0].value.as< std::string > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("output", sev);
     ctx.leave();
 }
-#line 3715 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3696 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 668:
-#line 2318 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2346 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr flush(new BoolElement(yystack_[0].value.as< bool > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("flush", flush);
 }
-#line 3724 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3705 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 669:
-#line 2323 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2351 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr maxsize(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("maxsize", maxsize);
 }
-#line 3733 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3714 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
   case 670:
-#line 2328 "dhcp6_parser.yy" // lalr1.cc:907
+#line 2356 "dhcp6_parser.yy" // lalr1.cc:859
     {
     ElementPtr maxver(new IntElement(yystack_[0].value.as< int64_t > (), ctx.loc2pos(yystack_[0].location)));
     ctx.stack_.back()->set("maxver", maxver);
 }
-#line 3742 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3723 "dhcp6_parser.cc" // lalr1.cc:859
     break;
 
 
-#line 3746 "dhcp6_parser.cc" // lalr1.cc:907
+#line 3727 "dhcp6_parser.cc" // lalr1.cc:859
             default:
               break;
             }
         }
-#if YY_EXCEPTIONS
       catch (const syntax_error& yyexc)
         {
           error (yyexc);
           YYERROR;
         }
-#endif // YY_EXCEPTIONS
       YY_SYMBOL_PRINT ("-> $$ =", yylhs);
       yypop_ (yylen);
       yylen = 0;
       YY_STACK_PRINT ();
 
       // Shift the result of the reduction.
-      yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
+      yypush_ (YY_NULLPTR, yylhs);
     }
     goto yynewstate;
 
@@ -3806,6 +3785,7 @@ namespace isc { namespace dhcp {
        code.  */
     if (false)
       goto yyerrorlab;
+    yyerror_range[1].location = yystack_[yylen - 1].location;
     /* Do not reclaim the symbols of the rule whose action triggered
        this YYERROR.  */
     yypop_ (yylen);
@@ -3848,7 +3828,7 @@ namespace isc { namespace dhcp {
 
       // Shift the error token.
       error_token.state = yyn;
-      yypush_ ("Shifting", YY_MOVE (error_token));
+      yypush_ ("Shifting", error_token);
     }
     goto yynewstate;
 
@@ -3877,12 +3857,12 @@ namespace isc { namespace dhcp {
 
     return yyresult;
   }
-#if YY_EXCEPTIONS
     catch (...)
       {
-        YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
+        YYCDEBUG << "Exception caught: cleaning lookahead and stack"
+                 << std::endl;
         // Do not try to display the values of the reclaimed symbols,
-        // as their printers might throw an exception.
+        // as their printer might throw an exception.
         if (!yyla.empty ())
           yy_destroy_ (YY_NULLPTR, yyla);
 
@@ -3893,13 +3873,12 @@ namespace isc { namespace dhcp {
           }
         throw;
       }
-#endif // YY_EXCEPTIONS
   }
 
   void
   Dhcp6Parser::error (const syntax_error& yyexc)
   {
-    error (yyexc.location, yyexc.what ());
+    error (yyexc.location, yyexc.what());
   }
 
   // Generate an error message.
@@ -3975,13 +3954,12 @@ namespace isc { namespace dhcp {
         case N:                               \
           yyformat = S;                       \
         break
-      default: // Avoid compiler warnings.
-        YYCASE_ (0, YY_("syntax error"));
-        YYCASE_ (1, YY_("syntax error, unexpected %s"));
-        YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
-        YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-        YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-        YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+        YYCASE_(0, YY_("syntax error"));
+        YYCASE_(1, YY_("syntax error, unexpected %s"));
+        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 #undef YYCASE_
       }
 
@@ -4000,11 +3978,11 @@ namespace isc { namespace dhcp {
   }
 
 
-  const short Dhcp6Parser::yypact_ninf_ = -826;
+  const short int Dhcp6Parser::yypact_ninf_ = -826;
 
   const signed char Dhcp6Parser::yytable_ninf_ = -1;
 
-  const short
+  const short int
   Dhcp6Parser::yypact_[] =
   {
      418,  -826,  -826,  -826,  -826,  -826,  -826,  -826,  -826,  -826,
@@ -4119,7 +4097,7 @@ namespace isc { namespace dhcp {
     -826
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp6Parser::yydefact_[] =
   {
        0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
@@ -4234,7 +4212,7 @@ namespace isc { namespace dhcp {
      667
   };
 
-  const short
+  const short int
   Dhcp6Parser::yypgoto_[] =
   {
     -826,  -826,  -826,  -826,  -826,  -826,  -826,  -826,  -826,  -826,
@@ -4278,7 +4256,7 @@ namespace isc { namespace dhcp {
     -826,  -170,  -826,  -826,  -185,  -826,  -826,  -826,  -826,  -826
   };
 
-  const short
+  const short int
   Dhcp6Parser::yydefgoto_[] =
   {
       -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
@@ -4322,7 +4300,7 @@ namespace isc { namespace dhcp {
     1063,  1064,  1065,  1072,  1073,  1074,  1079,  1075,  1076,  1077
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp6Parser::yytable_[] =
   {
      100,   140,   176,   193,   216,   230,   250,   293,   272,   291,
@@ -4430,7 +4408,7 @@ namespace isc { namespace dhcp {
        0,   962,     0,     0,     0,  1005
   };
 
-  const short
+  const short int
   Dhcp6Parser::yycheck_[] =
   {
       74,    75,    76,    77,    78,    79,    80,    83,    82,    83,
@@ -4538,7 +4516,7 @@ namespace isc { namespace dhcp {
       -1,  1032,    -1,    -1,    -1,  1049
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp6Parser::yystos_[] =
   {
        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
@@ -4653,7 +4631,7 @@ namespace isc { namespace dhcp {
      170
   };
 
-  const unsigned short
+  const unsigned short int
   Dhcp6Parser::yyr1_[] =
   {
        0,   174,   176,   175,   177,   175,   178,   175,   179,   175,
@@ -4950,7 +4928,7 @@ namespace isc { namespace dhcp {
   };
 
 #if PARSER6_DEBUG
-  const unsigned short
+  const unsigned short int
   Dhcp6Parser::yyrline_[] =
   {
        0,   257,   257,   257,   258,   258,   259,   259,   260,   260,
@@ -5008,19 +4986,19 @@ namespace isc { namespace dhcp {
     1833,  1836,  1837,  1838,  1839,  1840,  1841,  1842,  1843,  1844,
     1847,  1847,  1854,  1855,  1856,  1859,  1864,  1864,  1872,  1877,
     1884,  1891,  1891,  1901,  1902,  1905,  1906,  1907,  1908,  1909,
-    1912,  1912,  1920,  1920,  1930,  1930,  1948,  1948,  1960,  1960,
-    1970,  1971,  1974,  1975,  1976,  1977,  1978,  1979,  1980,  1981,
-    1982,  1983,  1984,  1985,  1986,  1987,  1988,  1989,  1990,  1991,
-    1994,  1999,  1999,  2007,  2007,  2015,  2020,  2020,  2028,  2033,
-    2038,  2038,  2046,  2047,  2050,  2050,  2058,  2063,  2068,  2068,
-    2076,  2079,  2082,  2085,  2088,  2094,  2094,  2102,  2102,  2110,
-    2110,  2120,  2120,  2127,  2127,  2134,  2134,  2143,  2143,  2152,
-    2152,  2163,  2163,  2173,  2174,  2178,  2179,  2182,  2182,  2197,
-    2197,  2207,  2207,  2218,  2219,  2223,  2227,  2227,  2239,  2240,
-    2244,  2244,  2252,  2253,  2256,  2257,  2258,  2259,  2260,  2261,
-    2262,  2265,  2270,  2270,  2278,  2278,  2288,  2289,  2292,  2292,
-    2300,  2301,  2304,  2305,  2306,  2307,  2310,  2310,  2318,  2323,
-    2328
+    1912,  1912,  1920,  1920,  1930,  1930,  1976,  1976,  1988,  1988,
+    1998,  1999,  2002,  2003,  2004,  2005,  2006,  2007,  2008,  2009,
+    2010,  2011,  2012,  2013,  2014,  2015,  2016,  2017,  2018,  2019,
+    2022,  2027,  2027,  2035,  2035,  2043,  2048,  2048,  2056,  2061,
+    2066,  2066,  2074,  2075,  2078,  2078,  2086,  2091,  2096,  2096,
+    2104,  2107,  2110,  2113,  2116,  2122,  2122,  2130,  2130,  2138,
+    2138,  2148,  2148,  2155,  2155,  2162,  2162,  2171,  2171,  2180,
+    2180,  2191,  2191,  2201,  2202,  2206,  2207,  2210,  2210,  2225,
+    2225,  2235,  2235,  2246,  2247,  2251,  2255,  2255,  2267,  2268,
+    2272,  2272,  2280,  2281,  2284,  2285,  2286,  2287,  2288,  2289,
+    2290,  2293,  2298,  2298,  2306,  2306,  2316,  2317,  2320,  2320,
+    2328,  2329,  2332,  2333,  2334,  2335,  2338,  2338,  2346,  2351,
+    2356
   };
 
   // Print the state stack on the debug stream.
@@ -5033,18 +5011,18 @@ namespace isc { namespace dhcp {
            i_end = yystack_.end ();
          i != i_end; ++i)
       *yycdebug_ << ' ' << i->state;
-    *yycdebug_ << '\n';
+    *yycdebug_ << std::endl;
   }
 
   // Report on the debug stream that the rule \a yyrule is going to be reduced.
   void
   Dhcp6Parser::yy_reduce_print_ (int yyrule)
   {
-    unsigned yylno = yyrline_[yyrule];
+    unsigned int yylno = yyrline_[yyrule];
     int yynrhs = yyr2_[yyrule];
     // Print the symbols being reduced, and their result.
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
-               << " (line " << yylno << "):\n";
+               << " (line " << yylno << "):" << std::endl;
     // The symbols being reduced.
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
@@ -5053,10 +5031,10 @@ namespace isc { namespace dhcp {
 #endif // PARSER6_DEBUG
 
 
-#line 14 "dhcp6_parser.yy" // lalr1.cc:1218
+#line 14 "dhcp6_parser.yy" // lalr1.cc:1167
 } } // isc::dhcp
-#line 5059 "dhcp6_parser.cc" // lalr1.cc:1218
-#line 2333 "dhcp6_parser.yy" // lalr1.cc:1219
+#line 5037 "dhcp6_parser.cc" // lalr1.cc:1167
+#line 2361 "dhcp6_parser.yy" // lalr1.cc:1168
 
 
 void
diff --git a/src/bin/dhcp6/dhcp6_parser.h b/src/bin/dhcp6/dhcp6_parser.h
index c45bf9c8fe..8fd3af5615 100644
--- a/src/bin/dhcp6/dhcp6_parser.h
+++ b/src/bin/dhcp6/dhcp6_parser.h
@@ -1,8 +1,8 @@
-// A Bison parser, made by GNU Bison 3.2.1.
+// A Bison parser, made by GNU Bison 3.0.4.
 
 // Skeleton interface for Bison LALR(1) parsers in C++
 
-// Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -30,7 +30,6 @@
 // This special exception was added by the Free Software Foundation in
 // version 2.2 of Bison.
 
-
 /**
  ** \file dhcp6_parser.h
  ** Define the isc::dhcp::parser class.
@@ -38,13 +37,10 @@
 
 // C++ LALR(1) parser skeleton written by Akim Demaille.
 
-// Undocumented macros, especially those whose name start with YY_,
-// are private implementation details.  Do not rely on them.
-
 #ifndef YY_PARSER6_DHCP6_PARSER_H_INCLUDED
 # define YY_PARSER6_DHCP6_PARSER_H_INCLUDED
 // //                    "%code requires" blocks.
-#line 17 "dhcp6_parser.yy" // lalr1.cc:404
+#line 17 "dhcp6_parser.yy" // lalr1.cc:377
 
 #include <string>
 #include <cc/data.h>
@@ -56,7 +52,7 @@ using namespace isc::dhcp;
 using namespace isc::data;
 using namespace std;
 
-#line 60 "dhcp6_parser.h" // lalr1.cc:404
+#line 56 "dhcp6_parser.h" // lalr1.cc:377
 
 # include <cassert>
 # include <cstdlib> // std::abort
@@ -64,21 +60,7 @@ using namespace std;
 # include <stdexcept>
 # include <string>
 # include <vector>
-
-// Support move semantics when possible.
-#if defined __cplusplus && 201103L <= __cplusplus
-# define YY_MOVE           std::move
-# define YY_MOVE_OR_COPY   move
-# define YY_MOVE_REF(Type) Type&&
-# define YY_RVREF(Type)    Type&&
-# define YY_COPY(Type)     Type
-#else
-# define YY_MOVE
-# define YY_MOVE_OR_COPY   copy
-# define YY_MOVE_REF(Type) Type&
-# define YY_RVREF(Type)    const Type&
-# define YY_COPY(Type)     const Type&
-#endif
+# include "stack.hh"
 # include "location.hh"
 #include <typeinfo>
 #ifndef YYASSERT
@@ -105,6 +87,15 @@ using namespace std;
 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 #endif
 
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
@@ -112,7 +103,7 @@ using namespace std;
 # define YYUSE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
@@ -131,18 +122,6 @@ using namespace std;
 # define YY_INITIAL_VALUE(Value) /* Nothing. */
 #endif
 
-# ifndef YY_NULLPTR
-#  if defined __cplusplus
-#   if 201103L <= __cplusplus
-#    define YY_NULLPTR nullptr
-#   else
-#    define YY_NULLPTR 0
-#   endif
-#  else
-#   define YY_NULLPTR ((void*)0)
-#  endif
-# endif
-
 /* Debug traces.  */
 #ifndef PARSER6_DEBUG
 # if defined YYDEBUG
@@ -156,128 +135,9 @@ using namespace std;
 # endif /* ! defined YYDEBUG */
 #endif  /* ! defined PARSER6_DEBUG */
 
-#line 14 "dhcp6_parser.yy" // lalr1.cc:404
+#line 14 "dhcp6_parser.yy" // lalr1.cc:377
 namespace isc { namespace dhcp {
-#line 162 "dhcp6_parser.h" // lalr1.cc:404
-
-  /// A stack with random access from its top.
-  template <typename T, typename S = std::vector<T> >
-  class stack
-  {
-  public:
-    // Hide our reversed order.
-    typedef typename S::reverse_iterator iterator;
-    typedef typename S::const_reverse_iterator const_iterator;
-    typedef typename S::size_type size_type;
-
-    stack (size_type n = 200)
-      : seq_ (n)
-    {}
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    T&
-    operator[] (size_type i)
-    {
-      return seq_[size () - 1 - i];
-    }
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    T&
-    operator[] (int i)
-    {
-      return operator[] (size_type (i));
-    }
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    const T&
-    operator[] (size_type i) const
-    {
-      return seq_[size () - 1 - i];
-    }
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    const T&
-    operator[] (int i) const
-    {
-      return operator[] (size_type (i));
-    }
-
-    /// Steal the contents of \a t.
-    ///
-    /// Close to move-semantics.
-    void
-    push (YY_MOVE_REF (T) t)
-    {
-      seq_.push_back (T ());
-      operator[](0).move (t);
-    }
-
-    void
-    pop (int n = 1)
-    {
-      for (; 0 < n; --n)
-        seq_.pop_back ();
-    }
-
-    void
-    clear ()
-    {
-      seq_.clear ();
-    }
-
-    size_type
-    size () const
-    {
-      return seq_.size ();
-    }
-
-    const_iterator
-    begin () const
-    {
-      return seq_.rbegin ();
-    }
-
-    const_iterator
-    end () const
-    {
-      return seq_.rend ();
-    }
-
-  private:
-    stack (const stack&);
-    stack& operator= (const stack&);
-    /// The wrapped container.
-    S seq_;
-  };
-
-  /// Present a slice of the top of a stack.
-  template <typename T, typename S = stack<T> >
-  class slice
-  {
-  public:
-    slice (const S& stack, int range)
-      : stack_ (stack)
-      , range_ (range)
-    {}
-
-    const T&
-    operator[] (int i) const
-    {
-      return stack_[range_ - i];
-    }
-
-  private:
-    const S& stack_;
-    int range_;
-  };
+#line 141 "dhcp6_parser.h" // lalr1.cc:377
 
 
 
@@ -294,17 +154,16 @@ namespace isc { namespace dhcp {
 
     /// Empty construction.
     variant ()
-      : yybuffer_ ()
-      , yytypeid_ (YY_NULLPTR)
+      : yytypeid_ (YY_NULLPTR)
     {}
 
     /// Construct and fill.
     template <typename T>
-    variant (YY_RVREF (T) t)
+    variant (const T& t)
       : yytypeid_ (&typeid (T))
     {
       YYASSERT (sizeof (T) <= S);
-      new (yyas_<T> ()) T (YY_MOVE (t));
+      new (yyas_<T> ()) T (t);
     }
 
     /// Destruction, allowed only if empty.
@@ -316,62 +175,30 @@ namespace isc { namespace dhcp {
     /// Instantiate an empty \a T in here.
     template <typename T>
     T&
-    emplace ()
+    build ()
     {
       YYASSERT (!yytypeid_);
       YYASSERT (sizeof (T) <= S);
       yytypeid_ = & typeid (T);
-      return *new (yyas_<T> ()) T ();
+      return *new (yyas_<T> ()) T;
     }
 
-# if defined __cplusplus && 201103L <= __cplusplus
-    /// Instantiate a \a T in here from \a t.
-    template <typename T, typename U>
-    T&
-    emplace (U&& u)
-    {
-      YYASSERT (!yytypeid_);
-      YYASSERT (sizeof (T) <= S);
-      yytypeid_ = & typeid (T);
-      return *new (yyas_<T> ()) T (std::forward <U>(u));
-    }
-# else
     /// Instantiate a \a T in here from \a t.
     template <typename T>
     T&
-    emplace (const T& t)
+    build (const T& t)
     {
       YYASSERT (!yytypeid_);
       YYASSERT (sizeof (T) <= S);
       yytypeid_ = & typeid (T);
       return *new (yyas_<T> ()) T (t);
     }
-# endif
-
-    /// Instantiate an empty \a T in here.
-    /// Obsolete, use emplace.
-    template <typename T>
-    T&
-    build ()
-    {
-      return emplace<T> ();
-    }
-
-    /// Instantiate a \a T in here from \a t.
-    /// Obsolete, use emplace.
-    template <typename T>
-    T&
-    build (const T& t)
-    {
-      return emplace<T> (t);
-    }
 
     /// Accessor to a built \a T.
     template <typename T>
     T&
     as ()
     {
-      YYASSERT (yytypeid_);
       YYASSERT (*yytypeid_ == typeid (T));
       YYASSERT (sizeof (T) <= S);
       return *yyas_<T> ();
@@ -382,7 +209,6 @@ namespace isc { namespace dhcp {
     const T&
     as () const
     {
-      YYASSERT (yytypeid_);
       YYASSERT (*yytypeid_ == typeid (T));
       YYASSERT (sizeof (T) <= S);
       return *yyas_<T> ();
@@ -393,7 +219,7 @@ namespace isc { namespace dhcp {
     /// Both variants must be built beforehand, because swapping the actual
     /// data requires reading it (with as()), and this is not possible on
     /// unconstructed variants: it would require some dynamic testing, which
-    /// should not be the variant's responsibility.
+    /// should not be the variant's responsability.
     /// Swapping between built and (possibly) non-built is done with
     /// variant::move ().
     template <typename T>
@@ -412,32 +238,17 @@ namespace isc { namespace dhcp {
     void
     move (self_type& other)
     {
-# if defined __cplusplus && 201103L <= __cplusplus
-      emplace<T> (std::move (other.as<T> ()));
-# else
-      emplace<T> ();
+      build<T> ();
       swap<T> (other);
-# endif
-      other.destroy<T> ();
-    }
-
-# if defined __cplusplus && 201103L <= __cplusplus
-    /// Move the content of \a other to this.
-    template <typename T>
-    void
-    move (self_type&& other)
-    {
-      emplace<T> (std::move (other.as<T> ()));
       other.destroy<T> ();
     }
-#endif
 
     /// Copy the content of \a other to this.
     template <typename T>
     void
     copy (const self_type& other)
     {
-      emplace<T> (other.as<T> ());
+      build<T> (other.as<T> ());
     }
 
     /// Destroy the stored \a T.
@@ -451,7 +262,7 @@ namespace isc { namespace dhcp {
 
   private:
     /// Prohibit blind copies.
-    self_type& operator= (const self_type&);
+    self_type& operator=(const self_type&);
     variant (const self_type&);
 
     /// Accessor to raw memory as \a T.
@@ -500,23 +311,23 @@ namespace isc { namespace dhcp {
       // duid_type
       // ncr_protocol_value
       // replace_client_name_value
-      char dummy1[sizeof (ElementPtr)];
+      char dummy1[sizeof(ElementPtr)];
 
       // "boolean"
-      char dummy2[sizeof (bool)];
+      char dummy2[sizeof(bool)];
 
       // "floating point"
-      char dummy3[sizeof (double)];
+      char dummy3[sizeof(double)];
 
       // "integer"
-      char dummy4[sizeof (int64_t)];
+      char dummy4[sizeof(int64_t)];
 
       // "constant string"
-      char dummy5[sizeof (std::string)];
+      char dummy5[sizeof(std::string)];
 };
 
     /// Symbol semantic values.
-    typedef variant<sizeof (union_type)> semantic_type;
+    typedef variant<sizeof(union_type)> semantic_type;
 #else
     typedef PARSER6_STYPE semantic_type;
 #endif
@@ -725,7 +536,7 @@ namespace isc { namespace dhcp {
     /// A complete symbol.
     ///
     /// Expects its Base type to provide access to the symbol type
-    /// via type_get ().
+    /// via type_get().
     ///
     /// Provide access to semantic value and location.
     template <typename Base>
@@ -737,18 +548,28 @@ namespace isc { namespace dhcp {
       /// Default constructor.
       basic_symbol ();
 
-      /// Move or copy constructor.
-      basic_symbol (YY_RVREF (basic_symbol) other);
-
+      /// Copy constructor.
+      basic_symbol (const basic_symbol& other);
 
       /// Constructor for valueless symbols, and symbols from each type.
-      basic_symbol (typename Base::kind_type t, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (ElementPtr) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (bool) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (double) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (int64_t) v, YY_RVREF (location_type) l);
-      basic_symbol (typename Base::kind_type t, YY_RVREF (std::string) v, YY_RVREF (location_type) l);
 
+  basic_symbol (typename Base::kind_type t, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const ElementPtr v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const bool v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const double v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const int64_t v, const location_type& l);
+
+  basic_symbol (typename Base::kind_type t, const std::string v, const location_type& l);
+
+
+      /// Constructor for symbols with semantic value.
+      basic_symbol (typename Base::kind_type t,
+                    const semantic_type& v,
+                    const location_type& l);
 
       /// Destroy the symbol.
       ~basic_symbol ();
@@ -769,10 +590,8 @@ namespace isc { namespace dhcp {
       location_type location;
 
     private:
-#if !defined __cplusplus || __cplusplus < 201103L
       /// Assignment operator.
       basic_symbol& operator= (const basic_symbol& other);
-#endif
     };
 
     /// Type access provider for token (enum) based symbols.
@@ -812,730 +631,725 @@ namespace isc { namespace dhcp {
     /// "External" symbols: returned by the scanner.
     typedef basic_symbol<by_type> symbol_type;
 
-    /// Build a parser object.
-    Dhcp6Parser (isc::dhcp::Parser6Context& ctx_yyarg);
-    virtual ~Dhcp6Parser ();
-
-    /// Parse.  An alias for parse ().
-    /// \returns  0 iff parsing succeeded.
-    int operator() ();
-
-    /// Parse.
-    /// \returns  0 iff parsing succeeded.
-    virtual int parse ();
-
-#if PARSER6_DEBUG
-    /// The current debugging stream.
-    std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
-    /// Set the current debugging stream.
-    void set_debug_stream (std::ostream &);
-
-    /// Type for debugging levels.
-    typedef int debug_level_type;
-    /// The current debugging level.
-    debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
-    /// Set the current debugging level.
-    void set_debug_level (debug_level_type l);
-#endif
-
-    /// Report a syntax error.
-    /// \param loc    where the syntax error is found.
-    /// \param msg    a description of the syntax error.
-    virtual void error (const location_type& loc, const std::string& msg);
-
-    /// Report a syntax error.
-    void error (const syntax_error& err);
-
     // Symbol constructors declarations.
-    static
+    static inline
     symbol_type
-    make_END (YY_COPY (location_type) l);
+    make_END (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_COMMA (YY_COPY (location_type) l);
+    make_COMMA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_COLON (YY_COPY (location_type) l);
+    make_COLON (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LSQUARE_BRACKET (YY_COPY (location_type) l);
+    make_LSQUARE_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RSQUARE_BRACKET (YY_COPY (location_type) l);
+    make_RSQUARE_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LCURLY_BRACKET (YY_COPY (location_type) l);
+    make_LCURLY_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RCURLY_BRACKET (YY_COPY (location_type) l);
+    make_RCURLY_BRACKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NULL_TYPE (YY_COPY (location_type) l);
+    make_NULL_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP6 (YY_COPY (location_type) l);
+    make_DHCP6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONFIG_CONTROL (YY_COPY (location_type) l);
+    make_CONFIG_CONTROL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONFIG_DATABASES (YY_COPY (location_type) l);
+    make_CONFIG_DATABASES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACES_CONFIG (YY_COPY (location_type) l);
+    make_INTERFACES_CONFIG (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACES (YY_COPY (location_type) l);
+    make_INTERFACES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RE_DETECT (YY_COPY (location_type) l);
+    make_RE_DETECT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LEASE_DATABASE (YY_COPY (location_type) l);
+    make_LEASE_DATABASE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTS_DATABASE (YY_COPY (location_type) l);
+    make_HOSTS_DATABASE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTS_DATABASES (YY_COPY (location_type) l);
+    make_HOSTS_DATABASES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TYPE (YY_COPY (location_type) l);
+    make_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MEMFILE (YY_COPY (location_type) l);
+    make_MEMFILE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MYSQL (YY_COPY (location_type) l);
+    make_MYSQL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_POSTGRESQL (YY_COPY (location_type) l);
+    make_POSTGRESQL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CQL (YY_COPY (location_type) l);
+    make_CQL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_USER (YY_COPY (location_type) l);
+    make_USER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PASSWORD (YY_COPY (location_type) l);
+    make_PASSWORD (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOST (YY_COPY (location_type) l);
+    make_HOST (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PORT (YY_COPY (location_type) l);
+    make_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PERSIST (YY_COPY (location_type) l);
+    make_PERSIST (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LFC_INTERVAL (YY_COPY (location_type) l);
+    make_LFC_INTERVAL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_READONLY (YY_COPY (location_type) l);
+    make_READONLY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONNECT_TIMEOUT (YY_COPY (location_type) l);
+    make_CONNECT_TIMEOUT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONTACT_POINTS (YY_COPY (location_type) l);
+    make_CONTACT_POINTS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_RECONNECT_TRIES (YY_COPY (location_type) l);
+    make_MAX_RECONNECT_TRIES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RECONNECT_WAIT_TIME (YY_COPY (location_type) l);
+    make_RECONNECT_WAIT_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_KEYSPACE (YY_COPY (location_type) l);
+    make_KEYSPACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REQUEST_TIMEOUT (YY_COPY (location_type) l);
+    make_REQUEST_TIMEOUT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TCP_KEEPALIVE (YY_COPY (location_type) l);
+    make_TCP_KEEPALIVE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TCP_NODELAY (YY_COPY (location_type) l);
+    make_TCP_NODELAY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PREFERRED_LIFETIME (YY_COPY (location_type) l);
+    make_PREFERRED_LIFETIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_VALID_LIFETIME (YY_COPY (location_type) l);
+    make_VALID_LIFETIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RENEW_TIMER (YY_COPY (location_type) l);
+    make_RENEW_TIMER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REBIND_TIMER (YY_COPY (location_type) l);
+    make_REBIND_TIMER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DECLINE_PROBATION_PERIOD (YY_COPY (location_type) l);
+    make_DECLINE_PROBATION_PERIOD (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_TAG (YY_COPY (location_type) l);
+    make_SERVER_TAG (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET6 (YY_COPY (location_type) l);
+    make_SUBNET6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OPTION_DEF (YY_COPY (location_type) l);
+    make_OPTION_DEF (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OPTION_DATA (YY_COPY (location_type) l);
+    make_OPTION_DATA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NAME (YY_COPY (location_type) l);
+    make_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DATA (YY_COPY (location_type) l);
+    make_DATA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CODE (YY_COPY (location_type) l);
+    make_CODE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SPACE (YY_COPY (location_type) l);
+    make_SPACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CSV_FORMAT (YY_COPY (location_type) l);
+    make_CSV_FORMAT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ALWAYS_SEND (YY_COPY (location_type) l);
+    make_ALWAYS_SEND (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RECORD_TYPES (YY_COPY (location_type) l);
+    make_RECORD_TYPES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ENCAPSULATE (YY_COPY (location_type) l);
+    make_ENCAPSULATE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ARRAY (YY_COPY (location_type) l);
+    make_ARRAY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_POOLS (YY_COPY (location_type) l);
+    make_POOLS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_POOL (YY_COPY (location_type) l);
+    make_POOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PD_POOLS (YY_COPY (location_type) l);
+    make_PD_POOLS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PREFIX (YY_COPY (location_type) l);
+    make_PREFIX (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PREFIX_LEN (YY_COPY (location_type) l);
+    make_PREFIX_LEN (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_EXCLUDED_PREFIX (YY_COPY (location_type) l);
+    make_EXCLUDED_PREFIX (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_EXCLUDED_PREFIX_LEN (YY_COPY (location_type) l);
+    make_EXCLUDED_PREFIX_LEN (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DELEGATED_LEN (YY_COPY (location_type) l);
+    make_DELEGATED_LEN (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_USER_CONTEXT (YY_COPY (location_type) l);
+    make_USER_CONTEXT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_COMMENT (YY_COPY (location_type) l);
+    make_COMMENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUBNET (YY_COPY (location_type) l);
+    make_SUBNET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACE (YY_COPY (location_type) l);
+    make_INTERFACE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTERFACE_ID (YY_COPY (location_type) l);
+    make_INTERFACE_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ID (YY_COPY (location_type) l);
+    make_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RAPID_COMMIT (YY_COPY (location_type) l);
+    make_RAPID_COMMIT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RESERVATION_MODE (YY_COPY (location_type) l);
+    make_RESERVATION_MODE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DISABLED (YY_COPY (location_type) l);
+    make_DISABLED (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUT_OF_POOL (YY_COPY (location_type) l);
+    make_OUT_OF_POOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_GLOBAL (YY_COPY (location_type) l);
+    make_GLOBAL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ALL (YY_COPY (location_type) l);
+    make_ALL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SHARED_NETWORKS (YY_COPY (location_type) l);
+    make_SHARED_NETWORKS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAC_SOURCES (YY_COPY (location_type) l);
+    make_MAC_SOURCES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RELAY_SUPPLIED_OPTIONS (YY_COPY (location_type) l);
+    make_RELAY_SUPPLIED_OPTIONS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOST_RESERVATION_IDENTIFIERS (YY_COPY (location_type) l);
+    make_HOST_RESERVATION_IDENTIFIERS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SANITY_CHECKS (YY_COPY (location_type) l);
+    make_SANITY_CHECKS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LEASE_CHECKS (YY_COPY (location_type) l);
+    make_LEASE_CHECKS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CLIENT_CLASSES (YY_COPY (location_type) l);
+    make_CLIENT_CLASSES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REQUIRE_CLIENT_CLASSES (YY_COPY (location_type) l);
+    make_REQUIRE_CLIENT_CLASSES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TEST (YY_COPY (location_type) l);
+    make_TEST (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ONLY_IF_REQUIRED (YY_COPY (location_type) l);
+    make_ONLY_IF_REQUIRED (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CLIENT_CLASS (YY_COPY (location_type) l);
+    make_CLIENT_CLASS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RESERVATIONS (YY_COPY (location_type) l);
+    make_RESERVATIONS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_IP_ADDRESSES (YY_COPY (location_type) l);
+    make_IP_ADDRESSES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PREFIXES (YY_COPY (location_type) l);
+    make_PREFIXES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DUID (YY_COPY (location_type) l);
+    make_DUID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HW_ADDRESS (YY_COPY (location_type) l);
+    make_HW_ADDRESS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTNAME (YY_COPY (location_type) l);
+    make_HOSTNAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLEX_ID (YY_COPY (location_type) l);
+    make_FLEX_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RELAY (YY_COPY (location_type) l);
+    make_RELAY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_IP_ADDRESS (YY_COPY (location_type) l);
+    make_IP_ADDRESS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOOKS_LIBRARIES (YY_COPY (location_type) l);
+    make_HOOKS_LIBRARIES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LIBRARY (YY_COPY (location_type) l);
+    make_LIBRARY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_PARAMETERS (YY_COPY (location_type) l);
+    make_PARAMETERS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_EXPIRED_LEASES_PROCESSING (YY_COPY (location_type) l);
+    make_EXPIRED_LEASES_PROCESSING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_RECLAIM_TIMER_WAIT_TIME (YY_COPY (location_type) l);
+    make_RECLAIM_TIMER_WAIT_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (YY_COPY (location_type) l);
+    make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOLD_RECLAIMED_TIME (YY_COPY (location_type) l);
+    make_HOLD_RECLAIMED_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_RECLAIM_LEASES (YY_COPY (location_type) l);
+    make_MAX_RECLAIM_LEASES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_RECLAIM_TIME (YY_COPY (location_type) l);
+    make_MAX_RECLAIM_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_UNWARNED_RECLAIM_CYCLES (YY_COPY (location_type) l);
+    make_UNWARNED_RECLAIM_CYCLES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_ID (YY_COPY (location_type) l);
+    make_SERVER_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LLT (YY_COPY (location_type) l);
+    make_LLT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_EN (YY_COPY (location_type) l);
+    make_EN (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LL (YY_COPY (location_type) l);
+    make_LL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_IDENTIFIER (YY_COPY (location_type) l);
+    make_IDENTIFIER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HTYPE (YY_COPY (location_type) l);
+    make_HTYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TIME (YY_COPY (location_type) l);
+    make_TIME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ENTERPRISE_ID (YY_COPY (location_type) l);
+    make_ENTERPRISE_ID (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP4O6_PORT (YY_COPY (location_type) l);
+    make_DHCP4O6_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONTROL_SOCKET (YY_COPY (location_type) l);
+    make_CONTROL_SOCKET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SOCKET_TYPE (YY_COPY (location_type) l);
+    make_SOCKET_TYPE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SOCKET_NAME (YY_COPY (location_type) l);
+    make_SOCKET_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP_QUEUE_CONTROL (YY_COPY (location_type) l);
+    make_DHCP_QUEUE_CONTROL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP_DDNS (YY_COPY (location_type) l);
+    make_DHCP_DDNS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ENABLE_UPDATES (YY_COPY (location_type) l);
+    make_ENABLE_UPDATES (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_QUALIFYING_SUFFIX (YY_COPY (location_type) l);
+    make_QUALIFYING_SUFFIX (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_IP (YY_COPY (location_type) l);
+    make_SERVER_IP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SERVER_PORT (YY_COPY (location_type) l);
+    make_SERVER_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SENDER_IP (YY_COPY (location_type) l);
+    make_SENDER_IP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SENDER_PORT (YY_COPY (location_type) l);
+    make_SENDER_PORT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAX_QUEUE_SIZE (YY_COPY (location_type) l);
+    make_MAX_QUEUE_SIZE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NCR_PROTOCOL (YY_COPY (location_type) l);
+    make_NCR_PROTOCOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NCR_FORMAT (YY_COPY (location_type) l);
+    make_NCR_FORMAT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OVERRIDE_NO_UPDATE (YY_COPY (location_type) l);
+    make_OVERRIDE_NO_UPDATE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OVERRIDE_CLIENT_UPDATE (YY_COPY (location_type) l);
+    make_OVERRIDE_CLIENT_UPDATE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_REPLACE_CLIENT_NAME (YY_COPY (location_type) l);
+    make_REPLACE_CLIENT_NAME (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_GENERATED_PREFIX (YY_COPY (location_type) l);
+    make_GENERATED_PREFIX (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_UDP (YY_COPY (location_type) l);
+    make_UDP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TCP (YY_COPY (location_type) l);
+    make_TCP (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_JSON (YY_COPY (location_type) l);
+    make_JSON (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_WHEN_PRESENT (YY_COPY (location_type) l);
+    make_WHEN_PRESENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_NEVER (YY_COPY (location_type) l);
+    make_NEVER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_ALWAYS (YY_COPY (location_type) l);
+    make_ALWAYS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_WHEN_NOT_PRESENT (YY_COPY (location_type) l);
+    make_WHEN_NOT_PRESENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTNAME_CHAR_SET (YY_COPY (location_type) l);
+    make_HOSTNAME_CHAR_SET (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_HOSTNAME_CHAR_REPLACEMENT (YY_COPY (location_type) l);
+    make_HOSTNAME_CHAR_REPLACEMENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LOGGING (YY_COPY (location_type) l);
+    make_LOGGING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_LOGGERS (YY_COPY (location_type) l);
+    make_LOGGERS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUTPUT_OPTIONS (YY_COPY (location_type) l);
+    make_OUTPUT_OPTIONS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_OUTPUT (YY_COPY (location_type) l);
+    make_OUTPUT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DEBUGLEVEL (YY_COPY (location_type) l);
+    make_DEBUGLEVEL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SEVERITY (YY_COPY (location_type) l);
+    make_SEVERITY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLUSH (YY_COPY (location_type) l);
+    make_FLUSH (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAXSIZE (YY_COPY (location_type) l);
+    make_MAXSIZE (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_MAXVER (YY_COPY (location_type) l);
+    make_MAXVER (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCP4 (YY_COPY (location_type) l);
+    make_DHCP4 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_DHCPDDNS (YY_COPY (location_type) l);
+    make_DHCPDDNS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_CONTROL_AGENT (YY_COPY (location_type) l);
+    make_CONTROL_AGENT (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TOPLEVEL_JSON (YY_COPY (location_type) l);
+    make_TOPLEVEL_JSON (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_TOPLEVEL_DHCP6 (YY_COPY (location_type) l);
+    make_TOPLEVEL_DHCP6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_DHCP6 (YY_COPY (location_type) l);
+    make_SUB_DHCP6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_INTERFACES6 (YY_COPY (location_type) l);
+    make_SUB_INTERFACES6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_SUBNET6 (YY_COPY (location_type) l);
+    make_SUB_SUBNET6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_POOL6 (YY_COPY (location_type) l);
+    make_SUB_POOL6 (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_PD_POOL (YY_COPY (location_type) l);
+    make_SUB_PD_POOL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_RESERVATION (YY_COPY (location_type) l);
+    make_SUB_RESERVATION (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_OPTION_DEFS (YY_COPY (location_type) l);
+    make_SUB_OPTION_DEFS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_OPTION_DEF (YY_COPY (location_type) l);
+    make_SUB_OPTION_DEF (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_OPTION_DATA (YY_COPY (location_type) l);
+    make_SUB_OPTION_DATA (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_HOOKS_LIBRARY (YY_COPY (location_type) l);
+    make_SUB_HOOKS_LIBRARY (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_DHCP_DDNS (YY_COPY (location_type) l);
+    make_SUB_DHCP_DDNS (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_LOGGING (YY_COPY (location_type) l);
+    make_SUB_LOGGING (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_SUB_CONFIG_CONTROL (YY_COPY (location_type) l);
+    make_SUB_CONFIG_CONTROL (const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_STRING (YY_COPY (std::string) v, YY_COPY (location_type) l);
+    make_STRING (const std::string& v, const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_INTEGER (YY_COPY (int64_t) v, YY_COPY (location_type) l);
+    make_INTEGER (const int64_t& v, const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_FLOAT (YY_COPY (double) v, YY_COPY (location_type) l);
+    make_FLOAT (const double& v, const location_type& l);
 
-    static
+    static inline
     symbol_type
-    make_BOOLEAN (YY_COPY (bool) v, YY_COPY (location_type) l);
+    make_BOOLEAN (const bool& v, const location_type& l);
 
 
+    /// Build a parser object.
+    Dhcp6Parser (isc::dhcp::Parser6Context& ctx_yyarg);
+    virtual ~Dhcp6Parser ();
+
+    /// Parse.
+    /// \returns  0 iff parsing succeeded.
+    virtual int parse ();
+
+#if PARSER6_DEBUG
+    /// The current debugging stream.
+    std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
+    /// Set the current debugging stream.
+    void set_debug_stream (std::ostream &);
+
+    /// Type for debugging levels.
+    typedef int debug_level_type;
+    /// The current debugging level.
+    debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
+    /// Set the current debugging level.
+    void set_debug_level (debug_level_type l);
+#endif
+
+    /// Report a syntax error.
+    /// \param loc    where the syntax error is found.
+    /// \param msg    a description of the syntax error.
+    virtual void error (const location_type& loc, const std::string& msg);
+
+    /// Report a syntax error.
+    void error (const syntax_error& err);
 
   private:
     /// This class is not copyable.
@@ -1564,7 +1378,7 @@ namespace isc { namespace dhcp {
     /// \param yyvalue   the value to check
     static bool yy_table_value_is_error_ (int yyvalue);
 
-    static const short yypact_ninf_;
+    static const short int yypact_ninf_;
     static const signed char yytable_ninf_;
 
     /// Convert a scanner token number \a t to a symbol number.
@@ -1573,32 +1387,32 @@ namespace isc { namespace dhcp {
     // Tables.
   // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   // STATE-NUM.
-  static const short yypact_[];
+  static const short int yypact_[];
 
   // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
   // Performed when YYTABLE does not specify something else to do.  Zero
   // means the default is an error.
-  static const unsigned short yydefact_[];
+  static const unsigned short int yydefact_[];
 
   // YYPGOTO[NTERM-NUM].
-  static const short yypgoto_[];
+  static const short int yypgoto_[];
 
   // YYDEFGOTO[NTERM-NUM].
-  static const short yydefgoto_[];
+  static const short int yydefgoto_[];
 
   // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
   // positive, shift that token.  If negative, reduce the rule whose
   // number is the opposite.  If YYTABLE_NINF, syntax error.
-  static const unsigned short yytable_[];
+  static const unsigned short int yytable_[];
 
-  static const short yycheck_[];
+  static const short int yycheck_[];
 
   // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   // symbol of state STATE-NUM.
-  static const unsigned short yystos_[];
+  static const unsigned short int yystos_[];
 
   // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
-  static const unsigned short yyr1_[];
+  static const unsigned short int yyr1_[];
 
   // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
   static const unsigned char yyr2_[];
@@ -1612,15 +1426,14 @@ namespace isc { namespace dhcp {
     static const char* const yytname_[];
 #if PARSER6_DEBUG
   // YYRLINE[YYN] -- Source line where rule number YYN was defined.
-  static const unsigned short yyrline_[];
+  static const unsigned short int yyrline_[];
     /// Report on the debug stream that the rule \a r is going to be reduced.
     virtual void yy_reduce_print_ (int r);
     /// Print the state stack on the debug stream.
     virtual void yystack_print_ ();
 
-    /// Debugging level.
+    // Debugging.
     int yydebug_;
-    /// Debug stream.
     std::ostream* yycdebug_;
 
     /// \brief Display a symbol type, value and location.
@@ -1678,15 +1491,10 @@ namespace isc { namespace dhcp {
       typedef basic_symbol<by_state> super_type;
       /// Construct an empty symbol.
       stack_symbol_type ();
-      /// Move or copy construction.
-      stack_symbol_type (YY_RVREF (stack_symbol_type) that);
       /// Steal the contents from \a sym to build this.
-      stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
-#if !defined __cplusplus || __cplusplus < 201103L
-      /// Assignment, needed by push_back by some old implementations.
-      /// Moves the contents of that.
-      stack_symbol_type& operator= (stack_symbol_type& that);
-#endif
+      stack_symbol_type (state_type s, symbol_type& sym);
+      /// Assignment, needed by push_back.
+      stack_symbol_type& operator= (const stack_symbol_type& that);
     };
 
     /// Stack type.
@@ -1698,20 +1506,20 @@ namespace isc { namespace dhcp {
     /// Push a new state on the stack.
     /// \param m    a debug message to display
     ///             if null, no trace is output.
-    /// \param sym  the symbol
+    /// \param s    the symbol
     /// \warning the contents of \a s.value is stolen.
-    void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
+    void yypush_ (const char* m, stack_symbol_type& s);
 
     /// Push a new look ahead token on the state on the stack.
     /// \param m    a debug message to display
     ///             if null, no trace is output.
     /// \param s    the state
     /// \param sym  the symbol (for its value and location).
-    /// \warning the contents of \a sym.value is stolen.
-    void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
+    /// \warning the contents of \a s.value is stolen.
+    void yypush_ (const char* m, state_type s, symbol_type& sym);
 
-    /// Pop \a n symbols from the stack.
-    void yypop_ (int n = 1);
+    /// Pop \a n symbols the three stacks.
+    void yypop_ (unsigned int n = 1);
 
     /// Constants.
     enum
@@ -1783,12 +1591,12 @@ namespace isc { namespace dhcp {
      155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
      165,   166,   167,   168,   169,   170,   171,   172,   173
     };
-    const unsigned user_token_number_max_ = 428;
+    const unsigned int user_token_number_max_ = 428;
     const token_number_type undef_token_ = 2;
 
-    if (static_cast<int> (t) <= yyeof_)
+    if (static_cast<int>(t) <= yyeof_)
       return yyeof_;
-    else if (static_cast<unsigned> (t) <= user_token_number_max_)
+    else if (static_cast<unsigned int> (t) <= user_token_number_max_)
       return translate_table[t];
     else
       return undef_token_;
@@ -1802,18 +1610,19 @@ namespace isc { namespace dhcp {
 
   // basic_symbol.
   template <typename Base>
+  inline
   Dhcp6Parser::basic_symbol<Base>::basic_symbol ()
     : value ()
-    , location ()
   {}
 
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (YY_RVREF (basic_symbol) other)
-    : Base (YY_MOVE (other))
+  inline
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
+    : Base (other)
     , value ()
-    , location (YY_MOVE (other.location))
+    , location (other.location)
   {
-    switch (other.type_get ())
+      switch (other.type_get ())
     {
       case 191: // value
       case 195: // map_value
@@ -1822,23 +1631,23 @@ namespace isc { namespace dhcp {
       case 472: // duid_type
       case 507: // ncr_protocol_value
       case 514: // replace_client_name_value
-        value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (other.value));
+        value.copy< ElementPtr > (other.value);
         break;
 
       case 173: // "boolean"
-        value.YY_MOVE_OR_COPY< bool > (YY_MOVE (other.value));
+        value.copy< bool > (other.value);
         break;
 
       case 172: // "floating point"
-        value.YY_MOVE_OR_COPY< double > (YY_MOVE (other.value));
+        value.copy< double > (other.value);
         break;
 
       case 171: // "integer"
-        value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (other.value));
+        value.copy< int64_t > (other.value);
         break;
 
       case 170: // "constant string"
-        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (other.value));
+        value.copy< std::string > (other.value);
         break;
 
       default:
@@ -1848,57 +1657,102 @@ namespace isc { namespace dhcp {
   }
 
 
+  template <typename Base>
+  inline
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const semantic_type& v, const location_type& l)
+    : Base (t)
+    , value ()
+    , location (l)
+  {
+    (void) v;
+      switch (this->type_get ())
+    {
+      case 191: // value
+      case 195: // map_value
+      case 247: // db_type
+      case 336: // hr_mode
+      case 472: // duid_type
+      case 507: // ncr_protocol_value
+      case 514: // replace_client_name_value
+        value.copy< ElementPtr > (v);
+        break;
+
+      case 173: // "boolean"
+        value.copy< bool > (v);
+        break;
+
+      case 172: // "floating point"
+        value.copy< double > (v);
+        break;
+
+      case 171: // "integer"
+        value.copy< int64_t > (v);
+        break;
+
+      case 170: // "constant string"
+        value.copy< std::string > (v);
+        break;
+
+      default:
+        break;
+    }
+}
+
+
   // Implementation of basic_symbol constructor for each type.
+
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (location_type) l)
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const location_type& l)
     : Base (t)
-    , location (YY_MOVE (l))
+    , value ()
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (ElementPtr) v, YY_RVREF (location_type) l)
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const ElementPtr v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (bool) v, YY_RVREF (location_type) l)
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const bool v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (double) v, YY_RVREF (location_type) l)
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const double v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (int64_t) v, YY_RVREF (location_type) l)
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const int64_t v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
   template <typename Base>
-  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (std::string) v, YY_RVREF (location_type) l)
+  Dhcp6Parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::string v, const location_type& l)
     : Base (t)
-    , value (YY_MOVE (v))
-    , location (YY_MOVE (l))
+    , value (v)
+    , location (l)
   {}
 
 
-
   template <typename Base>
+  inline
   Dhcp6Parser::basic_symbol<Base>::~basic_symbol ()
   {
     clear ();
   }
 
   template <typename Base>
+  inline
   void
   Dhcp6Parser::basic_symbol<Base>::clear ()
   {
@@ -1913,7 +1767,7 @@ namespace isc { namespace dhcp {
     }
 
     // Type destructor.
-  switch (yytype)
+    switch (yytype)
     {
       case 191: // value
       case 195: // map_value
@@ -1949,6 +1803,7 @@ namespace isc { namespace dhcp {
   }
 
   template <typename Base>
+  inline
   bool
   Dhcp6Parser::basic_symbol<Base>::empty () const
   {
@@ -1956,11 +1811,12 @@ namespace isc { namespace dhcp {
   }
 
   template <typename Base>
+  inline
   void
   Dhcp6Parser::basic_symbol<Base>::move (basic_symbol& s)
   {
-    super_type::move (s);
-    switch (this->type_get ())
+    super_type::move(s);
+      switch (this->type_get ())
     {
       case 191: // value
       case 195: // map_value
@@ -1969,30 +1825,30 @@ namespace isc { namespace dhcp {
       case 472: // duid_type
       case 507: // ncr_protocol_value
       case 514: // replace_client_name_value
-        value.move< ElementPtr > (YY_MOVE (s.value));
+        value.move< ElementPtr > (s.value);
         break;
 
       case 173: // "boolean"
-        value.move< bool > (YY_MOVE (s.value));
+        value.move< bool > (s.value);
         break;
 
       case 172: // "floating point"
-        value.move< double > (YY_MOVE (s.value));
+        value.move< double > (s.value);
         break;
 
       case 171: // "integer"
-        value.move< int64_t > (YY_MOVE (s.value));
+        value.move< int64_t > (s.value);
         break;
 
       case 170: // "constant string"
-        value.move< std::string > (YY_MOVE (s.value));
+        value.move< std::string > (s.value);
         break;
 
       default:
         break;
     }
 
-    location = YY_MOVE (s.location);
+    location = s.location;
   }
 
   // by_type.
@@ -2040,7 +1896,7 @@ namespace isc { namespace dhcp {
     // YYTOKNUM[NUM] -- (External) token number corresponding to the
     // (internal) symbol number NUM (which must be that of a token).  */
     static
-    const unsigned short
+    const unsigned short int
     yytoken_number_[] =
     {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
@@ -2064,1216 +1920,1043 @@ namespace isc { namespace dhcp {
     };
     return static_cast<token_type> (yytoken_number_[type]);
   }
-
   // Implementation of make_symbol for each symbol type.
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_END (YY_COPY (location_type) l)
+  Dhcp6Parser::make_END (const location_type& l)
   {
-    return symbol_type (token::TOKEN_END, YY_MOVE (l));
+    return symbol_type (token::TOKEN_END, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_COMMA (YY_COPY (location_type) l)
+  Dhcp6Parser::make_COMMA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_COMMA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_COMMA, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_COLON (YY_COPY (location_type) l)
+  Dhcp6Parser::make_COLON (const location_type& l)
   {
-    return symbol_type (token::TOKEN_COLON, YY_MOVE (l));
+    return symbol_type (token::TOKEN_COLON, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LSQUARE_BRACKET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LSQUARE_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LSQUARE_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LSQUARE_BRACKET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RSQUARE_BRACKET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RSQUARE_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RSQUARE_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RSQUARE_BRACKET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LCURLY_BRACKET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LCURLY_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LCURLY_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LCURLY_BRACKET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RCURLY_BRACKET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RCURLY_BRACKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RCURLY_BRACKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RCURLY_BRACKET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_NULL_TYPE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_NULL_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NULL_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NULL_TYPE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DHCP6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DHCP6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CONFIG_CONTROL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CONFIG_CONTROL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONFIG_CONTROL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONFIG_CONTROL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CONFIG_DATABASES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CONFIG_DATABASES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONFIG_DATABASES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONFIG_DATABASES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_INTERFACES_CONFIG (YY_COPY (location_type) l)
+  Dhcp6Parser::make_INTERFACES_CONFIG (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACES_CONFIG, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACES_CONFIG, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_INTERFACES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_INTERFACES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RE_DETECT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RE_DETECT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RE_DETECT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RE_DETECT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LEASE_DATABASE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LEASE_DATABASE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LEASE_DATABASE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LEASE_DATABASE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOSTS_DATABASE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOSTS_DATABASE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTS_DATABASE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTS_DATABASE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOSTS_DATABASES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOSTS_DATABASES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTS_DATABASES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTS_DATABASES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TYPE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TYPE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MEMFILE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MEMFILE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MEMFILE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MEMFILE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MYSQL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MYSQL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MYSQL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MYSQL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_POSTGRESQL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_POSTGRESQL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_POSTGRESQL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_POSTGRESQL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CQL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CQL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CQL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CQL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_USER (YY_COPY (location_type) l)
+  Dhcp6Parser::make_USER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_USER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_USER, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PASSWORD (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PASSWORD (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PASSWORD, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PASSWORD, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOST (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOST (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOST, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOST, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PORT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PORT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PERSIST (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PERSIST (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PERSIST, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PERSIST, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LFC_INTERVAL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LFC_INTERVAL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LFC_INTERVAL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LFC_INTERVAL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_READONLY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_READONLY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_READONLY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_READONLY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CONNECT_TIMEOUT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CONNECT_TIMEOUT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONNECT_TIMEOUT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONNECT_TIMEOUT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CONTACT_POINTS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CONTACT_POINTS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONTACT_POINTS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONTACT_POINTS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAX_RECONNECT_TRIES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAX_RECONNECT_TRIES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RECONNECT_WAIT_TIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RECONNECT_WAIT_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_KEYSPACE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_KEYSPACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_KEYSPACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_KEYSPACE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_REQUEST_TIMEOUT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_REQUEST_TIMEOUT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REQUEST_TIMEOUT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REQUEST_TIMEOUT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TCP_KEEPALIVE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TCP_KEEPALIVE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TCP_KEEPALIVE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TCP_KEEPALIVE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TCP_NODELAY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TCP_NODELAY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TCP_NODELAY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TCP_NODELAY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PREFERRED_LIFETIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PREFERRED_LIFETIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PREFERRED_LIFETIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PREFERRED_LIFETIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_VALID_LIFETIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_VALID_LIFETIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_VALID_LIFETIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_VALID_LIFETIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RENEW_TIMER (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RENEW_TIMER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RENEW_TIMER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RENEW_TIMER, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_REBIND_TIMER (YY_COPY (location_type) l)
+  Dhcp6Parser::make_REBIND_TIMER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REBIND_TIMER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REBIND_TIMER, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DECLINE_PROBATION_PERIOD (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DECLINE_PROBATION_PERIOD (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SERVER_TAG (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SERVER_TAG (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_TAG, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_TAG, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUBNET6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUBNET6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OPTION_DEF (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OPTION_DEF (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OPTION_DEF, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OPTION_DEF, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OPTION_DATA (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OPTION_DATA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OPTION_DATA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OPTION_DATA, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_NAME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NAME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DATA (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DATA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DATA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DATA, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CODE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CODE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CODE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CODE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SPACE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SPACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SPACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SPACE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CSV_FORMAT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CSV_FORMAT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CSV_FORMAT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CSV_FORMAT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ALWAYS_SEND (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ALWAYS_SEND (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ALWAYS_SEND, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ALWAYS_SEND, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RECORD_TYPES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RECORD_TYPES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RECORD_TYPES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RECORD_TYPES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ENCAPSULATE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ENCAPSULATE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ENCAPSULATE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ENCAPSULATE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ARRAY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ARRAY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ARRAY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ARRAY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_POOLS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_POOLS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_POOLS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_POOLS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_POOL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_POOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_POOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_POOL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PD_POOLS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PD_POOLS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PD_POOLS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PD_POOLS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PREFIX (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PREFIX (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PREFIX, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PREFIX, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PREFIX_LEN (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PREFIX_LEN (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PREFIX_LEN, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PREFIX_LEN, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_EXCLUDED_PREFIX (YY_COPY (location_type) l)
+  Dhcp6Parser::make_EXCLUDED_PREFIX (const location_type& l)
   {
-    return symbol_type (token::TOKEN_EXCLUDED_PREFIX, YY_MOVE (l));
+    return symbol_type (token::TOKEN_EXCLUDED_PREFIX, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_EXCLUDED_PREFIX_LEN (YY_COPY (location_type) l)
+  Dhcp6Parser::make_EXCLUDED_PREFIX_LEN (const location_type& l)
   {
-    return symbol_type (token::TOKEN_EXCLUDED_PREFIX_LEN, YY_MOVE (l));
+    return symbol_type (token::TOKEN_EXCLUDED_PREFIX_LEN, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DELEGATED_LEN (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DELEGATED_LEN (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DELEGATED_LEN, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DELEGATED_LEN, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_USER_CONTEXT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_USER_CONTEXT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_USER_CONTEXT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_USER_CONTEXT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_COMMENT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_COMMENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_COMMENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_COMMENT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUBNET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUBNET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUBNET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUBNET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_INTERFACE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_INTERFACE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_INTERFACE_ID (YY_COPY (location_type) l)
+  Dhcp6Parser::make_INTERFACE_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTERFACE_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTERFACE_ID, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ID (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ID, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RAPID_COMMIT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RAPID_COMMIT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RAPID_COMMIT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RAPID_COMMIT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RESERVATION_MODE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RESERVATION_MODE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RESERVATION_MODE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RESERVATION_MODE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DISABLED (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DISABLED (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DISABLED, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DISABLED, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OUT_OF_POOL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OUT_OF_POOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUT_OF_POOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUT_OF_POOL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_GLOBAL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_GLOBAL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_GLOBAL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_GLOBAL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ALL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ALL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ALL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ALL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SHARED_NETWORKS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SHARED_NETWORKS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SHARED_NETWORKS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SHARED_NETWORKS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAC_SOURCES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAC_SOURCES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAC_SOURCES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAC_SOURCES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RELAY_SUPPLIED_OPTIONS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RELAY_SUPPLIED_OPTIONS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RELAY_SUPPLIED_OPTIONS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RELAY_SUPPLIED_OPTIONS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOST_RESERVATION_IDENTIFIERS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOST_RESERVATION_IDENTIFIERS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SANITY_CHECKS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SANITY_CHECKS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SANITY_CHECKS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SANITY_CHECKS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LEASE_CHECKS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LEASE_CHECKS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LEASE_CHECKS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LEASE_CHECKS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CLIENT_CLASSES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CLIENT_CLASSES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CLIENT_CLASSES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CLIENT_CLASSES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_REQUIRE_CLIENT_CLASSES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_REQUIRE_CLIENT_CLASSES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TEST (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TEST (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TEST, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TEST, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ONLY_IF_REQUIRED (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ONLY_IF_REQUIRED (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CLIENT_CLASS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CLIENT_CLASS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CLIENT_CLASS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CLIENT_CLASS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RESERVATIONS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RESERVATIONS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RESERVATIONS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RESERVATIONS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_IP_ADDRESSES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_IP_ADDRESSES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_IP_ADDRESSES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_IP_ADDRESSES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PREFIXES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PREFIXES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PREFIXES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PREFIXES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DUID (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DUID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DUID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DUID, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HW_ADDRESS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HW_ADDRESS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HW_ADDRESS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HW_ADDRESS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOSTNAME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOSTNAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTNAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTNAME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_FLEX_ID (YY_COPY (location_type) l)
+  Dhcp6Parser::make_FLEX_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLEX_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLEX_ID, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RELAY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RELAY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RELAY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RELAY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_IP_ADDRESS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_IP_ADDRESS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_IP_ADDRESS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_IP_ADDRESS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOOKS_LIBRARIES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOOKS_LIBRARIES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOOKS_LIBRARIES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOOKS_LIBRARIES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LIBRARY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LIBRARY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LIBRARY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LIBRARY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_PARAMETERS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_PARAMETERS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_PARAMETERS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_PARAMETERS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_EXPIRED_LEASES_PROCESSING (YY_COPY (location_type) l)
+  Dhcp6Parser::make_EXPIRED_LEASES_PROCESSING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_RECLAIM_TIMER_WAIT_TIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_RECLAIM_TIMER_WAIT_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOLD_RECLAIMED_TIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOLD_RECLAIMED_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAX_RECLAIM_LEASES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAX_RECLAIM_LEASES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAX_RECLAIM_TIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAX_RECLAIM_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_UNWARNED_RECLAIM_CYCLES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_UNWARNED_RECLAIM_CYCLES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SERVER_ID (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SERVER_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_ID, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LLT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LLT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LLT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LLT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_EN (YY_COPY (location_type) l)
+  Dhcp6Parser::make_EN (const location_type& l)
   {
-    return symbol_type (token::TOKEN_EN, YY_MOVE (l));
+    return symbol_type (token::TOKEN_EN, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_IDENTIFIER (YY_COPY (location_type) l)
+  Dhcp6Parser::make_IDENTIFIER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_IDENTIFIER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_IDENTIFIER, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HTYPE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HTYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HTYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HTYPE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TIME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TIME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TIME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TIME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ENTERPRISE_ID (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ENTERPRISE_ID (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ENTERPRISE_ID, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ENTERPRISE_ID, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DHCP4O6_PORT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DHCP4O6_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP4O6_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP4O6_PORT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CONTROL_SOCKET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CONTROL_SOCKET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONTROL_SOCKET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONTROL_SOCKET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SOCKET_TYPE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SOCKET_TYPE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SOCKET_TYPE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SOCKET_TYPE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SOCKET_NAME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SOCKET_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SOCKET_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SOCKET_NAME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DHCP_QUEUE_CONTROL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DHCP_QUEUE_CONTROL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DHCP_DDNS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DHCP_DDNS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP_DDNS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP_DDNS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ENABLE_UPDATES (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ENABLE_UPDATES (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ENABLE_UPDATES, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ENABLE_UPDATES, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_QUALIFYING_SUFFIX (YY_COPY (location_type) l)
+  Dhcp6Parser::make_QUALIFYING_SUFFIX (const location_type& l)
   {
-    return symbol_type (token::TOKEN_QUALIFYING_SUFFIX, YY_MOVE (l));
+    return symbol_type (token::TOKEN_QUALIFYING_SUFFIX, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SERVER_IP (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SERVER_IP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_IP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_IP, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SERVER_PORT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SERVER_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SERVER_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SERVER_PORT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SENDER_IP (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SENDER_IP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SENDER_IP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SENDER_IP, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SENDER_PORT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SENDER_PORT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SENDER_PORT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SENDER_PORT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAX_QUEUE_SIZE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAX_QUEUE_SIZE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_NCR_PROTOCOL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_NCR_PROTOCOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NCR_PROTOCOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NCR_PROTOCOL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_NCR_FORMAT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_NCR_FORMAT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NCR_FORMAT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NCR_FORMAT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OVERRIDE_NO_UPDATE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OVERRIDE_NO_UPDATE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OVERRIDE_NO_UPDATE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OVERRIDE_NO_UPDATE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OVERRIDE_CLIENT_UPDATE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OVERRIDE_CLIENT_UPDATE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OVERRIDE_CLIENT_UPDATE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OVERRIDE_CLIENT_UPDATE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_REPLACE_CLIENT_NAME (YY_COPY (location_type) l)
+  Dhcp6Parser::make_REPLACE_CLIENT_NAME (const location_type& l)
   {
-    return symbol_type (token::TOKEN_REPLACE_CLIENT_NAME, YY_MOVE (l));
+    return symbol_type (token::TOKEN_REPLACE_CLIENT_NAME, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_GENERATED_PREFIX (YY_COPY (location_type) l)
+  Dhcp6Parser::make_GENERATED_PREFIX (const location_type& l)
   {
-    return symbol_type (token::TOKEN_GENERATED_PREFIX, YY_MOVE (l));
+    return symbol_type (token::TOKEN_GENERATED_PREFIX, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_UDP (YY_COPY (location_type) l)
+  Dhcp6Parser::make_UDP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_UDP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_UDP, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TCP (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TCP (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TCP, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TCP, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_JSON (YY_COPY (location_type) l)
+  Dhcp6Parser::make_JSON (const location_type& l)
   {
-    return symbol_type (token::TOKEN_JSON, YY_MOVE (l));
+    return symbol_type (token::TOKEN_JSON, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_WHEN_PRESENT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_WHEN_PRESENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_WHEN_PRESENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_WHEN_PRESENT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_NEVER (YY_COPY (location_type) l)
+  Dhcp6Parser::make_NEVER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_NEVER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_NEVER, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_ALWAYS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_ALWAYS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_ALWAYS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_ALWAYS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_WHEN_NOT_PRESENT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_WHEN_NOT_PRESENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOSTNAME_CHAR_SET (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOSTNAME_CHAR_SET (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_HOSTNAME_CHAR_REPLACEMENT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_HOSTNAME_CHAR_REPLACEMENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LOGGING (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LOGGING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LOGGING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LOGGING, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_LOGGERS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_LOGGERS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_LOGGERS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_LOGGERS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OUTPUT_OPTIONS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OUTPUT_OPTIONS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUTPUT_OPTIONS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUTPUT_OPTIONS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_OUTPUT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_OUTPUT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_OUTPUT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_OUTPUT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DEBUGLEVEL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DEBUGLEVEL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DEBUGLEVEL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DEBUGLEVEL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SEVERITY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SEVERITY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SEVERITY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SEVERITY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_FLUSH (YY_COPY (location_type) l)
+  Dhcp6Parser::make_FLUSH (const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLUSH, YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLUSH, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAXSIZE (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAXSIZE (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAXSIZE, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAXSIZE, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_MAXVER (YY_COPY (location_type) l)
+  Dhcp6Parser::make_MAXVER (const location_type& l)
   {
-    return symbol_type (token::TOKEN_MAXVER, YY_MOVE (l));
+    return symbol_type (token::TOKEN_MAXVER, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DHCP4 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DHCP4 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCP4, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCP4, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_DHCPDDNS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_DHCPDDNS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_DHCPDDNS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_DHCPDDNS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_CONTROL_AGENT (YY_COPY (location_type) l)
+  Dhcp6Parser::make_CONTROL_AGENT (const location_type& l)
   {
-    return symbol_type (token::TOKEN_CONTROL_AGENT, YY_MOVE (l));
+    return symbol_type (token::TOKEN_CONTROL_AGENT, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TOPLEVEL_JSON (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TOPLEVEL_JSON (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TOPLEVEL_JSON, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TOPLEVEL_JSON, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_TOPLEVEL_DHCP6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_TOPLEVEL_DHCP6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_TOPLEVEL_DHCP6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_TOPLEVEL_DHCP6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_DHCP6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_DHCP6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_DHCP6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_DHCP6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_INTERFACES6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_INTERFACES6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_INTERFACES6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_INTERFACES6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_SUBNET6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_SUBNET6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_SUBNET6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_SUBNET6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_POOL6 (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_POOL6 (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_POOL6, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_POOL6, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_PD_POOL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_PD_POOL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_PD_POOL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_PD_POOL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_RESERVATION (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_RESERVATION (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_RESERVATION, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_RESERVATION, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_OPTION_DEFS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_OPTION_DEFS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_OPTION_DEFS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_OPTION_DEFS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_OPTION_DEF (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_OPTION_DEF (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_OPTION_DEF, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_OPTION_DEF, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_OPTION_DATA (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_OPTION_DATA (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_OPTION_DATA, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_OPTION_DATA, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_HOOKS_LIBRARY (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_HOOKS_LIBRARY (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_DHCP_DDNS (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_DHCP_DDNS (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_DHCP_DDNS, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_DHCP_DDNS, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_LOGGING (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_LOGGING (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_LOGGING, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_LOGGING, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_SUB_CONFIG_CONTROL (YY_COPY (location_type) l)
+  Dhcp6Parser::make_SUB_CONFIG_CONTROL (const location_type& l)
   {
-    return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, YY_MOVE (l));
+    return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_STRING (YY_COPY (std::string) v, YY_COPY (location_type) l)
+  Dhcp6Parser::make_STRING (const std::string& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_STRING, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_STRING, v, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_INTEGER (YY_COPY (int64_t) v, YY_COPY (location_type) l)
+  Dhcp6Parser::make_INTEGER (const int64_t& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_INTEGER, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_INTEGER, v, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_FLOAT (YY_COPY (double) v, YY_COPY (location_type) l)
+  Dhcp6Parser::make_FLOAT (const double& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_FLOAT, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_FLOAT, v, l);
   }
 
-  inline
   Dhcp6Parser::symbol_type
-  Dhcp6Parser::make_BOOLEAN (YY_COPY (bool) v, YY_COPY (location_type) l)
+  Dhcp6Parser::make_BOOLEAN (const bool& v, const location_type& l)
   {
-    return symbol_type (token::TOKEN_BOOLEAN, YY_MOVE (v), YY_MOVE (l));
+    return symbol_type (token::TOKEN_BOOLEAN, v, l);
   }
 
 
-#line 14 "dhcp6_parser.yy" // lalr1.cc:404
+#line 14 "dhcp6_parser.yy" // lalr1.cc:377
 } } // isc::dhcp
-#line 3277 "dhcp6_parser.h" // lalr1.cc:404
+#line 2960 "dhcp6_parser.h" // lalr1.cc:377
 
 
 
diff --git a/src/bin/dhcp6/location.hh b/src/bin/dhcp6/location.hh
index 4c68d17ec7..239704683c 100644
--- a/src/bin/dhcp6/location.hh
+++ b/src/bin/dhcp6/location.hh
@@ -1,9 +1,8 @@
-// Generated 201811201411
-// A Bison parser, made by GNU Bison 3.2.1.
+// A Bison parser, made by GNU Bison 3.0.4.
 
 // Locations for Bison parsers in C++
 
-// Copyright (C) 2002-2015, 2018 Free Software Foundation, Inc.
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -39,145 +38,12 @@
 #ifndef YY_PARSER6_LOCATION_HH_INCLUDED
 # define YY_PARSER6_LOCATION_HH_INCLUDED
 
-# include <algorithm> // std::max
-# include <iostream>
-# include <string>
+# include "position.hh"
 
-# ifndef YY_NULLPTR
-#  if defined __cplusplus
-#   if 201103L <= __cplusplus
-#    define YY_NULLPTR nullptr
-#   else
-#    define YY_NULLPTR 0
-#   endif
-#  else
-#   define YY_NULLPTR ((void*)0)
-#  endif
-# endif
-
-#line 14 "dhcp6_parser.yy" // location.cc:339
+#line 14 "dhcp6_parser.yy" // location.cc:296
 namespace isc { namespace dhcp {
-#line 60 "location.hh" // location.cc:339
-  /// A point in a source file.
-  class position
-  {
-  public:
-    /// Construct a position.
-    explicit position (std::string* f = YY_NULLPTR,
-                       unsigned l = 1u,
-                       unsigned c = 1u)
-      : filename (f)
-      , line (l)
-      , column (c)
-    {}
-
-
-    /// Initialization.
-    void initialize (std::string* fn = YY_NULLPTR,
-                     unsigned l = 1u,
-                     unsigned c = 1u)
-    {
-      filename = fn;
-      line = l;
-      column = c;
-    }
-
-    /** \name Line and Column related manipulators
-     ** \{ */
-    /// (line related) Advance to the COUNT next lines.
-    void lines (int count = 1)
-    {
-      if (count)
-        {
-          column = 1u;
-          line = add_ (line, count, 1);
-        }
-    }
-
-    /// (column related) Advance to the COUNT next columns.
-    void columns (int count = 1)
-    {
-      column = add_ (column, count, 1);
-    }
-    /** \} */
-
-    /// File name to which this position refers.
-    std::string* filename;
-    /// Current line number.
-    unsigned line;
-    /// Current column number.
-    unsigned column;
-
-  private:
-    /// Compute max (min, lhs+rhs).
-    static unsigned add_ (unsigned lhs, int rhs, int min)
-    {
-      return static_cast<unsigned> (std::max (min,
-                                              static_cast<int> (lhs) + rhs));
-    }
-  };
-
-  /// Add \a width columns, in place.
-  inline position&
-  operator+= (position& res, int width)
-  {
-    res.columns (width);
-    return res;
-  }
-
-  /// Add \a width columns.
-  inline position
-  operator+ (position res, int width)
-  {
-    return res += width;
-  }
-
-  /// Subtract \a width columns, in place.
-  inline position&
-  operator-= (position& res, int width)
-  {
-    return res += -width;
-  }
-
-  /// Subtract \a width columns.
-  inline position
-  operator- (position res, int width)
-  {
-    return res -= width;
-  }
-
-  /// Compare two position objects.
-  inline bool
-  operator== (const position& pos1, const position& pos2)
-  {
-    return (pos1.line == pos2.line
-            && pos1.column == pos2.column
-            && (pos1.filename == pos2.filename
-                || (pos1.filename && pos2.filename
-                    && *pos1.filename == *pos2.filename)));
-  }
-
-  /// Compare two position objects.
-  inline bool
-  operator!= (const position& pos1, const position& pos2)
-  {
-    return !(pos1 == pos2);
-  }
-
-  /** \brief Intercept output stream redirection.
-   ** \param ostr the destination output stream
-   ** \param pos a reference to the position to redirect
-   */
-  template <typename YYChar>
-  std::basic_ostream<YYChar>&
-  operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
-  {
-    if (pos.filename)
-      ostr << *pos.filename << ':';
-    return ostr << pos.line << '.' << pos.column;
-  }
-
-  /// Two points in a source file.
+#line 46 "location.hh" // location.cc:296
+  /// Abstract a location.
   class location
   {
   public:
@@ -186,27 +52,30 @@ namespace isc { namespace dhcp {
     location (const position& b, const position& e)
       : begin (b)
       , end (e)
-    {}
+    {
+    }
 
     /// Construct a 0-width location in \a p.
     explicit location (const position& p = position ())
       : begin (p)
       , end (p)
-    {}
+    {
+    }
 
     /// Construct a 0-width location in \a f, \a l, \a c.
     explicit location (std::string* f,
-                       unsigned l = 1u,
-                       unsigned c = 1u)
+                       unsigned int l = 1u,
+                       unsigned int c = 1u)
       : begin (f, l, c)
       , end (f, l, c)
-    {}
+    {
+    }
 
 
     /// Initialization.
     void initialize (std::string* f = YY_NULLPTR,
-                     unsigned l = 1u,
-                     unsigned c = 1u)
+                     unsigned int l = 1u,
+                     unsigned int c = 1u)
     {
       begin.initialize (f, l, c);
       end = begin;
@@ -301,10 +170,10 @@ namespace isc { namespace dhcp {
    ** Avoid duplicate information.
    */
   template <typename YYChar>
-  std::basic_ostream<YYChar>&
+  inline std::basic_ostream<YYChar>&
   operator<< (std::basic_ostream<YYChar>& ostr, const location& loc)
   {
-    unsigned end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
+    unsigned int end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
     ostr << loc.begin;
     if (loc.end.filename
         && (!loc.begin.filename
@@ -317,7 +186,7 @@ namespace isc { namespace dhcp {
     return ostr;
   }
 
-#line 14 "dhcp6_parser.yy" // location.cc:339
+#line 14 "dhcp6_parser.yy" // location.cc:296
 } } // isc::dhcp
-#line 322 "location.hh" // location.cc:339
+#line 192 "location.hh" // location.cc:296
 #endif // !YY_PARSER6_LOCATION_HH_INCLUDED
diff --git a/src/bin/dhcp6/position.hh b/src/bin/dhcp6/position.hh
index 4a9a456ce0..2ee80e6d0a 100644
--- a/src/bin/dhcp6/position.hh
+++ b/src/bin/dhcp6/position.hh
@@ -1,12 +1,180 @@
-// Generated 201811201411
-// A Bison parser, made by GNU Bison 3.2.1.
-
-// Starting with Bison 3.2, this file is useless: the structure it
-// used to define is now defined in "location.hh".
-//
-// To get rid of this file:
-// 1. add 'require "3.2"' (or newer) to your grammar file
-// 2. remove references to this file from your build system
-// 3. if you used to include it, include "location.hh" instead.
-
-#include "location.hh"
+// A Bison parser, made by GNU Bison 3.0.4.
+
+// Positions for Bison parsers in C++
+
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file position.hh
+ ** Define the isc::dhcp::position class.
+ */
+
+#ifndef YY_PARSER6_POSITION_HH_INCLUDED
+# define YY_PARSER6_POSITION_HH_INCLUDED
+
+# include <algorithm> // std::max
+# include <iostream>
+# include <string>
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+#line 14 "dhcp6_parser.yy" // location.cc:296
+namespace isc { namespace dhcp {
+#line 56 "position.hh" // location.cc:296
+  /// Abstract a position.
+  class position
+  {
+  public:
+    /// Construct a position.
+    explicit position (std::string* f = YY_NULLPTR,
+                       unsigned int l = 1u,
+                       unsigned int c = 1u)
+      : filename (f)
+      , line (l)
+      , column (c)
+    {
+    }
+
+
+    /// Initialization.
+    void initialize (std::string* fn = YY_NULLPTR,
+                     unsigned int l = 1u,
+                     unsigned int c = 1u)
+    {
+      filename = fn;
+      line = l;
+      column = c;
+    }
+
+    /** \name Line and Column related manipulators
+     ** \{ */
+    /// (line related) Advance to the COUNT next lines.
+    void lines (int count = 1)
+    {
+      if (count)
+        {
+          column = 1u;
+          line = add_ (line, count, 1);
+        }
+    }
+
+    /// (column related) Advance to the COUNT next columns.
+    void columns (int count = 1)
+    {
+      column = add_ (column, count, 1);
+    }
+    /** \} */
+
+    /// File name to which this position refers.
+    std::string* filename;
+    /// Current line number.
+    unsigned int line;
+    /// Current column number.
+    unsigned int column;
+
+  private:
+    /// Compute max(min, lhs+rhs) (provided min <= lhs).
+    static unsigned int add_ (unsigned int lhs, int rhs, unsigned int min)
+    {
+      return (0 < rhs || -static_cast<unsigned int>(rhs) < lhs
+              ? rhs + lhs
+              : min);
+    }
+  };
+
+  /// Add \a width columns, in place.
+  inline position&
+  operator+= (position& res, int width)
+  {
+    res.columns (width);
+    return res;
+  }
+
+  /// Add \a width columns.
+  inline position
+  operator+ (position res, int width)
+  {
+    return res += width;
+  }
+
+  /// Subtract \a width columns, in place.
+  inline position&
+  operator-= (position& res, int width)
+  {
+    return res += -width;
+  }
+
+  /// Subtract \a width columns.
+  inline position
+  operator- (position res, int width)
+  {
+    return res -= width;
+  }
+
+  /// Compare two position objects.
+  inline bool
+  operator== (const position& pos1, const position& pos2)
+  {
+    return (pos1.line == pos2.line
+            && pos1.column == pos2.column
+            && (pos1.filename == pos2.filename
+                || (pos1.filename && pos2.filename
+                    && *pos1.filename == *pos2.filename)));
+  }
+
+  /// Compare two position objects.
+  inline bool
+  operator!= (const position& pos1, const position& pos2)
+  {
+    return !(pos1 == pos2);
+  }
+
+  /** \brief Intercept output stream redirection.
+   ** \param ostr the destination output stream
+   ** \param pos a reference to the position to redirect
+   */
+  template <typename YYChar>
+  inline std::basic_ostream<YYChar>&
+  operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
+  {
+    if (pos.filename)
+      ostr << *pos.filename << ':';
+    return ostr << pos.line << '.' << pos.column;
+  }
+
+#line 14 "dhcp6_parser.yy" // location.cc:296
+} } // isc::dhcp
+#line 180 "position.hh" // location.cc:296
+#endif // !YY_PARSER6_POSITION_HH_INCLUDED
diff --git a/src/bin/dhcp6/stack.hh b/src/bin/dhcp6/stack.hh
index 8d96cdf2b7..db2863a06e 100644
--- a/src/bin/dhcp6/stack.hh
+++ b/src/bin/dhcp6/stack.hh
@@ -1,9 +1,157 @@
-// Generated 201811201411
-// A Bison parser, made by GNU Bison 3.2.1.
-
-// Starting with Bison 3.2, this file is useless: the structure it
-// used to define is now defined with the parser itself.
-//
-// To get rid of this file:
-// 1. add 'require "3.2"' (or newer) to your grammar file
-// 2. remove references to this file from your build system.
+// A Bison parser, made by GNU Bison 3.0.4.
+
+// Stack handling for Bison parsers in C++
+
+// Copyright (C) 2002-2015 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+/**
+ ** \file stack.hh
+ ** Define the isc::dhcp::stack class.
+ */
+
+#ifndef YY_PARSER6_STACK_HH_INCLUDED
+# define YY_PARSER6_STACK_HH_INCLUDED
+
+# include <vector>
+
+#line 14 "dhcp6_parser.yy" // stack.hh:132
+namespace isc { namespace dhcp {
+#line 46 "stack.hh" // stack.hh:132
+  template <class T, class S = std::vector<T> >
+  class stack
+  {
+  public:
+    // Hide our reversed order.
+    typedef typename S::reverse_iterator iterator;
+    typedef typename S::const_reverse_iterator const_iterator;
+
+    stack ()
+      : seq_ ()
+    {
+      seq_.reserve (200);
+    }
+
+    stack (unsigned int n)
+      : seq_ (n)
+    {}
+
+    inline
+    T&
+    operator[] (unsigned int i)
+    {
+      return seq_[seq_.size () - 1 - i];
+    }
+
+    inline
+    const T&
+    operator[] (unsigned int i) const
+    {
+      return seq_[seq_.size () - 1 - i];
+    }
+
+    /// Steal the contents of \a t.
+    ///
+    /// Close to move-semantics.
+    inline
+    void
+    push (T& t)
+    {
+      seq_.push_back (T());
+      operator[](0).move (t);
+    }
+
+    inline
+    void
+    pop (unsigned int n = 1)
+    {
+      for (; n; --n)
+        seq_.pop_back ();
+    }
+
+    void
+    clear ()
+    {
+      seq_.clear ();
+    }
+
+    inline
+    typename S::size_type
+    size () const
+    {
+      return seq_.size ();
+    }
+
+    inline
+    const_iterator
+    begin () const
+    {
+      return seq_.rbegin ();
+    }
+
+    inline
+    const_iterator
+    end () const
+    {
+      return seq_.rend ();
+    }
+
+  private:
+    stack (const stack&);
+    stack& operator= (const stack&);
+    /// The wrapped container.
+    S seq_;
+  };
+
+  /// Present a slice of the top of a stack.
+  template <class T, class S = stack<T> >
+  class slice
+  {
+  public:
+    slice (const S& stack, unsigned int range)
+      : stack_ (stack)
+      , range_ (range)
+    {}
+
+    inline
+    const T&
+    operator [] (unsigned int i) const
+    {
+      return stack_[range_ - i];
+    }
+
+  private:
+    const S& stack_;
+    unsigned int range_;
+  };
+
+#line 14 "dhcp6_parser.yy" // stack.hh:132
+} } // isc::dhcp
+#line 156 "stack.hh" // stack.hh:132
+
+#endif // !YY_PARSER6_STACK_HH_INCLUDED