From: Andrei Pavel Date: Mon, 29 Mar 2021 18:53:47 +0000 (+0300) Subject: [#1772] regenerate parsers X-Git-Tag: Kea-1.9.6~6 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=1f533cdec278ece9243c9c81864f2dee9c30e6a1;p=thirdparty%2Fkea.git [#1772] regenerate parsers --- diff --git a/src/bin/dhcp4/dhcp4_lexer.cc b/src/bin/dhcp4/dhcp4_lexer.cc index 0c102164cd..00a47fa265 100644 --- a/src/bin/dhcp4/dhcp4_lexer.cc +++ b/src/bin/dhcp4/dhcp4_lexer.cc @@ -1,6 +1,6 @@ -#line 2 "dhcp4_lexer.cc" +#line 1 "dhcp4_lexer.cc" -#line 4 "dhcp4_lexer.cc" +#line 3 "dhcp4_lexer.cc" #define YY_INT_ALIGNED short int @@ -2027,7 +2027,7 @@ using namespace isc::dhcp; /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::dhcp::Parser4Context::fatal(msg) -#line 2031 "dhcp4_lexer.cc" +#line 2030 "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 @@ -2053,8 +2053,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 2056 "dhcp4_lexer.cc" #line 2057 "dhcp4_lexer.cc" -#line 2058 "dhcp4_lexer.cc" #define INITIAL 0 #define COMMENT 1 @@ -2382,7 +2382,7 @@ YY_DECL } -#line 2386 "dhcp4_lexer.cc" +#line 2385 "dhcp4_lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -5207,7 +5207,7 @@ YY_RULE_SETUP #line 2245 "dhcp4_lexer.ll" ECHO; YY_BREAK -#line 5211 "dhcp4_lexer.cc" +#line 5210 "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 3ed06eaf23..e154362294 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.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Skeleton implementation for Bison LALR(1) parsers in C++ -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. +// Copyright (C) 2002-2015, 2018-2021 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,8 +30,9 @@ // 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. +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. // Take the name prefix into account. @@ -47,7 +48,7 @@ #include -#line 51 "dhcp4_parser.cc" +#line 52 "dhcp4_parser.cc" #ifndef YY_ @@ -62,6 +63,7 @@ # endif #endif + // Whether we are compiled with exception support. #ifndef YY_EXCEPTIONS # if defined __GNUC__ && !defined __EXCEPTIONS @@ -117,13 +119,13 @@ # define YY_STACK_PRINT() \ do { \ if (yydebug_) \ - yystack_print_ (); \ + yy_stack_print_ (); \ } while (false) #else // !PARSER4_DEBUG # define YYCDEBUG if (false) std::cerr -# define YY_SYMBOL_PRINT(Title, Symbol) YYUSE (Symbol) +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) # define YY_REDUCE_PRINT(Rule) static_cast (0) # define YY_STACK_PRINT() static_cast (0) @@ -139,49 +141,7 @@ #line 14 "dhcp4_parser.yy" namespace isc { namespace dhcp { -#line 143 "dhcp4_parser.cc" - - - /* Return YYSTR after stripping away unnecessary quotes and - backslashes, so that it's suitable for yyerror. The heuristic is - that double-quoting is unnecessary unless the string contains an - apostrophe, a comma, or backslash (other than backslash-backslash). - YYSTR is taken from yytname. */ - std::string - Dhcp4Parser::yytnamerr_ (const char *yystr) - { - if (*yystr == '"') - { - std::string yyr; - char const *yyp = yystr; - - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - else - goto append; - - append: - default: - yyr += *yyp; - break; - - case '"': - return yyr; - } - do_not_strip_quotes: ; - } - - return yystr; - } - +#line 145 "dhcp4_parser.cc" /// Build a parser object. Dhcp4Parser::Dhcp4Parser (isc::dhcp::Parser4Context& ctx_yyarg) @@ -201,7 +161,7 @@ namespace isc { namespace dhcp { {} /*---------------. - | Symbol types. | + | symbol kinds. | `---------------*/ @@ -232,13 +192,13 @@ namespace isc { namespace dhcp { : state (s) {} - Dhcp4Parser::symbol_number_type - Dhcp4Parser::by_state::type_get () const YY_NOEXCEPT + Dhcp4Parser::symbol_kind_type + Dhcp4Parser::by_state::kind () const YY_NOEXCEPT { if (state == empty_state) - return empty_symbol; + return symbol_kind::S_YYEMPTY; else - return yystos_[+state]; + return YY_CAST (symbol_kind_type, yystos_[+state]); } Dhcp4Parser::stack_symbol_type::stack_symbol_type () @@ -247,33 +207,33 @@ namespace isc { namespace dhcp { 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 ()) + switch (that.kind ()) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value)); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value)); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value)); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value)); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); break; @@ -290,33 +250,33 @@ namespace isc { namespace dhcp { Dhcp4Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) : super_type (s, YY_MOVE (that.location)) { - switch (that.type_get ()) + switch (that.kind ()) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.move< ElementPtr > (YY_MOVE (that.value)); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.move< bool > (YY_MOVE (that.value)); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.move< double > (YY_MOVE (that.value)); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.move< int64_t > (YY_MOVE (that.value)); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.move< std::string > (YY_MOVE (that.value)); break; @@ -325,7 +285,7 @@ namespace isc { namespace dhcp { } // that is emptied. - that.type = empty_symbol; + that.kind_ = symbol_kind::S_YYEMPTY; } #if YY_CPLUSPLUS < 201103L @@ -333,33 +293,33 @@ namespace isc { namespace dhcp { Dhcp4Parser::stack_symbol_type::operator= (const stack_symbol_type& that) { state = that.state; - switch (that.type_get ()) + switch (that.kind ()) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.copy< ElementPtr > (that.value); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.copy< bool > (that.value); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.copy< double > (that.value); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.copy< int64_t > (that.value); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.copy< std::string > (that.value); break; @@ -375,33 +335,33 @@ namespace isc { namespace dhcp { Dhcp4Parser::stack_symbol_type::operator= (stack_symbol_type& that) { state = that.state; - switch (that.type_get ()) + switch (that.kind ()) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.move< ElementPtr > (that.value); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.move< bool > (that.value); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.move< double > (that.value); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.move< int64_t > (that.value); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.move< std::string > (that.value); break; @@ -427,105 +387,103 @@ namespace isc { namespace dhcp { #if PARSER4_DEBUG template void - Dhcp4Parser::yy_print_ (std::ostream& yyo, - const basic_symbol& yysym) const + Dhcp4Parser::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const { std::ostream& yyoutput = yyo; - YYUSE (yyoutput); - symbol_number_type yytype = yysym.type_get (); -#if defined __GNUC__ && ! defined __clang__ && ! defined __ICC && __GNUC__ * 100 + __GNUC_MINOR__ <= 408 - // Avoid a (spurious) G++ 4.8 warning about "array subscript is - // below array bounds". + YY_USE (yyoutput); if (yysym.empty ()) - std::abort (); -#endif - yyo << (yytype < yyntokens_ ? "token" : "nterm") - << ' ' << yytname_[yytype] << " (" - << yysym.location << ": "; - switch (yytype) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " (" + << yysym.location << ": "; + switch (yykind) { - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < std::string > (); } -#line 451 "dhcp4_parser.cc" +#line 408 "dhcp4_parser.cc" break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < int64_t > (); } -#line 457 "dhcp4_parser.cc" +#line 414 "dhcp4_parser.cc" break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < double > (); } -#line 463 "dhcp4_parser.cc" +#line 420 "dhcp4_parser.cc" break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < bool > (); } -#line 469 "dhcp4_parser.cc" +#line 426 "dhcp4_parser.cc" break; - case 217: // value + case symbol_kind::S_value: // value #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 475 "dhcp4_parser.cc" +#line 432 "dhcp4_parser.cc" break; - case 221: // map_value + case symbol_kind::S_map_value: // map_value #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 481 "dhcp4_parser.cc" +#line 438 "dhcp4_parser.cc" break; - case 262: // ddns_replace_client_name_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 487 "dhcp4_parser.cc" +#line 444 "dhcp4_parser.cc" break; - case 287: // socket_type + case symbol_kind::S_socket_type: // socket_type #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 493 "dhcp4_parser.cc" +#line 450 "dhcp4_parser.cc" break; - case 290: // outbound_interface_value + case symbol_kind::S_outbound_interface_value: // outbound_interface_value #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 499 "dhcp4_parser.cc" +#line 456 "dhcp4_parser.cc" break; - case 312: // db_type + case symbol_kind::S_db_type: // db_type #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 505 "dhcp4_parser.cc" +#line 462 "dhcp4_parser.cc" break; - case 341: // on_fail_mode + case symbol_kind::S_on_fail_mode: // on_fail_mode #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 511 "dhcp4_parser.cc" +#line 468 "dhcp4_parser.cc" break; - case 412: // hr_mode + case symbol_kind::S_hr_mode: // hr_mode #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 517 "dhcp4_parser.cc" +#line 474 "dhcp4_parser.cc" break; - case 567: // ncr_protocol_value + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value #line 281 "dhcp4_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 523 "dhcp4_parser.cc" +#line 480 "dhcp4_parser.cc" break; default: break; } - yyo << ')'; + yyo << ')'; + } } #endif @@ -584,11 +542,11 @@ namespace isc { namespace dhcp { Dhcp4Parser::state_type Dhcp4Parser::yy_lr_goto_state_ (state_type yystate, int yysym) { - int yyr = yypgoto_[yysym - yyntokens_] + yystate; + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) return yytable_[yyr]; else - return yydefgoto_[yysym - yyntokens_]; + return yydefgoto_[yysym - YYNTOKENS]; } bool @@ -648,6 +606,7 @@ namespace isc { namespace dhcp { `-----------------------------------------------*/ yynewstate: YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); // Accept? if (yystack_[0].state == yyfinal_) @@ -668,7 +627,7 @@ namespace isc { namespace dhcp { // Read a lookahead token. if (yyla.empty ()) { - YYCDEBUG << "Reading a token: "; + YYCDEBUG << "Reading a token\n"; #if YY_EXCEPTIONS try #endif // YY_EXCEPTIONS @@ -687,10 +646,20 @@ namespace isc { namespace dhcp { } YY_SYMBOL_PRINT ("Next token is", yyla); + if (yyla.kind () == symbol_kind::S_YYerror) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = symbol_kind::S_YYUNDEF; + goto yyerrlab1; + } + /* If the proper action on seeing token YYLA.TYPE is to reduce or to detect an error, take that action. */ - yyn += yyla.type_get (); - if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ()) + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) { goto yydefault; } @@ -737,31 +706,31 @@ namespace isc { namespace dhcp { when using variants. */ switch (yyr1_[yyn]) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value yylhs.value.emplace< ElementPtr > (); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" yylhs.value.emplace< bool > (); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" yylhs.value.emplace< double > (); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" yylhs.value.emplace< int64_t > (); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" yylhs.value.emplace< std::string > (); break; @@ -785,136 +754,136 @@ namespace isc { namespace dhcp { { switch (yyn) { - case 2: + case 2: // $@1: %empty #line 290 "dhcp4_parser.yy" { ctx.ctx_ = ctx.NO_KEYWORD; } -#line 792 "dhcp4_parser.cc" +#line 761 "dhcp4_parser.cc" break; - case 4: + case 4: // $@2: %empty #line 291 "dhcp4_parser.yy" { ctx.ctx_ = ctx.CONFIG; } -#line 798 "dhcp4_parser.cc" +#line 767 "dhcp4_parser.cc" break; - case 6: + case 6: // $@3: %empty #line 292 "dhcp4_parser.yy" { ctx.ctx_ = ctx.DHCP4; } -#line 804 "dhcp4_parser.cc" +#line 773 "dhcp4_parser.cc" break; - case 8: + case 8: // $@4: %empty #line 293 "dhcp4_parser.yy" { ctx.ctx_ = ctx.INTERFACES_CONFIG; } -#line 810 "dhcp4_parser.cc" +#line 779 "dhcp4_parser.cc" break; - case 10: + case 10: // $@5: %empty #line 294 "dhcp4_parser.yy" { ctx.ctx_ = ctx.SUBNET4; } -#line 816 "dhcp4_parser.cc" +#line 785 "dhcp4_parser.cc" break; - case 12: + case 12: // $@6: %empty #line 295 "dhcp4_parser.yy" { ctx.ctx_ = ctx.POOLS; } -#line 822 "dhcp4_parser.cc" +#line 791 "dhcp4_parser.cc" break; - case 14: + case 14: // $@7: %empty #line 296 "dhcp4_parser.yy" { ctx.ctx_ = ctx.RESERVATIONS; } -#line 828 "dhcp4_parser.cc" +#line 797 "dhcp4_parser.cc" break; - case 16: + case 16: // $@8: %empty #line 297 "dhcp4_parser.yy" { ctx.ctx_ = ctx.DHCP4; } -#line 834 "dhcp4_parser.cc" +#line 803 "dhcp4_parser.cc" break; - case 18: + case 18: // $@9: %empty #line 298 "dhcp4_parser.yy" { ctx.ctx_ = ctx.OPTION_DEF; } -#line 840 "dhcp4_parser.cc" +#line 809 "dhcp4_parser.cc" break; - case 20: + case 20: // $@10: %empty #line 299 "dhcp4_parser.yy" { ctx.ctx_ = ctx.OPTION_DATA; } -#line 846 "dhcp4_parser.cc" +#line 815 "dhcp4_parser.cc" break; - case 22: + case 22: // $@11: %empty #line 300 "dhcp4_parser.yy" { ctx.ctx_ = ctx.HOOKS_LIBRARIES; } -#line 852 "dhcp4_parser.cc" +#line 821 "dhcp4_parser.cc" break; - case 24: + case 24: // $@12: %empty #line 301 "dhcp4_parser.yy" { ctx.ctx_ = ctx.DHCP_DDNS; } -#line 858 "dhcp4_parser.cc" +#line 827 "dhcp4_parser.cc" break; - case 26: + case 26: // $@13: %empty #line 302 "dhcp4_parser.yy" { ctx.ctx_ = ctx.CONFIG_CONTROL; } -#line 864 "dhcp4_parser.cc" +#line 833 "dhcp4_parser.cc" break; - case 28: + case 28: // value: "integer" #line 310 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); } -#line 870 "dhcp4_parser.cc" +#line 839 "dhcp4_parser.cc" break; - case 29: + case 29: // value: "floating point" #line 311 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); } -#line 876 "dhcp4_parser.cc" +#line 845 "dhcp4_parser.cc" break; - case 30: + case 30: // value: "boolean" #line 312 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); } -#line 882 "dhcp4_parser.cc" +#line 851 "dhcp4_parser.cc" break; - case 31: + case 31: // value: "constant string" #line 313 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); } -#line 888 "dhcp4_parser.cc" +#line 857 "dhcp4_parser.cc" break; - case 32: + case 32: // value: "null" #line 314 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); } -#line 894 "dhcp4_parser.cc" +#line 863 "dhcp4_parser.cc" break; - case 33: + case 33: // value: map2 #line 315 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); } -#line 900 "dhcp4_parser.cc" +#line 869 "dhcp4_parser.cc" break; - case 34: + case 34: // value: list_generic #line 316 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); } -#line 906 "dhcp4_parser.cc" +#line 875 "dhcp4_parser.cc" break; - case 35: + case 35: // sub_json: value #line 319 "dhcp4_parser.yy" { // Push back the JSON value on the stack ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ()); } -#line 915 "dhcp4_parser.cc" +#line 884 "dhcp4_parser.cc" break; - case 36: + case 36: // $@14: %empty #line 324 "dhcp4_parser.yy" { // This code is executed when we're about to start parsing @@ -922,36 +891,36 @@ namespace isc { namespace dhcp { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 926 "dhcp4_parser.cc" +#line 895 "dhcp4_parser.cc" break; - case 37: + case 37: // map2: "{" $@14 map_content "}" #line 329 "dhcp4_parser.yy" { // 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 936 "dhcp4_parser.cc" +#line 905 "dhcp4_parser.cc" break; - case 38: + case 38: // map_value: map2 #line 335 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); } -#line 942 "dhcp4_parser.cc" +#line 911 "dhcp4_parser.cc" break; - case 41: + case 41: // not_empty_map: "constant string" ":" value #line 342 "dhcp4_parser.yy" { // map containing a single entry ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location)); ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ()); } -#line 952 "dhcp4_parser.cc" +#line 921 "dhcp4_parser.cc" break; - case 42: + case 42: // not_empty_map: not_empty_map "," "constant string" ":" value #line 347 "dhcp4_parser.yy" { // map consisting of a shorter map followed by @@ -959,80 +928,80 @@ namespace isc { namespace dhcp { ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location)); ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ()); } -#line 963 "dhcp4_parser.cc" +#line 932 "dhcp4_parser.cc" break; - case 43: + case 43: // $@15: %empty #line 355 "dhcp4_parser.yy" { ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(l); } -#line 972 "dhcp4_parser.cc" +#line 941 "dhcp4_parser.cc" break; - case 44: + case 44: // list_generic: "[" $@15 list_content "]" #line 358 "dhcp4_parser.yy" { // list parsing complete. Put any sanity checking here } -#line 980 "dhcp4_parser.cc" +#line 949 "dhcp4_parser.cc" break; - case 47: + case 47: // not_empty_list: value #line 366 "dhcp4_parser.yy" { // List consisting of a single element. ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ()); } -#line 989 "dhcp4_parser.cc" +#line 958 "dhcp4_parser.cc" break; - case 48: + case 48: // not_empty_list: not_empty_list "," value #line 370 "dhcp4_parser.yy" { // List ending with , and a value. ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ()); } -#line 998 "dhcp4_parser.cc" +#line 967 "dhcp4_parser.cc" break; - case 49: + case 49: // $@16: %empty #line 377 "dhcp4_parser.yy" { // List parsing about to start } -#line 1006 "dhcp4_parser.cc" +#line 975 "dhcp4_parser.cc" break; - case 50: + case 50: // list_strings: "[" $@16 list_strings_content "]" #line 379 "dhcp4_parser.yy" { // list parsing complete. Put any sanity checking here //ctx.stack_.pop_back(); } -#line 1015 "dhcp4_parser.cc" +#line 984 "dhcp4_parser.cc" break; - case 53: + case 53: // not_empty_list_strings: "constant string" #line 388 "dhcp4_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(s); } -#line 1024 "dhcp4_parser.cc" +#line 993 "dhcp4_parser.cc" break; - case 54: + case 54: // not_empty_list_strings: not_empty_list_strings "," "constant string" #line 392 "dhcp4_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(s); } -#line 1033 "dhcp4_parser.cc" +#line 1002 "dhcp4_parser.cc" break; - case 55: + case 55: // unknown_map_entry: "constant string" ":" #line 403 "dhcp4_parser.yy" { const std::string& where = ctx.contextName(); @@ -1040,10 +1009,10 @@ namespace isc { namespace dhcp { error(yystack_[1].location, "got unexpected keyword \"" + keyword + "\" in " + where + " map."); } -#line 1044 "dhcp4_parser.cc" +#line 1013 "dhcp4_parser.cc" break; - case 56: + case 56: // $@17: %empty #line 412 "dhcp4_parser.yy" { // This code is executed when we're about to start parsing @@ -1051,10 +1020,10 @@ namespace isc { namespace dhcp { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 1055 "dhcp4_parser.cc" +#line 1024 "dhcp4_parser.cc" break; - case 57: + case 57: // syntax_map: "{" $@17 global_object "}" #line 417 "dhcp4_parser.yy" { // map parsing completed. If we ever want to do any wrap up @@ -1064,10 +1033,10 @@ namespace isc { namespace dhcp { // Dhcp4 is required ctx.require("Dhcp4", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); } -#line 1068 "dhcp4_parser.cc" +#line 1037 "dhcp4_parser.cc" break; - case 58: + case 58: // $@18: %empty #line 427 "dhcp4_parser.yy" { // This code is executed when we're about to start parsing @@ -1079,423 +1048,423 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.DHCP4); } -#line 1083 "dhcp4_parser.cc" +#line 1052 "dhcp4_parser.cc" break; - case 59: + case 59: // global_object: "Dhcp4" $@18 ":" "{" global_params "}" #line 436 "dhcp4_parser.yy" { // No global parameter is required ctx.stack_.pop_back(); ctx.leave(); } -#line 1093 "dhcp4_parser.cc" +#line 1062 "dhcp4_parser.cc" break; - case 60: + case 60: // $@19: %empty #line 444 "dhcp4_parser.yy" { // Parse the Dhcp4 map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 1103 "dhcp4_parser.cc" +#line 1072 "dhcp4_parser.cc" break; - case 61: + case 61: // sub_dhcp4: "{" $@19 global_params "}" #line 448 "dhcp4_parser.yy" { // No global parameter is required // parsing completed } -#line 1112 "dhcp4_parser.cc" +#line 1081 "dhcp4_parser.cc" break; - case 124: + case 124: // valid_lifetime: "valid-lifetime" ":" "integer" #line 521 "dhcp4_parser.yy" { ctx.unique("valid-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("valid-lifetime", prf); } -#line 1122 "dhcp4_parser.cc" +#line 1091 "dhcp4_parser.cc" break; - case 125: + case 125: // min_valid_lifetime: "min-valid-lifetime" ":" "integer" #line 527 "dhcp4_parser.yy" { ctx.unique("min-valid-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("min-valid-lifetime", prf); } -#line 1132 "dhcp4_parser.cc" +#line 1101 "dhcp4_parser.cc" break; - case 126: + case 126: // max_valid_lifetime: "max-valid-lifetime" ":" "integer" #line 533 "dhcp4_parser.yy" { ctx.unique("max-valid-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-valid-lifetime", prf); } -#line 1142 "dhcp4_parser.cc" +#line 1111 "dhcp4_parser.cc" break; - case 127: + case 127: // renew_timer: "renew-timer" ":" "integer" #line 539 "dhcp4_parser.yy" { ctx.unique("renew-timer", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("renew-timer", prf); } -#line 1152 "dhcp4_parser.cc" +#line 1121 "dhcp4_parser.cc" break; - case 128: + case 128: // rebind_timer: "rebind-timer" ":" "integer" #line 545 "dhcp4_parser.yy" { ctx.unique("rebind-timer", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("rebind-timer", prf); } -#line 1162 "dhcp4_parser.cc" +#line 1131 "dhcp4_parser.cc" break; - case 129: + case 129: // calculate_tee_times: "calculate-tee-times" ":" "boolean" #line 551 "dhcp4_parser.yy" { ctx.unique("calculate-tee-times", ctx.loc2pos(yystack_[2].location)); ElementPtr ctt(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("calculate-tee-times", ctt); } -#line 1172 "dhcp4_parser.cc" +#line 1141 "dhcp4_parser.cc" break; - case 130: + case 130: // t1_percent: "t1-percent" ":" "floating point" #line 557 "dhcp4_parser.yy" { ctx.unique("t1-percent", ctx.loc2pos(yystack_[2].location)); ElementPtr t1(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("t1-percent", t1); } -#line 1182 "dhcp4_parser.cc" +#line 1151 "dhcp4_parser.cc" break; - case 131: + case 131: // t2_percent: "t2-percent" ":" "floating point" #line 563 "dhcp4_parser.yy" { ctx.unique("t2-percent", ctx.loc2pos(yystack_[2].location)); ElementPtr t2(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("t2-percent", t2); } -#line 1192 "dhcp4_parser.cc" +#line 1161 "dhcp4_parser.cc" break; - case 132: + case 132: // cache_threshold: "cache-threshold" ":" "floating point" #line 569 "dhcp4_parser.yy" { ctx.unique("cache-threshold", ctx.loc2pos(yystack_[2].location)); ElementPtr ct(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("cache-threshold", ct); } -#line 1202 "dhcp4_parser.cc" +#line 1171 "dhcp4_parser.cc" break; - case 133: + case 133: // cache_max_age: "cache-max-age" ":" "integer" #line 575 "dhcp4_parser.yy" { ctx.unique("cache-max-age", ctx.loc2pos(yystack_[2].location)); ElementPtr cm(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("cache-max-age", cm); } -#line 1212 "dhcp4_parser.cc" +#line 1181 "dhcp4_parser.cc" break; - case 134: + case 134: // decline_probation_period: "decline-probation-period" ":" "integer" #line 581 "dhcp4_parser.yy" { ctx.unique("decline-probation-period", ctx.loc2pos(yystack_[2].location)); ElementPtr dpp(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("decline-probation-period", dpp); } -#line 1222 "dhcp4_parser.cc" +#line 1191 "dhcp4_parser.cc" break; - case 135: + case 135: // $@20: %empty #line 587 "dhcp4_parser.yy" { ctx.unique("server-tag", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1231 "dhcp4_parser.cc" +#line 1200 "dhcp4_parser.cc" break; - case 136: + case 136: // server_tag: "server-tag" $@20 ":" "constant string" #line 590 "dhcp4_parser.yy" { 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 1241 "dhcp4_parser.cc" +#line 1210 "dhcp4_parser.cc" break; - case 137: + case 137: // echo_client_id: "echo-client-id" ":" "boolean" #line 596 "dhcp4_parser.yy" { ctx.unique("echo-client-id", ctx.loc2pos(yystack_[2].location)); ElementPtr echo(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("echo-client-id", echo); } -#line 1251 "dhcp4_parser.cc" +#line 1220 "dhcp4_parser.cc" break; - case 138: + case 138: // match_client_id: "match-client-id" ":" "boolean" #line 602 "dhcp4_parser.yy" { ctx.unique("match-client-id", ctx.loc2pos(yystack_[2].location)); ElementPtr match(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("match-client-id", match); } -#line 1261 "dhcp4_parser.cc" +#line 1230 "dhcp4_parser.cc" break; - case 139: + case 139: // authoritative: "authoritative" ":" "boolean" #line 608 "dhcp4_parser.yy" { ctx.unique("authoritative", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("authoritative", prf); } -#line 1271 "dhcp4_parser.cc" +#line 1240 "dhcp4_parser.cc" break; - case 140: + case 140: // ddns_send_updates: "ddns-send-updates" ":" "boolean" #line 614 "dhcp4_parser.yy" { ctx.unique("ddns-send-updates", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-send-updates", b); } -#line 1281 "dhcp4_parser.cc" +#line 1250 "dhcp4_parser.cc" break; - case 141: + case 141: // ddns_override_no_update: "ddns-override-no-update" ":" "boolean" #line 620 "dhcp4_parser.yy" { ctx.unique("ddns-override-no-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-override-no-update", b); } -#line 1291 "dhcp4_parser.cc" +#line 1260 "dhcp4_parser.cc" break; - case 142: + case 142: // ddns_override_client_update: "ddns-override-client-update" ":" "boolean" #line 626 "dhcp4_parser.yy" { ctx.unique("ddns-override-client-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-override-client-update", b); } -#line 1301 "dhcp4_parser.cc" +#line 1270 "dhcp4_parser.cc" break; - case 143: + case 143: // $@21: %empty #line 632 "dhcp4_parser.yy" { ctx.enter(ctx.REPLACE_CLIENT_NAME); ctx.unique("ddns-replace-client-name", ctx.loc2pos(yystack_[0].location)); } -#line 1310 "dhcp4_parser.cc" +#line 1279 "dhcp4_parser.cc" break; - case 144: + case 144: // ddns_replace_client_name: "ddns-replace-client-name" $@21 ":" ddns_replace_client_name_value #line 635 "dhcp4_parser.yy" { ctx.stack_.back()->set("ddns-replace-client-name", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1319 "dhcp4_parser.cc" +#line 1288 "dhcp4_parser.cc" break; - case 145: + case 145: // ddns_replace_client_name_value: "when-present" #line 641 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location))); } -#line 1327 "dhcp4_parser.cc" +#line 1296 "dhcp4_parser.cc" break; - case 146: + case 146: // ddns_replace_client_name_value: "never" #line 644 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location))); } -#line 1335 "dhcp4_parser.cc" +#line 1304 "dhcp4_parser.cc" break; - case 147: + case 147: // ddns_replace_client_name_value: "always" #line 647 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location))); } -#line 1343 "dhcp4_parser.cc" +#line 1312 "dhcp4_parser.cc" break; - case 148: + case 148: // ddns_replace_client_name_value: "when-not-present" #line 650 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location))); } -#line 1351 "dhcp4_parser.cc" +#line 1320 "dhcp4_parser.cc" break; - case 149: + case 149: // ddns_replace_client_name_value: "boolean" #line 653 "dhcp4_parser.yy" { error(yystack_[0].location, "boolean values for the replace-client-name are " "no longer supported"); } -#line 1360 "dhcp4_parser.cc" +#line 1329 "dhcp4_parser.cc" break; - case 150: + case 150: // $@22: %empty #line 659 "dhcp4_parser.yy" { ctx.unique("ddns-generated-prefix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1369 "dhcp4_parser.cc" +#line 1338 "dhcp4_parser.cc" break; - case 151: + case 151: // ddns_generated_prefix: "ddns-generated-prefix" $@22 ":" "constant string" #line 662 "dhcp4_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-generated-prefix", s); ctx.leave(); } -#line 1379 "dhcp4_parser.cc" +#line 1348 "dhcp4_parser.cc" break; - case 152: + case 152: // $@23: %empty #line 668 "dhcp4_parser.yy" { ctx.unique("ddns-qualifying-suffix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1388 "dhcp4_parser.cc" +#line 1357 "dhcp4_parser.cc" break; - case 153: + case 153: // ddns_qualifying_suffix: "ddns-qualifying-suffix" $@23 ":" "constant string" #line 671 "dhcp4_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-qualifying-suffix", s); ctx.leave(); } -#line 1398 "dhcp4_parser.cc" +#line 1367 "dhcp4_parser.cc" break; - case 154: + case 154: // ddns_update_on_renew: "ddns-update-on-renew" ":" "boolean" #line 677 "dhcp4_parser.yy" { ctx.unique("ddns-update-on-renew", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-update-on-renew", b); } -#line 1408 "dhcp4_parser.cc" +#line 1377 "dhcp4_parser.cc" break; - case 155: + case 155: // ddns_use_conflict_resolution: "ddns-use-conflict-resolution" ":" "boolean" #line 683 "dhcp4_parser.yy" { ctx.unique("ddns-use-conflict-resolution", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-use-conflict-resolution", b); } -#line 1418 "dhcp4_parser.cc" +#line 1387 "dhcp4_parser.cc" break; - case 156: + case 156: // $@24: %empty #line 689 "dhcp4_parser.yy" { ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1427 "dhcp4_parser.cc" +#line 1396 "dhcp4_parser.cc" break; - case 157: + case 157: // hostname_char_set: "hostname-char-set" $@24 ":" "constant string" #line 692 "dhcp4_parser.yy" { 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 1437 "dhcp4_parser.cc" +#line 1406 "dhcp4_parser.cc" break; - case 158: + case 158: // $@25: %empty #line 698 "dhcp4_parser.yy" { ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1446 "dhcp4_parser.cc" +#line 1415 "dhcp4_parser.cc" break; - case 159: + case 159: // hostname_char_replacement: "hostname-char-replacement" $@25 ":" "constant string" #line 701 "dhcp4_parser.yy" { 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 1456 "dhcp4_parser.cc" +#line 1425 "dhcp4_parser.cc" break; - case 160: + case 160: // store_extended_info: "store-extended-info" ":" "boolean" #line 707 "dhcp4_parser.yy" { ctx.unique("store-extended-info", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("store-extended-info", b); } -#line 1466 "dhcp4_parser.cc" +#line 1435 "dhcp4_parser.cc" break; - case 161: + case 161: // statistic_default_sample_count: "statistic-default-sample-count" ":" "integer" #line 713 "dhcp4_parser.yy" { ctx.unique("statistic-default-sample-count", ctx.loc2pos(yystack_[2].location)); ElementPtr count(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("statistic-default-sample-count", count); } -#line 1476 "dhcp4_parser.cc" +#line 1445 "dhcp4_parser.cc" break; - case 162: + case 162: // statistic_default_sample_age: "statistic-default-sample-age" ":" "integer" #line 719 "dhcp4_parser.yy" { ctx.unique("statistic-default-sample-age", ctx.loc2pos(yystack_[2].location)); ElementPtr age(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("statistic-default-sample-age", age); } -#line 1486 "dhcp4_parser.cc" +#line 1455 "dhcp4_parser.cc" break; - case 163: + case 163: // ip_reservations_unique: "ip-reservations-unique" ":" "boolean" #line 725 "dhcp4_parser.yy" { ctx.unique("ip-reservations-unique", ctx.loc2pos(yystack_[2].location)); ElementPtr unique(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ip-reservations-unique", unique); } -#line 1496 "dhcp4_parser.cc" +#line 1465 "dhcp4_parser.cc" break; - case 164: + case 164: // $@26: %empty #line 731 "dhcp4_parser.yy" { ctx.unique("interfaces-config", ctx.loc2pos(yystack_[0].location)); @@ -1504,39 +1473,39 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.INTERFACES_CONFIG); } -#line 1508 "dhcp4_parser.cc" +#line 1477 "dhcp4_parser.cc" break; - case 165: + case 165: // interfaces_config: "interfaces-config" $@26 ":" "{" interfaces_config_params "}" #line 737 "dhcp4_parser.yy" { // No interfaces config param is required ctx.stack_.pop_back(); ctx.leave(); } -#line 1518 "dhcp4_parser.cc" +#line 1487 "dhcp4_parser.cc" break; - case 175: + case 175: // $@27: %empty #line 756 "dhcp4_parser.yy" { // Parse the interfaces-config map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 1528 "dhcp4_parser.cc" +#line 1497 "dhcp4_parser.cc" break; - case 176: + case 176: // sub_interfaces4: "{" $@27 interfaces_config_params "}" #line 760 "dhcp4_parser.yy" { // No interfaces config param is required // parsing completed } -#line 1537 "dhcp4_parser.cc" +#line 1506 "dhcp4_parser.cc" break; - case 177: + case 177: // $@28: %empty #line 765 "dhcp4_parser.yy" { ctx.unique("interfaces", ctx.loc2pos(yystack_[0].location)); @@ -1545,93 +1514,93 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.NO_KEYWORD); } -#line 1549 "dhcp4_parser.cc" +#line 1518 "dhcp4_parser.cc" break; - case 178: + case 178: // interfaces_list: "interfaces" $@28 ":" list_strings #line 771 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 1558 "dhcp4_parser.cc" +#line 1527 "dhcp4_parser.cc" break; - case 179: + case 179: // $@29: %empty #line 776 "dhcp4_parser.yy" { ctx.unique("dhcp-socket-type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.DHCP_SOCKET_TYPE); } -#line 1567 "dhcp4_parser.cc" +#line 1536 "dhcp4_parser.cc" break; - case 180: + case 180: // dhcp_socket_type: "dhcp-socket-type" $@29 ":" socket_type #line 779 "dhcp4_parser.yy" { ctx.stack_.back()->set("dhcp-socket-type", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1576 "dhcp4_parser.cc" +#line 1545 "dhcp4_parser.cc" break; - case 181: + case 181: // socket_type: "raw" #line 784 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("raw", ctx.loc2pos(yystack_[0].location))); } -#line 1582 "dhcp4_parser.cc" +#line 1551 "dhcp4_parser.cc" break; - case 182: + case 182: // socket_type: "udp" #line 785 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("udp", ctx.loc2pos(yystack_[0].location))); } -#line 1588 "dhcp4_parser.cc" +#line 1557 "dhcp4_parser.cc" break; - case 183: + case 183: // $@30: %empty #line 788 "dhcp4_parser.yy" { ctx.unique("outbound-interface", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.OUTBOUND_INTERFACE); } -#line 1597 "dhcp4_parser.cc" +#line 1566 "dhcp4_parser.cc" break; - case 184: + case 184: // outbound_interface: "outbound-interface" $@30 ":" outbound_interface_value #line 791 "dhcp4_parser.yy" { ctx.stack_.back()->set("outbound-interface", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1606 "dhcp4_parser.cc" +#line 1575 "dhcp4_parser.cc" break; - case 185: + case 185: // outbound_interface_value: "same-as-inbound" #line 796 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("same-as-inbound", ctx.loc2pos(yystack_[0].location))); } -#line 1614 "dhcp4_parser.cc" +#line 1583 "dhcp4_parser.cc" break; - case 186: + case 186: // outbound_interface_value: "use-routing" #line 798 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("use-routing", ctx.loc2pos(yystack_[0].location))); } -#line 1622 "dhcp4_parser.cc" +#line 1591 "dhcp4_parser.cc" break; - case 187: + case 187: // re_detect: "re-detect" ":" "boolean" #line 802 "dhcp4_parser.yy" { ctx.unique("re-detect", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("re-detect", b); } -#line 1632 "dhcp4_parser.cc" +#line 1601 "dhcp4_parser.cc" break; - case 188: + case 188: // $@31: %empty #line 809 "dhcp4_parser.yy" { ctx.unique("lease-database", ctx.loc2pos(yystack_[0].location)); @@ -1640,10 +1609,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.LEASE_DATABASE); } -#line 1644 "dhcp4_parser.cc" +#line 1613 "dhcp4_parser.cc" break; - case 189: + case 189: // lease_database: "lease-database" $@31 ":" "{" database_map_params "}" #line 815 "dhcp4_parser.yy" { // The type parameter is required @@ -1651,10 +1620,10 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 1655 "dhcp4_parser.cc" +#line 1624 "dhcp4_parser.cc" break; - case 190: + case 190: // $@32: %empty #line 822 "dhcp4_parser.yy" { ctx.unique("sanity-checks", ctx.loc2pos(yystack_[0].location)); @@ -1663,28 +1632,28 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.SANITY_CHECKS); } -#line 1667 "dhcp4_parser.cc" +#line 1636 "dhcp4_parser.cc" break; - case 191: + case 191: // sanity_checks: "sanity-checks" $@32 ":" "{" sanity_checks_params "}" #line 828 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 1676 "dhcp4_parser.cc" +#line 1645 "dhcp4_parser.cc" break; - case 195: + case 195: // $@33: %empty #line 838 "dhcp4_parser.yy" { ctx.unique("lease-checks", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1685 "dhcp4_parser.cc" +#line 1654 "dhcp4_parser.cc" break; - case 196: + case 196: // lease_checks: "lease-checks" $@33 ":" "constant string" #line 841 "dhcp4_parser.yy" { @@ -1701,10 +1670,10 @@ namespace isc { namespace dhcp { ", supported values are: none, warn, fix, fix-del, del"); } } -#line 1705 "dhcp4_parser.cc" +#line 1674 "dhcp4_parser.cc" break; - case 197: + case 197: // $@34: %empty #line 857 "dhcp4_parser.yy" { ctx.unique("hosts-database", ctx.loc2pos(yystack_[0].location)); @@ -1713,10 +1682,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.HOSTS_DATABASE); } -#line 1717 "dhcp4_parser.cc" +#line 1686 "dhcp4_parser.cc" break; - case 198: + case 198: // hosts_database: "hosts-database" $@34 ":" "{" database_map_params "}" #line 863 "dhcp4_parser.yy" { // The type parameter is required @@ -1724,10 +1693,10 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 1728 "dhcp4_parser.cc" +#line 1697 "dhcp4_parser.cc" break; - case 199: + case 199: // $@35: %empty #line 870 "dhcp4_parser.yy" { ctx.unique("hosts-databases", ctx.loc2pos(yystack_[0].location)); @@ -1736,379 +1705,379 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.HOSTS_DATABASE); } -#line 1740 "dhcp4_parser.cc" +#line 1709 "dhcp4_parser.cc" break; - case 200: + case 200: // hosts_databases: "hosts-databases" $@35 ":" "[" database_list "]" #line 876 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 1749 "dhcp4_parser.cc" +#line 1718 "dhcp4_parser.cc" break; - case 205: + case 205: // $@36: %empty #line 889 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 1759 "dhcp4_parser.cc" +#line 1728 "dhcp4_parser.cc" break; - case 206: + case 206: // database: "{" $@36 database_map_params "}" #line 893 "dhcp4_parser.yy" { // The type parameter is required ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 1769 "dhcp4_parser.cc" +#line 1738 "dhcp4_parser.cc" break; - case 231: + case 231: // $@37: %empty #line 927 "dhcp4_parser.yy" { ctx.unique("type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.DATABASE_TYPE); } -#line 1778 "dhcp4_parser.cc" +#line 1747 "dhcp4_parser.cc" break; - case 232: + case 232: // database_type: "type" $@37 ":" db_type #line 930 "dhcp4_parser.yy" { ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1787 "dhcp4_parser.cc" +#line 1756 "dhcp4_parser.cc" break; - case 233: + case 233: // db_type: "memfile" #line 935 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); } -#line 1793 "dhcp4_parser.cc" +#line 1762 "dhcp4_parser.cc" break; - case 234: + case 234: // db_type: "mysql" #line 936 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); } -#line 1799 "dhcp4_parser.cc" +#line 1768 "dhcp4_parser.cc" break; - case 235: + case 235: // db_type: "postgresql" #line 937 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); } -#line 1805 "dhcp4_parser.cc" +#line 1774 "dhcp4_parser.cc" break; - case 236: + case 236: // db_type: "cql" #line 938 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("cql", ctx.loc2pos(yystack_[0].location))); } -#line 1811 "dhcp4_parser.cc" +#line 1780 "dhcp4_parser.cc" break; - case 237: + case 237: // $@38: %empty #line 941 "dhcp4_parser.yy" { ctx.unique("user", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1820 "dhcp4_parser.cc" +#line 1789 "dhcp4_parser.cc" break; - case 238: + case 238: // user: "user" $@38 ":" "constant string" #line 944 "dhcp4_parser.yy" { ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("user", user); ctx.leave(); } -#line 1830 "dhcp4_parser.cc" +#line 1799 "dhcp4_parser.cc" break; - case 239: + case 239: // $@39: %empty #line 950 "dhcp4_parser.yy" { ctx.unique("password", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1839 "dhcp4_parser.cc" +#line 1808 "dhcp4_parser.cc" break; - case 240: + case 240: // password: "password" $@39 ":" "constant string" #line 953 "dhcp4_parser.yy" { ElementPtr pwd(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("password", pwd); ctx.leave(); } -#line 1849 "dhcp4_parser.cc" +#line 1818 "dhcp4_parser.cc" break; - case 241: + case 241: // $@40: %empty #line 959 "dhcp4_parser.yy" { ctx.unique("host", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1858 "dhcp4_parser.cc" +#line 1827 "dhcp4_parser.cc" break; - case 242: + case 242: // host: "host" $@40 ":" "constant string" #line 962 "dhcp4_parser.yy" { ElementPtr h(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("host", h); ctx.leave(); } -#line 1868 "dhcp4_parser.cc" +#line 1837 "dhcp4_parser.cc" break; - case 243: + case 243: // port: "port" ":" "integer" #line 968 "dhcp4_parser.yy" { ctx.unique("port", ctx.loc2pos(yystack_[2].location)); ElementPtr p(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("port", p); } -#line 1878 "dhcp4_parser.cc" +#line 1847 "dhcp4_parser.cc" break; - case 244: + case 244: // $@41: %empty #line 974 "dhcp4_parser.yy" { ctx.unique("name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1887 "dhcp4_parser.cc" +#line 1856 "dhcp4_parser.cc" break; - case 245: + case 245: // name: "name" $@41 ":" "constant string" #line 977 "dhcp4_parser.yy" { ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("name", name); ctx.leave(); } -#line 1897 "dhcp4_parser.cc" +#line 1866 "dhcp4_parser.cc" break; - case 246: + case 246: // persist: "persist" ":" "boolean" #line 983 "dhcp4_parser.yy" { ctx.unique("persist", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("persist", n); } -#line 1907 "dhcp4_parser.cc" +#line 1876 "dhcp4_parser.cc" break; - case 247: + case 247: // lfc_interval: "lfc-interval" ":" "integer" #line 989 "dhcp4_parser.yy" { ctx.unique("lfc-interval", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("lfc-interval", n); } -#line 1917 "dhcp4_parser.cc" +#line 1886 "dhcp4_parser.cc" break; - case 248: + case 248: // readonly: "readonly" ":" "boolean" #line 995 "dhcp4_parser.yy" { ctx.unique("readonly", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("readonly", n); } -#line 1927 "dhcp4_parser.cc" +#line 1896 "dhcp4_parser.cc" break; - case 249: + case 249: // connect_timeout: "connect-timeout" ":" "integer" #line 1001 "dhcp4_parser.yy" { ctx.unique("connect-timeout", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("connect-timeout", n); } -#line 1937 "dhcp4_parser.cc" +#line 1906 "dhcp4_parser.cc" break; - case 250: + case 250: // request_timeout: "request-timeout" ":" "integer" #line 1007 "dhcp4_parser.yy" { ctx.unique("request-timeout", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("request-timeout", n); } -#line 1947 "dhcp4_parser.cc" +#line 1916 "dhcp4_parser.cc" break; - case 251: + case 251: // tcp_keepalive: "tcp-keepalive" ":" "integer" #line 1013 "dhcp4_parser.yy" { ctx.unique("tcp-keepalive", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("tcp-keepalive", n); } -#line 1957 "dhcp4_parser.cc" +#line 1926 "dhcp4_parser.cc" break; - case 252: + case 252: // tcp_nodelay: "tcp-nodelay" ":" "boolean" #line 1019 "dhcp4_parser.yy" { ctx.unique("tcp-nodelay", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("tcp-nodelay", n); } -#line 1967 "dhcp4_parser.cc" +#line 1936 "dhcp4_parser.cc" break; - case 253: + case 253: // $@42: %empty #line 1025 "dhcp4_parser.yy" { ctx.unique("contact-points", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1976 "dhcp4_parser.cc" +#line 1945 "dhcp4_parser.cc" break; - case 254: + case 254: // contact_points: "contact-points" $@42 ":" "constant string" #line 1028 "dhcp4_parser.yy" { 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 1986 "dhcp4_parser.cc" +#line 1955 "dhcp4_parser.cc" break; - case 255: + case 255: // $@43: %empty #line 1034 "dhcp4_parser.yy" { ctx.unique("keyspace", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1995 "dhcp4_parser.cc" +#line 1964 "dhcp4_parser.cc" break; - case 256: + case 256: // keyspace: "keyspace" $@43 ":" "constant string" #line 1037 "dhcp4_parser.yy" { ElementPtr ks(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("keyspace", ks); ctx.leave(); } -#line 2005 "dhcp4_parser.cc" +#line 1974 "dhcp4_parser.cc" break; - case 257: + case 257: // $@44: %empty #line 1043 "dhcp4_parser.yy" { ctx.unique("consistency", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2014 "dhcp4_parser.cc" +#line 1983 "dhcp4_parser.cc" break; - case 258: + case 258: // consistency: "consistency" $@44 ":" "constant string" #line 1046 "dhcp4_parser.yy" { ElementPtr c(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("consistency", c); ctx.leave(); } -#line 2024 "dhcp4_parser.cc" +#line 1993 "dhcp4_parser.cc" break; - case 259: + case 259: // $@45: %empty #line 1052 "dhcp4_parser.yy" { ctx.unique("serial-consistency", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2033 "dhcp4_parser.cc" +#line 2002 "dhcp4_parser.cc" break; - case 260: + case 260: // serial_consistency: "serial-consistency" $@45 ":" "constant string" #line 1055 "dhcp4_parser.yy" { ElementPtr c(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("serial-consistency", c); ctx.leave(); } -#line 2043 "dhcp4_parser.cc" +#line 2012 "dhcp4_parser.cc" break; - case 261: + case 261: // max_reconnect_tries: "max-reconnect-tries" ":" "integer" #line 1061 "dhcp4_parser.yy" { ctx.unique("max-reconnect-tries", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-reconnect-tries", n); } -#line 2053 "dhcp4_parser.cc" +#line 2022 "dhcp4_parser.cc" break; - case 262: + case 262: // reconnect_wait_time: "reconnect-wait-time" ":" "integer" #line 1067 "dhcp4_parser.yy" { ctx.unique("reconnect-wait-time", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reconnect-wait-time", n); } -#line 2063 "dhcp4_parser.cc" +#line 2032 "dhcp4_parser.cc" break; - case 263: + case 263: // $@46: %empty #line 1073 "dhcp4_parser.yy" { ctx.unique("on-fail", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.DATABASE_ON_FAIL); } -#line 2072 "dhcp4_parser.cc" +#line 2041 "dhcp4_parser.cc" break; - case 264: + case 264: // on_fail: "on-fail" $@46 ":" on_fail_mode #line 1076 "dhcp4_parser.yy" { ctx.stack_.back()->set("on-fail", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 2081 "dhcp4_parser.cc" +#line 2050 "dhcp4_parser.cc" break; - case 265: + case 265: // on_fail_mode: "stop-retry-exit" #line 1081 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("stop-retry-exit", ctx.loc2pos(yystack_[0].location))); } -#line 2087 "dhcp4_parser.cc" +#line 2056 "dhcp4_parser.cc" break; - case 266: + case 266: // on_fail_mode: "serve-retry-exit" #line 1082 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-exit", ctx.loc2pos(yystack_[0].location))); } -#line 2093 "dhcp4_parser.cc" +#line 2062 "dhcp4_parser.cc" break; - case 267: + case 267: // on_fail_mode: "serve-retry-continue" #line 1083 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-continue", ctx.loc2pos(yystack_[0].location))); } -#line 2099 "dhcp4_parser.cc" +#line 2068 "dhcp4_parser.cc" break; - case 268: + case 268: // max_row_errors: "max-row-errors" ":" "integer" #line 1086 "dhcp4_parser.yy" { ctx.unique("max-row-errors", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-row-errors", n); } -#line 2109 "dhcp4_parser.cc" +#line 2078 "dhcp4_parser.cc" break; - case 269: + case 269: // $@47: %empty #line 1093 "dhcp4_parser.yy" { ctx.unique("host-reservation-identifiers", ctx.loc2pos(yystack_[0].location)); @@ -2117,64 +2086,64 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.HOST_RESERVATION_IDENTIFIERS); } -#line 2121 "dhcp4_parser.cc" +#line 2090 "dhcp4_parser.cc" break; - case 270: + case 270: // host_reservation_identifiers: "host-reservation-identifiers" $@47 ":" "[" host_reservation_identifiers_list "]" #line 1099 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2130 "dhcp4_parser.cc" +#line 2099 "dhcp4_parser.cc" break; - case 278: + case 278: // duid_id: "duid" #line 1115 "dhcp4_parser.yy" { ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(duid); } -#line 2139 "dhcp4_parser.cc" +#line 2108 "dhcp4_parser.cc" break; - case 279: + case 279: // hw_address_id: "hw-address" #line 1120 "dhcp4_parser.yy" { ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(hwaddr); } -#line 2148 "dhcp4_parser.cc" +#line 2117 "dhcp4_parser.cc" break; - case 280: + case 280: // circuit_id: "circuit-id" #line 1125 "dhcp4_parser.yy" { ElementPtr circuit(new StringElement("circuit-id", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(circuit); } -#line 2157 "dhcp4_parser.cc" +#line 2126 "dhcp4_parser.cc" break; - case 281: + case 281: // client_id: "client-id" #line 1130 "dhcp4_parser.yy" { ElementPtr client(new StringElement("client-id", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(client); } -#line 2166 "dhcp4_parser.cc" +#line 2135 "dhcp4_parser.cc" break; - case 282: + case 282: // flex_id: "flex-id" #line 1135 "dhcp4_parser.yy" { ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(flex_id); } -#line 2175 "dhcp4_parser.cc" +#line 2144 "dhcp4_parser.cc" break; - case 283: + case 283: // $@48: %empty #line 1142 "dhcp4_parser.yy" { ctx.unique("multi-threading", ctx.loc2pos(yystack_[0].location)); @@ -2183,10 +2152,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(mt); ctx.enter(ctx.DHCP_MULTI_THREADING); } -#line 2187 "dhcp4_parser.cc" +#line 2156 "dhcp4_parser.cc" break; - case 284: + case 284: // dhcp_multi_threading: "multi-threading" $@48 ":" "{" multi_threading_params "}" #line 1148 "dhcp4_parser.yy" { // The enable parameter is required. @@ -2194,40 +2163,40 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 2198 "dhcp4_parser.cc" +#line 2167 "dhcp4_parser.cc" break; - case 293: + case 293: // enable_multi_threading: "enable-multi-threading" ":" "boolean" #line 1167 "dhcp4_parser.yy" { ctx.unique("enable-multi-threading", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enable-multi-threading", b); } -#line 2208 "dhcp4_parser.cc" +#line 2177 "dhcp4_parser.cc" break; - case 294: + case 294: // thread_pool_size: "thread-pool-size" ":" "integer" #line 1173 "dhcp4_parser.yy" { ctx.unique("thread-pool-size", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("thread-pool-size", prf); } -#line 2218 "dhcp4_parser.cc" +#line 2187 "dhcp4_parser.cc" break; - case 295: + case 295: // packet_queue_size: "packet-queue-size" ":" "integer" #line 1179 "dhcp4_parser.yy" { ctx.unique("packet-queue-size", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("packet-queue-size", prf); } -#line 2228 "dhcp4_parser.cc" +#line 2197 "dhcp4_parser.cc" break; - case 296: + case 296: // $@49: %empty #line 1185 "dhcp4_parser.yy" { ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location)); @@ -2236,96 +2205,96 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.HOOKS_LIBRARIES); } -#line 2240 "dhcp4_parser.cc" +#line 2209 "dhcp4_parser.cc" break; - case 297: + case 297: // hooks_libraries: "hooks-libraries" $@49 ":" "[" hooks_libraries_list "]" #line 1191 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2249 "dhcp4_parser.cc" +#line 2218 "dhcp4_parser.cc" break; - case 302: + case 302: // $@50: %empty #line 1204 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2259 "dhcp4_parser.cc" +#line 2228 "dhcp4_parser.cc" break; - case 303: + case 303: // hooks_library: "{" $@50 hooks_params "}" #line 1208 "dhcp4_parser.yy" { // The library hooks parameter is required ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 2269 "dhcp4_parser.cc" +#line 2238 "dhcp4_parser.cc" break; - case 304: + case 304: // $@51: %empty #line 1214 "dhcp4_parser.yy" { // Parse the hooks-libraries list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2279 "dhcp4_parser.cc" +#line 2248 "dhcp4_parser.cc" break; - case 305: + case 305: // sub_hooks_library: "{" $@51 hooks_params "}" #line 1218 "dhcp4_parser.yy" { // The library hooks parameter is required ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 2289 "dhcp4_parser.cc" +#line 2258 "dhcp4_parser.cc" break; - case 311: + case 311: // $@52: %empty #line 1233 "dhcp4_parser.yy" { ctx.unique("library", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2298 "dhcp4_parser.cc" +#line 2267 "dhcp4_parser.cc" break; - case 312: + case 312: // library: "library" $@52 ":" "constant string" #line 1236 "dhcp4_parser.yy" { ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("library", lib); ctx.leave(); } -#line 2308 "dhcp4_parser.cc" +#line 2277 "dhcp4_parser.cc" break; - case 313: + case 313: // $@53: %empty #line 1242 "dhcp4_parser.yy" { ctx.unique("parameters", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2317 "dhcp4_parser.cc" +#line 2286 "dhcp4_parser.cc" break; - case 314: + case 314: // parameters: "parameters" $@53 ":" map_value #line 1245 "dhcp4_parser.yy" { ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 2326 "dhcp4_parser.cc" +#line 2295 "dhcp4_parser.cc" break; - case 315: + case 315: // $@54: %empty #line 1251 "dhcp4_parser.yy" { ctx.unique("expired-leases-processing", ctx.loc2pos(yystack_[0].location)); @@ -2334,80 +2303,80 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.EXPIRED_LEASES_PROCESSING); } -#line 2338 "dhcp4_parser.cc" +#line 2307 "dhcp4_parser.cc" break; - case 316: + case 316: // expired_leases_processing: "expired-leases-processing" $@54 ":" "{" expired_leases_params "}" #line 1257 "dhcp4_parser.yy" { // No expired lease parameter is required ctx.stack_.pop_back(); ctx.leave(); } -#line 2348 "dhcp4_parser.cc" +#line 2317 "dhcp4_parser.cc" break; - case 325: + case 325: // reclaim_timer_wait_time: "reclaim-timer-wait-time" ":" "integer" #line 1275 "dhcp4_parser.yy" { ctx.unique("reclaim-timer-wait-time", ctx.loc2pos(yystack_[2].location)); 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 2358 "dhcp4_parser.cc" +#line 2327 "dhcp4_parser.cc" break; - case 326: + case 326: // flush_reclaimed_timer_wait_time: "flush-reclaimed-timer-wait-time" ":" "integer" #line 1281 "dhcp4_parser.yy" { ctx.unique("flush-reclaimed-timer-wait-time", ctx.loc2pos(yystack_[2].location)); 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 2368 "dhcp4_parser.cc" +#line 2337 "dhcp4_parser.cc" break; - case 327: + case 327: // hold_reclaimed_time: "hold-reclaimed-time" ":" "integer" #line 1287 "dhcp4_parser.yy" { ctx.unique("hold-reclaimed-time", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("hold-reclaimed-time", value); } -#line 2378 "dhcp4_parser.cc" +#line 2347 "dhcp4_parser.cc" break; - case 328: + case 328: // max_reclaim_leases: "max-reclaim-leases" ":" "integer" #line 1293 "dhcp4_parser.yy" { ctx.unique("max-reclaim-leases", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-reclaim-leases", value); } -#line 2388 "dhcp4_parser.cc" +#line 2357 "dhcp4_parser.cc" break; - case 329: + case 329: // max_reclaim_time: "max-reclaim-time" ":" "integer" #line 1299 "dhcp4_parser.yy" { ctx.unique("max-reclaim-time", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-reclaim-time", value); } -#line 2398 "dhcp4_parser.cc" +#line 2367 "dhcp4_parser.cc" break; - case 330: + case 330: // unwarned_reclaim_cycles: "unwarned-reclaim-cycles" ":" "integer" #line 1305 "dhcp4_parser.yy" { ctx.unique("unwarned-reclaim-cycles", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("unwarned-reclaim-cycles", value); } -#line 2408 "dhcp4_parser.cc" +#line 2377 "dhcp4_parser.cc" break; - case 331: + case 331: // $@55: %empty #line 1314 "dhcp4_parser.yy" { ctx.unique("subnet4", ctx.loc2pos(yystack_[0].location)); @@ -2416,29 +2385,29 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.SUBNET4); } -#line 2420 "dhcp4_parser.cc" +#line 2389 "dhcp4_parser.cc" break; - case 332: + case 332: // subnet4_list: "subnet4" $@55 ":" "[" subnet4_list_content "]" #line 1320 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2429 "dhcp4_parser.cc" +#line 2398 "dhcp4_parser.cc" break; - case 337: + case 337: // $@56: %empty #line 1340 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2439 "dhcp4_parser.cc" +#line 2408 "dhcp4_parser.cc" break; - case 338: + case 338: // subnet4: "{" $@56 subnet4_params "}" #line 1344 "dhcp4_parser.yy" { // Once we reached this place, the subnet parsing is now complete. @@ -2461,144 +2430,144 @@ namespace isc { namespace dhcp { ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 2465 "dhcp4_parser.cc" +#line 2434 "dhcp4_parser.cc" break; - case 339: + case 339: // $@57: %empty #line 1366 "dhcp4_parser.yy" { // Parse the subnet4 list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2475 "dhcp4_parser.cc" +#line 2444 "dhcp4_parser.cc" break; - case 340: + case 340: // sub_subnet4: "{" $@57 subnet4_params "}" #line 1370 "dhcp4_parser.yy" { // The subnet subnet4 parameter is required ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 2485 "dhcp4_parser.cc" +#line 2454 "dhcp4_parser.cc" break; - case 388: + case 388: // $@58: %empty #line 1429 "dhcp4_parser.yy" { ctx.unique("subnet", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2494 "dhcp4_parser.cc" +#line 2463 "dhcp4_parser.cc" break; - case 389: + case 389: // subnet: "subnet" $@58 ":" "constant string" #line 1432 "dhcp4_parser.yy" { ElementPtr subnet(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("subnet", subnet); ctx.leave(); } -#line 2504 "dhcp4_parser.cc" +#line 2473 "dhcp4_parser.cc" break; - case 390: + case 390: // $@59: %empty #line 1438 "dhcp4_parser.yy" { ctx.unique("4o6-interface", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2513 "dhcp4_parser.cc" +#line 2482 "dhcp4_parser.cc" break; - case 391: + case 391: // subnet_4o6_interface: "4o6-interface" $@59 ":" "constant string" #line 1441 "dhcp4_parser.yy" { 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 2523 "dhcp4_parser.cc" +#line 2492 "dhcp4_parser.cc" break; - case 392: + case 392: // $@60: %empty #line 1447 "dhcp4_parser.yy" { ctx.unique("4o6-interface-id", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2532 "dhcp4_parser.cc" +#line 2501 "dhcp4_parser.cc" break; - case 393: + case 393: // subnet_4o6_interface_id: "4o6-interface-id" $@60 ":" "constant string" #line 1450 "dhcp4_parser.yy" { 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 2542 "dhcp4_parser.cc" +#line 2511 "dhcp4_parser.cc" break; - case 394: + case 394: // $@61: %empty #line 1456 "dhcp4_parser.yy" { ctx.unique("4o6-subnet", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2551 "dhcp4_parser.cc" +#line 2520 "dhcp4_parser.cc" break; - case 395: + case 395: // subnet_4o6_subnet: "4o6-subnet" $@61 ":" "constant string" #line 1459 "dhcp4_parser.yy" { 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 2561 "dhcp4_parser.cc" +#line 2530 "dhcp4_parser.cc" break; - case 396: + case 396: // $@62: %empty #line 1465 "dhcp4_parser.yy" { ctx.unique("interface", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2570 "dhcp4_parser.cc" +#line 2539 "dhcp4_parser.cc" break; - case 397: + case 397: // interface: "interface" $@62 ":" "constant string" #line 1468 "dhcp4_parser.yy" { ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("interface", iface); ctx.leave(); } -#line 2580 "dhcp4_parser.cc" +#line 2549 "dhcp4_parser.cc" break; - case 398: + case 398: // $@63: %empty #line 1474 "dhcp4_parser.yy" { ctx.unique("client-class", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2589 "dhcp4_parser.cc" +#line 2558 "dhcp4_parser.cc" break; - case 399: + case 399: // client_class: "client-class" $@63 ":" "constant string" #line 1477 "dhcp4_parser.yy" { 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 2599 "dhcp4_parser.cc" +#line 2568 "dhcp4_parser.cc" break; - case 400: + case 400: // $@64: %empty #line 1483 "dhcp4_parser.yy" { ctx.unique("require-client-classes", ctx.loc2pos(yystack_[0].location)); @@ -2607,101 +2576,101 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(c); ctx.enter(ctx.NO_KEYWORD); } -#line 2611 "dhcp4_parser.cc" +#line 2580 "dhcp4_parser.cc" break; - case 401: + case 401: // require_client_classes: "require-client-classes" $@64 ":" list_strings #line 1489 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2620 "dhcp4_parser.cc" +#line 2589 "dhcp4_parser.cc" break; - case 402: + case 402: // reservations_global: "reservations-global" ":" "boolean" #line 1494 "dhcp4_parser.yy" { ctx.unique("reservations-global", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reservations-global", b); } -#line 2630 "dhcp4_parser.cc" +#line 2599 "dhcp4_parser.cc" break; - case 403: + case 403: // reservations_in_subnet: "reservations-in-subnet" ":" "boolean" #line 1500 "dhcp4_parser.yy" { ctx.unique("reservations-in-subnet", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reservations-in-subnet", b); } -#line 2640 "dhcp4_parser.cc" +#line 2609 "dhcp4_parser.cc" break; - case 404: + case 404: // reservations_out_of_pool: "reservations-out-of-pool" ":" "boolean" #line 1506 "dhcp4_parser.yy" { ctx.unique("reservations-out-of-pool", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reservations-out-of-pool", b); } -#line 2650 "dhcp4_parser.cc" +#line 2619 "dhcp4_parser.cc" break; - case 405: + case 405: // $@65: %empty #line 1512 "dhcp4_parser.yy" { ctx.unique("reservation-mode", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.RESERVATION_MODE); } -#line 2659 "dhcp4_parser.cc" +#line 2628 "dhcp4_parser.cc" break; - case 406: + case 406: // reservation_mode: "reservation-mode" $@65 ":" hr_mode #line 1515 "dhcp4_parser.yy" { ctx.stack_.back()->set("reservation-mode", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 2668 "dhcp4_parser.cc" +#line 2637 "dhcp4_parser.cc" break; - case 407: + case 407: // hr_mode: "disabled" #line 1520 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("disabled", ctx.loc2pos(yystack_[0].location))); } -#line 2674 "dhcp4_parser.cc" +#line 2643 "dhcp4_parser.cc" break; - case 408: + case 408: // hr_mode: "out-of-pool" #line 1521 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("out-of-pool", ctx.loc2pos(yystack_[0].location))); } -#line 2680 "dhcp4_parser.cc" +#line 2649 "dhcp4_parser.cc" break; - case 409: + case 409: // hr_mode: "global" #line 1522 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("global", ctx.loc2pos(yystack_[0].location))); } -#line 2686 "dhcp4_parser.cc" +#line 2655 "dhcp4_parser.cc" break; - case 410: + case 410: // hr_mode: "all" #line 1523 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("all", ctx.loc2pos(yystack_[0].location))); } -#line 2692 "dhcp4_parser.cc" +#line 2661 "dhcp4_parser.cc" break; - case 411: + case 411: // id: "id" ":" "integer" #line 1526 "dhcp4_parser.yy" { ctx.unique("id", ctx.loc2pos(yystack_[2].location)); ElementPtr id(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("id", id); } -#line 2702 "dhcp4_parser.cc" +#line 2671 "dhcp4_parser.cc" break; - case 412: + case 412: // $@66: %empty #line 1534 "dhcp4_parser.yy" { ctx.unique("shared-networks", ctx.loc2pos(yystack_[0].location)); @@ -2710,37 +2679,37 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.SHARED_NETWORK); } -#line 2714 "dhcp4_parser.cc" +#line 2683 "dhcp4_parser.cc" break; - case 413: + case 413: // shared_networks: "shared-networks" $@66 ":" "[" shared_networks_content "]" #line 1540 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2723 "dhcp4_parser.cc" +#line 2692 "dhcp4_parser.cc" break; - case 418: + case 418: // $@67: %empty #line 1555 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2733 "dhcp4_parser.cc" +#line 2702 "dhcp4_parser.cc" break; - case 419: + case 419: // shared_network: "{" $@67 shared_network_params "}" #line 1559 "dhcp4_parser.yy" { ctx.stack_.pop_back(); } -#line 2741 "dhcp4_parser.cc" +#line 2710 "dhcp4_parser.cc" break; - case 462: + case 462: // $@68: %empty #line 1613 "dhcp4_parser.yy" { ctx.unique("option-def", ctx.loc2pos(yystack_[0].location)); @@ -2749,46 +2718,46 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.OPTION_DEF); } -#line 2753 "dhcp4_parser.cc" +#line 2722 "dhcp4_parser.cc" break; - case 463: + case 463: // option_def_list: "option-def" $@68 ":" "[" option_def_list_content "]" #line 1619 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2762 "dhcp4_parser.cc" +#line 2731 "dhcp4_parser.cc" break; - case 464: + case 464: // $@69: %empty #line 1627 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2771 "dhcp4_parser.cc" +#line 2740 "dhcp4_parser.cc" break; - case 465: + case 465: // sub_option_def_list: "{" $@69 option_def_list "}" #line 1630 "dhcp4_parser.yy" { // parsing completed } -#line 2779 "dhcp4_parser.cc" +#line 2748 "dhcp4_parser.cc" break; - case 470: + case 470: // $@70: %empty #line 1646 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2789 "dhcp4_parser.cc" +#line 2758 "dhcp4_parser.cc" break; - case 471: + case 471: // option_def_entry: "{" $@70 option_def_params "}" #line 1650 "dhcp4_parser.yy" { // The name, code and type option def parameters are required. @@ -2797,20 +2766,20 @@ namespace isc { namespace dhcp { ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 2801 "dhcp4_parser.cc" +#line 2770 "dhcp4_parser.cc" break; - case 472: + case 472: // $@71: %empty #line 1661 "dhcp4_parser.yy" { // Parse the option-def list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2811 "dhcp4_parser.cc" +#line 2780 "dhcp4_parser.cc" break; - case 473: + case 473: // sub_option_def: "{" $@71 option_def_params "}" #line 1665 "dhcp4_parser.yy" { // The name, code and type option def parameters are required. @@ -2819,106 +2788,106 @@ namespace isc { namespace dhcp { ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 2823 "dhcp4_parser.cc" +#line 2792 "dhcp4_parser.cc" break; - case 489: + case 489: // code: "code" ":" "integer" #line 1697 "dhcp4_parser.yy" { ctx.unique("code", ctx.loc2pos(yystack_[2].location)); ElementPtr code(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("code", code); } -#line 2833 "dhcp4_parser.cc" +#line 2802 "dhcp4_parser.cc" break; - case 491: + case 491: // $@72: %empty #line 1705 "dhcp4_parser.yy" { ctx.unique("type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2842 "dhcp4_parser.cc" +#line 2811 "dhcp4_parser.cc" break; - case 492: + case 492: // option_def_type: "type" $@72 ":" "constant string" #line 1708 "dhcp4_parser.yy" { ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("type", prf); ctx.leave(); } -#line 2852 "dhcp4_parser.cc" +#line 2821 "dhcp4_parser.cc" break; - case 493: + case 493: // $@73: %empty #line 1714 "dhcp4_parser.yy" { ctx.unique("record-types", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2861 "dhcp4_parser.cc" +#line 2830 "dhcp4_parser.cc" break; - case 494: + case 494: // option_def_record_types: "record-types" $@73 ":" "constant string" #line 1717 "dhcp4_parser.yy" { 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 2871 "dhcp4_parser.cc" +#line 2840 "dhcp4_parser.cc" break; - case 495: + case 495: // $@74: %empty #line 1723 "dhcp4_parser.yy" { ctx.unique("space", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2880 "dhcp4_parser.cc" +#line 2849 "dhcp4_parser.cc" break; - case 496: + case 496: // space: "space" $@74 ":" "constant string" #line 1726 "dhcp4_parser.yy" { ElementPtr space(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("space", space); ctx.leave(); } -#line 2890 "dhcp4_parser.cc" +#line 2859 "dhcp4_parser.cc" break; - case 498: + case 498: // $@75: %empty #line 1734 "dhcp4_parser.yy" { ctx.unique("encapsulate", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2899 "dhcp4_parser.cc" +#line 2868 "dhcp4_parser.cc" break; - case 499: + case 499: // option_def_encapsulate: "encapsulate" $@75 ":" "constant string" #line 1737 "dhcp4_parser.yy" { ElementPtr encap(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("encapsulate", encap); ctx.leave(); } -#line 2909 "dhcp4_parser.cc" +#line 2878 "dhcp4_parser.cc" break; - case 500: + case 500: // option_def_array: "array" ":" "boolean" #line 1743 "dhcp4_parser.yy" { ctx.unique("array", ctx.loc2pos(yystack_[2].location)); ElementPtr array(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("array", array); } -#line 2919 "dhcp4_parser.cc" +#line 2888 "dhcp4_parser.cc" break; - case 501: + case 501: // $@76: %empty #line 1753 "dhcp4_parser.yy" { ctx.unique("option-data", ctx.loc2pos(yystack_[0].location)); @@ -2927,96 +2896,96 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.OPTION_DATA); } -#line 2931 "dhcp4_parser.cc" +#line 2900 "dhcp4_parser.cc" break; - case 502: + case 502: // option_data_list: "option-data" $@76 ":" "[" option_data_list_content "]" #line 1759 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2940 "dhcp4_parser.cc" +#line 2909 "dhcp4_parser.cc" break; - case 507: + case 507: // $@77: %empty #line 1778 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2950 "dhcp4_parser.cc" +#line 2919 "dhcp4_parser.cc" break; - case 508: + case 508: // option_data_entry: "{" $@77 option_data_params "}" #line 1782 "dhcp4_parser.yy" { /// @todo: the code or name parameters are required. ctx.stack_.pop_back(); } -#line 2959 "dhcp4_parser.cc" +#line 2928 "dhcp4_parser.cc" break; - case 509: + case 509: // $@78: %empty #line 1790 "dhcp4_parser.yy" { // Parse the option-data list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2969 "dhcp4_parser.cc" +#line 2938 "dhcp4_parser.cc" break; - case 510: + case 510: // sub_option_data: "{" $@78 option_data_params "}" #line 1794 "dhcp4_parser.yy" { /// @todo: the code or name parameters are required. // parsing completed } -#line 2978 "dhcp4_parser.cc" +#line 2947 "dhcp4_parser.cc" break; - case 525: + case 525: // $@79: %empty #line 1827 "dhcp4_parser.yy" { ctx.unique("data", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2987 "dhcp4_parser.cc" +#line 2956 "dhcp4_parser.cc" break; - case 526: + case 526: // option_data_data: "data" $@79 ":" "constant string" #line 1830 "dhcp4_parser.yy" { ElementPtr data(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("data", data); ctx.leave(); } -#line 2997 "dhcp4_parser.cc" +#line 2966 "dhcp4_parser.cc" break; - case 529: + case 529: // option_data_csv_format: "csv-format" ":" "boolean" #line 1840 "dhcp4_parser.yy" { ctx.unique("csv-format", ctx.loc2pos(yystack_[2].location)); ElementPtr space(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("csv-format", space); } -#line 3007 "dhcp4_parser.cc" +#line 2976 "dhcp4_parser.cc" break; - case 530: + case 530: // option_data_always_send: "always-send" ":" "boolean" #line 1846 "dhcp4_parser.yy" { ctx.unique("always-send", ctx.loc2pos(yystack_[2].location)); ElementPtr persist(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("always-send", persist); } -#line 3017 "dhcp4_parser.cc" +#line 2986 "dhcp4_parser.cc" break; - case 531: + case 531: // $@80: %empty #line 1855 "dhcp4_parser.yy" { ctx.unique("pools", ctx.loc2pos(yystack_[0].location)); @@ -3025,86 +2994,86 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.POOLS); } -#line 3029 "dhcp4_parser.cc" +#line 2998 "dhcp4_parser.cc" break; - case 532: + case 532: // pools_list: "pools" $@80 ":" "[" pools_list_content "]" #line 1861 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3038 "dhcp4_parser.cc" +#line 3007 "dhcp4_parser.cc" break; - case 537: + case 537: // $@81: %empty #line 1876 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3048 "dhcp4_parser.cc" +#line 3017 "dhcp4_parser.cc" break; - case 538: + case 538: // pool_list_entry: "{" $@81 pool_params "}" #line 1880 "dhcp4_parser.yy" { // The pool parameter is required. ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 3058 "dhcp4_parser.cc" +#line 3027 "dhcp4_parser.cc" break; - case 539: + case 539: // $@82: %empty #line 1886 "dhcp4_parser.yy" { // Parse the pool list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3068 "dhcp4_parser.cc" +#line 3037 "dhcp4_parser.cc" break; - case 540: + case 540: // sub_pool4: "{" $@82 pool_params "}" #line 1890 "dhcp4_parser.yy" { // The pool parameter is required. ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 3078 "dhcp4_parser.cc" +#line 3047 "dhcp4_parser.cc" break; - case 550: + case 550: // $@83: %empty #line 1909 "dhcp4_parser.yy" { ctx.unique("pool", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3087 "dhcp4_parser.cc" +#line 3056 "dhcp4_parser.cc" break; - case 551: + case 551: // pool_entry: "pool" $@83 ":" "constant string" #line 1912 "dhcp4_parser.yy" { ElementPtr pool(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("pool", pool); ctx.leave(); } -#line 3097 "dhcp4_parser.cc" +#line 3066 "dhcp4_parser.cc" break; - case 552: + case 552: // $@84: %empty #line 1918 "dhcp4_parser.yy" { ctx.enter(ctx.NO_KEYWORD); } -#line 3105 "dhcp4_parser.cc" +#line 3074 "dhcp4_parser.cc" break; - case 553: + case 553: // user_context: "user-context" $@84 ":" map_value #line 1920 "dhcp4_parser.yy" { ElementPtr parent = ctx.stack_.back(); @@ -3128,18 +3097,18 @@ namespace isc { namespace dhcp { parent->set("user-context", user_context); ctx.leave(); } -#line 3132 "dhcp4_parser.cc" +#line 3101 "dhcp4_parser.cc" break; - case 554: + case 554: // $@85: %empty #line 1943 "dhcp4_parser.yy" { ctx.enter(ctx.NO_KEYWORD); } -#line 3140 "dhcp4_parser.cc" +#line 3109 "dhcp4_parser.cc" break; - case 555: + case 555: // comment: "comment" $@85 ":" "constant string" #line 1945 "dhcp4_parser.yy" { ElementPtr parent = ctx.stack_.back(); @@ -3165,10 +3134,10 @@ namespace isc { namespace dhcp { parent->set("user-context", user_context); ctx.leave(); } -#line 3169 "dhcp4_parser.cc" +#line 3138 "dhcp4_parser.cc" break; - case 556: + case 556: // $@86: %empty #line 1973 "dhcp4_parser.yy" { ctx.unique("reservations", ctx.loc2pos(yystack_[0].location)); @@ -3177,133 +3146,133 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.RESERVATIONS); } -#line 3181 "dhcp4_parser.cc" +#line 3150 "dhcp4_parser.cc" break; - case 557: + case 557: // reservations: "reservations" $@86 ":" "[" reservations_list "]" #line 1979 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3190 "dhcp4_parser.cc" +#line 3159 "dhcp4_parser.cc" break; - case 562: + case 562: // $@87: %empty #line 1992 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3200 "dhcp4_parser.cc" +#line 3169 "dhcp4_parser.cc" break; - case 563: + case 563: // reservation: "{" $@87 reservation_params "}" #line 1996 "dhcp4_parser.yy" { /// @todo: an identifier parameter is required. ctx.stack_.pop_back(); } -#line 3209 "dhcp4_parser.cc" +#line 3178 "dhcp4_parser.cc" break; - case 564: + case 564: // $@88: %empty #line 2001 "dhcp4_parser.yy" { // Parse the reservations list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3219 "dhcp4_parser.cc" +#line 3188 "dhcp4_parser.cc" break; - case 565: + case 565: // sub_reservation: "{" $@88 reservation_params "}" #line 2005 "dhcp4_parser.yy" { /// @todo: an identifier parameter is required. // parsing completed } -#line 3228 "dhcp4_parser.cc" +#line 3197 "dhcp4_parser.cc" break; - case 585: + case 585: // $@89: %empty #line 2036 "dhcp4_parser.yy" { ctx.unique("next-server", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3237 "dhcp4_parser.cc" +#line 3206 "dhcp4_parser.cc" break; - case 586: + case 586: // next_server: "next-server" $@89 ":" "constant string" #line 2039 "dhcp4_parser.yy" { 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 3247 "dhcp4_parser.cc" +#line 3216 "dhcp4_parser.cc" break; - case 587: + case 587: // $@90: %empty #line 2045 "dhcp4_parser.yy" { ctx.unique("server-hostname", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3256 "dhcp4_parser.cc" +#line 3225 "dhcp4_parser.cc" break; - case 588: + case 588: // server_hostname: "server-hostname" $@90 ":" "constant string" #line 2048 "dhcp4_parser.yy" { 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 3266 "dhcp4_parser.cc" +#line 3235 "dhcp4_parser.cc" break; - case 589: + case 589: // $@91: %empty #line 2054 "dhcp4_parser.yy" { ctx.unique("boot-file-name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3275 "dhcp4_parser.cc" +#line 3244 "dhcp4_parser.cc" break; - case 590: + case 590: // boot_file_name: "boot-file-name" $@91 ":" "constant string" #line 2057 "dhcp4_parser.yy" { 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 3285 "dhcp4_parser.cc" +#line 3254 "dhcp4_parser.cc" break; - case 591: + case 591: // $@92: %empty #line 2063 "dhcp4_parser.yy" { ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3294 "dhcp4_parser.cc" +#line 3263 "dhcp4_parser.cc" break; - case 592: + case 592: // ip_address: "ip-address" $@92 ":" "constant string" #line 2066 "dhcp4_parser.yy" { 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 3304 "dhcp4_parser.cc" +#line 3273 "dhcp4_parser.cc" break; - case 593: + case 593: // $@93: %empty #line 2072 "dhcp4_parser.yy" { ctx.unique("ip-addresses", ctx.loc2pos(yystack_[0].location)); @@ -3312,133 +3281,133 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.NO_KEYWORD); } -#line 3316 "dhcp4_parser.cc" +#line 3285 "dhcp4_parser.cc" break; - case 594: + case 594: // ip_addresses: "ip-addresses" $@93 ":" list_strings #line 2078 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3325 "dhcp4_parser.cc" +#line 3294 "dhcp4_parser.cc" break; - case 595: + case 595: // $@94: %empty #line 2083 "dhcp4_parser.yy" { ctx.unique("duid", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3334 "dhcp4_parser.cc" +#line 3303 "dhcp4_parser.cc" break; - case 596: + case 596: // duid: "duid" $@94 ":" "constant string" #line 2086 "dhcp4_parser.yy" { ElementPtr d(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("duid", d); ctx.leave(); } -#line 3344 "dhcp4_parser.cc" +#line 3313 "dhcp4_parser.cc" break; - case 597: + case 597: // $@95: %empty #line 2092 "dhcp4_parser.yy" { ctx.unique("hw-address", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3353 "dhcp4_parser.cc" +#line 3322 "dhcp4_parser.cc" break; - case 598: + case 598: // hw_address: "hw-address" $@95 ":" "constant string" #line 2095 "dhcp4_parser.yy" { 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 3363 "dhcp4_parser.cc" +#line 3332 "dhcp4_parser.cc" break; - case 599: + case 599: // $@96: %empty #line 2101 "dhcp4_parser.yy" { ctx.unique("client-id", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3372 "dhcp4_parser.cc" +#line 3341 "dhcp4_parser.cc" break; - case 600: + case 600: // client_id_value: "client-id" $@96 ":" "constant string" #line 2104 "dhcp4_parser.yy" { 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 3382 "dhcp4_parser.cc" +#line 3351 "dhcp4_parser.cc" break; - case 601: + case 601: // $@97: %empty #line 2110 "dhcp4_parser.yy" { ctx.unique("circuit-id", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3391 "dhcp4_parser.cc" +#line 3360 "dhcp4_parser.cc" break; - case 602: + case 602: // circuit_id_value: "circuit-id" $@97 ":" "constant string" #line 2113 "dhcp4_parser.yy" { 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 3401 "dhcp4_parser.cc" +#line 3370 "dhcp4_parser.cc" break; - case 603: + case 603: // $@98: %empty #line 2119 "dhcp4_parser.yy" { ctx.unique("flex-id", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3410 "dhcp4_parser.cc" +#line 3379 "dhcp4_parser.cc" break; - case 604: + case 604: // flex_id_value: "flex-id" $@98 ":" "constant string" #line 2122 "dhcp4_parser.yy" { 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 3420 "dhcp4_parser.cc" +#line 3389 "dhcp4_parser.cc" break; - case 605: + case 605: // $@99: %empty #line 2128 "dhcp4_parser.yy" { ctx.unique("hostname", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3429 "dhcp4_parser.cc" +#line 3398 "dhcp4_parser.cc" break; - case 606: + case 606: // hostname: "hostname" $@99 ":" "constant string" #line 2131 "dhcp4_parser.yy" { ElementPtr host(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("hostname", host); ctx.leave(); } -#line 3439 "dhcp4_parser.cc" +#line 3408 "dhcp4_parser.cc" break; - case 607: + case 607: // $@100: %empty #line 2137 "dhcp4_parser.yy" { ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location)); @@ -3447,19 +3416,19 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(c); ctx.enter(ctx.NO_KEYWORD); } -#line 3451 "dhcp4_parser.cc" +#line 3420 "dhcp4_parser.cc" break; - case 608: + case 608: // reservation_client_classes: "client-classes" $@100 ":" list_strings #line 2143 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3460 "dhcp4_parser.cc" +#line 3429 "dhcp4_parser.cc" break; - case 609: + case 609: // $@101: %empty #line 2151 "dhcp4_parser.yy" { ctx.unique("relay", ctx.loc2pos(yystack_[0].location)); @@ -3468,19 +3437,19 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.RELAY); } -#line 3472 "dhcp4_parser.cc" +#line 3441 "dhcp4_parser.cc" break; - case 610: + case 610: // relay: "relay" $@101 ":" "{" relay_map "}" #line 2157 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3481 "dhcp4_parser.cc" +#line 3450 "dhcp4_parser.cc" break; - case 613: + case 613: // $@102: %empty #line 2169 "dhcp4_parser.yy" { ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location)); @@ -3489,78 +3458,78 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.CLIENT_CLASSES); } -#line 3493 "dhcp4_parser.cc" +#line 3462 "dhcp4_parser.cc" break; - case 614: + case 614: // client_classes: "client-classes" $@102 ":" "[" client_classes_list "]" #line 2175 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3502 "dhcp4_parser.cc" +#line 3471 "dhcp4_parser.cc" break; - case 617: + case 617: // $@103: %empty #line 2184 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3512 "dhcp4_parser.cc" +#line 3481 "dhcp4_parser.cc" break; - case 618: + case 618: // client_class_entry: "{" $@103 client_class_params "}" #line 2188 "dhcp4_parser.yy" { // 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 3522 "dhcp4_parser.cc" +#line 3491 "dhcp4_parser.cc" break; - case 638: + case 638: // $@104: %empty #line 2220 "dhcp4_parser.yy" { ctx.unique("test", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3531 "dhcp4_parser.cc" +#line 3500 "dhcp4_parser.cc" break; - case 639: + case 639: // client_class_test: "test" $@104 ":" "constant string" #line 2223 "dhcp4_parser.yy" { ElementPtr test(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("test", test); ctx.leave(); } -#line 3541 "dhcp4_parser.cc" +#line 3510 "dhcp4_parser.cc" break; - case 640: + case 640: // only_if_required: "only-if-required" ":" "boolean" #line 2229 "dhcp4_parser.yy" { ctx.unique("only-if-required", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("only-if-required", b); } -#line 3551 "dhcp4_parser.cc" +#line 3520 "dhcp4_parser.cc" break; - case 641: + case 641: // dhcp4o6_port: "dhcp4o6-port" ":" "integer" #line 2237 "dhcp4_parser.yy" { ctx.unique("dhcp4o6-port", ctx.loc2pos(yystack_[2].location)); ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("dhcp4o6-port", time); } -#line 3561 "dhcp4_parser.cc" +#line 3530 "dhcp4_parser.cc" break; - case 642: + case 642: // $@105: %empty #line 2245 "dhcp4_parser.yy" { ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location)); @@ -3569,57 +3538,57 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.CONTROL_SOCKET); } -#line 3573 "dhcp4_parser.cc" +#line 3542 "dhcp4_parser.cc" break; - case 643: + case 643: // control_socket: "control-socket" $@105 ":" "{" control_socket_params "}" #line 2251 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3582 "dhcp4_parser.cc" +#line 3551 "dhcp4_parser.cc" break; - case 651: + case 651: // $@106: %empty #line 2267 "dhcp4_parser.yy" { ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3591 "dhcp4_parser.cc" +#line 3560 "dhcp4_parser.cc" break; - case 652: + case 652: // control_socket_type: "socket-type" $@106 ":" "constant string" #line 2270 "dhcp4_parser.yy" { 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 3601 "dhcp4_parser.cc" +#line 3570 "dhcp4_parser.cc" break; - case 653: + case 653: // $@107: %empty #line 2276 "dhcp4_parser.yy" { ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3610 "dhcp4_parser.cc" +#line 3579 "dhcp4_parser.cc" break; - case 654: + case 654: // control_socket_name: "socket-name" $@107 ":" "constant string" #line 2279 "dhcp4_parser.yy" { 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 3620 "dhcp4_parser.cc" +#line 3589 "dhcp4_parser.cc" break; - case 655: + case 655: // $@108: %empty #line 2288 "dhcp4_parser.yy" { ctx.unique("dhcp-queue-control", ctx.loc2pos(yystack_[0].location)); @@ -3628,10 +3597,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(qc); ctx.enter(ctx.DHCP_QUEUE_CONTROL); } -#line 3632 "dhcp4_parser.cc" +#line 3601 "dhcp4_parser.cc" break; - case 656: + case 656: // dhcp_queue_control: "dhcp-queue-control" $@108 ":" "{" queue_control_params "}" #line 2294 "dhcp4_parser.yy" { // The enable queue parameter is required. @@ -3639,67 +3608,67 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 3643 "dhcp4_parser.cc" +#line 3612 "dhcp4_parser.cc" break; - case 665: + case 665: // enable_queue: "enable-queue" ":" "boolean" #line 2313 "dhcp4_parser.yy" { ctx.unique("enable-queue", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enable-queue", b); } -#line 3653 "dhcp4_parser.cc" +#line 3622 "dhcp4_parser.cc" break; - case 666: + case 666: // $@109: %empty #line 2319 "dhcp4_parser.yy" { ctx.unique("queue-type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3662 "dhcp4_parser.cc" +#line 3631 "dhcp4_parser.cc" break; - case 667: + case 667: // queue_type: "queue-type" $@109 ":" "constant string" #line 2322 "dhcp4_parser.yy" { ElementPtr qt(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("queue-type", qt); ctx.leave(); } -#line 3672 "dhcp4_parser.cc" +#line 3641 "dhcp4_parser.cc" break; - case 668: + case 668: // capacity: "capacity" ":" "integer" #line 2328 "dhcp4_parser.yy" { ctx.unique("capacity", ctx.loc2pos(yystack_[2].location)); ElementPtr c(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("capacity", c); } -#line 3682 "dhcp4_parser.cc" +#line 3651 "dhcp4_parser.cc" break; - case 669: + case 669: // $@110: %empty #line 2334 "dhcp4_parser.yy" { ctx.unique(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3691 "dhcp4_parser.cc" +#line 3660 "dhcp4_parser.cc" break; - case 670: + case 670: // arbitrary_map_entry: "constant string" $@110 ":" value #line 2337 "dhcp4_parser.yy" { ctx.stack_.back()->set(yystack_[3].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 3700 "dhcp4_parser.cc" +#line 3669 "dhcp4_parser.cc" break; - case 671: + case 671: // $@111: %empty #line 2344 "dhcp4_parser.yy" { ctx.unique("dhcp-ddns", ctx.loc2pos(yystack_[0].location)); @@ -3708,10 +3677,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.DHCP_DDNS); } -#line 3712 "dhcp4_parser.cc" +#line 3681 "dhcp4_parser.cc" break; - case 672: + case 672: // dhcp_ddns: "dhcp-ddns" $@111 ":" "{" dhcp_ddns_params "}" #line 2350 "dhcp4_parser.yy" { // The enable updates DHCP DDNS parameter is required. @@ -3719,271 +3688,271 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 3723 "dhcp4_parser.cc" +#line 3692 "dhcp4_parser.cc" break; - case 673: + case 673: // $@112: %empty #line 2357 "dhcp4_parser.yy" { // Parse the dhcp-ddns map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3733 "dhcp4_parser.cc" +#line 3702 "dhcp4_parser.cc" break; - case 674: + case 674: // sub_dhcp_ddns: "{" $@112 dhcp_ddns_params "}" #line 2361 "dhcp4_parser.yy" { // 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 3743 "dhcp4_parser.cc" +#line 3712 "dhcp4_parser.cc" break; - case 695: + case 695: // enable_updates: "enable-updates" ":" "boolean" #line 2391 "dhcp4_parser.yy" { ctx.unique("enable-updates", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enable-updates", b); } -#line 3753 "dhcp4_parser.cc" +#line 3722 "dhcp4_parser.cc" break; - case 696: + case 696: // $@113: %empty #line 2397 "dhcp4_parser.yy" { ctx.unique("server-ip", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3762 "dhcp4_parser.cc" +#line 3731 "dhcp4_parser.cc" break; - case 697: + case 697: // server_ip: "server-ip" $@113 ":" "constant string" #line 2400 "dhcp4_parser.yy" { 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 3772 "dhcp4_parser.cc" +#line 3741 "dhcp4_parser.cc" break; - case 698: + case 698: // server_port: "server-port" ":" "integer" #line 2406 "dhcp4_parser.yy" { ctx.unique("server-port", ctx.loc2pos(yystack_[2].location)); ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("server-port", i); } -#line 3782 "dhcp4_parser.cc" +#line 3751 "dhcp4_parser.cc" break; - case 699: + case 699: // $@114: %empty #line 2412 "dhcp4_parser.yy" { ctx.unique("sender-ip", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3791 "dhcp4_parser.cc" +#line 3760 "dhcp4_parser.cc" break; - case 700: + case 700: // sender_ip: "sender-ip" $@114 ":" "constant string" #line 2415 "dhcp4_parser.yy" { 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 3801 "dhcp4_parser.cc" +#line 3770 "dhcp4_parser.cc" break; - case 701: + case 701: // sender_port: "sender-port" ":" "integer" #line 2421 "dhcp4_parser.yy" { ctx.unique("sender-port", ctx.loc2pos(yystack_[2].location)); ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("sender-port", i); } -#line 3811 "dhcp4_parser.cc" +#line 3780 "dhcp4_parser.cc" break; - case 702: + case 702: // max_queue_size: "max-queue-size" ":" "integer" #line 2427 "dhcp4_parser.yy" { ctx.unique("max-queue-size", ctx.loc2pos(yystack_[2].location)); ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-queue-size", i); } -#line 3821 "dhcp4_parser.cc" +#line 3790 "dhcp4_parser.cc" break; - case 703: + case 703: // $@115: %empty #line 2433 "dhcp4_parser.yy" { ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NCR_PROTOCOL); } -#line 3830 "dhcp4_parser.cc" +#line 3799 "dhcp4_parser.cc" break; - case 704: + case 704: // ncr_protocol: "ncr-protocol" $@115 ":" ncr_protocol_value #line 2436 "dhcp4_parser.yy" { ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 3839 "dhcp4_parser.cc" +#line 3808 "dhcp4_parser.cc" break; - case 705: + case 705: // ncr_protocol_value: "udp" #line 2442 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); } -#line 3845 "dhcp4_parser.cc" +#line 3814 "dhcp4_parser.cc" break; - case 706: + case 706: // ncr_protocol_value: "tcp" #line 2443 "dhcp4_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); } -#line 3851 "dhcp4_parser.cc" +#line 3820 "dhcp4_parser.cc" break; - case 707: + case 707: // $@116: %empty #line 2446 "dhcp4_parser.yy" { ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NCR_FORMAT); } -#line 3860 "dhcp4_parser.cc" +#line 3829 "dhcp4_parser.cc" break; - case 708: + case 708: // ncr_format: "ncr-format" $@116 ":" "JSON" #line 2449 "dhcp4_parser.yy" { ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ncr-format", json); ctx.leave(); } -#line 3870 "dhcp4_parser.cc" +#line 3839 "dhcp4_parser.cc" break; - case 709: + case 709: // $@117: %empty #line 2456 "dhcp4_parser.yy" { ctx.unique("qualifying-suffix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3879 "dhcp4_parser.cc" +#line 3848 "dhcp4_parser.cc" break; - case 710: + case 710: // dep_qualifying_suffix: "qualifying-suffix" $@117 ":" "constant string" #line 2459 "dhcp4_parser.yy" { 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 3889 "dhcp4_parser.cc" +#line 3858 "dhcp4_parser.cc" break; - case 711: + case 711: // dep_override_no_update: "override-no-update" ":" "boolean" #line 2466 "dhcp4_parser.yy" { ctx.unique("override-no-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("override-no-update", b); } -#line 3899 "dhcp4_parser.cc" +#line 3868 "dhcp4_parser.cc" break; - case 712: + case 712: // dep_override_client_update: "override-client-update" ":" "boolean" #line 2473 "dhcp4_parser.yy" { ctx.unique("override-client-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("override-client-update", b); } -#line 3909 "dhcp4_parser.cc" +#line 3878 "dhcp4_parser.cc" break; - case 713: + case 713: // $@118: %empty #line 2480 "dhcp4_parser.yy" { ctx.unique("replace-client-name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.REPLACE_CLIENT_NAME); } -#line 3918 "dhcp4_parser.cc" +#line 3887 "dhcp4_parser.cc" break; - case 714: + case 714: // dep_replace_client_name: "replace-client-name" $@118 ":" ddns_replace_client_name_value #line 2483 "dhcp4_parser.yy" { ctx.stack_.back()->set("replace-client-name", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 3927 "dhcp4_parser.cc" +#line 3896 "dhcp4_parser.cc" break; - case 715: + case 715: // $@119: %empty #line 2489 "dhcp4_parser.yy" { ctx.unique("generated-prefix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3936 "dhcp4_parser.cc" +#line 3905 "dhcp4_parser.cc" break; - case 716: + case 716: // dep_generated_prefix: "generated-prefix" $@119 ":" "constant string" #line 2492 "dhcp4_parser.yy" { 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 3946 "dhcp4_parser.cc" +#line 3915 "dhcp4_parser.cc" break; - case 717: + case 717: // $@120: %empty #line 2499 "dhcp4_parser.yy" { ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3955 "dhcp4_parser.cc" +#line 3924 "dhcp4_parser.cc" break; - case 718: + case 718: // dep_hostname_char_set: "hostname-char-set" $@120 ":" "constant string" #line 2502 "dhcp4_parser.yy" { 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 3965 "dhcp4_parser.cc" +#line 3934 "dhcp4_parser.cc" break; - case 719: + case 719: // $@121: %empty #line 2509 "dhcp4_parser.yy" { ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3974 "dhcp4_parser.cc" +#line 3943 "dhcp4_parser.cc" break; - case 720: + case 720: // dep_hostname_char_replacement: "hostname-char-replacement" $@121 ":" "constant string" #line 2512 "dhcp4_parser.yy" { 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 3984 "dhcp4_parser.cc" +#line 3953 "dhcp4_parser.cc" break; - case 721: + case 721: // $@122: %empty #line 2521 "dhcp4_parser.yy" { ctx.unique("config-control", ctx.loc2pos(yystack_[0].location)); @@ -3992,39 +3961,39 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.CONFIG_CONTROL); } -#line 3996 "dhcp4_parser.cc" +#line 3965 "dhcp4_parser.cc" break; - case 722: + case 722: // config_control: "config-control" $@122 ":" "{" config_control_params "}" #line 2527 "dhcp4_parser.yy" { // No config control params are required ctx.stack_.pop_back(); ctx.leave(); } -#line 4006 "dhcp4_parser.cc" +#line 3975 "dhcp4_parser.cc" break; - case 723: + case 723: // $@123: %empty #line 2533 "dhcp4_parser.yy" { // Parse the config-control map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 4016 "dhcp4_parser.cc" +#line 3985 "dhcp4_parser.cc" break; - case 724: + case 724: // sub_config_control: "{" $@123 config_control_params "}" #line 2537 "dhcp4_parser.yy" { // No config_control params are required // parsing completed } -#line 4025 "dhcp4_parser.cc" +#line 3994 "dhcp4_parser.cc" break; - case 729: + case 729: // $@124: %empty #line 2552 "dhcp4_parser.yy" { ctx.unique("config-databases", ctx.loc2pos(yystack_[0].location)); @@ -4033,29 +4002,29 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.CONFIG_DATABASE); } -#line 4037 "dhcp4_parser.cc" +#line 4006 "dhcp4_parser.cc" break; - case 730: + case 730: // config_databases: "config-databases" $@124 ":" "[" database_list "]" #line 2558 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 4046 "dhcp4_parser.cc" +#line 4015 "dhcp4_parser.cc" break; - case 731: + case 731: // config_fetch_wait_time: "config-fetch-wait-time" ":" "integer" #line 2563 "dhcp4_parser.yy" { ctx.unique("config-fetch-wait-time", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("config-fetch-wait-time", value); } -#line 4056 "dhcp4_parser.cc" +#line 4025 "dhcp4_parser.cc" break; - case 732: + case 732: // $@125: %empty #line 2571 "dhcp4_parser.yy" { ctx.unique("loggers", ctx.loc2pos(yystack_[0].location)); @@ -4064,66 +4033,66 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.LOGGERS); } -#line 4068 "dhcp4_parser.cc" +#line 4037 "dhcp4_parser.cc" break; - case 733: + case 733: // loggers: "loggers" $@125 ":" "[" loggers_entries "]" #line 2577 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 4077 "dhcp4_parser.cc" +#line 4046 "dhcp4_parser.cc" break; - case 736: + case 736: // $@126: %empty #line 2589 "dhcp4_parser.yy" { ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(l); ctx.stack_.push_back(l); } -#line 4087 "dhcp4_parser.cc" +#line 4056 "dhcp4_parser.cc" break; - case 737: + case 737: // logger_entry: "{" $@126 logger_params "}" #line 2593 "dhcp4_parser.yy" { ctx.stack_.pop_back(); } -#line 4095 "dhcp4_parser.cc" +#line 4064 "dhcp4_parser.cc" break; - case 747: + case 747: // debuglevel: "debuglevel" ":" "integer" #line 2610 "dhcp4_parser.yy" { ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location)); ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("debuglevel", dl); } -#line 4105 "dhcp4_parser.cc" +#line 4074 "dhcp4_parser.cc" break; - case 748: + case 748: // $@127: %empty #line 2616 "dhcp4_parser.yy" { ctx.unique("severity", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4114 "dhcp4_parser.cc" +#line 4083 "dhcp4_parser.cc" break; - case 749: + case 749: // severity: "severity" $@127 ":" "constant string" #line 2619 "dhcp4_parser.yy" { ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("severity", sev); ctx.leave(); } -#line 4124 "dhcp4_parser.cc" +#line 4093 "dhcp4_parser.cc" break; - case 750: + case 750: // $@128: %empty #line 2625 "dhcp4_parser.yy" { ctx.unique("output_options", ctx.loc2pos(yystack_[0].location)); @@ -4132,106 +4101,106 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.OUTPUT_OPTIONS); } -#line 4136 "dhcp4_parser.cc" +#line 4105 "dhcp4_parser.cc" break; - case 751: + case 751: // output_options_list: "output_options" $@128 ":" "[" output_options_list_content "]" #line 2631 "dhcp4_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 4145 "dhcp4_parser.cc" +#line 4114 "dhcp4_parser.cc" break; - case 754: + case 754: // $@129: %empty #line 2640 "dhcp4_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 4155 "dhcp4_parser.cc" +#line 4124 "dhcp4_parser.cc" break; - case 755: + case 755: // output_entry: "{" $@129 output_params_list "}" #line 2644 "dhcp4_parser.yy" { ctx.stack_.pop_back(); } -#line 4163 "dhcp4_parser.cc" +#line 4132 "dhcp4_parser.cc" break; - case 763: + case 763: // $@130: %empty #line 2659 "dhcp4_parser.yy" { ctx.unique("output", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4172 "dhcp4_parser.cc" +#line 4141 "dhcp4_parser.cc" break; - case 764: + case 764: // output: "output" $@130 ":" "constant string" #line 2662 "dhcp4_parser.yy" { ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("output", sev); ctx.leave(); } -#line 4182 "dhcp4_parser.cc" +#line 4151 "dhcp4_parser.cc" break; - case 765: + case 765: // flush: "flush" ":" "boolean" #line 2668 "dhcp4_parser.yy" { ctx.unique("flush", ctx.loc2pos(yystack_[2].location)); ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("flush", flush); } -#line 4192 "dhcp4_parser.cc" +#line 4161 "dhcp4_parser.cc" break; - case 766: + case 766: // maxsize: "maxsize" ":" "integer" #line 2674 "dhcp4_parser.yy" { ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location)); ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("maxsize", maxsize); } -#line 4202 "dhcp4_parser.cc" +#line 4171 "dhcp4_parser.cc" break; - case 767: + case 767: // maxver: "maxver" ":" "integer" #line 2680 "dhcp4_parser.yy" { ctx.unique("maxver", ctx.loc2pos(yystack_[2].location)); ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("maxver", maxver); } -#line 4212 "dhcp4_parser.cc" +#line 4181 "dhcp4_parser.cc" break; - case 768: + case 768: // $@131: %empty #line 2686 "dhcp4_parser.yy" { ctx.unique("pattern", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4221 "dhcp4_parser.cc" +#line 4190 "dhcp4_parser.cc" break; - case 769: + case 769: // pattern: "pattern" $@131 ":" "constant string" #line 2689 "dhcp4_parser.yy" { ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("pattern", sev); ctx.leave(); } -#line 4231 "dhcp4_parser.cc" +#line 4200 "dhcp4_parser.cc" break; -#line 4235 "dhcp4_parser.cc" +#line 4204 "dhcp4_parser.cc" default: break; @@ -4248,7 +4217,6 @@ namespace isc { namespace dhcp { YY_SYMBOL_PRINT ("-> $$ =", yylhs); yypop_ (yylen); yylen = 0; - YY_STACK_PRINT (); // Shift the result of the reduction. yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); @@ -4264,7 +4232,9 @@ namespace isc { namespace dhcp { if (!yyerrstatus_) { ++yynerrs_; - error (yyla.location, yysyntax_error_ (yystack_[0].state, yyla)); + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (yyla.location, YY_MOVE (msg)); } @@ -4275,7 +4245,7 @@ namespace isc { namespace dhcp { error, discard it. */ // Return failure if at end of input. - if (yyla.type_get () == yyeof_) + if (yyla.kind () == symbol_kind::S_YYEOF) YYABORT; else if (!yyla.empty ()) { @@ -4301,6 +4271,7 @@ namespace isc { namespace dhcp { this YYERROR. */ yypop_ (yylen); yylen = 0; + YY_STACK_PRINT (); goto yyerrlab1; @@ -4309,31 +4280,33 @@ namespace isc { namespace dhcp { `-------------------------------------------------------------*/ yyerrlab1: yyerrstatus_ = 3; // Each real token shifted decrements this. - { - stack_symbol_type error_token; - for (;;) - { - yyn = yypact_[+yystack_[0].state]; - if (!yy_pact_value_is_default_ (yyn)) - { - yyn += yy_error_token_; - if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yy_error_token_) - { - yyn = yytable_[yyn]; - if (0 < yyn) - break; - } - } + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += symbol_kind::S_YYerror; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == symbol_kind::S_YYerror) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } - // Pop the current state because it cannot handle the error token. - if (yystack_.size () == 1) - YYABORT; + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; - yyerror_range[1].location = yystack_[0].location; - yy_destroy_ ("Error: popping", yystack_[0]); - yypop_ (); - YY_STACK_PRINT (); - } + yyerror_range[1].location = yystack_[0].location; + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; yyerror_range[2].location = yyla.location; YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); @@ -4371,6 +4344,7 @@ namespace isc { namespace dhcp { /* Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT. */ yypop_ (yylen); + YY_STACK_PRINT (); while (1 < yystack_.size ()) { yy_destroy_ ("Cleanup: popping", yystack_[0]); @@ -4404,18 +4378,100 @@ namespace isc { namespace dhcp { error (yyexc.location, yyexc.what ()); } - // Generate an error message. + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ std::string - Dhcp4Parser::yysyntax_error_ (state_type yystate, const symbol_type& yyla) const + Dhcp4Parser::yytnamerr_ (const char *yystr) { - // Number of reported tokens (one for the "unexpected", one per - // "expected"). - std::ptrdiff_t yycount = 0; - // Its maximum. - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - // Arguments of yyformat. - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + if (*yystr == '"') + { + std::string yyr; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + yyr += *yyp; + break; + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + Dhcp4Parser::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } + + + + // Dhcp4Parser::context. + Dhcp4Parser::context::context (const Dhcp4Parser& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + Dhcp4Parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + + int yyn = yypact_[+yyparser_.yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } + + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = symbol_kind::S_YYEMPTY; + return yycount; + } + + + + int + Dhcp4Parser::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then the only way this function was invoked is if the default action @@ -4440,35 +4496,26 @@ namespace isc { namespace dhcp { one exception: it will still contain any token that will not be accepted due to an error action in a later state. */ - if (!yyla.empty ()) - { - symbol_number_type yytoken = yyla.type_get (); - yyarg[yycount++] = yytname_[yytoken]; - int yyn = yypact_[+yystate]; - if (!yy_pact_value_is_default_ (yyn)) - { - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. In other words, skip the first -YYN actions for - this state because they are default actions. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - // Stay within bounds of both yycheck and yytname. - int yychecklim = yylast_ - yyn + 1; - int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; - for (int yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck_[yyx + yyn] == yyx && yyx != yy_error_token_ - && !yy_table_value_is_error_ (yytable_[yyx + yyn])) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - break; - } - else - yyarg[yycount++] = yytname_[yyx]; - } - } + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; } + return 0; + } + + // Generate an error message. + std::string + Dhcp4Parser::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); char const* yyformat = YY_NULLPTR; switch (yycount) @@ -4493,7 +4540,7 @@ namespace isc { namespace dhcp { for (char const* yyp = yyformat; *yyp; ++yyp) if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) { - yyres += yytnamerr_ (yyarg[yyi++]); + yyres += symbol_name (yyarg[yyi++]); ++yyp; } else @@ -4812,7 +4859,7 @@ namespace isc { namespace dhcp { const short Dhcp4Parser::yydefgoto_[] = { - -1, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 0, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 36, 37, 38, 65, 694, 82, 83, 39, 64, 79, 80, 714, 905, 998, 999, 787, 41, 66, 85, 409, 43, 67, 147, 148, 149, @@ -5407,33 +5454,33 @@ namespace isc { namespace dhcp { }; - +#if PARSER4_DEBUG || 1 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - // First, the terminals, then, starting at \a yyntokens_, nonterminals. + // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. const char* const Dhcp4Parser::yytname_[] = { - "\"end of file\"", "error", "$undefined", "\",\"", "\":\"", "\"[\"", - "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"Dhcp4\"", "\"config-control\"", - "\"config-databases\"", "\"config-fetch-wait-time\"", - "\"interfaces-config\"", "\"interfaces\"", "\"dhcp-socket-type\"", - "\"raw\"", "\"udp\"", "\"outbound-interface\"", "\"same-as-inbound\"", - "\"use-routing\"", "\"re-detect\"", "\"sanity-checks\"", - "\"lease-checks\"", "\"echo-client-id\"", "\"match-client-id\"", - "\"authoritative\"", "\"next-server\"", "\"server-hostname\"", - "\"boot-file-name\"", "\"lease-database\"", "\"hosts-database\"", - "\"hosts-databases\"", "\"type\"", "\"memfile\"", "\"mysql\"", - "\"postgresql\"", "\"cql\"", "\"user\"", "\"password\"", "\"host\"", - "\"port\"", "\"persist\"", "\"lfc-interval\"", "\"readonly\"", - "\"connect-timeout\"", "\"contact-points\"", "\"keyspace\"", - "\"consistency\"", "\"serial-consistency\"", "\"max-reconnect-tries\"", - "\"reconnect-wait-time\"", "\"on-fail\"", "\"stop-retry-exit\"", - "\"serve-retry-exit\"", "\"serve-retry-continue\"", - "\"request-timeout\"", "\"tcp-keepalive\"", "\"tcp-nodelay\"", - "\"max-row-errors\"", "\"valid-lifetime\"", "\"min-valid-lifetime\"", - "\"max-valid-lifetime\"", "\"renew-timer\"", "\"rebind-timer\"", - "\"calculate-tee-times\"", "\"t1-percent\"", "\"t2-percent\"", - "\"cache-threshold\"", "\"cache-max-age\"", + "\"end of file\"", "error", "\"invalid token\"", "\",\"", "\":\"", + "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"Dhcp4\"", + "\"config-control\"", "\"config-databases\"", + "\"config-fetch-wait-time\"", "\"interfaces-config\"", "\"interfaces\"", + "\"dhcp-socket-type\"", "\"raw\"", "\"udp\"", "\"outbound-interface\"", + "\"same-as-inbound\"", "\"use-routing\"", "\"re-detect\"", + "\"sanity-checks\"", "\"lease-checks\"", "\"echo-client-id\"", + "\"match-client-id\"", "\"authoritative\"", "\"next-server\"", + "\"server-hostname\"", "\"boot-file-name\"", "\"lease-database\"", + "\"hosts-database\"", "\"hosts-databases\"", "\"type\"", "\"memfile\"", + "\"mysql\"", "\"postgresql\"", "\"cql\"", "\"user\"", "\"password\"", + "\"host\"", "\"port\"", "\"persist\"", "\"lfc-interval\"", + "\"readonly\"", "\"connect-timeout\"", "\"contact-points\"", + "\"keyspace\"", "\"consistency\"", "\"serial-consistency\"", + "\"max-reconnect-tries\"", "\"reconnect-wait-time\"", "\"on-fail\"", + "\"stop-retry-exit\"", "\"serve-retry-exit\"", + "\"serve-retry-continue\"", "\"request-timeout\"", "\"tcp-keepalive\"", + "\"tcp-nodelay\"", "\"max-row-errors\"", "\"valid-lifetime\"", + "\"min-valid-lifetime\"", "\"max-valid-lifetime\"", "\"renew-timer\"", + "\"rebind-timer\"", "\"calculate-tee-times\"", "\"t1-percent\"", + "\"t2-percent\"", "\"cache-threshold\"", "\"cache-max-age\"", "\"decline-probation-period\"", "\"server-tag\"", "\"statistic-default-sample-count\"", "\"statistic-default-sample-age\"", "\"ddns-send-updates\"", "\"ddns-override-no-update\"", @@ -5579,6 +5626,8 @@ namespace isc { namespace dhcp { "output_params_list", "output_params", "output", "$@130", "flush", "maxsize", "maxver", "pattern", "$@131", YY_NULLPTR }; +#endif + #if PARSER4_DEBUG const short @@ -5663,9 +5712,8 @@ namespace isc { namespace dhcp { 2654, 2655, 2656, 2659, 2659, 2668, 2674, 2680, 2686, 2686 }; - // Print the state stack on the debug stream. void - Dhcp4Parser::yystack_print_ () + Dhcp4Parser::yy_stack_print_ () const { *yycdebug_ << "Stack now"; for (stack_type::const_iterator @@ -5676,9 +5724,8 @@ namespace isc { namespace dhcp { *yycdebug_ << '\n'; } - // Report on the debug stream that the rule \a yyrule is going to be reduced. void - Dhcp4Parser::yy_reduce_print_ (int yyrule) + Dhcp4Parser::yy_reduce_print_ (int yyrule) const { int yylno = yyrline_[yyrule]; int yynrhs = yyr2_[yyrule]; @@ -5695,7 +5742,7 @@ namespace isc { namespace dhcp { #line 14 "dhcp4_parser.yy" } } // isc::dhcp -#line 5699 "dhcp4_parser.cc" +#line 5746 "dhcp4_parser.cc" #line 2695 "dhcp4_parser.yy" diff --git a/src/bin/dhcp4/dhcp4_parser.h b/src/bin/dhcp4/dhcp4_parser.h index 165693c280..918a3a9645 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.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Skeleton interface for Bison LALR(1) parsers in C++ -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. +// Copyright (C) 2002-2015, 2018-2021 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 @@ -38,8 +38,9 @@ // 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. +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. #ifndef YY_PARSER4_DHCP4_PARSER_H_INCLUDED # define YY_PARSER4_DHCP4_PARSER_H_INCLUDED @@ -56,7 +57,7 @@ using namespace isc::dhcp; using namespace isc::data; using namespace std; -#line 60 "dhcp4_parser.h" +#line 61 "dhcp4_parser.h" # include # include // std::abort @@ -103,9 +104,9 @@ using namespace std; #endif # include "location.hh" #include -#ifndef YY_ASSERT +#ifndef PARSER4__ASSERT # include -# define YY_ASSERT assert +# define PARSER4__ASSERT assert #endif @@ -127,9 +128,9 @@ using namespace std; /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ -# define YYUSE(E) ((void) (E)) +# define YY_USE(E) ((void) (E)) #else -# define YYUSE(E) /* empty */ +# define YY_USE(E) /* empty */ #endif #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ @@ -199,7 +200,7 @@ using namespace std; #line 14 "dhcp4_parser.yy" namespace isc { namespace dhcp { -#line 203 "dhcp4_parser.h" +#line 204 "dhcp4_parser.h" @@ -231,14 +232,21 @@ namespace isc { namespace dhcp { semantic_type (YY_RVREF (T) t) : yytypeid_ (&typeid (T)) { - YY_ASSERT (sizeof (T) <= size); + PARSER4__ASSERT (sizeof (T) <= size); new (yyas_ ()) T (YY_MOVE (t)); } +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + semantic_type (const self_type&) = delete; + /// Non copyable. + self_type& operator= (const self_type&) = delete; +#endif + /// Destruction, allowed only if empty. ~semantic_type () YY_NOEXCEPT { - YY_ASSERT (!yytypeid_); + PARSER4__ASSERT (!yytypeid_); } # if 201103L <= YY_CPLUSPLUS @@ -247,8 +255,8 @@ namespace isc { namespace dhcp { T& emplace (U&&... u) { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); + PARSER4__ASSERT (!yytypeid_); + PARSER4__ASSERT (sizeof (T) <= size); yytypeid_ = & typeid (T); return *new (yyas_ ()) T (std::forward (u)...); } @@ -258,8 +266,8 @@ namespace isc { namespace dhcp { T& emplace () { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); + PARSER4__ASSERT (!yytypeid_); + PARSER4__ASSERT (sizeof (T) <= size); yytypeid_ = & typeid (T); return *new (yyas_ ()) T (); } @@ -269,8 +277,8 @@ namespace isc { namespace dhcp { T& emplace (const T& t) { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); + PARSER4__ASSERT (!yytypeid_); + PARSER4__ASSERT (sizeof (T) <= size); yytypeid_ = & typeid (T); return *new (yyas_ ()) T (t); } @@ -299,9 +307,9 @@ namespace isc { namespace dhcp { T& as () YY_NOEXCEPT { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == typeid (T)); - YY_ASSERT (sizeof (T) <= size); + PARSER4__ASSERT (yytypeid_); + PARSER4__ASSERT (*yytypeid_ == typeid (T)); + PARSER4__ASSERT (sizeof (T) <= size); return *yyas_ (); } @@ -310,9 +318,9 @@ namespace isc { namespace dhcp { const T& as () const YY_NOEXCEPT { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == typeid (T)); - YY_ASSERT (sizeof (T) <= size); + PARSER4__ASSERT (yytypeid_); + PARSER4__ASSERT (*yytypeid_ == typeid (T)); + PARSER4__ASSERT (sizeof (T) <= size); return *yyas_ (); } @@ -328,8 +336,8 @@ namespace isc { namespace dhcp { void swap (self_type& that) YY_NOEXCEPT { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == *that.yytypeid_); + PARSER4__ASSERT (yytypeid_); + PARSER4__ASSERT (*yytypeid_ == *that.yytypeid_); std::swap (as (), that.as ()); } @@ -378,9 +386,12 @@ namespace isc { namespace dhcp { } private: - /// Prohibit blind copies. - self_type& operator= (const self_type&); +#if YY_CPLUSPLUS < 201103L + /// Non copyable. semantic_type (const self_type&); + /// Non copyable. + self_type& operator= (const self_type&); +#endif /// Accessor to raw memory as \a T. template @@ -467,230 +478,860 @@ namespace isc { namespace dhcp { location_type location; }; - /// Tokens. + /// Token kinds. struct token { - enum yytokentype - { - TOKEN_END = 0, - TOKEN_COMMA = 258, - TOKEN_COLON = 259, - TOKEN_LSQUARE_BRACKET = 260, - TOKEN_RSQUARE_BRACKET = 261, - TOKEN_LCURLY_BRACKET = 262, - TOKEN_RCURLY_BRACKET = 263, - TOKEN_NULL_TYPE = 264, - TOKEN_DHCP4 = 265, - TOKEN_CONFIG_CONTROL = 266, - TOKEN_CONFIG_DATABASES = 267, - TOKEN_CONFIG_FETCH_WAIT_TIME = 268, - TOKEN_INTERFACES_CONFIG = 269, - TOKEN_INTERFACES = 270, - TOKEN_DHCP_SOCKET_TYPE = 271, - TOKEN_RAW = 272, - TOKEN_UDP = 273, - TOKEN_OUTBOUND_INTERFACE = 274, - TOKEN_SAME_AS_INBOUND = 275, - TOKEN_USE_ROUTING = 276, - TOKEN_RE_DETECT = 277, - TOKEN_SANITY_CHECKS = 278, - TOKEN_LEASE_CHECKS = 279, - TOKEN_ECHO_CLIENT_ID = 280, - TOKEN_MATCH_CLIENT_ID = 281, - TOKEN_AUTHORITATIVE = 282, - TOKEN_NEXT_SERVER = 283, - TOKEN_SERVER_HOSTNAME = 284, - TOKEN_BOOT_FILE_NAME = 285, - TOKEN_LEASE_DATABASE = 286, - TOKEN_HOSTS_DATABASE = 287, - TOKEN_HOSTS_DATABASES = 288, - TOKEN_TYPE = 289, - TOKEN_MEMFILE = 290, - TOKEN_MYSQL = 291, - TOKEN_POSTGRESQL = 292, - TOKEN_CQL = 293, - TOKEN_USER = 294, - TOKEN_PASSWORD = 295, - TOKEN_HOST = 296, - TOKEN_PORT = 297, - TOKEN_PERSIST = 298, - TOKEN_LFC_INTERVAL = 299, - TOKEN_READONLY = 300, - TOKEN_CONNECT_TIMEOUT = 301, - TOKEN_CONTACT_POINTS = 302, - TOKEN_KEYSPACE = 303, - TOKEN_CONSISTENCY = 304, - TOKEN_SERIAL_CONSISTENCY = 305, - TOKEN_MAX_RECONNECT_TRIES = 306, - TOKEN_RECONNECT_WAIT_TIME = 307, - TOKEN_ON_FAIL = 308, - TOKEN_STOP_RETRY_EXIT = 309, - TOKEN_SERVE_RETRY_EXIT = 310, - TOKEN_SERVE_RETRY_CONTINUE = 311, - TOKEN_REQUEST_TIMEOUT = 312, - TOKEN_TCP_KEEPALIVE = 313, - TOKEN_TCP_NODELAY = 314, - TOKEN_MAX_ROW_ERRORS = 315, - TOKEN_VALID_LIFETIME = 316, - TOKEN_MIN_VALID_LIFETIME = 317, - TOKEN_MAX_VALID_LIFETIME = 318, - TOKEN_RENEW_TIMER = 319, - TOKEN_REBIND_TIMER = 320, - TOKEN_CALCULATE_TEE_TIMES = 321, - TOKEN_T1_PERCENT = 322, - TOKEN_T2_PERCENT = 323, - TOKEN_CACHE_THRESHOLD = 324, - TOKEN_CACHE_MAX_AGE = 325, - TOKEN_DECLINE_PROBATION_PERIOD = 326, - TOKEN_SERVER_TAG = 327, - TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT = 328, - TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE = 329, - TOKEN_DDNS_SEND_UPDATES = 330, - TOKEN_DDNS_OVERRIDE_NO_UPDATE = 331, - TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE = 332, - TOKEN_DDNS_REPLACE_CLIENT_NAME = 333, - TOKEN_DDNS_GENERATED_PREFIX = 334, - TOKEN_DDNS_QUALIFYING_SUFFIX = 335, - TOKEN_DDNS_UPDATE_ON_RENEW = 336, - TOKEN_DDNS_USE_CONFLICT_RESOLUTION = 337, - TOKEN_STORE_EXTENDED_INFO = 338, - TOKEN_SUBNET4 = 339, - TOKEN_SUBNET_4O6_INTERFACE = 340, - TOKEN_SUBNET_4O6_INTERFACE_ID = 341, - TOKEN_SUBNET_4O6_SUBNET = 342, - TOKEN_OPTION_DEF = 343, - TOKEN_OPTION_DATA = 344, - TOKEN_NAME = 345, - TOKEN_DATA = 346, - TOKEN_CODE = 347, - TOKEN_SPACE = 348, - TOKEN_CSV_FORMAT = 349, - TOKEN_ALWAYS_SEND = 350, - TOKEN_RECORD_TYPES = 351, - TOKEN_ENCAPSULATE = 352, - TOKEN_ARRAY = 353, - TOKEN_SHARED_NETWORKS = 354, - TOKEN_POOLS = 355, - TOKEN_POOL = 356, - TOKEN_USER_CONTEXT = 357, - TOKEN_COMMENT = 358, - TOKEN_SUBNET = 359, - TOKEN_INTERFACE = 360, - TOKEN_ID = 361, - TOKEN_RESERVATION_MODE = 362, - TOKEN_DISABLED = 363, - TOKEN_OUT_OF_POOL = 364, - TOKEN_GLOBAL = 365, - TOKEN_ALL = 366, - TOKEN_RESERVATIONS_GLOBAL = 367, - TOKEN_RESERVATIONS_IN_SUBNET = 368, - TOKEN_RESERVATIONS_OUT_OF_POOL = 369, - TOKEN_HOST_RESERVATION_IDENTIFIERS = 370, - TOKEN_CLIENT_CLASSES = 371, - TOKEN_REQUIRE_CLIENT_CLASSES = 372, - TOKEN_TEST = 373, - TOKEN_ONLY_IF_REQUIRED = 374, - TOKEN_CLIENT_CLASS = 375, - TOKEN_RESERVATIONS = 376, - TOKEN_DUID = 377, - TOKEN_HW_ADDRESS = 378, - TOKEN_CIRCUIT_ID = 379, - TOKEN_CLIENT_ID = 380, - TOKEN_HOSTNAME = 381, - TOKEN_FLEX_ID = 382, - TOKEN_RELAY = 383, - TOKEN_IP_ADDRESS = 384, - TOKEN_IP_ADDRESSES = 385, - TOKEN_HOOKS_LIBRARIES = 386, - TOKEN_LIBRARY = 387, - TOKEN_PARAMETERS = 388, - TOKEN_EXPIRED_LEASES_PROCESSING = 389, - TOKEN_RECLAIM_TIMER_WAIT_TIME = 390, - TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 391, - TOKEN_HOLD_RECLAIMED_TIME = 392, - TOKEN_MAX_RECLAIM_LEASES = 393, - TOKEN_MAX_RECLAIM_TIME = 394, - TOKEN_UNWARNED_RECLAIM_CYCLES = 395, - TOKEN_DHCP4O6_PORT = 396, - TOKEN_DHCP_MULTI_THREADING = 397, - TOKEN_ENABLE_MULTI_THREADING = 398, - TOKEN_THREAD_POOL_SIZE = 399, - TOKEN_PACKET_QUEUE_SIZE = 400, - TOKEN_CONTROL_SOCKET = 401, - TOKEN_SOCKET_TYPE = 402, - TOKEN_SOCKET_NAME = 403, - TOKEN_DHCP_QUEUE_CONTROL = 404, - TOKEN_ENABLE_QUEUE = 405, - TOKEN_QUEUE_TYPE = 406, - TOKEN_CAPACITY = 407, - TOKEN_DHCP_DDNS = 408, - TOKEN_ENABLE_UPDATES = 409, - TOKEN_QUALIFYING_SUFFIX = 410, - TOKEN_SERVER_IP = 411, - TOKEN_SERVER_PORT = 412, - TOKEN_SENDER_IP = 413, - TOKEN_SENDER_PORT = 414, - TOKEN_MAX_QUEUE_SIZE = 415, - TOKEN_NCR_PROTOCOL = 416, - TOKEN_NCR_FORMAT = 417, - TOKEN_OVERRIDE_NO_UPDATE = 418, - TOKEN_OVERRIDE_CLIENT_UPDATE = 419, - TOKEN_REPLACE_CLIENT_NAME = 420, - TOKEN_GENERATED_PREFIX = 421, - TOKEN_TCP = 422, - TOKEN_JSON = 423, - TOKEN_WHEN_PRESENT = 424, - TOKEN_NEVER = 425, - TOKEN_ALWAYS = 426, - TOKEN_WHEN_NOT_PRESENT = 427, - TOKEN_HOSTNAME_CHAR_SET = 428, - TOKEN_HOSTNAME_CHAR_REPLACEMENT = 429, - TOKEN_IP_RESERVATIONS_UNIQUE = 430, - TOKEN_LOGGERS = 431, - TOKEN_OUTPUT_OPTIONS = 432, - TOKEN_OUTPUT = 433, - TOKEN_DEBUGLEVEL = 434, - TOKEN_SEVERITY = 435, - TOKEN_FLUSH = 436, - TOKEN_MAXSIZE = 437, - TOKEN_MAXVER = 438, - TOKEN_PATTERN = 439, - TOKEN_TOPLEVEL_JSON = 440, - TOKEN_TOPLEVEL_DHCP4 = 441, - TOKEN_SUB_DHCP4 = 442, - TOKEN_SUB_INTERFACES4 = 443, - TOKEN_SUB_SUBNET4 = 444, - TOKEN_SUB_POOL4 = 445, - TOKEN_SUB_RESERVATION = 446, - TOKEN_SUB_OPTION_DEFS = 447, - TOKEN_SUB_OPTION_DEF = 448, - TOKEN_SUB_OPTION_DATA = 449, - TOKEN_SUB_HOOKS_LIBRARY = 450, - TOKEN_SUB_DHCP_DDNS = 451, - TOKEN_SUB_CONFIG_CONTROL = 452, - TOKEN_STRING = 453, - TOKEN_INTEGER = 454, - TOKEN_FLOAT = 455, - TOKEN_BOOLEAN = 456 + enum token_kind_type + { + TOKEN_PARSER4_EMPTY = -2, + TOKEN_END = 0, // "end of file" + TOKEN_PARSER4_error = 256, // error + TOKEN_PARSER4_UNDEF = 257, // "invalid token" + TOKEN_COMMA = 258, // "," + TOKEN_COLON = 259, // ":" + TOKEN_LSQUARE_BRACKET = 260, // "[" + TOKEN_RSQUARE_BRACKET = 261, // "]" + TOKEN_LCURLY_BRACKET = 262, // "{" + TOKEN_RCURLY_BRACKET = 263, // "}" + TOKEN_NULL_TYPE = 264, // "null" + TOKEN_DHCP4 = 265, // "Dhcp4" + TOKEN_CONFIG_CONTROL = 266, // "config-control" + TOKEN_CONFIG_DATABASES = 267, // "config-databases" + TOKEN_CONFIG_FETCH_WAIT_TIME = 268, // "config-fetch-wait-time" + TOKEN_INTERFACES_CONFIG = 269, // "interfaces-config" + TOKEN_INTERFACES = 270, // "interfaces" + TOKEN_DHCP_SOCKET_TYPE = 271, // "dhcp-socket-type" + TOKEN_RAW = 272, // "raw" + TOKEN_UDP = 273, // "udp" + TOKEN_OUTBOUND_INTERFACE = 274, // "outbound-interface" + TOKEN_SAME_AS_INBOUND = 275, // "same-as-inbound" + TOKEN_USE_ROUTING = 276, // "use-routing" + TOKEN_RE_DETECT = 277, // "re-detect" + TOKEN_SANITY_CHECKS = 278, // "sanity-checks" + TOKEN_LEASE_CHECKS = 279, // "lease-checks" + TOKEN_ECHO_CLIENT_ID = 280, // "echo-client-id" + TOKEN_MATCH_CLIENT_ID = 281, // "match-client-id" + TOKEN_AUTHORITATIVE = 282, // "authoritative" + TOKEN_NEXT_SERVER = 283, // "next-server" + TOKEN_SERVER_HOSTNAME = 284, // "server-hostname" + TOKEN_BOOT_FILE_NAME = 285, // "boot-file-name" + TOKEN_LEASE_DATABASE = 286, // "lease-database" + TOKEN_HOSTS_DATABASE = 287, // "hosts-database" + TOKEN_HOSTS_DATABASES = 288, // "hosts-databases" + TOKEN_TYPE = 289, // "type" + TOKEN_MEMFILE = 290, // "memfile" + TOKEN_MYSQL = 291, // "mysql" + TOKEN_POSTGRESQL = 292, // "postgresql" + TOKEN_CQL = 293, // "cql" + TOKEN_USER = 294, // "user" + TOKEN_PASSWORD = 295, // "password" + TOKEN_HOST = 296, // "host" + TOKEN_PORT = 297, // "port" + TOKEN_PERSIST = 298, // "persist" + TOKEN_LFC_INTERVAL = 299, // "lfc-interval" + TOKEN_READONLY = 300, // "readonly" + TOKEN_CONNECT_TIMEOUT = 301, // "connect-timeout" + TOKEN_CONTACT_POINTS = 302, // "contact-points" + TOKEN_KEYSPACE = 303, // "keyspace" + TOKEN_CONSISTENCY = 304, // "consistency" + TOKEN_SERIAL_CONSISTENCY = 305, // "serial-consistency" + TOKEN_MAX_RECONNECT_TRIES = 306, // "max-reconnect-tries" + TOKEN_RECONNECT_WAIT_TIME = 307, // "reconnect-wait-time" + TOKEN_ON_FAIL = 308, // "on-fail" + TOKEN_STOP_RETRY_EXIT = 309, // "stop-retry-exit" + TOKEN_SERVE_RETRY_EXIT = 310, // "serve-retry-exit" + TOKEN_SERVE_RETRY_CONTINUE = 311, // "serve-retry-continue" + TOKEN_REQUEST_TIMEOUT = 312, // "request-timeout" + TOKEN_TCP_KEEPALIVE = 313, // "tcp-keepalive" + TOKEN_TCP_NODELAY = 314, // "tcp-nodelay" + TOKEN_MAX_ROW_ERRORS = 315, // "max-row-errors" + TOKEN_VALID_LIFETIME = 316, // "valid-lifetime" + TOKEN_MIN_VALID_LIFETIME = 317, // "min-valid-lifetime" + TOKEN_MAX_VALID_LIFETIME = 318, // "max-valid-lifetime" + TOKEN_RENEW_TIMER = 319, // "renew-timer" + TOKEN_REBIND_TIMER = 320, // "rebind-timer" + TOKEN_CALCULATE_TEE_TIMES = 321, // "calculate-tee-times" + TOKEN_T1_PERCENT = 322, // "t1-percent" + TOKEN_T2_PERCENT = 323, // "t2-percent" + TOKEN_CACHE_THRESHOLD = 324, // "cache-threshold" + TOKEN_CACHE_MAX_AGE = 325, // "cache-max-age" + TOKEN_DECLINE_PROBATION_PERIOD = 326, // "decline-probation-period" + TOKEN_SERVER_TAG = 327, // "server-tag" + TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT = 328, // "statistic-default-sample-count" + TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE = 329, // "statistic-default-sample-age" + TOKEN_DDNS_SEND_UPDATES = 330, // "ddns-send-updates" + TOKEN_DDNS_OVERRIDE_NO_UPDATE = 331, // "ddns-override-no-update" + TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE = 332, // "ddns-override-client-update" + TOKEN_DDNS_REPLACE_CLIENT_NAME = 333, // "ddns-replace-client-name" + TOKEN_DDNS_GENERATED_PREFIX = 334, // "ddns-generated-prefix" + TOKEN_DDNS_QUALIFYING_SUFFIX = 335, // "ddns-qualifying-suffix" + TOKEN_DDNS_UPDATE_ON_RENEW = 336, // "ddns-update-on-renew" + TOKEN_DDNS_USE_CONFLICT_RESOLUTION = 337, // "ddns-use-conflict-resolution" + TOKEN_STORE_EXTENDED_INFO = 338, // "store-extended-info" + TOKEN_SUBNET4 = 339, // "subnet4" + TOKEN_SUBNET_4O6_INTERFACE = 340, // "4o6-interface" + TOKEN_SUBNET_4O6_INTERFACE_ID = 341, // "4o6-interface-id" + TOKEN_SUBNET_4O6_SUBNET = 342, // "4o6-subnet" + TOKEN_OPTION_DEF = 343, // "option-def" + TOKEN_OPTION_DATA = 344, // "option-data" + TOKEN_NAME = 345, // "name" + TOKEN_DATA = 346, // "data" + TOKEN_CODE = 347, // "code" + TOKEN_SPACE = 348, // "space" + TOKEN_CSV_FORMAT = 349, // "csv-format" + TOKEN_ALWAYS_SEND = 350, // "always-send" + TOKEN_RECORD_TYPES = 351, // "record-types" + TOKEN_ENCAPSULATE = 352, // "encapsulate" + TOKEN_ARRAY = 353, // "array" + TOKEN_SHARED_NETWORKS = 354, // "shared-networks" + TOKEN_POOLS = 355, // "pools" + TOKEN_POOL = 356, // "pool" + TOKEN_USER_CONTEXT = 357, // "user-context" + TOKEN_COMMENT = 358, // "comment" + TOKEN_SUBNET = 359, // "subnet" + TOKEN_INTERFACE = 360, // "interface" + TOKEN_ID = 361, // "id" + TOKEN_RESERVATION_MODE = 362, // "reservation-mode" + TOKEN_DISABLED = 363, // "disabled" + TOKEN_OUT_OF_POOL = 364, // "out-of-pool" + TOKEN_GLOBAL = 365, // "global" + TOKEN_ALL = 366, // "all" + TOKEN_RESERVATIONS_GLOBAL = 367, // "reservations-global" + TOKEN_RESERVATIONS_IN_SUBNET = 368, // "reservations-in-subnet" + TOKEN_RESERVATIONS_OUT_OF_POOL = 369, // "reservations-out-of-pool" + TOKEN_HOST_RESERVATION_IDENTIFIERS = 370, // "host-reservation-identifiers" + TOKEN_CLIENT_CLASSES = 371, // "client-classes" + TOKEN_REQUIRE_CLIENT_CLASSES = 372, // "require-client-classes" + TOKEN_TEST = 373, // "test" + TOKEN_ONLY_IF_REQUIRED = 374, // "only-if-required" + TOKEN_CLIENT_CLASS = 375, // "client-class" + TOKEN_RESERVATIONS = 376, // "reservations" + TOKEN_DUID = 377, // "duid" + TOKEN_HW_ADDRESS = 378, // "hw-address" + TOKEN_CIRCUIT_ID = 379, // "circuit-id" + TOKEN_CLIENT_ID = 380, // "client-id" + TOKEN_HOSTNAME = 381, // "hostname" + TOKEN_FLEX_ID = 382, // "flex-id" + TOKEN_RELAY = 383, // "relay" + TOKEN_IP_ADDRESS = 384, // "ip-address" + TOKEN_IP_ADDRESSES = 385, // "ip-addresses" + TOKEN_HOOKS_LIBRARIES = 386, // "hooks-libraries" + TOKEN_LIBRARY = 387, // "library" + TOKEN_PARAMETERS = 388, // "parameters" + TOKEN_EXPIRED_LEASES_PROCESSING = 389, // "expired-leases-processing" + TOKEN_RECLAIM_TIMER_WAIT_TIME = 390, // "reclaim-timer-wait-time" + TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 391, // "flush-reclaimed-timer-wait-time" + TOKEN_HOLD_RECLAIMED_TIME = 392, // "hold-reclaimed-time" + TOKEN_MAX_RECLAIM_LEASES = 393, // "max-reclaim-leases" + TOKEN_MAX_RECLAIM_TIME = 394, // "max-reclaim-time" + TOKEN_UNWARNED_RECLAIM_CYCLES = 395, // "unwarned-reclaim-cycles" + TOKEN_DHCP4O6_PORT = 396, // "dhcp4o6-port" + TOKEN_DHCP_MULTI_THREADING = 397, // "multi-threading" + TOKEN_ENABLE_MULTI_THREADING = 398, // "enable-multi-threading" + TOKEN_THREAD_POOL_SIZE = 399, // "thread-pool-size" + TOKEN_PACKET_QUEUE_SIZE = 400, // "packet-queue-size" + TOKEN_CONTROL_SOCKET = 401, // "control-socket" + TOKEN_SOCKET_TYPE = 402, // "socket-type" + TOKEN_SOCKET_NAME = 403, // "socket-name" + TOKEN_DHCP_QUEUE_CONTROL = 404, // "dhcp-queue-control" + TOKEN_ENABLE_QUEUE = 405, // "enable-queue" + TOKEN_QUEUE_TYPE = 406, // "queue-type" + TOKEN_CAPACITY = 407, // "capacity" + TOKEN_DHCP_DDNS = 408, // "dhcp-ddns" + TOKEN_ENABLE_UPDATES = 409, // "enable-updates" + TOKEN_QUALIFYING_SUFFIX = 410, // "qualifying-suffix" + TOKEN_SERVER_IP = 411, // "server-ip" + TOKEN_SERVER_PORT = 412, // "server-port" + TOKEN_SENDER_IP = 413, // "sender-ip" + TOKEN_SENDER_PORT = 414, // "sender-port" + TOKEN_MAX_QUEUE_SIZE = 415, // "max-queue-size" + TOKEN_NCR_PROTOCOL = 416, // "ncr-protocol" + TOKEN_NCR_FORMAT = 417, // "ncr-format" + TOKEN_OVERRIDE_NO_UPDATE = 418, // "override-no-update" + TOKEN_OVERRIDE_CLIENT_UPDATE = 419, // "override-client-update" + TOKEN_REPLACE_CLIENT_NAME = 420, // "replace-client-name" + TOKEN_GENERATED_PREFIX = 421, // "generated-prefix" + TOKEN_TCP = 422, // "tcp" + TOKEN_JSON = 423, // "JSON" + TOKEN_WHEN_PRESENT = 424, // "when-present" + TOKEN_NEVER = 425, // "never" + TOKEN_ALWAYS = 426, // "always" + TOKEN_WHEN_NOT_PRESENT = 427, // "when-not-present" + TOKEN_HOSTNAME_CHAR_SET = 428, // "hostname-char-set" + TOKEN_HOSTNAME_CHAR_REPLACEMENT = 429, // "hostname-char-replacement" + TOKEN_IP_RESERVATIONS_UNIQUE = 430, // "ip-reservations-unique" + TOKEN_LOGGERS = 431, // "loggers" + TOKEN_OUTPUT_OPTIONS = 432, // "output_options" + TOKEN_OUTPUT = 433, // "output" + TOKEN_DEBUGLEVEL = 434, // "debuglevel" + TOKEN_SEVERITY = 435, // "severity" + TOKEN_FLUSH = 436, // "flush" + TOKEN_MAXSIZE = 437, // "maxsize" + TOKEN_MAXVER = 438, // "maxver" + TOKEN_PATTERN = 439, // "pattern" + TOKEN_TOPLEVEL_JSON = 440, // TOPLEVEL_JSON + TOKEN_TOPLEVEL_DHCP4 = 441, // TOPLEVEL_DHCP4 + TOKEN_SUB_DHCP4 = 442, // SUB_DHCP4 + TOKEN_SUB_INTERFACES4 = 443, // SUB_INTERFACES4 + TOKEN_SUB_SUBNET4 = 444, // SUB_SUBNET4 + TOKEN_SUB_POOL4 = 445, // SUB_POOL4 + TOKEN_SUB_RESERVATION = 446, // SUB_RESERVATION + TOKEN_SUB_OPTION_DEFS = 447, // SUB_OPTION_DEFS + TOKEN_SUB_OPTION_DEF = 448, // SUB_OPTION_DEF + TOKEN_SUB_OPTION_DATA = 449, // SUB_OPTION_DATA + TOKEN_SUB_HOOKS_LIBRARY = 450, // SUB_HOOKS_LIBRARY + TOKEN_SUB_DHCP_DDNS = 451, // SUB_DHCP_DDNS + TOKEN_SUB_CONFIG_CONTROL = 452, // SUB_CONFIG_CONTROL + TOKEN_STRING = 453, // "constant string" + TOKEN_INTEGER = 454, // "integer" + TOKEN_FLOAT = 455, // "floating point" + TOKEN_BOOLEAN = 456 // "boolean" }; + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type yytokentype; }; - /// (External) token type, as returned by yylex. - typedef token::yytokentype token_type; + /// Token kind, as returned by yylex. + typedef token::yytokentype token_kind_type; + + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type token_type; - /// Symbol type: an internal symbol number. - typedef int symbol_number_type; + /// Symbol kinds. + struct symbol_kind + { + enum symbol_kind_type + { + YYNTOKENS = 202, ///< Number of tokens. + S_YYEMPTY = -2, + S_YYEOF = 0, // "end of file" + S_YYerror = 1, // error + S_YYUNDEF = 2, // "invalid token" + S_COMMA = 3, // "," + S_COLON = 4, // ":" + S_LSQUARE_BRACKET = 5, // "[" + S_RSQUARE_BRACKET = 6, // "]" + S_LCURLY_BRACKET = 7, // "{" + S_RCURLY_BRACKET = 8, // "}" + S_NULL_TYPE = 9, // "null" + S_DHCP4 = 10, // "Dhcp4" + S_CONFIG_CONTROL = 11, // "config-control" + S_CONFIG_DATABASES = 12, // "config-databases" + S_CONFIG_FETCH_WAIT_TIME = 13, // "config-fetch-wait-time" + S_INTERFACES_CONFIG = 14, // "interfaces-config" + S_INTERFACES = 15, // "interfaces" + S_DHCP_SOCKET_TYPE = 16, // "dhcp-socket-type" + S_RAW = 17, // "raw" + S_UDP = 18, // "udp" + S_OUTBOUND_INTERFACE = 19, // "outbound-interface" + S_SAME_AS_INBOUND = 20, // "same-as-inbound" + S_USE_ROUTING = 21, // "use-routing" + S_RE_DETECT = 22, // "re-detect" + S_SANITY_CHECKS = 23, // "sanity-checks" + S_LEASE_CHECKS = 24, // "lease-checks" + S_ECHO_CLIENT_ID = 25, // "echo-client-id" + S_MATCH_CLIENT_ID = 26, // "match-client-id" + S_AUTHORITATIVE = 27, // "authoritative" + S_NEXT_SERVER = 28, // "next-server" + S_SERVER_HOSTNAME = 29, // "server-hostname" + S_BOOT_FILE_NAME = 30, // "boot-file-name" + S_LEASE_DATABASE = 31, // "lease-database" + S_HOSTS_DATABASE = 32, // "hosts-database" + S_HOSTS_DATABASES = 33, // "hosts-databases" + S_TYPE = 34, // "type" + S_MEMFILE = 35, // "memfile" + S_MYSQL = 36, // "mysql" + S_POSTGRESQL = 37, // "postgresql" + S_CQL = 38, // "cql" + S_USER = 39, // "user" + S_PASSWORD = 40, // "password" + S_HOST = 41, // "host" + S_PORT = 42, // "port" + S_PERSIST = 43, // "persist" + S_LFC_INTERVAL = 44, // "lfc-interval" + S_READONLY = 45, // "readonly" + S_CONNECT_TIMEOUT = 46, // "connect-timeout" + S_CONTACT_POINTS = 47, // "contact-points" + S_KEYSPACE = 48, // "keyspace" + S_CONSISTENCY = 49, // "consistency" + S_SERIAL_CONSISTENCY = 50, // "serial-consistency" + S_MAX_RECONNECT_TRIES = 51, // "max-reconnect-tries" + S_RECONNECT_WAIT_TIME = 52, // "reconnect-wait-time" + S_ON_FAIL = 53, // "on-fail" + S_STOP_RETRY_EXIT = 54, // "stop-retry-exit" + S_SERVE_RETRY_EXIT = 55, // "serve-retry-exit" + S_SERVE_RETRY_CONTINUE = 56, // "serve-retry-continue" + S_REQUEST_TIMEOUT = 57, // "request-timeout" + S_TCP_KEEPALIVE = 58, // "tcp-keepalive" + S_TCP_NODELAY = 59, // "tcp-nodelay" + S_MAX_ROW_ERRORS = 60, // "max-row-errors" + S_VALID_LIFETIME = 61, // "valid-lifetime" + S_MIN_VALID_LIFETIME = 62, // "min-valid-lifetime" + S_MAX_VALID_LIFETIME = 63, // "max-valid-lifetime" + S_RENEW_TIMER = 64, // "renew-timer" + S_REBIND_TIMER = 65, // "rebind-timer" + S_CALCULATE_TEE_TIMES = 66, // "calculate-tee-times" + S_T1_PERCENT = 67, // "t1-percent" + S_T2_PERCENT = 68, // "t2-percent" + S_CACHE_THRESHOLD = 69, // "cache-threshold" + S_CACHE_MAX_AGE = 70, // "cache-max-age" + S_DECLINE_PROBATION_PERIOD = 71, // "decline-probation-period" + S_SERVER_TAG = 72, // "server-tag" + S_STATISTIC_DEFAULT_SAMPLE_COUNT = 73, // "statistic-default-sample-count" + S_STATISTIC_DEFAULT_SAMPLE_AGE = 74, // "statistic-default-sample-age" + S_DDNS_SEND_UPDATES = 75, // "ddns-send-updates" + S_DDNS_OVERRIDE_NO_UPDATE = 76, // "ddns-override-no-update" + S_DDNS_OVERRIDE_CLIENT_UPDATE = 77, // "ddns-override-client-update" + S_DDNS_REPLACE_CLIENT_NAME = 78, // "ddns-replace-client-name" + S_DDNS_GENERATED_PREFIX = 79, // "ddns-generated-prefix" + S_DDNS_QUALIFYING_SUFFIX = 80, // "ddns-qualifying-suffix" + S_DDNS_UPDATE_ON_RENEW = 81, // "ddns-update-on-renew" + S_DDNS_USE_CONFLICT_RESOLUTION = 82, // "ddns-use-conflict-resolution" + S_STORE_EXTENDED_INFO = 83, // "store-extended-info" + S_SUBNET4 = 84, // "subnet4" + S_SUBNET_4O6_INTERFACE = 85, // "4o6-interface" + S_SUBNET_4O6_INTERFACE_ID = 86, // "4o6-interface-id" + S_SUBNET_4O6_SUBNET = 87, // "4o6-subnet" + S_OPTION_DEF = 88, // "option-def" + S_OPTION_DATA = 89, // "option-data" + S_NAME = 90, // "name" + S_DATA = 91, // "data" + S_CODE = 92, // "code" + S_SPACE = 93, // "space" + S_CSV_FORMAT = 94, // "csv-format" + S_ALWAYS_SEND = 95, // "always-send" + S_RECORD_TYPES = 96, // "record-types" + S_ENCAPSULATE = 97, // "encapsulate" + S_ARRAY = 98, // "array" + S_SHARED_NETWORKS = 99, // "shared-networks" + S_POOLS = 100, // "pools" + S_POOL = 101, // "pool" + S_USER_CONTEXT = 102, // "user-context" + S_COMMENT = 103, // "comment" + S_SUBNET = 104, // "subnet" + S_INTERFACE = 105, // "interface" + S_ID = 106, // "id" + S_RESERVATION_MODE = 107, // "reservation-mode" + S_DISABLED = 108, // "disabled" + S_OUT_OF_POOL = 109, // "out-of-pool" + S_GLOBAL = 110, // "global" + S_ALL = 111, // "all" + S_RESERVATIONS_GLOBAL = 112, // "reservations-global" + S_RESERVATIONS_IN_SUBNET = 113, // "reservations-in-subnet" + S_RESERVATIONS_OUT_OF_POOL = 114, // "reservations-out-of-pool" + S_HOST_RESERVATION_IDENTIFIERS = 115, // "host-reservation-identifiers" + S_CLIENT_CLASSES = 116, // "client-classes" + S_REQUIRE_CLIENT_CLASSES = 117, // "require-client-classes" + S_TEST = 118, // "test" + S_ONLY_IF_REQUIRED = 119, // "only-if-required" + S_CLIENT_CLASS = 120, // "client-class" + S_RESERVATIONS = 121, // "reservations" + S_DUID = 122, // "duid" + S_HW_ADDRESS = 123, // "hw-address" + S_CIRCUIT_ID = 124, // "circuit-id" + S_CLIENT_ID = 125, // "client-id" + S_HOSTNAME = 126, // "hostname" + S_FLEX_ID = 127, // "flex-id" + S_RELAY = 128, // "relay" + S_IP_ADDRESS = 129, // "ip-address" + S_IP_ADDRESSES = 130, // "ip-addresses" + S_HOOKS_LIBRARIES = 131, // "hooks-libraries" + S_LIBRARY = 132, // "library" + S_PARAMETERS = 133, // "parameters" + S_EXPIRED_LEASES_PROCESSING = 134, // "expired-leases-processing" + S_RECLAIM_TIMER_WAIT_TIME = 135, // "reclaim-timer-wait-time" + S_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 136, // "flush-reclaimed-timer-wait-time" + S_HOLD_RECLAIMED_TIME = 137, // "hold-reclaimed-time" + S_MAX_RECLAIM_LEASES = 138, // "max-reclaim-leases" + S_MAX_RECLAIM_TIME = 139, // "max-reclaim-time" + S_UNWARNED_RECLAIM_CYCLES = 140, // "unwarned-reclaim-cycles" + S_DHCP4O6_PORT = 141, // "dhcp4o6-port" + S_DHCP_MULTI_THREADING = 142, // "multi-threading" + S_ENABLE_MULTI_THREADING = 143, // "enable-multi-threading" + S_THREAD_POOL_SIZE = 144, // "thread-pool-size" + S_PACKET_QUEUE_SIZE = 145, // "packet-queue-size" + S_CONTROL_SOCKET = 146, // "control-socket" + S_SOCKET_TYPE = 147, // "socket-type" + S_SOCKET_NAME = 148, // "socket-name" + S_DHCP_QUEUE_CONTROL = 149, // "dhcp-queue-control" + S_ENABLE_QUEUE = 150, // "enable-queue" + S_QUEUE_TYPE = 151, // "queue-type" + S_CAPACITY = 152, // "capacity" + S_DHCP_DDNS = 153, // "dhcp-ddns" + S_ENABLE_UPDATES = 154, // "enable-updates" + S_QUALIFYING_SUFFIX = 155, // "qualifying-suffix" + S_SERVER_IP = 156, // "server-ip" + S_SERVER_PORT = 157, // "server-port" + S_SENDER_IP = 158, // "sender-ip" + S_SENDER_PORT = 159, // "sender-port" + S_MAX_QUEUE_SIZE = 160, // "max-queue-size" + S_NCR_PROTOCOL = 161, // "ncr-protocol" + S_NCR_FORMAT = 162, // "ncr-format" + S_OVERRIDE_NO_UPDATE = 163, // "override-no-update" + S_OVERRIDE_CLIENT_UPDATE = 164, // "override-client-update" + S_REPLACE_CLIENT_NAME = 165, // "replace-client-name" + S_GENERATED_PREFIX = 166, // "generated-prefix" + S_TCP = 167, // "tcp" + S_JSON = 168, // "JSON" + S_WHEN_PRESENT = 169, // "when-present" + S_NEVER = 170, // "never" + S_ALWAYS = 171, // "always" + S_WHEN_NOT_PRESENT = 172, // "when-not-present" + S_HOSTNAME_CHAR_SET = 173, // "hostname-char-set" + S_HOSTNAME_CHAR_REPLACEMENT = 174, // "hostname-char-replacement" + S_IP_RESERVATIONS_UNIQUE = 175, // "ip-reservations-unique" + S_LOGGERS = 176, // "loggers" + S_OUTPUT_OPTIONS = 177, // "output_options" + S_OUTPUT = 178, // "output" + S_DEBUGLEVEL = 179, // "debuglevel" + S_SEVERITY = 180, // "severity" + S_FLUSH = 181, // "flush" + S_MAXSIZE = 182, // "maxsize" + S_MAXVER = 183, // "maxver" + S_PATTERN = 184, // "pattern" + S_TOPLEVEL_JSON = 185, // TOPLEVEL_JSON + S_TOPLEVEL_DHCP4 = 186, // TOPLEVEL_DHCP4 + S_SUB_DHCP4 = 187, // SUB_DHCP4 + S_SUB_INTERFACES4 = 188, // SUB_INTERFACES4 + S_SUB_SUBNET4 = 189, // SUB_SUBNET4 + S_SUB_POOL4 = 190, // SUB_POOL4 + S_SUB_RESERVATION = 191, // SUB_RESERVATION + S_SUB_OPTION_DEFS = 192, // SUB_OPTION_DEFS + S_SUB_OPTION_DEF = 193, // SUB_OPTION_DEF + S_SUB_OPTION_DATA = 194, // SUB_OPTION_DATA + S_SUB_HOOKS_LIBRARY = 195, // SUB_HOOKS_LIBRARY + S_SUB_DHCP_DDNS = 196, // SUB_DHCP_DDNS + S_SUB_CONFIG_CONTROL = 197, // SUB_CONFIG_CONTROL + S_STRING = 198, // "constant string" + S_INTEGER = 199, // "integer" + S_FLOAT = 200, // "floating point" + S_BOOLEAN = 201, // "boolean" + S_YYACCEPT = 202, // $accept + S_start = 203, // start + S_204_1 = 204, // $@1 + S_205_2 = 205, // $@2 + S_206_3 = 206, // $@3 + S_207_4 = 207, // $@4 + S_208_5 = 208, // $@5 + S_209_6 = 209, // $@6 + S_210_7 = 210, // $@7 + S_211_8 = 211, // $@8 + S_212_9 = 212, // $@9 + S_213_10 = 213, // $@10 + S_214_11 = 214, // $@11 + S_215_12 = 215, // $@12 + S_216_13 = 216, // $@13 + S_value = 217, // value + S_sub_json = 218, // sub_json + S_map2 = 219, // map2 + S_220_14 = 220, // $@14 + S_map_value = 221, // map_value + S_map_content = 222, // map_content + S_not_empty_map = 223, // not_empty_map + S_list_generic = 224, // list_generic + S_225_15 = 225, // $@15 + S_list_content = 226, // list_content + S_not_empty_list = 227, // not_empty_list + S_list_strings = 228, // list_strings + S_229_16 = 229, // $@16 + S_list_strings_content = 230, // list_strings_content + S_not_empty_list_strings = 231, // not_empty_list_strings + S_unknown_map_entry = 232, // unknown_map_entry + S_syntax_map = 233, // syntax_map + S_234_17 = 234, // $@17 + S_global_object = 235, // global_object + S_236_18 = 236, // $@18 + S_sub_dhcp4 = 237, // sub_dhcp4 + S_238_19 = 238, // $@19 + S_global_params = 239, // global_params + S_global_param = 240, // global_param + S_valid_lifetime = 241, // valid_lifetime + S_min_valid_lifetime = 242, // min_valid_lifetime + S_max_valid_lifetime = 243, // max_valid_lifetime + S_renew_timer = 244, // renew_timer + S_rebind_timer = 245, // rebind_timer + S_calculate_tee_times = 246, // calculate_tee_times + S_t1_percent = 247, // t1_percent + S_t2_percent = 248, // t2_percent + S_cache_threshold = 249, // cache_threshold + S_cache_max_age = 250, // cache_max_age + S_decline_probation_period = 251, // decline_probation_period + S_server_tag = 252, // server_tag + S_253_20 = 253, // $@20 + S_echo_client_id = 254, // echo_client_id + S_match_client_id = 255, // match_client_id + S_authoritative = 256, // authoritative + S_ddns_send_updates = 257, // ddns_send_updates + S_ddns_override_no_update = 258, // ddns_override_no_update + S_ddns_override_client_update = 259, // ddns_override_client_update + S_ddns_replace_client_name = 260, // ddns_replace_client_name + S_261_21 = 261, // $@21 + S_ddns_replace_client_name_value = 262, // ddns_replace_client_name_value + S_ddns_generated_prefix = 263, // ddns_generated_prefix + S_264_22 = 264, // $@22 + S_ddns_qualifying_suffix = 265, // ddns_qualifying_suffix + S_266_23 = 266, // $@23 + S_ddns_update_on_renew = 267, // ddns_update_on_renew + S_ddns_use_conflict_resolution = 268, // ddns_use_conflict_resolution + S_hostname_char_set = 269, // hostname_char_set + S_270_24 = 270, // $@24 + S_hostname_char_replacement = 271, // hostname_char_replacement + S_272_25 = 272, // $@25 + S_store_extended_info = 273, // store_extended_info + S_statistic_default_sample_count = 274, // statistic_default_sample_count + S_statistic_default_sample_age = 275, // statistic_default_sample_age + S_ip_reservations_unique = 276, // ip_reservations_unique + S_interfaces_config = 277, // interfaces_config + S_278_26 = 278, // $@26 + S_interfaces_config_params = 279, // interfaces_config_params + S_interfaces_config_param = 280, // interfaces_config_param + S_sub_interfaces4 = 281, // sub_interfaces4 + S_282_27 = 282, // $@27 + S_interfaces_list = 283, // interfaces_list + S_284_28 = 284, // $@28 + S_dhcp_socket_type = 285, // dhcp_socket_type + S_286_29 = 286, // $@29 + S_socket_type = 287, // socket_type + S_outbound_interface = 288, // outbound_interface + S_289_30 = 289, // $@30 + S_outbound_interface_value = 290, // outbound_interface_value + S_re_detect = 291, // re_detect + S_lease_database = 292, // lease_database + S_293_31 = 293, // $@31 + S_sanity_checks = 294, // sanity_checks + S_295_32 = 295, // $@32 + S_sanity_checks_params = 296, // sanity_checks_params + S_sanity_checks_param = 297, // sanity_checks_param + S_lease_checks = 298, // lease_checks + S_299_33 = 299, // $@33 + S_hosts_database = 300, // hosts_database + S_301_34 = 301, // $@34 + S_hosts_databases = 302, // hosts_databases + S_303_35 = 303, // $@35 + S_database_list = 304, // database_list + S_not_empty_database_list = 305, // not_empty_database_list + S_database = 306, // database + S_307_36 = 307, // $@36 + S_database_map_params = 308, // database_map_params + S_database_map_param = 309, // database_map_param + S_database_type = 310, // database_type + S_311_37 = 311, // $@37 + S_db_type = 312, // db_type + S_user = 313, // user + S_314_38 = 314, // $@38 + S_password = 315, // password + S_316_39 = 316, // $@39 + S_host = 317, // host + S_318_40 = 318, // $@40 + S_port = 319, // port + S_name = 320, // name + S_321_41 = 321, // $@41 + S_persist = 322, // persist + S_lfc_interval = 323, // lfc_interval + S_readonly = 324, // readonly + S_connect_timeout = 325, // connect_timeout + S_request_timeout = 326, // request_timeout + S_tcp_keepalive = 327, // tcp_keepalive + S_tcp_nodelay = 328, // tcp_nodelay + S_contact_points = 329, // contact_points + S_330_42 = 330, // $@42 + S_keyspace = 331, // keyspace + S_332_43 = 332, // $@43 + S_consistency = 333, // consistency + S_334_44 = 334, // $@44 + S_serial_consistency = 335, // serial_consistency + S_336_45 = 336, // $@45 + S_max_reconnect_tries = 337, // max_reconnect_tries + S_reconnect_wait_time = 338, // reconnect_wait_time + S_on_fail = 339, // on_fail + S_340_46 = 340, // $@46 + S_on_fail_mode = 341, // on_fail_mode + S_max_row_errors = 342, // max_row_errors + S_host_reservation_identifiers = 343, // host_reservation_identifiers + S_344_47 = 344, // $@47 + S_host_reservation_identifiers_list = 345, // host_reservation_identifiers_list + S_host_reservation_identifier = 346, // host_reservation_identifier + S_duid_id = 347, // duid_id + S_hw_address_id = 348, // hw_address_id + S_circuit_id = 349, // circuit_id + S_client_id = 350, // client_id + S_flex_id = 351, // flex_id + S_dhcp_multi_threading = 352, // dhcp_multi_threading + S_353_48 = 353, // $@48 + S_multi_threading_params = 354, // multi_threading_params + S_multi_threading_param = 355, // multi_threading_param + S_enable_multi_threading = 356, // enable_multi_threading + S_thread_pool_size = 357, // thread_pool_size + S_packet_queue_size = 358, // packet_queue_size + S_hooks_libraries = 359, // hooks_libraries + S_360_49 = 360, // $@49 + S_hooks_libraries_list = 361, // hooks_libraries_list + S_not_empty_hooks_libraries_list = 362, // not_empty_hooks_libraries_list + S_hooks_library = 363, // hooks_library + S_364_50 = 364, // $@50 + S_sub_hooks_library = 365, // sub_hooks_library + S_366_51 = 366, // $@51 + S_hooks_params = 367, // hooks_params + S_hooks_param = 368, // hooks_param + S_library = 369, // library + S_370_52 = 370, // $@52 + S_parameters = 371, // parameters + S_372_53 = 372, // $@53 + S_expired_leases_processing = 373, // expired_leases_processing + S_374_54 = 374, // $@54 + S_expired_leases_params = 375, // expired_leases_params + S_expired_leases_param = 376, // expired_leases_param + S_reclaim_timer_wait_time = 377, // reclaim_timer_wait_time + S_flush_reclaimed_timer_wait_time = 378, // flush_reclaimed_timer_wait_time + S_hold_reclaimed_time = 379, // hold_reclaimed_time + S_max_reclaim_leases = 380, // max_reclaim_leases + S_max_reclaim_time = 381, // max_reclaim_time + S_unwarned_reclaim_cycles = 382, // unwarned_reclaim_cycles + S_subnet4_list = 383, // subnet4_list + S_384_55 = 384, // $@55 + S_subnet4_list_content = 385, // subnet4_list_content + S_not_empty_subnet4_list = 386, // not_empty_subnet4_list + S_subnet4 = 387, // subnet4 + S_388_56 = 388, // $@56 + S_sub_subnet4 = 389, // sub_subnet4 + S_390_57 = 390, // $@57 + S_subnet4_params = 391, // subnet4_params + S_subnet4_param = 392, // subnet4_param + S_subnet = 393, // subnet + S_394_58 = 394, // $@58 + S_subnet_4o6_interface = 395, // subnet_4o6_interface + S_396_59 = 396, // $@59 + S_subnet_4o6_interface_id = 397, // subnet_4o6_interface_id + S_398_60 = 398, // $@60 + S_subnet_4o6_subnet = 399, // subnet_4o6_subnet + S_400_61 = 400, // $@61 + S_interface = 401, // interface + S_402_62 = 402, // $@62 + S_client_class = 403, // client_class + S_404_63 = 404, // $@63 + S_require_client_classes = 405, // require_client_classes + S_406_64 = 406, // $@64 + S_reservations_global = 407, // reservations_global + S_reservations_in_subnet = 408, // reservations_in_subnet + S_reservations_out_of_pool = 409, // reservations_out_of_pool + S_reservation_mode = 410, // reservation_mode + S_411_65 = 411, // $@65 + S_hr_mode = 412, // hr_mode + S_id = 413, // id + S_shared_networks = 414, // shared_networks + S_415_66 = 415, // $@66 + S_shared_networks_content = 416, // shared_networks_content + S_shared_networks_list = 417, // shared_networks_list + S_shared_network = 418, // shared_network + S_419_67 = 419, // $@67 + S_shared_network_params = 420, // shared_network_params + S_shared_network_param = 421, // shared_network_param + S_option_def_list = 422, // option_def_list + S_423_68 = 423, // $@68 + S_sub_option_def_list = 424, // sub_option_def_list + S_425_69 = 425, // $@69 + S_option_def_list_content = 426, // option_def_list_content + S_not_empty_option_def_list = 427, // not_empty_option_def_list + S_option_def_entry = 428, // option_def_entry + S_429_70 = 429, // $@70 + S_sub_option_def = 430, // sub_option_def + S_431_71 = 431, // $@71 + S_option_def_params = 432, // option_def_params + S_not_empty_option_def_params = 433, // not_empty_option_def_params + S_option_def_param = 434, // option_def_param + S_option_def_name = 435, // option_def_name + S_code = 436, // code + S_option_def_code = 437, // option_def_code + S_option_def_type = 438, // option_def_type + S_439_72 = 439, // $@72 + S_option_def_record_types = 440, // option_def_record_types + S_441_73 = 441, // $@73 + S_space = 442, // space + S_443_74 = 443, // $@74 + S_option_def_space = 444, // option_def_space + S_option_def_encapsulate = 445, // option_def_encapsulate + S_446_75 = 446, // $@75 + S_option_def_array = 447, // option_def_array + S_option_data_list = 448, // option_data_list + S_449_76 = 449, // $@76 + S_option_data_list_content = 450, // option_data_list_content + S_not_empty_option_data_list = 451, // not_empty_option_data_list + S_option_data_entry = 452, // option_data_entry + S_453_77 = 453, // $@77 + S_sub_option_data = 454, // sub_option_data + S_455_78 = 455, // $@78 + S_option_data_params = 456, // option_data_params + S_not_empty_option_data_params = 457, // not_empty_option_data_params + S_option_data_param = 458, // option_data_param + S_option_data_name = 459, // option_data_name + S_option_data_data = 460, // option_data_data + S_461_79 = 461, // $@79 + S_option_data_code = 462, // option_data_code + S_option_data_space = 463, // option_data_space + S_option_data_csv_format = 464, // option_data_csv_format + S_option_data_always_send = 465, // option_data_always_send + S_pools_list = 466, // pools_list + S_467_80 = 467, // $@80 + S_pools_list_content = 468, // pools_list_content + S_not_empty_pools_list = 469, // not_empty_pools_list + S_pool_list_entry = 470, // pool_list_entry + S_471_81 = 471, // $@81 + S_sub_pool4 = 472, // sub_pool4 + S_473_82 = 473, // $@82 + S_pool_params = 474, // pool_params + S_pool_param = 475, // pool_param + S_pool_entry = 476, // pool_entry + S_477_83 = 477, // $@83 + S_user_context = 478, // user_context + S_479_84 = 479, // $@84 + S_comment = 480, // comment + S_481_85 = 481, // $@85 + S_reservations = 482, // reservations + S_483_86 = 483, // $@86 + S_reservations_list = 484, // reservations_list + S_not_empty_reservations_list = 485, // not_empty_reservations_list + S_reservation = 486, // reservation + S_487_87 = 487, // $@87 + S_sub_reservation = 488, // sub_reservation + S_489_88 = 489, // $@88 + S_reservation_params = 490, // reservation_params + S_not_empty_reservation_params = 491, // not_empty_reservation_params + S_reservation_param = 492, // reservation_param + S_next_server = 493, // next_server + S_494_89 = 494, // $@89 + S_server_hostname = 495, // server_hostname + S_496_90 = 496, // $@90 + S_boot_file_name = 497, // boot_file_name + S_498_91 = 498, // $@91 + S_ip_address = 499, // ip_address + S_500_92 = 500, // $@92 + S_ip_addresses = 501, // ip_addresses + S_502_93 = 502, // $@93 + S_duid = 503, // duid + S_504_94 = 504, // $@94 + S_hw_address = 505, // hw_address + S_506_95 = 506, // $@95 + S_client_id_value = 507, // client_id_value + S_508_96 = 508, // $@96 + S_circuit_id_value = 509, // circuit_id_value + S_510_97 = 510, // $@97 + S_flex_id_value = 511, // flex_id_value + S_512_98 = 512, // $@98 + S_hostname = 513, // hostname + S_514_99 = 514, // $@99 + S_reservation_client_classes = 515, // reservation_client_classes + S_516_100 = 516, // $@100 + S_relay = 517, // relay + S_518_101 = 518, // $@101 + S_relay_map = 519, // relay_map + S_client_classes = 520, // client_classes + S_521_102 = 521, // $@102 + S_client_classes_list = 522, // client_classes_list + S_client_class_entry = 523, // client_class_entry + S_524_103 = 524, // $@103 + S_client_class_params = 525, // client_class_params + S_not_empty_client_class_params = 526, // not_empty_client_class_params + S_client_class_param = 527, // client_class_param + S_client_class_name = 528, // client_class_name + S_client_class_test = 529, // client_class_test + S_530_104 = 530, // $@104 + S_only_if_required = 531, // only_if_required + S_dhcp4o6_port = 532, // dhcp4o6_port + S_control_socket = 533, // control_socket + S_534_105 = 534, // $@105 + S_control_socket_params = 535, // control_socket_params + S_control_socket_param = 536, // control_socket_param + S_control_socket_type = 537, // control_socket_type + S_538_106 = 538, // $@106 + S_control_socket_name = 539, // control_socket_name + S_540_107 = 540, // $@107 + S_dhcp_queue_control = 541, // dhcp_queue_control + S_542_108 = 542, // $@108 + S_queue_control_params = 543, // queue_control_params + S_queue_control_param = 544, // queue_control_param + S_enable_queue = 545, // enable_queue + S_queue_type = 546, // queue_type + S_547_109 = 547, // $@109 + S_capacity = 548, // capacity + S_arbitrary_map_entry = 549, // arbitrary_map_entry + S_550_110 = 550, // $@110 + S_dhcp_ddns = 551, // dhcp_ddns + S_552_111 = 552, // $@111 + S_sub_dhcp_ddns = 553, // sub_dhcp_ddns + S_554_112 = 554, // $@112 + S_dhcp_ddns_params = 555, // dhcp_ddns_params + S_dhcp_ddns_param = 556, // dhcp_ddns_param + S_enable_updates = 557, // enable_updates + S_server_ip = 558, // server_ip + S_559_113 = 559, // $@113 + S_server_port = 560, // server_port + S_sender_ip = 561, // sender_ip + S_562_114 = 562, // $@114 + S_sender_port = 563, // sender_port + S_max_queue_size = 564, // max_queue_size + S_ncr_protocol = 565, // ncr_protocol + S_566_115 = 566, // $@115 + S_ncr_protocol_value = 567, // ncr_protocol_value + S_ncr_format = 568, // ncr_format + S_569_116 = 569, // $@116 + S_dep_qualifying_suffix = 570, // dep_qualifying_suffix + S_571_117 = 571, // $@117 + S_dep_override_no_update = 572, // dep_override_no_update + S_dep_override_client_update = 573, // dep_override_client_update + S_dep_replace_client_name = 574, // dep_replace_client_name + S_575_118 = 575, // $@118 + S_dep_generated_prefix = 576, // dep_generated_prefix + S_577_119 = 577, // $@119 + S_dep_hostname_char_set = 578, // dep_hostname_char_set + S_579_120 = 579, // $@120 + S_dep_hostname_char_replacement = 580, // dep_hostname_char_replacement + S_581_121 = 581, // $@121 + S_config_control = 582, // config_control + S_583_122 = 583, // $@122 + S_sub_config_control = 584, // sub_config_control + S_585_123 = 585, // $@123 + S_config_control_params = 586, // config_control_params + S_config_control_param = 587, // config_control_param + S_config_databases = 588, // config_databases + S_589_124 = 589, // $@124 + S_config_fetch_wait_time = 590, // config_fetch_wait_time + S_loggers = 591, // loggers + S_592_125 = 592, // $@125 + S_loggers_entries = 593, // loggers_entries + S_logger_entry = 594, // logger_entry + S_595_126 = 595, // $@126 + S_logger_params = 596, // logger_params + S_logger_param = 597, // logger_param + S_debuglevel = 598, // debuglevel + S_severity = 599, // severity + S_600_127 = 600, // $@127 + S_output_options_list = 601, // output_options_list + S_602_128 = 602, // $@128 + S_output_options_list_content = 603, // output_options_list_content + S_output_entry = 604, // output_entry + S_605_129 = 605, // $@129 + S_output_params_list = 606, // output_params_list + S_output_params = 607, // output_params + S_output = 608, // output + S_609_130 = 609, // $@130 + S_flush = 610, // flush + S_maxsize = 611, // maxsize + S_maxver = 612, // maxver + S_pattern = 613, // pattern + S_614_131 = 614 // $@131 + }; + }; - /// The symbol type number to denote an empty symbol. - enum { empty_symbol = -2 }; + /// (Internal) symbol kind. + typedef symbol_kind::symbol_kind_type symbol_kind_type; - /// Internal symbol number for tokens (subsumed by symbol_number_type). - typedef unsigned char token_number_type; + /// The number of tokens. + static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; /// A complete symbol. /// - /// Expects its Base type to provide access to the symbol type - /// via type_get (). + /// Expects its Base type to provide access to the symbol kind + /// via kind (). /// /// Provide access to semantic value and location. template @@ -707,13 +1348,52 @@ namespace isc { namespace dhcp { #if 201103L <= YY_CPLUSPLUS /// Move constructor. - basic_symbol (basic_symbol&& that); + basic_symbol (basic_symbol&& that) + : Base (std::move (that)) + , value () + , location (std::move (that.location)) + { + switch (this->kind ()) + { + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value + value.move< ElementPtr > (std::move (that.value)); + break; + + case symbol_kind::S_BOOLEAN: // "boolean" + value.move< bool > (std::move (that.value)); + break; + + case symbol_kind::S_FLOAT: // "floating point" + value.move< double > (std::move (that.value)); + break; + + case symbol_kind::S_INTEGER: // "integer" + value.move< int64_t > (std::move (that.value)); + break; + + case symbol_kind::S_STRING: // "constant string" + value.move< std::string > (std::move (that.value)); + break; + + default: + break; + } + + } #endif /// Copy constructor. basic_symbol (const basic_symbol& that); - /// Constructor for valueless symbols, and symbols from each type. + /// Constructors for typed symbols. #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, location_type&& l) : Base (t) @@ -725,6 +1405,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, ElementPtr&& v, location_type&& l) : Base (t) @@ -738,6 +1419,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, bool&& v, location_type&& l) : Base (t) @@ -751,6 +1433,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, double&& v, location_type&& l) : Base (t) @@ -764,6 +1447,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, int64_t&& v, location_type&& l) : Base (t) @@ -777,6 +1461,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l) : Base (t) @@ -798,46 +1483,46 @@ namespace isc { namespace dhcp { } /// Destroy contents, and record that is empty. - void clear () + void clear () YY_NOEXCEPT { // User destructor. - symbol_number_type yytype = this->type_get (); + symbol_kind_type yykind = this->kind (); basic_symbol& yysym = *this; (void) yysym; - switch (yytype) + switch (yykind) { default: break; } - // Type destructor. -switch (yytype) + // Value type destructor. +switch (yykind) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.template destroy< ElementPtr > (); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.template destroy< bool > (); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.template destroy< double > (); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.template destroy< int64_t > (); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.template destroy< std::string > (); break; @@ -848,6 +1533,15 @@ switch (yytype) Base::clear (); } + /// The user-facing name of this symbol. + std::string name () const YY_NOEXCEPT + { + return Dhcp4Parser::symbol_name (this->kind ()); + } + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + /// Whether empty. bool empty () const YY_NOEXCEPT; @@ -868,46 +1562,51 @@ switch (yytype) }; /// Type access provider for token (enum) based symbols. - struct by_type + struct by_kind { /// Default constructor. - by_type (); + by_kind (); #if 201103L <= YY_CPLUSPLUS /// Move constructor. - by_type (by_type&& that); + by_kind (by_kind&& that); #endif /// Copy constructor. - by_type (const by_type& that); + by_kind (const by_kind& that); - /// The symbol type as needed by the constructor. - typedef token_type kind_type; + /// The symbol kind as needed by the constructor. + typedef token_kind_type kind_type; /// Constructor from (external) token numbers. - by_type (kind_type t); + by_kind (kind_type t); /// Record that this symbol is empty. - void clear (); + void clear () YY_NOEXCEPT; - /// Steal the symbol type from \a that. - void move (by_type& that); + /// Steal the symbol kind from \a that. + void move (by_kind& that); /// The (internal) type number (corresponding to \a type). /// \a empty when empty. - symbol_number_type type_get () const YY_NOEXCEPT; + symbol_kind_type kind () const YY_NOEXCEPT; - /// The symbol type. - /// \a empty_symbol when empty. - /// An int, not token_number_type, to be able to store empty_symbol. - int type; + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + + /// The symbol kind. + /// \a S_YYEMPTY when empty. + symbol_kind_type kind_; }; + /// Backward compatibility for a private implementation detail (Bison 3.6). + typedef by_kind by_type; + /// "External" symbols: returned by the scanner. - struct symbol_type : basic_symbol + struct symbol_type : basic_symbol { /// Superclass. - typedef basic_symbol super_type; + typedef basic_symbol super_type; /// Empty symbol. symbol_type () {} @@ -916,74 +1615,67 @@ switch (yytype) #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, location_type l) : super_type(token_type (tok), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_END || tok == token::TOKEN_COMMA || tok == token::TOKEN_COLON || tok == token::TOKEN_LSQUARE_BRACKET || tok == token::TOKEN_RSQUARE_BRACKET || tok == token::TOKEN_LCURLY_BRACKET || tok == token::TOKEN_RCURLY_BRACKET || tok == token::TOKEN_NULL_TYPE || tok == token::TOKEN_DHCP4 || tok == token::TOKEN_CONFIG_CONTROL || tok == token::TOKEN_CONFIG_DATABASES || tok == token::TOKEN_CONFIG_FETCH_WAIT_TIME || tok == token::TOKEN_INTERFACES_CONFIG || tok == token::TOKEN_INTERFACES || tok == token::TOKEN_DHCP_SOCKET_TYPE || tok == token::TOKEN_RAW || tok == token::TOKEN_UDP || tok == token::TOKEN_OUTBOUND_INTERFACE || tok == token::TOKEN_SAME_AS_INBOUND || tok == token::TOKEN_USE_ROUTING || tok == token::TOKEN_RE_DETECT || tok == token::TOKEN_SANITY_CHECKS || tok == token::TOKEN_LEASE_CHECKS || tok == token::TOKEN_ECHO_CLIENT_ID || tok == token::TOKEN_MATCH_CLIENT_ID || tok == token::TOKEN_AUTHORITATIVE || tok == token::TOKEN_NEXT_SERVER || tok == token::TOKEN_SERVER_HOSTNAME || tok == token::TOKEN_BOOT_FILE_NAME || tok == token::TOKEN_LEASE_DATABASE || tok == token::TOKEN_HOSTS_DATABASE || tok == token::TOKEN_HOSTS_DATABASES || tok == token::TOKEN_TYPE || tok == token::TOKEN_MEMFILE || tok == token::TOKEN_MYSQL || tok == token::TOKEN_POSTGRESQL || tok == token::TOKEN_CQL || tok == token::TOKEN_USER || tok == token::TOKEN_PASSWORD || tok == token::TOKEN_HOST || tok == token::TOKEN_PORT || tok == token::TOKEN_PERSIST || tok == token::TOKEN_LFC_INTERVAL || tok == token::TOKEN_READONLY || tok == token::TOKEN_CONNECT_TIMEOUT || tok == token::TOKEN_CONTACT_POINTS || tok == token::TOKEN_KEYSPACE || tok == token::TOKEN_CONSISTENCY || tok == token::TOKEN_SERIAL_CONSISTENCY || tok == token::TOKEN_MAX_RECONNECT_TRIES || tok == token::TOKEN_RECONNECT_WAIT_TIME || tok == token::TOKEN_ON_FAIL || tok == token::TOKEN_STOP_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_CONTINUE || tok == token::TOKEN_REQUEST_TIMEOUT || tok == token::TOKEN_TCP_KEEPALIVE || tok == token::TOKEN_TCP_NODELAY || tok == token::TOKEN_MAX_ROW_ERRORS || tok == token::TOKEN_VALID_LIFETIME || tok == token::TOKEN_MIN_VALID_LIFETIME || tok == token::TOKEN_MAX_VALID_LIFETIME || tok == token::TOKEN_RENEW_TIMER || tok == token::TOKEN_REBIND_TIMER || tok == token::TOKEN_CALCULATE_TEE_TIMES || tok == token::TOKEN_T1_PERCENT || tok == token::TOKEN_T2_PERCENT || tok == token::TOKEN_CACHE_THRESHOLD || tok == token::TOKEN_CACHE_MAX_AGE || tok == token::TOKEN_DECLINE_PROBATION_PERIOD || tok == token::TOKEN_SERVER_TAG || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE || tok == token::TOKEN_DDNS_SEND_UPDATES || tok == token::TOKEN_DDNS_OVERRIDE_NO_UPDATE || tok == token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_DDNS_REPLACE_CLIENT_NAME || tok == token::TOKEN_DDNS_GENERATED_PREFIX || tok == token::TOKEN_DDNS_QUALIFYING_SUFFIX || tok == token::TOKEN_DDNS_UPDATE_ON_RENEW || tok == token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION || tok == token::TOKEN_STORE_EXTENDED_INFO || tok == token::TOKEN_SUBNET4 || tok == token::TOKEN_SUBNET_4O6_INTERFACE || tok == token::TOKEN_SUBNET_4O6_INTERFACE_ID || tok == token::TOKEN_SUBNET_4O6_SUBNET || tok == token::TOKEN_OPTION_DEF || tok == token::TOKEN_OPTION_DATA || tok == token::TOKEN_NAME || tok == token::TOKEN_DATA || tok == token::TOKEN_CODE || tok == token::TOKEN_SPACE || tok == token::TOKEN_CSV_FORMAT || tok == token::TOKEN_ALWAYS_SEND || tok == token::TOKEN_RECORD_TYPES || tok == token::TOKEN_ENCAPSULATE || tok == token::TOKEN_ARRAY || tok == token::TOKEN_SHARED_NETWORKS || tok == token::TOKEN_POOLS || tok == token::TOKEN_POOL || tok == token::TOKEN_USER_CONTEXT || tok == token::TOKEN_COMMENT || tok == token::TOKEN_SUBNET || tok == token::TOKEN_INTERFACE || tok == token::TOKEN_ID || tok == token::TOKEN_RESERVATION_MODE || tok == token::TOKEN_DISABLED || tok == token::TOKEN_OUT_OF_POOL || tok == token::TOKEN_GLOBAL || tok == token::TOKEN_ALL || tok == token::TOKEN_RESERVATIONS_GLOBAL || tok == token::TOKEN_RESERVATIONS_IN_SUBNET || tok == token::TOKEN_RESERVATIONS_OUT_OF_POOL || tok == token::TOKEN_HOST_RESERVATION_IDENTIFIERS || tok == token::TOKEN_CLIENT_CLASSES || tok == token::TOKEN_REQUIRE_CLIENT_CLASSES || tok == token::TOKEN_TEST || tok == token::TOKEN_ONLY_IF_REQUIRED || tok == token::TOKEN_CLIENT_CLASS || tok == token::TOKEN_RESERVATIONS || tok == token::TOKEN_DUID || tok == token::TOKEN_HW_ADDRESS || tok == token::TOKEN_CIRCUIT_ID || tok == token::TOKEN_CLIENT_ID || tok == token::TOKEN_HOSTNAME || tok == token::TOKEN_FLEX_ID || tok == token::TOKEN_RELAY || tok == token::TOKEN_IP_ADDRESS || tok == token::TOKEN_IP_ADDRESSES || tok == token::TOKEN_HOOKS_LIBRARIES || tok == token::TOKEN_LIBRARY || tok == token::TOKEN_PARAMETERS || tok == token::TOKEN_EXPIRED_LEASES_PROCESSING || tok == token::TOKEN_RECLAIM_TIMER_WAIT_TIME || tok == token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME || tok == token::TOKEN_HOLD_RECLAIMED_TIME || tok == token::TOKEN_MAX_RECLAIM_LEASES || tok == token::TOKEN_MAX_RECLAIM_TIME || tok == token::TOKEN_UNWARNED_RECLAIM_CYCLES || tok == token::TOKEN_DHCP4O6_PORT || tok == token::TOKEN_DHCP_MULTI_THREADING || tok == token::TOKEN_ENABLE_MULTI_THREADING || tok == token::TOKEN_THREAD_POOL_SIZE || tok == token::TOKEN_PACKET_QUEUE_SIZE || tok == token::TOKEN_CONTROL_SOCKET || tok == token::TOKEN_SOCKET_TYPE || tok == token::TOKEN_SOCKET_NAME || tok == token::TOKEN_DHCP_QUEUE_CONTROL || tok == token::TOKEN_ENABLE_QUEUE || tok == token::TOKEN_QUEUE_TYPE || tok == token::TOKEN_CAPACITY || tok == token::TOKEN_DHCP_DDNS || tok == token::TOKEN_ENABLE_UPDATES || tok == token::TOKEN_QUALIFYING_SUFFIX || tok == token::TOKEN_SERVER_IP || tok == token::TOKEN_SERVER_PORT || tok == token::TOKEN_SENDER_IP || tok == token::TOKEN_SENDER_PORT || tok == token::TOKEN_MAX_QUEUE_SIZE || tok == token::TOKEN_NCR_PROTOCOL || tok == token::TOKEN_NCR_FORMAT || tok == token::TOKEN_OVERRIDE_NO_UPDATE || tok == token::TOKEN_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_REPLACE_CLIENT_NAME || tok == token::TOKEN_GENERATED_PREFIX || tok == token::TOKEN_TCP || tok == token::TOKEN_JSON || tok == token::TOKEN_WHEN_PRESENT || tok == token::TOKEN_NEVER || tok == token::TOKEN_ALWAYS || tok == token::TOKEN_WHEN_NOT_PRESENT || tok == token::TOKEN_HOSTNAME_CHAR_SET || tok == token::TOKEN_HOSTNAME_CHAR_REPLACEMENT || tok == token::TOKEN_IP_RESERVATIONS_UNIQUE || tok == token::TOKEN_LOGGERS || tok == token::TOKEN_OUTPUT_OPTIONS || tok == token::TOKEN_OUTPUT || tok == token::TOKEN_DEBUGLEVEL || tok == token::TOKEN_SEVERITY || tok == token::TOKEN_FLUSH || tok == token::TOKEN_MAXSIZE || tok == token::TOKEN_MAXVER || tok == token::TOKEN_PATTERN || tok == token::TOKEN_TOPLEVEL_JSON || tok == token::TOKEN_TOPLEVEL_DHCP4 || tok == token::TOKEN_SUB_DHCP4 || tok == token::TOKEN_SUB_INTERFACES4 || tok == token::TOKEN_SUB_SUBNET4 || tok == token::TOKEN_SUB_POOL4 || tok == token::TOKEN_SUB_RESERVATION || tok == token::TOKEN_SUB_OPTION_DEFS || tok == token::TOKEN_SUB_OPTION_DEF || tok == token::TOKEN_SUB_OPTION_DATA || tok == token::TOKEN_SUB_HOOKS_LIBRARY || tok == token::TOKEN_SUB_DHCP_DDNS || tok == token::TOKEN_SUB_CONFIG_CONTROL); - } #else symbol_type (int tok, const location_type& l) : super_type(token_type (tok), l) +#endif { - YY_ASSERT (tok == token::TOKEN_END || tok == token::TOKEN_COMMA || tok == token::TOKEN_COLON || tok == token::TOKEN_LSQUARE_BRACKET || tok == token::TOKEN_RSQUARE_BRACKET || tok == token::TOKEN_LCURLY_BRACKET || tok == token::TOKEN_RCURLY_BRACKET || tok == token::TOKEN_NULL_TYPE || tok == token::TOKEN_DHCP4 || tok == token::TOKEN_CONFIG_CONTROL || tok == token::TOKEN_CONFIG_DATABASES || tok == token::TOKEN_CONFIG_FETCH_WAIT_TIME || tok == token::TOKEN_INTERFACES_CONFIG || tok == token::TOKEN_INTERFACES || tok == token::TOKEN_DHCP_SOCKET_TYPE || tok == token::TOKEN_RAW || tok == token::TOKEN_UDP || tok == token::TOKEN_OUTBOUND_INTERFACE || tok == token::TOKEN_SAME_AS_INBOUND || tok == token::TOKEN_USE_ROUTING || tok == token::TOKEN_RE_DETECT || tok == token::TOKEN_SANITY_CHECKS || tok == token::TOKEN_LEASE_CHECKS || tok == token::TOKEN_ECHO_CLIENT_ID || tok == token::TOKEN_MATCH_CLIENT_ID || tok == token::TOKEN_AUTHORITATIVE || tok == token::TOKEN_NEXT_SERVER || tok == token::TOKEN_SERVER_HOSTNAME || tok == token::TOKEN_BOOT_FILE_NAME || tok == token::TOKEN_LEASE_DATABASE || tok == token::TOKEN_HOSTS_DATABASE || tok == token::TOKEN_HOSTS_DATABASES || tok == token::TOKEN_TYPE || tok == token::TOKEN_MEMFILE || tok == token::TOKEN_MYSQL || tok == token::TOKEN_POSTGRESQL || tok == token::TOKEN_CQL || tok == token::TOKEN_USER || tok == token::TOKEN_PASSWORD || tok == token::TOKEN_HOST || tok == token::TOKEN_PORT || tok == token::TOKEN_PERSIST || tok == token::TOKEN_LFC_INTERVAL || tok == token::TOKEN_READONLY || tok == token::TOKEN_CONNECT_TIMEOUT || tok == token::TOKEN_CONTACT_POINTS || tok == token::TOKEN_KEYSPACE || tok == token::TOKEN_CONSISTENCY || tok == token::TOKEN_SERIAL_CONSISTENCY || tok == token::TOKEN_MAX_RECONNECT_TRIES || tok == token::TOKEN_RECONNECT_WAIT_TIME || tok == token::TOKEN_ON_FAIL || tok == token::TOKEN_STOP_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_CONTINUE || tok == token::TOKEN_REQUEST_TIMEOUT || tok == token::TOKEN_TCP_KEEPALIVE || tok == token::TOKEN_TCP_NODELAY || tok == token::TOKEN_MAX_ROW_ERRORS || tok == token::TOKEN_VALID_LIFETIME || tok == token::TOKEN_MIN_VALID_LIFETIME || tok == token::TOKEN_MAX_VALID_LIFETIME || tok == token::TOKEN_RENEW_TIMER || tok == token::TOKEN_REBIND_TIMER || tok == token::TOKEN_CALCULATE_TEE_TIMES || tok == token::TOKEN_T1_PERCENT || tok == token::TOKEN_T2_PERCENT || tok == token::TOKEN_CACHE_THRESHOLD || tok == token::TOKEN_CACHE_MAX_AGE || tok == token::TOKEN_DECLINE_PROBATION_PERIOD || tok == token::TOKEN_SERVER_TAG || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE || tok == token::TOKEN_DDNS_SEND_UPDATES || tok == token::TOKEN_DDNS_OVERRIDE_NO_UPDATE || tok == token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_DDNS_REPLACE_CLIENT_NAME || tok == token::TOKEN_DDNS_GENERATED_PREFIX || tok == token::TOKEN_DDNS_QUALIFYING_SUFFIX || tok == token::TOKEN_DDNS_UPDATE_ON_RENEW || tok == token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION || tok == token::TOKEN_STORE_EXTENDED_INFO || tok == token::TOKEN_SUBNET4 || tok == token::TOKEN_SUBNET_4O6_INTERFACE || tok == token::TOKEN_SUBNET_4O6_INTERFACE_ID || tok == token::TOKEN_SUBNET_4O6_SUBNET || tok == token::TOKEN_OPTION_DEF || tok == token::TOKEN_OPTION_DATA || tok == token::TOKEN_NAME || tok == token::TOKEN_DATA || tok == token::TOKEN_CODE || tok == token::TOKEN_SPACE || tok == token::TOKEN_CSV_FORMAT || tok == token::TOKEN_ALWAYS_SEND || tok == token::TOKEN_RECORD_TYPES || tok == token::TOKEN_ENCAPSULATE || tok == token::TOKEN_ARRAY || tok == token::TOKEN_SHARED_NETWORKS || tok == token::TOKEN_POOLS || tok == token::TOKEN_POOL || tok == token::TOKEN_USER_CONTEXT || tok == token::TOKEN_COMMENT || tok == token::TOKEN_SUBNET || tok == token::TOKEN_INTERFACE || tok == token::TOKEN_ID || tok == token::TOKEN_RESERVATION_MODE || tok == token::TOKEN_DISABLED || tok == token::TOKEN_OUT_OF_POOL || tok == token::TOKEN_GLOBAL || tok == token::TOKEN_ALL || tok == token::TOKEN_RESERVATIONS_GLOBAL || tok == token::TOKEN_RESERVATIONS_IN_SUBNET || tok == token::TOKEN_RESERVATIONS_OUT_OF_POOL || tok == token::TOKEN_HOST_RESERVATION_IDENTIFIERS || tok == token::TOKEN_CLIENT_CLASSES || tok == token::TOKEN_REQUIRE_CLIENT_CLASSES || tok == token::TOKEN_TEST || tok == token::TOKEN_ONLY_IF_REQUIRED || tok == token::TOKEN_CLIENT_CLASS || tok == token::TOKEN_RESERVATIONS || tok == token::TOKEN_DUID || tok == token::TOKEN_HW_ADDRESS || tok == token::TOKEN_CIRCUIT_ID || tok == token::TOKEN_CLIENT_ID || tok == token::TOKEN_HOSTNAME || tok == token::TOKEN_FLEX_ID || tok == token::TOKEN_RELAY || tok == token::TOKEN_IP_ADDRESS || tok == token::TOKEN_IP_ADDRESSES || tok == token::TOKEN_HOOKS_LIBRARIES || tok == token::TOKEN_LIBRARY || tok == token::TOKEN_PARAMETERS || tok == token::TOKEN_EXPIRED_LEASES_PROCESSING || tok == token::TOKEN_RECLAIM_TIMER_WAIT_TIME || tok == token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME || tok == token::TOKEN_HOLD_RECLAIMED_TIME || tok == token::TOKEN_MAX_RECLAIM_LEASES || tok == token::TOKEN_MAX_RECLAIM_TIME || tok == token::TOKEN_UNWARNED_RECLAIM_CYCLES || tok == token::TOKEN_DHCP4O6_PORT || tok == token::TOKEN_DHCP_MULTI_THREADING || tok == token::TOKEN_ENABLE_MULTI_THREADING || tok == token::TOKEN_THREAD_POOL_SIZE || tok == token::TOKEN_PACKET_QUEUE_SIZE || tok == token::TOKEN_CONTROL_SOCKET || tok == token::TOKEN_SOCKET_TYPE || tok == token::TOKEN_SOCKET_NAME || tok == token::TOKEN_DHCP_QUEUE_CONTROL || tok == token::TOKEN_ENABLE_QUEUE || tok == token::TOKEN_QUEUE_TYPE || tok == token::TOKEN_CAPACITY || tok == token::TOKEN_DHCP_DDNS || tok == token::TOKEN_ENABLE_UPDATES || tok == token::TOKEN_QUALIFYING_SUFFIX || tok == token::TOKEN_SERVER_IP || tok == token::TOKEN_SERVER_PORT || tok == token::TOKEN_SENDER_IP || tok == token::TOKEN_SENDER_PORT || tok == token::TOKEN_MAX_QUEUE_SIZE || tok == token::TOKEN_NCR_PROTOCOL || tok == token::TOKEN_NCR_FORMAT || tok == token::TOKEN_OVERRIDE_NO_UPDATE || tok == token::TOKEN_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_REPLACE_CLIENT_NAME || tok == token::TOKEN_GENERATED_PREFIX || tok == token::TOKEN_TCP || tok == token::TOKEN_JSON || tok == token::TOKEN_WHEN_PRESENT || tok == token::TOKEN_NEVER || tok == token::TOKEN_ALWAYS || tok == token::TOKEN_WHEN_NOT_PRESENT || tok == token::TOKEN_HOSTNAME_CHAR_SET || tok == token::TOKEN_HOSTNAME_CHAR_REPLACEMENT || tok == token::TOKEN_IP_RESERVATIONS_UNIQUE || tok == token::TOKEN_LOGGERS || tok == token::TOKEN_OUTPUT_OPTIONS || tok == token::TOKEN_OUTPUT || tok == token::TOKEN_DEBUGLEVEL || tok == token::TOKEN_SEVERITY || tok == token::TOKEN_FLUSH || tok == token::TOKEN_MAXSIZE || tok == token::TOKEN_MAXVER || tok == token::TOKEN_PATTERN || tok == token::TOKEN_TOPLEVEL_JSON || tok == token::TOKEN_TOPLEVEL_DHCP4 || tok == token::TOKEN_SUB_DHCP4 || tok == token::TOKEN_SUB_INTERFACES4 || tok == token::TOKEN_SUB_SUBNET4 || tok == token::TOKEN_SUB_POOL4 || tok == token::TOKEN_SUB_RESERVATION || tok == token::TOKEN_SUB_OPTION_DEFS || tok == token::TOKEN_SUB_OPTION_DEF || tok == token::TOKEN_SUB_OPTION_DATA || tok == token::TOKEN_SUB_HOOKS_LIBRARY || tok == token::TOKEN_SUB_DHCP_DDNS || tok == token::TOKEN_SUB_CONFIG_CONTROL); + PARSER4__ASSERT (tok == token::TOKEN_END + || (token::TOKEN_PARSER4_error <= tok && tok <= token::TOKEN_SUB_CONFIG_CONTROL)); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, bool v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_BOOLEAN); - } #else symbol_type (int tok, const bool& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_BOOLEAN); + PARSER4__ASSERT (tok == token::TOKEN_BOOLEAN); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, double v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_FLOAT); - } #else symbol_type (int tok, const double& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_FLOAT); + PARSER4__ASSERT (tok == token::TOKEN_FLOAT); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, int64_t v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_INTEGER); - } #else symbol_type (int tok, const int64_t& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_INTEGER); + PARSER4__ASSERT (tok == token::TOKEN_INTEGER); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, std::string v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_STRING); - } #else symbol_type (int tok, const std::string& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_STRING); + PARSER4__ASSERT (tok == token::TOKEN_STRING); } -#endif }; /// Build a parser object. Dhcp4Parser (isc::dhcp::Parser4Context& ctx_yyarg); virtual ~Dhcp4Parser (); +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + Dhcp4Parser (const Dhcp4Parser&) = delete; + /// Non copyable. + Dhcp4Parser& operator= (const Dhcp4Parser&) = delete; +#endif + /// Parse. An alias for parse (). /// \returns 0 iff parsing succeeded. int operator() (); @@ -1014,6 +1706,10 @@ switch (yytype) /// Report a syntax error. void error (const syntax_error& err); + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static std::string symbol_name (symbol_kind_type yysymbol); + // Implementation of make_symbol for each symbol type. #if 201103L <= YY_CPLUSPLUS static @@ -1030,6 +1726,36 @@ switch (yytype) return symbol_type (token::TOKEN_END, l); } #endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_PARSER4_error (location_type l) + { + return symbol_type (token::TOKEN_PARSER4_error, std::move (l)); + } +#else + static + symbol_type + make_PARSER4_error (const location_type& l) + { + return symbol_type (token::TOKEN_PARSER4_error, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_PARSER4_UNDEF (location_type l) + { + return symbol_type (token::TOKEN_PARSER4_UNDEF, std::move (l)); + } +#else + static + symbol_type + make_PARSER4_UNDEF (const location_type& l) + { + return symbol_type (token::TOKEN_PARSER4_UNDEF, l); + } +#endif #if 201103L <= YY_CPLUSPLUS static symbol_type @@ -4017,20 +4743,43 @@ switch (yytype) #endif + class context + { + public: + context (const Dhcp4Parser& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); } + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } + + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const Dhcp4Parser& yyparser_; + const symbol_type& yyla_; + }; + private: - /// This class is not copyable. +#if YY_CPLUSPLUS < 201103L + /// Non copyable. Dhcp4Parser (const Dhcp4Parser&); + /// Non copyable. Dhcp4Parser& operator= (const Dhcp4Parser&); +#endif + /// Stored state numbers (used for stacks). typedef short state_type; - /// Generate an error message. - /// \param yystate the state where the error occurred. - /// \param yyla the lookahead token. - virtual std::string yysyntax_error_ (state_type yystate, - const symbol_type& yyla) const; + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const; /// Compute post-reduction state. /// \param yystate the current state /// \param yysym the nonterminal to push on the stack @@ -4047,10 +4796,17 @@ switch (yytype) static const short yypact_ninf_; static const signed char yytable_ninf_; - /// Convert a scanner token number \a t to a symbol number. - /// In theory \a t should be a token_type, but character literals + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals /// are valid, yet not members of the token_type enum. - static token_number_type yytranslate_ (int t); + static symbol_kind_type yytranslate_ (int t); + + /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + + /// For a symbol, its name in clear. + static const char* const yytname_[]; + // Tables. // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing @@ -4086,26 +4842,20 @@ switch (yytype) static const signed char yyr2_[]; - /// Convert the symbol name \a n to a form suitable for a diagnostic. - static std::string yytnamerr_ (const char *n); - - - /// For a symbol, its name in clear. - static const char* const yytname_[]; #if PARSER4_DEBUG // YYRLINE[YYN] -- Source line where rule number YYN was defined. static const short yyrline_[]; /// Report on the debug stream that the rule \a r is going to be reduced. - virtual void yy_reduce_print_ (int r); + virtual void yy_reduce_print_ (int r) const; /// Print the state stack on the debug stream. - virtual void yystack_print_ (); + virtual void yy_stack_print_ () const; /// Debugging level. int yydebug_; /// Debug stream. std::ostream* yycdebug_; - /// \brief Display a symbol type, value and location. + /// \brief Display a symbol kind, value and location. /// \param yyo The output stream. /// \param yysym The symbol. template @@ -4126,7 +4876,7 @@ switch (yytype) /// Default constructor. by_state () YY_NOEXCEPT; - /// The symbol type as needed by the constructor. + /// The symbol kind as needed by the constructor. typedef state_type kind_type; /// Constructor. @@ -4138,12 +4888,12 @@ switch (yytype) /// Record that this symbol is empty. void clear () YY_NOEXCEPT; - /// Steal the symbol type from \a that. + /// Steal the symbol kind from \a that. void move (by_state& that); - /// The (internal) type number (corresponding to \a state). - /// \a empty_symbol when empty. - symbol_number_type type_get () const YY_NOEXCEPT; + /// The symbol kind (corresponding to \a state). + /// \a symbol_kind::S_YYEMPTY when empty. + symbol_kind_type kind () const YY_NOEXCEPT; /// The state number used to denote an empty symbol. /// We use the initial state, as it does not have a value. @@ -4182,8 +4932,8 @@ switch (yytype) { public: // Hide our reversed order. - typedef typename S::reverse_iterator iterator; - typedef typename S::const_reverse_iterator const_iterator; + typedef typename S::iterator iterator; + typedef typename S::const_iterator const_iterator; typedef typename S::size_type size_type; typedef typename std::ptrdiff_t index_type; @@ -4191,6 +4941,13 @@ switch (yytype) : seq_ (n) {} +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + stack (const stack&) = delete; + /// Non copyable. + stack& operator= (const stack&) = delete; +#endif + /// Random access. /// /// Index 0 returns the topmost element. @@ -4241,24 +4998,18 @@ switch (yytype) return index_type (seq_.size ()); } - std::ptrdiff_t - ssize () const YY_NOEXCEPT - { - return std::ptrdiff_t (size ()); - } - /// Iterator on top of the stack (going downwards). const_iterator begin () const YY_NOEXCEPT { - return seq_.rbegin (); + return seq_.begin (); } /// Bottom of the stack. const_iterator end () const YY_NOEXCEPT { - return seq_.rend (); + return seq_.end (); } /// Present a slice of the top of a stack. @@ -4282,8 +5033,12 @@ switch (yytype) }; private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. stack (const stack&); + /// Non copyable. stack& operator= (const stack&); +#endif /// The wrapped container. S seq_; }; @@ -4313,33 +5068,28 @@ switch (yytype) /// Pop \a n symbols from the stack. void yypop_ (int n = 1); - /// Some specific tokens. - static const token_number_type yy_error_token_ = 1; - static const token_number_type yy_undef_token_ = 2; - /// Constants. enum { - yyeof_ = 0, yylast_ = 1230, ///< Last index in yytable_. yynnts_ = 413, ///< Number of nonterminal symbols. - yyfinal_ = 28, ///< Termination state number. - yyntokens_ = 202 ///< Number of tokens. + yyfinal_ = 28 ///< Termination state number. }; // User arguments. isc::dhcp::Parser4Context& ctx; + }; inline - Dhcp4Parser::token_number_type + Dhcp4Parser::symbol_kind_type Dhcp4Parser::yytranslate_ (int t) { // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to // TOKEN-NUM as returned by yylex. static - const token_number_type + const unsigned char translate_table[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -4389,94 +5139,51 @@ switch (yytype) 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201 }; - const int user_token_number_max_ = 456; + // Last valid token kind. + const int code_max = 456; if (t <= 0) - return yyeof_; - else if (t <= user_token_number_max_) - return translate_table[t]; + return symbol_kind::S_YYEOF; + else if (t <= code_max) + return YY_CAST (symbol_kind_type, translate_table[t]); else - return yy_undef_token_; + return symbol_kind::S_YYUNDEF; } // basic_symbol. -#if 201103L <= YY_CPLUSPLUS - template - Dhcp4Parser::basic_symbol::basic_symbol (basic_symbol&& that) - : Base (std::move (that)) - , value () - , location (std::move (that.location)) - { - switch (this->type_get ()) - { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value - value.move< ElementPtr > (std::move (that.value)); - break; - - case 201: // "boolean" - value.move< bool > (std::move (that.value)); - break; - - case 200: // "floating point" - value.move< double > (std::move (that.value)); - break; - - case 199: // "integer" - value.move< int64_t > (std::move (that.value)); - break; - - case 198: // "constant string" - value.move< std::string > (std::move (that.value)); - break; - - default: - break; - } - - } -#endif - template Dhcp4Parser::basic_symbol::basic_symbol (const basic_symbol& that) : Base (that) , value () , location (that.location) { - switch (this->type_get ()) + switch (this->kind ()) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.copy< ElementPtr > (YY_MOVE (that.value)); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.copy< bool > (YY_MOVE (that.value)); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.copy< double > (YY_MOVE (that.value)); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.copy< int64_t > (YY_MOVE (that.value)); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.copy< std::string > (YY_MOVE (that.value)); break; @@ -4488,11 +5195,18 @@ switch (yytype) + template + Dhcp4Parser::symbol_kind_type + Dhcp4Parser::basic_symbol::type_get () const YY_NOEXCEPT + { + return this->kind (); + } + template bool Dhcp4Parser::basic_symbol::empty () const YY_NOEXCEPT { - return Base::type_get () == empty_symbol; + return this->kind () == symbol_kind::S_YYEMPTY; } template @@ -4500,33 +5214,33 @@ switch (yytype) Dhcp4Parser::basic_symbol::move (basic_symbol& s) { super_type::move (s); - switch (this->type_get ()) + switch (this->kind ()) { - case 217: // value - case 221: // map_value - case 262: // ddns_replace_client_name_value - case 287: // socket_type - case 290: // outbound_interface_value - case 312: // db_type - case 341: // on_fail_mode - case 412: // hr_mode - case 567: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_socket_type: // socket_type + case symbol_kind::S_outbound_interface_value: // outbound_interface_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.move< ElementPtr > (YY_MOVE (s.value)); break; - case 201: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.move< bool > (YY_MOVE (s.value)); break; - case 200: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.move< double > (YY_MOVE (s.value)); break; - case 199: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.move< int64_t > (YY_MOVE (s.value)); break; - case 198: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.move< std::string > (YY_MOVE (s.value)); break; @@ -4537,57 +5251,63 @@ switch (yytype) location = YY_MOVE (s.location); } - // by_type. + // by_kind. inline - Dhcp4Parser::by_type::by_type () - : type (empty_symbol) + Dhcp4Parser::by_kind::by_kind () + : kind_ (symbol_kind::S_YYEMPTY) {} #if 201103L <= YY_CPLUSPLUS inline - Dhcp4Parser::by_type::by_type (by_type&& that) - : type (that.type) + Dhcp4Parser::by_kind::by_kind (by_kind&& that) + : kind_ (that.kind_) { that.clear (); } #endif inline - Dhcp4Parser::by_type::by_type (const by_type& that) - : type (that.type) + Dhcp4Parser::by_kind::by_kind (const by_kind& that) + : kind_ (that.kind_) {} inline - Dhcp4Parser::by_type::by_type (token_type t) - : type (yytranslate_ (t)) + Dhcp4Parser::by_kind::by_kind (token_kind_type t) + : kind_ (yytranslate_ (t)) {} inline void - Dhcp4Parser::by_type::clear () + Dhcp4Parser::by_kind::clear () YY_NOEXCEPT { - type = empty_symbol; + kind_ = symbol_kind::S_YYEMPTY; } inline void - Dhcp4Parser::by_type::move (by_type& that) + Dhcp4Parser::by_kind::move (by_kind& that) { - type = that.type; + kind_ = that.kind_; that.clear (); } inline - int - Dhcp4Parser::by_type::type_get () const YY_NOEXCEPT + Dhcp4Parser::symbol_kind_type + Dhcp4Parser::by_kind::kind () const YY_NOEXCEPT { - return type; + return kind_; + } + + inline + Dhcp4Parser::symbol_kind_type + Dhcp4Parser::by_kind::type_get () const YY_NOEXCEPT + { + return this->kind (); } #line 14 "dhcp4_parser.yy" } } // isc::dhcp -#line 4590 "dhcp4_parser.h" - +#line 5311 "dhcp4_parser.h" diff --git a/src/bin/dhcp4/location.hh b/src/bin/dhcp4/location.hh index 72951b2f6d..1f2986e43f 100644 --- a/src/bin/dhcp4/location.hh +++ b/src/bin/dhcp4/location.hh @@ -1,8 +1,8 @@ -// A Bison parser, made by GNU Bison 3.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Locations for Bison parsers in C++ -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. +// Copyright (C) 2002-2015, 2018-2021 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 @@ -61,11 +61,13 @@ namespace isc { namespace dhcp { class position { public: + /// Type for file name. + typedef const std::string filename_type; /// Type for line and column numbers. typedef int counter_type; /// Construct a position. - explicit position (std::string* f = YY_NULLPTR, + explicit position (filename_type* f = YY_NULLPTR, counter_type l = 1, counter_type c = 1) : filename (f) @@ -75,7 +77,7 @@ namespace isc { namespace dhcp { /// Initialization. - void initialize (std::string* fn = YY_NULLPTR, + void initialize (filename_type* fn = YY_NULLPTR, counter_type l = 1, counter_type c = 1) { @@ -104,7 +106,7 @@ namespace isc { namespace dhcp { /** \} */ /// File name to which this position refers. - std::string* filename; + filename_type* filename; /// Current line number. counter_type line; /// Current column number. @@ -147,24 +149,6 @@ namespace isc { namespace dhcp { 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 @@ -182,6 +166,8 @@ namespace isc { namespace dhcp { class location { public: + /// Type for file name. + typedef position::filename_type filename_type; /// Type for line and column numbers. typedef position::counter_type counter_type; @@ -198,7 +184,7 @@ namespace isc { namespace dhcp { {} /// Construct a 0-width location in \a f, \a l, \a c. - explicit location (std::string* f, + explicit location (filename_type* f, counter_type l = 1, counter_type c = 1) : begin (f, l, c) @@ -207,7 +193,7 @@ namespace isc { namespace dhcp { /// Initialization. - void initialize (std::string* f = YY_NULLPTR, + void initialize (filename_type* f = YY_NULLPTR, counter_type l = 1, counter_type c = 1) { @@ -289,20 +275,6 @@ namespace isc { namespace dhcp { return res -= width; } - /// Compare two location objects. - inline bool - operator== (const location& loc1, const location& loc2) - { - return loc1.begin == loc2.begin && loc1.end == loc2.end; - } - - /// Compare two location objects. - inline bool - operator!= (const location& loc1, const location& loc2) - { - return !(loc1 == loc2); - } - /** \brief Intercept output stream redirection. ** \param ostr the destination output stream ** \param loc a reference to the location to redirect @@ -329,6 +301,6 @@ namespace isc { namespace dhcp { #line 14 "dhcp4_parser.yy" } } // isc::dhcp -#line 333 "location.hh" +#line 305 "location.hh" #endif // !YY_PARSER4_LOCATION_HH_INCLUDED diff --git a/src/bin/dhcp4/position.hh b/src/bin/dhcp4/position.hh index bf34c1c57a..2d3317f224 100644 --- a/src/bin/dhcp4/position.hh +++ b/src/bin/dhcp4/position.hh @@ -1,4 +1,4 @@ -// A Bison parser, made by GNU Bison 3.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Starting with Bison 3.2, this file is useless: the structure it // used to define is now defined in "location.hh". diff --git a/src/bin/dhcp4/stack.hh b/src/bin/dhcp4/stack.hh index c15d84c73d..fe7f93f75b 100644 --- a/src/bin/dhcp4/stack.hh +++ b/src/bin/dhcp4/stack.hh @@ -1,4 +1,4 @@ -// A Bison parser, made by GNU Bison 3.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Starting with Bison 3.2, this file is useless: the structure it // used to define is now defined with the parser itself. diff --git a/src/bin/dhcp6/dhcp6_lexer.cc b/src/bin/dhcp6/dhcp6_lexer.cc index 917877a681..a61ee461fd 100644 --- a/src/bin/dhcp6/dhcp6_lexer.cc +++ b/src/bin/dhcp6/dhcp6_lexer.cc @@ -1,6 +1,6 @@ -#line 2 "dhcp6_lexer.cc" +#line 1 "dhcp6_lexer.cc" -#line 4 "dhcp6_lexer.cc" +#line 3 "dhcp6_lexer.cc" #define YY_INT_ALIGNED short int @@ -2049,7 +2049,7 @@ using namespace isc::dhcp; /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::dhcp::Parser6Context::fatal(msg) -#line 2053 "dhcp6_lexer.cc" +#line 2052 "dhcp6_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 @@ -2075,8 +2075,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 2078 "dhcp6_lexer.cc" #line 2079 "dhcp6_lexer.cc" -#line 2080 "dhcp6_lexer.cc" #define INITIAL 0 #define COMMENT 1 @@ -2406,7 +2406,7 @@ YY_DECL } -#line 2410 "dhcp6_lexer.cc" +#line 2409 "dhcp6_lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -5310,7 +5310,7 @@ YY_RULE_SETUP #line 2304 "dhcp6_lexer.ll" ECHO; YY_BREAK -#line 5314 "dhcp6_lexer.cc" +#line 5313 "dhcp6_lexer.cc" case YY_END_OF_BUFFER: { diff --git a/src/bin/dhcp6/dhcp6_parser.cc b/src/bin/dhcp6/dhcp6_parser.cc index d13b56a375..54122e7578 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.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Skeleton implementation for Bison LALR(1) parsers in C++ -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. +// Copyright (C) 2002-2015, 2018-2021 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,8 +30,9 @@ // 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. +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. // Take the name prefix into account. @@ -47,7 +48,7 @@ #include -#line 51 "dhcp6_parser.cc" +#line 52 "dhcp6_parser.cc" #ifndef YY_ @@ -62,6 +63,7 @@ # endif #endif + // Whether we are compiled with exception support. #ifndef YY_EXCEPTIONS # if defined __GNUC__ && !defined __EXCEPTIONS @@ -117,13 +119,13 @@ # define YY_STACK_PRINT() \ do { \ if (yydebug_) \ - yystack_print_ (); \ + yy_stack_print_ (); \ } while (false) #else // !PARSER6_DEBUG # define YYCDEBUG if (false) std::cerr -# define YY_SYMBOL_PRINT(Title, Symbol) YYUSE (Symbol) +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) # define YY_REDUCE_PRINT(Rule) static_cast (0) # define YY_STACK_PRINT() static_cast (0) @@ -139,49 +141,7 @@ #line 14 "dhcp6_parser.yy" namespace isc { namespace dhcp { -#line 143 "dhcp6_parser.cc" - - - /* Return YYSTR after stripping away unnecessary quotes and - backslashes, so that it's suitable for yyerror. The heuristic is - that double-quoting is unnecessary unless the string contains an - apostrophe, a comma, or backslash (other than backslash-backslash). - YYSTR is taken from yytname. */ - std::string - Dhcp6Parser::yytnamerr_ (const char *yystr) - { - if (*yystr == '"') - { - std::string yyr; - char const *yyp = yystr; - - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - else - goto append; - - append: - default: - yyr += *yyp; - break; - - case '"': - return yyr; - } - do_not_strip_quotes: ; - } - - return yystr; - } - +#line 145 "dhcp6_parser.cc" /// Build a parser object. Dhcp6Parser::Dhcp6Parser (isc::dhcp::Parser6Context& ctx_yyarg) @@ -201,7 +161,7 @@ namespace isc { namespace dhcp { {} /*---------------. - | Symbol types. | + | symbol kinds. | `---------------*/ @@ -232,13 +192,13 @@ namespace isc { namespace dhcp { : state (s) {} - Dhcp6Parser::symbol_number_type - Dhcp6Parser::by_state::type_get () const YY_NOEXCEPT + Dhcp6Parser::symbol_kind_type + Dhcp6Parser::by_state::kind () const YY_NOEXCEPT { if (state == empty_state) - return empty_symbol; + return symbol_kind::S_YYEMPTY; else - return yystos_[+state]; + return YY_CAST (symbol_kind_type, yystos_[+state]); } Dhcp6Parser::stack_symbol_type::stack_symbol_type () @@ -247,32 +207,32 @@ namespace isc { namespace dhcp { 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 ()) + switch (that.kind ()) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value)); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value)); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value)); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value)); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); break; @@ -289,32 +249,32 @@ namespace isc { namespace dhcp { Dhcp6Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) : super_type (s, YY_MOVE (that.location)) { - switch (that.type_get ()) + switch (that.kind ()) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.move< ElementPtr > (YY_MOVE (that.value)); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.move< bool > (YY_MOVE (that.value)); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.move< double > (YY_MOVE (that.value)); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.move< int64_t > (YY_MOVE (that.value)); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.move< std::string > (YY_MOVE (that.value)); break; @@ -323,7 +283,7 @@ namespace isc { namespace dhcp { } // that is emptied. - that.type = empty_symbol; + that.kind_ = symbol_kind::S_YYEMPTY; } #if YY_CPLUSPLUS < 201103L @@ -331,32 +291,32 @@ namespace isc { namespace dhcp { Dhcp6Parser::stack_symbol_type::operator= (const stack_symbol_type& that) { state = that.state; - switch (that.type_get ()) + switch (that.kind ()) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.copy< ElementPtr > (that.value); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.copy< bool > (that.value); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.copy< double > (that.value); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.copy< int64_t > (that.value); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.copy< std::string > (that.value); break; @@ -372,32 +332,32 @@ namespace isc { namespace dhcp { Dhcp6Parser::stack_symbol_type::operator= (stack_symbol_type& that) { state = that.state; - switch (that.type_get ()) + switch (that.kind ()) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.move< ElementPtr > (that.value); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.move< bool > (that.value); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.move< double > (that.value); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.move< int64_t > (that.value); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.move< std::string > (that.value); break; @@ -423,99 +383,97 @@ namespace isc { namespace dhcp { #if PARSER6_DEBUG template void - Dhcp6Parser::yy_print_ (std::ostream& yyo, - const basic_symbol& yysym) const + Dhcp6Parser::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const { std::ostream& yyoutput = yyo; - YYUSE (yyoutput); - symbol_number_type yytype = yysym.type_get (); -#if defined __GNUC__ && ! defined __clang__ && ! defined __ICC && __GNUC__ * 100 + __GNUC_MINOR__ <= 408 - // Avoid a (spurious) G++ 4.8 warning about "array subscript is - // below array bounds". + YY_USE (yyoutput); if (yysym.empty ()) - std::abort (); -#endif - yyo << (yytype < yyntokens_ ? "token" : "nterm") - << ' ' << yytname_[yytype] << " (" - << yysym.location << ": "; - switch (yytype) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " (" + << yysym.location << ": "; + switch (yykind) { - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < std::string > (); } -#line 447 "dhcp6_parser.cc" +#line 404 "dhcp6_parser.cc" break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < int64_t > (); } -#line 453 "dhcp6_parser.cc" +#line 410 "dhcp6_parser.cc" break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < double > (); } -#line 459 "dhcp6_parser.cc" +#line 416 "dhcp6_parser.cc" break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < bool > (); } -#line 465 "dhcp6_parser.cc" +#line 422 "dhcp6_parser.cc" break; - case 226: // value + case symbol_kind::S_value: // value #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 471 "dhcp6_parser.cc" +#line 428 "dhcp6_parser.cc" break; - case 230: // map_value + case symbol_kind::S_map_value: // map_value #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 477 "dhcp6_parser.cc" +#line 434 "dhcp6_parser.cc" break; - case 271: // ddns_replace_client_name_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 483 "dhcp6_parser.cc" +#line 440 "dhcp6_parser.cc" break; - case 311: // db_type + case symbol_kind::S_db_type: // db_type #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 489 "dhcp6_parser.cc" +#line 446 "dhcp6_parser.cc" break; - case 328: // on_fail_mode + case symbol_kind::S_on_fail_mode: // on_fail_mode #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 495 "dhcp6_parser.cc" +#line 452 "dhcp6_parser.cc" break; - case 418: // hr_mode + case symbol_kind::S_hr_mode: // hr_mode #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 501 "dhcp6_parser.cc" +#line 458 "dhcp6_parser.cc" break; - case 554: // duid_type + case symbol_kind::S_duid_type: // duid_type #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 507 "dhcp6_parser.cc" +#line 464 "dhcp6_parser.cc" break; - case 597: // ncr_protocol_value + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value #line 288 "dhcp6_parser.yy" { yyoutput << yysym.value.template as < ElementPtr > (); } -#line 513 "dhcp6_parser.cc" +#line 470 "dhcp6_parser.cc" break; default: break; } - yyo << ')'; + yyo << ')'; + } } #endif @@ -574,11 +532,11 @@ namespace isc { namespace dhcp { Dhcp6Parser::state_type Dhcp6Parser::yy_lr_goto_state_ (state_type yystate, int yysym) { - int yyr = yypgoto_[yysym - yyntokens_] + yystate; + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) return yytable_[yyr]; else - return yydefgoto_[yysym - yyntokens_]; + return yydefgoto_[yysym - YYNTOKENS]; } bool @@ -638,6 +596,7 @@ namespace isc { namespace dhcp { `-----------------------------------------------*/ yynewstate: YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); // Accept? if (yystack_[0].state == yyfinal_) @@ -658,7 +617,7 @@ namespace isc { namespace dhcp { // Read a lookahead token. if (yyla.empty ()) { - YYCDEBUG << "Reading a token: "; + YYCDEBUG << "Reading a token\n"; #if YY_EXCEPTIONS try #endif // YY_EXCEPTIONS @@ -677,10 +636,20 @@ namespace isc { namespace dhcp { } YY_SYMBOL_PRINT ("Next token is", yyla); + if (yyla.kind () == symbol_kind::S_YYerror) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = symbol_kind::S_YYUNDEF; + goto yyerrlab1; + } + /* If the proper action on seeing token YYLA.TYPE is to reduce or to detect an error, take that action. */ - yyn += yyla.type_get (); - if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ()) + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) { goto yydefault; } @@ -727,30 +696,30 @@ namespace isc { namespace dhcp { when using variants. */ switch (yyr1_[yyn]) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value yylhs.value.emplace< ElementPtr > (); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" yylhs.value.emplace< bool > (); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" yylhs.value.emplace< double > (); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" yylhs.value.emplace< int64_t > (); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" yylhs.value.emplace< std::string > (); break; @@ -774,142 +743,142 @@ namespace isc { namespace dhcp { { switch (yyn) { - case 2: + case 2: // $@1: %empty #line 297 "dhcp6_parser.yy" { ctx.ctx_ = ctx.NO_KEYWORD; } -#line 781 "dhcp6_parser.cc" +#line 750 "dhcp6_parser.cc" break; - case 4: + case 4: // $@2: %empty #line 298 "dhcp6_parser.yy" { ctx.ctx_ = ctx.CONFIG; } -#line 787 "dhcp6_parser.cc" +#line 756 "dhcp6_parser.cc" break; - case 6: + case 6: // $@3: %empty #line 299 "dhcp6_parser.yy" { ctx.ctx_ = ctx.DHCP6; } -#line 793 "dhcp6_parser.cc" +#line 762 "dhcp6_parser.cc" break; - case 8: + case 8: // $@4: %empty #line 300 "dhcp6_parser.yy" { ctx.ctx_ = ctx.INTERFACES_CONFIG; } -#line 799 "dhcp6_parser.cc" +#line 768 "dhcp6_parser.cc" break; - case 10: + case 10: // $@5: %empty #line 301 "dhcp6_parser.yy" { ctx.ctx_ = ctx.SUBNET6; } -#line 805 "dhcp6_parser.cc" +#line 774 "dhcp6_parser.cc" break; - case 12: + case 12: // $@6: %empty #line 302 "dhcp6_parser.yy" { ctx.ctx_ = ctx.POOLS; } -#line 811 "dhcp6_parser.cc" +#line 780 "dhcp6_parser.cc" break; - case 14: + case 14: // $@7: %empty #line 303 "dhcp6_parser.yy" { ctx.ctx_ = ctx.PD_POOLS; } -#line 817 "dhcp6_parser.cc" +#line 786 "dhcp6_parser.cc" break; - case 16: + case 16: // $@8: %empty #line 304 "dhcp6_parser.yy" { ctx.ctx_ = ctx.RESERVATIONS; } -#line 823 "dhcp6_parser.cc" +#line 792 "dhcp6_parser.cc" break; - case 18: + case 18: // $@9: %empty #line 305 "dhcp6_parser.yy" { ctx.ctx_ = ctx.DHCP6; } -#line 829 "dhcp6_parser.cc" +#line 798 "dhcp6_parser.cc" break; - case 20: + case 20: // $@10: %empty #line 306 "dhcp6_parser.yy" { ctx.ctx_ = ctx.OPTION_DEF; } -#line 835 "dhcp6_parser.cc" +#line 804 "dhcp6_parser.cc" break; - case 22: + case 22: // $@11: %empty #line 307 "dhcp6_parser.yy" { ctx.ctx_ = ctx.OPTION_DATA; } -#line 841 "dhcp6_parser.cc" +#line 810 "dhcp6_parser.cc" break; - case 24: + case 24: // $@12: %empty #line 308 "dhcp6_parser.yy" { ctx.ctx_ = ctx.HOOKS_LIBRARIES; } -#line 847 "dhcp6_parser.cc" +#line 816 "dhcp6_parser.cc" break; - case 26: + case 26: // $@13: %empty #line 309 "dhcp6_parser.yy" { ctx.ctx_ = ctx.DHCP_DDNS; } -#line 853 "dhcp6_parser.cc" +#line 822 "dhcp6_parser.cc" break; - case 28: + case 28: // $@14: %empty #line 310 "dhcp6_parser.yy" { ctx.ctx_ = ctx.CONFIG_CONTROL; } -#line 859 "dhcp6_parser.cc" +#line 828 "dhcp6_parser.cc" break; - case 30: + case 30: // value: "integer" #line 318 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); } -#line 865 "dhcp6_parser.cc" +#line 834 "dhcp6_parser.cc" break; - case 31: + case 31: // value: "floating point" #line 319 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); } -#line 871 "dhcp6_parser.cc" +#line 840 "dhcp6_parser.cc" break; - case 32: + case 32: // value: "boolean" #line 320 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); } -#line 877 "dhcp6_parser.cc" +#line 846 "dhcp6_parser.cc" break; - case 33: + case 33: // value: "constant string" #line 321 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); } -#line 883 "dhcp6_parser.cc" +#line 852 "dhcp6_parser.cc" break; - case 34: + case 34: // value: "null" #line 322 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); } -#line 889 "dhcp6_parser.cc" +#line 858 "dhcp6_parser.cc" break; - case 35: + case 35: // value: map2 #line 323 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); } -#line 895 "dhcp6_parser.cc" +#line 864 "dhcp6_parser.cc" break; - case 36: + case 36: // value: list_generic #line 324 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); } -#line 901 "dhcp6_parser.cc" +#line 870 "dhcp6_parser.cc" break; - case 37: + case 37: // sub_json: value #line 327 "dhcp6_parser.yy" { // Push back the JSON value on the stack ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ()); } -#line 910 "dhcp6_parser.cc" +#line 879 "dhcp6_parser.cc" break; - case 38: + case 38: // $@15: %empty #line 332 "dhcp6_parser.yy" { // This code is executed when we're about to start parsing @@ -917,36 +886,36 @@ namespace isc { namespace dhcp { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 921 "dhcp6_parser.cc" +#line 890 "dhcp6_parser.cc" break; - case 39: + case 39: // map2: "{" $@15 map_content "}" #line 337 "dhcp6_parser.yy" { // 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 931 "dhcp6_parser.cc" +#line 900 "dhcp6_parser.cc" break; - case 40: + case 40: // map_value: map2 #line 343 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); } -#line 937 "dhcp6_parser.cc" +#line 906 "dhcp6_parser.cc" break; - case 43: + case 43: // not_empty_map: "constant string" ":" value #line 350 "dhcp6_parser.yy" { // map containing a single entry ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location)); ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ()); } -#line 947 "dhcp6_parser.cc" +#line 916 "dhcp6_parser.cc" break; - case 44: + case 44: // not_empty_map: not_empty_map "," "constant string" ":" value #line 355 "dhcp6_parser.yy" { // map consisting of a shorter map followed by @@ -954,80 +923,80 @@ namespace isc { namespace dhcp { ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location)); ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ()); } -#line 958 "dhcp6_parser.cc" +#line 927 "dhcp6_parser.cc" break; - case 45: + case 45: // $@16: %empty #line 363 "dhcp6_parser.yy" { ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(l); } -#line 967 "dhcp6_parser.cc" +#line 936 "dhcp6_parser.cc" break; - case 46: + case 46: // list_generic: "[" $@16 list_content "]" #line 366 "dhcp6_parser.yy" { // list parsing complete. Put any sanity checking here } -#line 975 "dhcp6_parser.cc" +#line 944 "dhcp6_parser.cc" break; - case 49: + case 49: // not_empty_list: value #line 374 "dhcp6_parser.yy" { // List consisting of a single element. ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ()); } -#line 984 "dhcp6_parser.cc" +#line 953 "dhcp6_parser.cc" break; - case 50: + case 50: // not_empty_list: not_empty_list "," value #line 378 "dhcp6_parser.yy" { // List ending with , and a value. ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ()); } -#line 993 "dhcp6_parser.cc" +#line 962 "dhcp6_parser.cc" break; - case 51: + case 51: // $@17: %empty #line 385 "dhcp6_parser.yy" { // List parsing about to start } -#line 1001 "dhcp6_parser.cc" +#line 970 "dhcp6_parser.cc" break; - case 52: + case 52: // list_strings: "[" $@17 list_strings_content "]" #line 387 "dhcp6_parser.yy" { // list parsing complete. Put any sanity checking here //ctx.stack_.pop_back(); } -#line 1010 "dhcp6_parser.cc" +#line 979 "dhcp6_parser.cc" break; - case 55: + case 55: // not_empty_list_strings: "constant string" #line 396 "dhcp6_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(s); } -#line 1019 "dhcp6_parser.cc" +#line 988 "dhcp6_parser.cc" break; - case 56: + case 56: // not_empty_list_strings: not_empty_list_strings "," "constant string" #line 400 "dhcp6_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(s); } -#line 1028 "dhcp6_parser.cc" +#line 997 "dhcp6_parser.cc" break; - case 57: + case 57: // unknown_map_entry: "constant string" ":" #line 411 "dhcp6_parser.yy" { const std::string& where = ctx.contextName(); @@ -1035,10 +1004,10 @@ namespace isc { namespace dhcp { error(yystack_[1].location, "got unexpected keyword \"" + keyword + "\" in " + where + " map."); } -#line 1039 "dhcp6_parser.cc" +#line 1008 "dhcp6_parser.cc" break; - case 58: + case 58: // $@18: %empty #line 420 "dhcp6_parser.yy" { // This code is executed when we're about to start parsing @@ -1046,10 +1015,10 @@ namespace isc { namespace dhcp { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 1050 "dhcp6_parser.cc" +#line 1019 "dhcp6_parser.cc" break; - case 59: + case 59: // syntax_map: "{" $@18 global_object "}" #line 425 "dhcp6_parser.yy" { // map parsing completed. If we ever want to do any wrap up @@ -1059,10 +1028,10 @@ namespace isc { namespace dhcp { // Dhcp6 is required ctx.require("Dhcp6", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); } -#line 1063 "dhcp6_parser.cc" +#line 1032 "dhcp6_parser.cc" break; - case 60: + case 60: // $@19: %empty #line 435 "dhcp6_parser.yy" { // This code is executed when we're about to start parsing @@ -1074,442 +1043,442 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.DHCP6); } -#line 1078 "dhcp6_parser.cc" +#line 1047 "dhcp6_parser.cc" break; - case 61: + case 61: // global_object: "Dhcp6" $@19 ":" "{" global_params "}" #line 444 "dhcp6_parser.yy" { // No global parameter is required ctx.stack_.pop_back(); ctx.leave(); } -#line 1088 "dhcp6_parser.cc" +#line 1057 "dhcp6_parser.cc" break; - case 62: + case 62: // $@20: %empty #line 452 "dhcp6_parser.yy" { // Parse the Dhcp6 map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 1098 "dhcp6_parser.cc" +#line 1067 "dhcp6_parser.cc" break; - case 63: + case 63: // sub_dhcp6: "{" $@20 global_params "}" #line 456 "dhcp6_parser.yy" { // No global parameter is required // parsing completed } -#line 1107 "dhcp6_parser.cc" +#line 1076 "dhcp6_parser.cc" break; - case 127: + case 127: // $@21: %empty #line 530 "dhcp6_parser.yy" { ctx.unique("data-directory", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1116 "dhcp6_parser.cc" +#line 1085 "dhcp6_parser.cc" break; - case 128: + case 128: // data_directory: "data-directory" $@21 ":" "constant string" #line 533 "dhcp6_parser.yy" { ElementPtr datadir(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("data-directory", datadir); ctx.leave(); } -#line 1126 "dhcp6_parser.cc" +#line 1095 "dhcp6_parser.cc" break; - case 129: + case 129: // preferred_lifetime: "preferred-lifetime" ":" "integer" #line 539 "dhcp6_parser.yy" { ctx.unique("preferred-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("preferred-lifetime", prf); } -#line 1136 "dhcp6_parser.cc" +#line 1105 "dhcp6_parser.cc" break; - case 130: + case 130: // min_preferred_lifetime: "min-preferred-lifetime" ":" "integer" #line 545 "dhcp6_parser.yy" { ctx.unique("min-preferred-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("min-preferred-lifetime", prf); } -#line 1146 "dhcp6_parser.cc" +#line 1115 "dhcp6_parser.cc" break; - case 131: + case 131: // max_preferred_lifetime: "max-preferred-lifetime" ":" "integer" #line 551 "dhcp6_parser.yy" { ctx.unique("max-preferred-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-preferred-lifetime", prf); } -#line 1156 "dhcp6_parser.cc" +#line 1125 "dhcp6_parser.cc" break; - case 132: + case 132: // valid_lifetime: "valid-lifetime" ":" "integer" #line 557 "dhcp6_parser.yy" { ctx.unique("valid-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("valid-lifetime", prf); } -#line 1166 "dhcp6_parser.cc" +#line 1135 "dhcp6_parser.cc" break; - case 133: + case 133: // min_valid_lifetime: "min-valid-lifetime" ":" "integer" #line 563 "dhcp6_parser.yy" { ctx.unique("min-valid-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("min-valid-lifetime", prf); } -#line 1176 "dhcp6_parser.cc" +#line 1145 "dhcp6_parser.cc" break; - case 134: + case 134: // max_valid_lifetime: "max-valid-lifetime" ":" "integer" #line 569 "dhcp6_parser.yy" { ctx.unique("max-valid-lifetime", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-valid-lifetime", prf); } -#line 1186 "dhcp6_parser.cc" +#line 1155 "dhcp6_parser.cc" break; - case 135: + case 135: // renew_timer: "renew-timer" ":" "integer" #line 575 "dhcp6_parser.yy" { ctx.unique("renew-timer", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("renew-timer", prf); } -#line 1196 "dhcp6_parser.cc" +#line 1165 "dhcp6_parser.cc" break; - case 136: + case 136: // rebind_timer: "rebind-timer" ":" "integer" #line 581 "dhcp6_parser.yy" { ctx.unique("rebind-timer", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("rebind-timer", prf); } -#line 1206 "dhcp6_parser.cc" +#line 1175 "dhcp6_parser.cc" break; - case 137: + case 137: // calculate_tee_times: "calculate-tee-times" ":" "boolean" #line 587 "dhcp6_parser.yy" { ctx.unique("calculate-tee-times", ctx.loc2pos(yystack_[2].location)); ElementPtr ctt(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("calculate-tee-times", ctt); } -#line 1216 "dhcp6_parser.cc" +#line 1185 "dhcp6_parser.cc" break; - case 138: + case 138: // t1_percent: "t1-percent" ":" "floating point" #line 593 "dhcp6_parser.yy" { ctx.unique("t1-percent", ctx.loc2pos(yystack_[2].location)); ElementPtr t1(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("t1-percent", t1); } -#line 1226 "dhcp6_parser.cc" +#line 1195 "dhcp6_parser.cc" break; - case 139: + case 139: // t2_percent: "t2-percent" ":" "floating point" #line 599 "dhcp6_parser.yy" { ctx.unique("t2-percent", ctx.loc2pos(yystack_[2].location)); ElementPtr t2(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("t2-percent", t2); } -#line 1236 "dhcp6_parser.cc" +#line 1205 "dhcp6_parser.cc" break; - case 140: + case 140: // cache_threshold: "cache-threshold" ":" "floating point" #line 605 "dhcp6_parser.yy" { ctx.unique("cache-threshold", ctx.loc2pos(yystack_[2].location)); ElementPtr ct(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("cache-threshold", ct); } -#line 1246 "dhcp6_parser.cc" +#line 1215 "dhcp6_parser.cc" break; - case 141: + case 141: // cache_max_age: "cache-max-age" ":" "integer" #line 611 "dhcp6_parser.yy" { ctx.unique("cache-max-age", ctx.loc2pos(yystack_[2].location)); ElementPtr cm(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("cache-max-age", cm); } -#line 1256 "dhcp6_parser.cc" +#line 1225 "dhcp6_parser.cc" break; - case 142: + case 142: // decline_probation_period: "decline-probation-period" ":" "integer" #line 617 "dhcp6_parser.yy" { ctx.unique("decline-probation-period", ctx.loc2pos(yystack_[2].location)); ElementPtr dpp(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("decline-probation-period", dpp); } -#line 1266 "dhcp6_parser.cc" +#line 1235 "dhcp6_parser.cc" break; - case 143: + case 143: // ddns_send_updates: "ddns-send-updates" ":" "boolean" #line 623 "dhcp6_parser.yy" { ctx.unique("ddns-send-updates", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-send-updates", b); } -#line 1276 "dhcp6_parser.cc" +#line 1245 "dhcp6_parser.cc" break; - case 144: + case 144: // ddns_override_no_update: "ddns-override-no-update" ":" "boolean" #line 629 "dhcp6_parser.yy" { ctx.unique("ddns-override-no-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-override-no-update", b); } -#line 1286 "dhcp6_parser.cc" +#line 1255 "dhcp6_parser.cc" break; - case 145: + case 145: // ddns_override_client_update: "ddns-override-client-update" ":" "boolean" #line 635 "dhcp6_parser.yy" { ctx.unique("ddns-override-client-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-override-client-update", b); } -#line 1296 "dhcp6_parser.cc" +#line 1265 "dhcp6_parser.cc" break; - case 146: + case 146: // $@22: %empty #line 641 "dhcp6_parser.yy" { ctx.unique("ddns-replace-client-name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.REPLACE_CLIENT_NAME); } -#line 1305 "dhcp6_parser.cc" +#line 1274 "dhcp6_parser.cc" break; - case 147: + case 147: // ddns_replace_client_name: "ddns-replace-client-name" $@22 ":" ddns_replace_client_name_value #line 644 "dhcp6_parser.yy" { ctx.stack_.back()->set("ddns-replace-client-name", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1314 "dhcp6_parser.cc" +#line 1283 "dhcp6_parser.cc" break; - case 148: + case 148: // ddns_replace_client_name_value: "when-present" #line 650 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location))); } -#line 1322 "dhcp6_parser.cc" +#line 1291 "dhcp6_parser.cc" break; - case 149: + case 149: // ddns_replace_client_name_value: "never" #line 653 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location))); } -#line 1330 "dhcp6_parser.cc" +#line 1299 "dhcp6_parser.cc" break; - case 150: + case 150: // ddns_replace_client_name_value: "always" #line 656 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location))); } -#line 1338 "dhcp6_parser.cc" +#line 1307 "dhcp6_parser.cc" break; - case 151: + case 151: // ddns_replace_client_name_value: "when-not-present" #line 659 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location))); } -#line 1346 "dhcp6_parser.cc" +#line 1315 "dhcp6_parser.cc" break; - case 152: + case 152: // ddns_replace_client_name_value: "boolean" #line 662 "dhcp6_parser.yy" { error(yystack_[0].location, "boolean values for the replace-client-name are " "no longer supported"); } -#line 1355 "dhcp6_parser.cc" +#line 1324 "dhcp6_parser.cc" break; - case 153: + case 153: // $@23: %empty #line 668 "dhcp6_parser.yy" { ctx.unique("ddns-generated-prefix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1364 "dhcp6_parser.cc" +#line 1333 "dhcp6_parser.cc" break; - case 154: + case 154: // ddns_generated_prefix: "ddns-generated-prefix" $@23 ":" "constant string" #line 671 "dhcp6_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-generated-prefix", s); ctx.leave(); } -#line 1374 "dhcp6_parser.cc" +#line 1343 "dhcp6_parser.cc" break; - case 155: + case 155: // $@24: %empty #line 677 "dhcp6_parser.yy" { ctx.unique("ddns-qualifying-suffix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1383 "dhcp6_parser.cc" +#line 1352 "dhcp6_parser.cc" break; - case 156: + case 156: // ddns_qualifying_suffix: "ddns-qualifying-suffix" $@24 ":" "constant string" #line 680 "dhcp6_parser.yy" { ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-qualifying-suffix", s); ctx.leave(); } -#line 1393 "dhcp6_parser.cc" +#line 1362 "dhcp6_parser.cc" break; - case 157: + case 157: // ddns_update_on_renew: "ddns-update-on-renew" ":" "boolean" #line 686 "dhcp6_parser.yy" { ctx.unique("ddns-update-on-renew", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-update-on-renew", b); } -#line 1403 "dhcp6_parser.cc" +#line 1372 "dhcp6_parser.cc" break; - case 158: + case 158: // ddns_use_conflict_resolution: "ddns-use-conflict-resolution" ":" "boolean" #line 692 "dhcp6_parser.yy" { ctx.unique("ddns-use-conflict-resolution", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ddns-use-conflict-resolution", b); } -#line 1413 "dhcp6_parser.cc" +#line 1382 "dhcp6_parser.cc" break; - case 159: + case 159: // $@25: %empty #line 698 "dhcp6_parser.yy" { ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1422 "dhcp6_parser.cc" +#line 1391 "dhcp6_parser.cc" break; - case 160: + case 160: // hostname_char_set: "hostname-char-set" $@25 ":" "constant string" #line 701 "dhcp6_parser.yy" { 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 1432 "dhcp6_parser.cc" +#line 1401 "dhcp6_parser.cc" break; - case 161: + case 161: // $@26: %empty #line 707 "dhcp6_parser.yy" { ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1441 "dhcp6_parser.cc" +#line 1410 "dhcp6_parser.cc" break; - case 162: + case 162: // hostname_char_replacement: "hostname-char-replacement" $@26 ":" "constant string" #line 710 "dhcp6_parser.yy" { 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 1451 "dhcp6_parser.cc" +#line 1420 "dhcp6_parser.cc" break; - case 163: + case 163: // store_extended_info: "store-extended-info" ":" "boolean" #line 716 "dhcp6_parser.yy" { ctx.unique("store-extended-info", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("store-extended-info", b); } -#line 1461 "dhcp6_parser.cc" +#line 1430 "dhcp6_parser.cc" break; - case 164: + case 164: // statistic_default_sample_count: "statistic-default-sample-count" ":" "integer" #line 722 "dhcp6_parser.yy" { ctx.unique("statistic-default-sample-count", ctx.loc2pos(yystack_[2].location)); ElementPtr count(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("statistic-default-sample-count", count); } -#line 1471 "dhcp6_parser.cc" +#line 1440 "dhcp6_parser.cc" break; - case 165: + case 165: // statistic_default_sample_age: "statistic-default-sample-age" ":" "integer" #line 728 "dhcp6_parser.yy" { ctx.unique("statistic-default-sample-age", ctx.loc2pos(yystack_[2].location)); ElementPtr age(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("statistic-default-sample-age", age); } -#line 1481 "dhcp6_parser.cc" +#line 1450 "dhcp6_parser.cc" break; - case 166: + case 166: // $@27: %empty #line 734 "dhcp6_parser.yy" { ctx.unique("server-tag", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1490 "dhcp6_parser.cc" +#line 1459 "dhcp6_parser.cc" break; - case 167: + case 167: // server_tag: "server-tag" $@27 ":" "constant string" #line 737 "dhcp6_parser.yy" { 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 1500 "dhcp6_parser.cc" +#line 1469 "dhcp6_parser.cc" break; - case 168: + case 168: // ip_reservations_unique: "ip-reservations-unique" ":" "boolean" #line 743 "dhcp6_parser.yy" { ctx.unique("ip-reservations-unique", ctx.loc2pos(yystack_[2].location)); ElementPtr unique(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ip-reservations-unique", unique); } -#line 1510 "dhcp6_parser.cc" +#line 1479 "dhcp6_parser.cc" break; - case 169: + case 169: // $@28: %empty #line 749 "dhcp6_parser.yy" { ctx.unique("interfaces-config", ctx.loc2pos(yystack_[0].location)); @@ -1518,39 +1487,39 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.INTERFACES_CONFIG); } -#line 1522 "dhcp6_parser.cc" +#line 1491 "dhcp6_parser.cc" break; - case 170: + case 170: // interfaces_config: "interfaces-config" $@28 ":" "{" interfaces_config_params "}" #line 755 "dhcp6_parser.yy" { // No interfaces config param is required ctx.stack_.pop_back(); ctx.leave(); } -#line 1532 "dhcp6_parser.cc" +#line 1501 "dhcp6_parser.cc" break; - case 171: + case 171: // $@29: %empty #line 761 "dhcp6_parser.yy" { // Parse the interfaces-config map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 1542 "dhcp6_parser.cc" +#line 1511 "dhcp6_parser.cc" break; - case 172: + case 172: // sub_interfaces6: "{" $@29 interfaces_config_params "}" #line 765 "dhcp6_parser.yy" { // No interfaces config param is required // parsing completed } -#line 1551 "dhcp6_parser.cc" +#line 1520 "dhcp6_parser.cc" break; - case 180: + case 180: // $@30: %empty #line 781 "dhcp6_parser.yy" { ctx.unique("interfaces", ctx.loc2pos(yystack_[0].location)); @@ -1559,29 +1528,29 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.NO_KEYWORD); } -#line 1563 "dhcp6_parser.cc" +#line 1532 "dhcp6_parser.cc" break; - case 181: + case 181: // interfaces_list: "interfaces" $@30 ":" list_strings #line 787 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 1572 "dhcp6_parser.cc" +#line 1541 "dhcp6_parser.cc" break; - case 182: + case 182: // re_detect: "re-detect" ":" "boolean" #line 792 "dhcp6_parser.yy" { ctx.unique("re-detect", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("re-detect", b); } -#line 1582 "dhcp6_parser.cc" +#line 1551 "dhcp6_parser.cc" break; - case 183: + case 183: // $@31: %empty #line 798 "dhcp6_parser.yy" { ctx.unique("lease-database", ctx.loc2pos(yystack_[0].location)); @@ -1590,10 +1559,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.LEASE_DATABASE); } -#line 1594 "dhcp6_parser.cc" +#line 1563 "dhcp6_parser.cc" break; - case 184: + case 184: // lease_database: "lease-database" $@31 ":" "{" database_map_params "}" #line 804 "dhcp6_parser.yy" { // The type parameter is required @@ -1601,10 +1570,10 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 1605 "dhcp6_parser.cc" +#line 1574 "dhcp6_parser.cc" break; - case 185: + case 185: // $@32: %empty #line 811 "dhcp6_parser.yy" { ctx.unique("hosts-database", ctx.loc2pos(yystack_[0].location)); @@ -1613,10 +1582,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.HOSTS_DATABASE); } -#line 1617 "dhcp6_parser.cc" +#line 1586 "dhcp6_parser.cc" break; - case 186: + case 186: // hosts_database: "hosts-database" $@32 ":" "{" database_map_params "}" #line 817 "dhcp6_parser.yy" { // The type parameter is required @@ -1624,10 +1593,10 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 1628 "dhcp6_parser.cc" +#line 1597 "dhcp6_parser.cc" break; - case 187: + case 187: // $@33: %empty #line 824 "dhcp6_parser.yy" { ctx.unique("hosts-databases", ctx.loc2pos(yystack_[0].location)); @@ -1636,379 +1605,379 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.HOSTS_DATABASE); } -#line 1640 "dhcp6_parser.cc" +#line 1609 "dhcp6_parser.cc" break; - case 188: + case 188: // hosts_databases: "hosts-databases" $@33 ":" "[" database_list "]" #line 830 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 1649 "dhcp6_parser.cc" +#line 1618 "dhcp6_parser.cc" break; - case 193: + case 193: // $@34: %empty #line 843 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 1659 "dhcp6_parser.cc" +#line 1628 "dhcp6_parser.cc" break; - case 194: + case 194: // database: "{" $@34 database_map_params "}" #line 847 "dhcp6_parser.yy" { // The type parameter is required ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 1669 "dhcp6_parser.cc" +#line 1638 "dhcp6_parser.cc" break; - case 219: + case 219: // $@35: %empty #line 881 "dhcp6_parser.yy" { ctx.unique("type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.DATABASE_TYPE); } -#line 1678 "dhcp6_parser.cc" +#line 1647 "dhcp6_parser.cc" break; - case 220: + case 220: // database_type: "type" $@35 ":" db_type #line 884 "dhcp6_parser.yy" { ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1687 "dhcp6_parser.cc" +#line 1656 "dhcp6_parser.cc" break; - case 221: + case 221: // db_type: "memfile" #line 889 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); } -#line 1693 "dhcp6_parser.cc" +#line 1662 "dhcp6_parser.cc" break; - case 222: + case 222: // db_type: "mysql" #line 890 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); } -#line 1699 "dhcp6_parser.cc" +#line 1668 "dhcp6_parser.cc" break; - case 223: + case 223: // db_type: "postgresql" #line 891 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); } -#line 1705 "dhcp6_parser.cc" +#line 1674 "dhcp6_parser.cc" break; - case 224: + case 224: // db_type: "cql" #line 892 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("cql", ctx.loc2pos(yystack_[0].location))); } -#line 1711 "dhcp6_parser.cc" +#line 1680 "dhcp6_parser.cc" break; - case 225: + case 225: // $@36: %empty #line 895 "dhcp6_parser.yy" { ctx.unique("user", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1720 "dhcp6_parser.cc" +#line 1689 "dhcp6_parser.cc" break; - case 226: + case 226: // user: "user" $@36 ":" "constant string" #line 898 "dhcp6_parser.yy" { ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("user", user); ctx.leave(); } -#line 1730 "dhcp6_parser.cc" +#line 1699 "dhcp6_parser.cc" break; - case 227: + case 227: // $@37: %empty #line 904 "dhcp6_parser.yy" { ctx.unique("password", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1739 "dhcp6_parser.cc" +#line 1708 "dhcp6_parser.cc" break; - case 228: + case 228: // password: "password" $@37 ":" "constant string" #line 907 "dhcp6_parser.yy" { ElementPtr pwd(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("password", pwd); ctx.leave(); } -#line 1749 "dhcp6_parser.cc" +#line 1718 "dhcp6_parser.cc" break; - case 229: + case 229: // $@38: %empty #line 913 "dhcp6_parser.yy" { ctx.unique("host", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1758 "dhcp6_parser.cc" +#line 1727 "dhcp6_parser.cc" break; - case 230: + case 230: // host: "host" $@38 ":" "constant string" #line 916 "dhcp6_parser.yy" { ElementPtr h(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("host", h); ctx.leave(); } -#line 1768 "dhcp6_parser.cc" +#line 1737 "dhcp6_parser.cc" break; - case 231: + case 231: // port: "port" ":" "integer" #line 922 "dhcp6_parser.yy" { ctx.unique("port", ctx.loc2pos(yystack_[2].location)); ElementPtr p(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("port", p); } -#line 1778 "dhcp6_parser.cc" +#line 1747 "dhcp6_parser.cc" break; - case 232: + case 232: // $@39: %empty #line 928 "dhcp6_parser.yy" { ctx.unique("name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1787 "dhcp6_parser.cc" +#line 1756 "dhcp6_parser.cc" break; - case 233: + case 233: // name: "name" $@39 ":" "constant string" #line 931 "dhcp6_parser.yy" { ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("name", name); ctx.leave(); } -#line 1797 "dhcp6_parser.cc" +#line 1766 "dhcp6_parser.cc" break; - case 234: + case 234: // persist: "persist" ":" "boolean" #line 937 "dhcp6_parser.yy" { ctx.unique("persist", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("persist", n); } -#line 1807 "dhcp6_parser.cc" +#line 1776 "dhcp6_parser.cc" break; - case 235: + case 235: // lfc_interval: "lfc-interval" ":" "integer" #line 943 "dhcp6_parser.yy" { ctx.unique("lfc-interval", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("lfc-interval", n); } -#line 1817 "dhcp6_parser.cc" +#line 1786 "dhcp6_parser.cc" break; - case 236: + case 236: // readonly: "readonly" ":" "boolean" #line 949 "dhcp6_parser.yy" { ctx.unique("readonly", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("readonly", n); } -#line 1827 "dhcp6_parser.cc" +#line 1796 "dhcp6_parser.cc" break; - case 237: + case 237: // connect_timeout: "connect-timeout" ":" "integer" #line 955 "dhcp6_parser.yy" { ctx.unique("connect-timeout", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("connect-timeout", n); } -#line 1837 "dhcp6_parser.cc" +#line 1806 "dhcp6_parser.cc" break; - case 238: + case 238: // reconnect_wait_time: "reconnect-wait-time" ":" "integer" #line 961 "dhcp6_parser.yy" { ctx.unique("reconnect-wait-time", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reconnect-wait-time", n); } -#line 1847 "dhcp6_parser.cc" +#line 1816 "dhcp6_parser.cc" break; - case 239: + case 239: // $@40: %empty #line 967 "dhcp6_parser.yy" { ctx.unique("on-fail", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.DATABASE_ON_FAIL); } -#line 1856 "dhcp6_parser.cc" +#line 1825 "dhcp6_parser.cc" break; - case 240: + case 240: // on_fail: "on-fail" $@40 ":" on_fail_mode #line 970 "dhcp6_parser.yy" { ctx.stack_.back()->set("on-fail", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 1865 "dhcp6_parser.cc" +#line 1834 "dhcp6_parser.cc" break; - case 241: + case 241: // on_fail_mode: "stop-retry-exit" #line 975 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("stop-retry-exit", ctx.loc2pos(yystack_[0].location))); } -#line 1871 "dhcp6_parser.cc" +#line 1840 "dhcp6_parser.cc" break; - case 242: + case 242: // on_fail_mode: "serve-retry-exit" #line 976 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-exit", ctx.loc2pos(yystack_[0].location))); } -#line 1877 "dhcp6_parser.cc" +#line 1846 "dhcp6_parser.cc" break; - case 243: + case 243: // on_fail_mode: "serve-retry-continue" #line 977 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-continue", ctx.loc2pos(yystack_[0].location))); } -#line 1883 "dhcp6_parser.cc" +#line 1852 "dhcp6_parser.cc" break; - case 244: + case 244: // max_row_errors: "max-row-errors" ":" "integer" #line 980 "dhcp6_parser.yy" { ctx.unique("max-row-errors", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-row-errors", n); } -#line 1893 "dhcp6_parser.cc" +#line 1862 "dhcp6_parser.cc" break; - case 245: + case 245: // request_timeout: "request-timeout" ":" "integer" #line 986 "dhcp6_parser.yy" { ctx.unique("request-timeout", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("request-timeout", n); } -#line 1903 "dhcp6_parser.cc" +#line 1872 "dhcp6_parser.cc" break; - case 246: + case 246: // tcp_keepalive: "tcp-keepalive" ":" "integer" #line 992 "dhcp6_parser.yy" { ctx.unique("tcp-keepalive", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("tcp-keepalive", n); } -#line 1913 "dhcp6_parser.cc" +#line 1882 "dhcp6_parser.cc" break; - case 247: + case 247: // tcp_nodelay: "tcp-nodelay" ":" "boolean" #line 998 "dhcp6_parser.yy" { ctx.unique("tcp-nodelay", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("tcp-nodelay", n); } -#line 1923 "dhcp6_parser.cc" +#line 1892 "dhcp6_parser.cc" break; - case 248: + case 248: // $@41: %empty #line 1004 "dhcp6_parser.yy" { ctx.unique("contact-points", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1932 "dhcp6_parser.cc" +#line 1901 "dhcp6_parser.cc" break; - case 249: + case 249: // contact_points: "contact-points" $@41 ":" "constant string" #line 1007 "dhcp6_parser.yy" { 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 1942 "dhcp6_parser.cc" +#line 1911 "dhcp6_parser.cc" break; - case 250: + case 250: // max_reconnect_tries: "max-reconnect-tries" ":" "integer" #line 1013 "dhcp6_parser.yy" { ctx.unique("max-reconnect-tries", ctx.loc2pos(yystack_[2].location)); ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-reconnect-tries", n); } -#line 1952 "dhcp6_parser.cc" +#line 1921 "dhcp6_parser.cc" break; - case 251: + case 251: // $@42: %empty #line 1019 "dhcp6_parser.yy" { ctx.unique("keyspace", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1961 "dhcp6_parser.cc" +#line 1930 "dhcp6_parser.cc" break; - case 252: + case 252: // keyspace: "keyspace" $@42 ":" "constant string" #line 1022 "dhcp6_parser.yy" { ElementPtr ks(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("keyspace", ks); ctx.leave(); } -#line 1971 "dhcp6_parser.cc" +#line 1940 "dhcp6_parser.cc" break; - case 253: + case 253: // $@43: %empty #line 1028 "dhcp6_parser.yy" { ctx.unique("consistency", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1980 "dhcp6_parser.cc" +#line 1949 "dhcp6_parser.cc" break; - case 254: + case 254: // consistency: "consistency" $@43 ":" "constant string" #line 1031 "dhcp6_parser.yy" { ElementPtr c(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("consistency", c); ctx.leave(); } -#line 1990 "dhcp6_parser.cc" +#line 1959 "dhcp6_parser.cc" break; - case 255: + case 255: // $@44: %empty #line 1037 "dhcp6_parser.yy" { ctx.unique("serial-consistency", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 1999 "dhcp6_parser.cc" +#line 1968 "dhcp6_parser.cc" break; - case 256: + case 256: // serial_consistency: "serial-consistency" $@44 ":" "constant string" #line 1040 "dhcp6_parser.yy" { ElementPtr c(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("serial-consistency", c); ctx.leave(); } -#line 2009 "dhcp6_parser.cc" +#line 1978 "dhcp6_parser.cc" break; - case 257: + case 257: // $@45: %empty #line 1046 "dhcp6_parser.yy" { ctx.unique("sanity-checks", ctx.loc2pos(yystack_[0].location)); @@ -2017,28 +1986,28 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.SANITY_CHECKS); } -#line 2021 "dhcp6_parser.cc" +#line 1990 "dhcp6_parser.cc" break; - case 258: + case 258: // sanity_checks: "sanity-checks" $@45 ":" "{" sanity_checks_params "}" #line 1052 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2030 "dhcp6_parser.cc" +#line 1999 "dhcp6_parser.cc" break; - case 262: + case 262: // $@46: %empty #line 1062 "dhcp6_parser.yy" { ctx.unique("lease-checks", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2039 "dhcp6_parser.cc" +#line 2008 "dhcp6_parser.cc" break; - case 263: + case 263: // lease_checks: "lease-checks" $@46 ":" "constant string" #line 1065 "dhcp6_parser.yy" { @@ -2055,10 +2024,10 @@ namespace isc { namespace dhcp { ", supported values are: none, warn, fix, fix-del, del"); } } -#line 2059 "dhcp6_parser.cc" +#line 2028 "dhcp6_parser.cc" break; - case 264: + case 264: // $@47: %empty #line 1081 "dhcp6_parser.yy" { ctx.unique("mac-sources", ctx.loc2pos(yystack_[0].location)); @@ -2067,37 +2036,37 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.MAC_SOURCES); } -#line 2071 "dhcp6_parser.cc" +#line 2040 "dhcp6_parser.cc" break; - case 265: + case 265: // mac_sources: "mac-sources" $@47 ":" "[" mac_sources_list "]" #line 1087 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2080 "dhcp6_parser.cc" +#line 2049 "dhcp6_parser.cc" break; - case 270: + case 270: // duid_id: "duid" #line 1100 "dhcp6_parser.yy" { ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(duid); } -#line 2089 "dhcp6_parser.cc" +#line 2058 "dhcp6_parser.cc" break; - case 271: + case 271: // string_id: "constant string" #line 1105 "dhcp6_parser.yy" { ElementPtr duid(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(duid); } -#line 2098 "dhcp6_parser.cc" +#line 2067 "dhcp6_parser.cc" break; - case 272: + case 272: // $@48: %empty #line 1110 "dhcp6_parser.yy" { ctx.unique("host-reservation-identifiers", ctx.loc2pos(yystack_[0].location)); @@ -2106,37 +2075,37 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.HOST_RESERVATION_IDENTIFIERS); } -#line 2110 "dhcp6_parser.cc" +#line 2079 "dhcp6_parser.cc" break; - case 273: + case 273: // host_reservation_identifiers: "host-reservation-identifiers" $@48 ":" "[" host_reservation_identifiers_list "]" #line 1116 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2119 "dhcp6_parser.cc" +#line 2088 "dhcp6_parser.cc" break; - case 279: + case 279: // hw_address_id: "hw-address" #line 1130 "dhcp6_parser.yy" { ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(hwaddr); } -#line 2128 "dhcp6_parser.cc" +#line 2097 "dhcp6_parser.cc" break; - case 280: + case 280: // flex_id: "flex-id" #line 1135 "dhcp6_parser.yy" { ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(flex_id); } -#line 2137 "dhcp6_parser.cc" +#line 2106 "dhcp6_parser.cc" break; - case 281: + case 281: // $@49: %empty #line 1142 "dhcp6_parser.yy" { ctx.unique("relay-supplied-options", ctx.loc2pos(yystack_[0].location)); @@ -2145,19 +2114,19 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.NO_KEYWORD); } -#line 2149 "dhcp6_parser.cc" +#line 2118 "dhcp6_parser.cc" break; - case 282: + case 282: // relay_supplied_options: "relay-supplied-options" $@49 ":" "[" list_content "]" #line 1148 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2158 "dhcp6_parser.cc" +#line 2127 "dhcp6_parser.cc" break; - case 283: + case 283: // $@50: %empty #line 1155 "dhcp6_parser.yy" { ctx.unique("multi-threading", ctx.loc2pos(yystack_[0].location)); @@ -2166,10 +2135,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(mt); ctx.enter(ctx.DHCP_MULTI_THREADING); } -#line 2170 "dhcp6_parser.cc" +#line 2139 "dhcp6_parser.cc" break; - case 284: + case 284: // dhcp_multi_threading: "multi-threading" $@50 ":" "{" multi_threading_params "}" #line 1161 "dhcp6_parser.yy" { // The enable parameter is required. @@ -2177,40 +2146,40 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 2181 "dhcp6_parser.cc" +#line 2150 "dhcp6_parser.cc" break; - case 293: + case 293: // enable_multi_threading: "enable-multi-threading" ":" "boolean" #line 1180 "dhcp6_parser.yy" { ctx.unique("enable-multi-threading", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enable-multi-threading", b); } -#line 2191 "dhcp6_parser.cc" +#line 2160 "dhcp6_parser.cc" break; - case 294: + case 294: // thread_pool_size: "thread-pool-size" ":" "integer" #line 1186 "dhcp6_parser.yy" { ctx.unique("thread-pool-size", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("thread-pool-size", prf); } -#line 2201 "dhcp6_parser.cc" +#line 2170 "dhcp6_parser.cc" break; - case 295: + case 295: // packet_queue_size: "packet-queue-size" ":" "integer" #line 1192 "dhcp6_parser.yy" { ctx.unique("packet-queue-size", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("packet-queue-size", prf); } -#line 2211 "dhcp6_parser.cc" +#line 2180 "dhcp6_parser.cc" break; - case 296: + case 296: // $@51: %empty #line 1198 "dhcp6_parser.yy" { ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location)); @@ -2219,96 +2188,96 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.HOOKS_LIBRARIES); } -#line 2223 "dhcp6_parser.cc" +#line 2192 "dhcp6_parser.cc" break; - case 297: + case 297: // hooks_libraries: "hooks-libraries" $@51 ":" "[" hooks_libraries_list "]" #line 1204 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2232 "dhcp6_parser.cc" +#line 2201 "dhcp6_parser.cc" break; - case 302: + case 302: // $@52: %empty #line 1217 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2242 "dhcp6_parser.cc" +#line 2211 "dhcp6_parser.cc" break; - case 303: + case 303: // hooks_library: "{" $@52 hooks_params "}" #line 1221 "dhcp6_parser.yy" { // The library hooks parameter is required ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 2252 "dhcp6_parser.cc" +#line 2221 "dhcp6_parser.cc" break; - case 304: + case 304: // $@53: %empty #line 1227 "dhcp6_parser.yy" { // Parse the hooks-libraries list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2262 "dhcp6_parser.cc" +#line 2231 "dhcp6_parser.cc" break; - case 305: + case 305: // sub_hooks_library: "{" $@53 hooks_params "}" #line 1231 "dhcp6_parser.yy" { // The library hooks parameter is required ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 2272 "dhcp6_parser.cc" +#line 2241 "dhcp6_parser.cc" break; - case 311: + case 311: // $@54: %empty #line 1246 "dhcp6_parser.yy" { ctx.unique("library", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2281 "dhcp6_parser.cc" +#line 2250 "dhcp6_parser.cc" break; - case 312: + case 312: // library: "library" $@54 ":" "constant string" #line 1249 "dhcp6_parser.yy" { ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("library", lib); ctx.leave(); } -#line 2291 "dhcp6_parser.cc" +#line 2260 "dhcp6_parser.cc" break; - case 313: + case 313: // $@55: %empty #line 1255 "dhcp6_parser.yy" { ctx.unique("parameters", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2300 "dhcp6_parser.cc" +#line 2269 "dhcp6_parser.cc" break; - case 314: + case 314: // parameters: "parameters" $@55 ":" map_value #line 1258 "dhcp6_parser.yy" { ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 2309 "dhcp6_parser.cc" +#line 2278 "dhcp6_parser.cc" break; - case 315: + case 315: // $@56: %empty #line 1264 "dhcp6_parser.yy" { ctx.unique("expired-leases-processing", ctx.loc2pos(yystack_[0].location)); @@ -2317,80 +2286,80 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.EXPIRED_LEASES_PROCESSING); } -#line 2321 "dhcp6_parser.cc" +#line 2290 "dhcp6_parser.cc" break; - case 316: + case 316: // expired_leases_processing: "expired-leases-processing" $@56 ":" "{" expired_leases_params "}" #line 1270 "dhcp6_parser.yy" { // No expired lease parameter is required ctx.stack_.pop_back(); ctx.leave(); } -#line 2331 "dhcp6_parser.cc" +#line 2300 "dhcp6_parser.cc" break; - case 325: + case 325: // reclaim_timer_wait_time: "reclaim-timer-wait-time" ":" "integer" #line 1288 "dhcp6_parser.yy" { ctx.unique("reclaim-timer-wait-time", ctx.loc2pos(yystack_[2].location)); 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 2341 "dhcp6_parser.cc" +#line 2310 "dhcp6_parser.cc" break; - case 326: + case 326: // flush_reclaimed_timer_wait_time: "flush-reclaimed-timer-wait-time" ":" "integer" #line 1294 "dhcp6_parser.yy" { ctx.unique("flush-reclaimed-timer-wait-time", ctx.loc2pos(yystack_[2].location)); 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 2351 "dhcp6_parser.cc" +#line 2320 "dhcp6_parser.cc" break; - case 327: + case 327: // hold_reclaimed_time: "hold-reclaimed-time" ":" "integer" #line 1300 "dhcp6_parser.yy" { ctx.unique("hold-reclaimed-time", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("hold-reclaimed-time", value); } -#line 2361 "dhcp6_parser.cc" +#line 2330 "dhcp6_parser.cc" break; - case 328: + case 328: // max_reclaim_leases: "max-reclaim-leases" ":" "integer" #line 1306 "dhcp6_parser.yy" { ctx.unique("max-reclaim-leases", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-reclaim-leases", value); } -#line 2371 "dhcp6_parser.cc" +#line 2340 "dhcp6_parser.cc" break; - case 329: + case 329: // max_reclaim_time: "max-reclaim-time" ":" "integer" #line 1312 "dhcp6_parser.yy" { ctx.unique("max-reclaim-time", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-reclaim-time", value); } -#line 2381 "dhcp6_parser.cc" +#line 2350 "dhcp6_parser.cc" break; - case 330: + case 330: // unwarned_reclaim_cycles: "unwarned-reclaim-cycles" ":" "integer" #line 1318 "dhcp6_parser.yy" { ctx.unique("unwarned-reclaim-cycles", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("unwarned-reclaim-cycles", value); } -#line 2391 "dhcp6_parser.cc" +#line 2360 "dhcp6_parser.cc" break; - case 331: + case 331: // $@57: %empty #line 1327 "dhcp6_parser.yy" { ctx.unique("subnet6", ctx.loc2pos(yystack_[0].location)); @@ -2399,29 +2368,29 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.SUBNET6); } -#line 2403 "dhcp6_parser.cc" +#line 2372 "dhcp6_parser.cc" break; - case 332: + case 332: // subnet6_list: "subnet6" $@57 ":" "[" subnet6_list_content "]" #line 1333 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2412 "dhcp6_parser.cc" +#line 2381 "dhcp6_parser.cc" break; - case 337: + case 337: // $@58: %empty #line 1353 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2422 "dhcp6_parser.cc" +#line 2391 "dhcp6_parser.cc" break; - case 338: + case 338: // subnet6: "{" $@58 subnet6_params "}" #line 1357 "dhcp6_parser.yy" { // Once we reached this place, the subnet parsing is now complete. @@ -2444,106 +2413,106 @@ namespace isc { namespace dhcp { ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 2448 "dhcp6_parser.cc" +#line 2417 "dhcp6_parser.cc" break; - case 339: + case 339: // $@59: %empty #line 1379 "dhcp6_parser.yy" { // Parse the subnet6 list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2458 "dhcp6_parser.cc" +#line 2427 "dhcp6_parser.cc" break; - case 340: + case 340: // sub_subnet6: "{" $@59 subnet6_params "}" #line 1383 "dhcp6_parser.yy" { // The subnet subnet6 parameter is required ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 2468 "dhcp6_parser.cc" +#line 2437 "dhcp6_parser.cc" break; - case 386: + case 386: // $@60: %empty #line 1440 "dhcp6_parser.yy" { ctx.unique("subnet", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2477 "dhcp6_parser.cc" +#line 2446 "dhcp6_parser.cc" break; - case 387: + case 387: // subnet: "subnet" $@60 ":" "constant string" #line 1443 "dhcp6_parser.yy" { ElementPtr subnet(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("subnet", subnet); ctx.leave(); } -#line 2487 "dhcp6_parser.cc" +#line 2456 "dhcp6_parser.cc" break; - case 388: + case 388: // $@61: %empty #line 1449 "dhcp6_parser.yy" { ctx.unique("interface", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2496 "dhcp6_parser.cc" +#line 2465 "dhcp6_parser.cc" break; - case 389: + case 389: // interface: "interface" $@61 ":" "constant string" #line 1452 "dhcp6_parser.yy" { ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("interface", iface); ctx.leave(); } -#line 2506 "dhcp6_parser.cc" +#line 2475 "dhcp6_parser.cc" break; - case 390: + case 390: // $@62: %empty #line 1458 "dhcp6_parser.yy" { ctx.unique("interface-id", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2515 "dhcp6_parser.cc" +#line 2484 "dhcp6_parser.cc" break; - case 391: + case 391: // interface_id: "interface-id" $@62 ":" "constant string" #line 1461 "dhcp6_parser.yy" { 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 2525 "dhcp6_parser.cc" +#line 2494 "dhcp6_parser.cc" break; - case 392: + case 392: // $@63: %empty #line 1467 "dhcp6_parser.yy" { ctx.unique("client-class", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2534 "dhcp6_parser.cc" +#line 2503 "dhcp6_parser.cc" break; - case 393: + case 393: // client_class: "client-class" $@63 ":" "constant string" #line 1470 "dhcp6_parser.yy" { 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 2544 "dhcp6_parser.cc" +#line 2513 "dhcp6_parser.cc" break; - case 394: + case 394: // $@64: %empty #line 1476 "dhcp6_parser.yy" { ctx.unique("require-client-classes", ctx.loc2pos(yystack_[0].location)); @@ -2552,111 +2521,111 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(c); ctx.enter(ctx.NO_KEYWORD); } -#line 2556 "dhcp6_parser.cc" +#line 2525 "dhcp6_parser.cc" break; - case 395: + case 395: // require_client_classes: "require-client-classes" $@64 ":" list_strings #line 1482 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2565 "dhcp6_parser.cc" +#line 2534 "dhcp6_parser.cc" break; - case 396: + case 396: // reservations_global: "reservations-global" ":" "boolean" #line 1487 "dhcp6_parser.yy" { ctx.unique("reservations-global", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reservations-global", b); } -#line 2575 "dhcp6_parser.cc" +#line 2544 "dhcp6_parser.cc" break; - case 397: + case 397: // reservations_in_subnet: "reservations-in-subnet" ":" "boolean" #line 1493 "dhcp6_parser.yy" { ctx.unique("reservations-in-subnet", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reservations-in-subnet", b); } -#line 2585 "dhcp6_parser.cc" +#line 2554 "dhcp6_parser.cc" break; - case 398: + case 398: // reservations_out_of_pool: "reservations-out-of-pool" ":" "boolean" #line 1499 "dhcp6_parser.yy" { ctx.unique("reservations-out-of-pool", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("reservations-out-of-pool", b); } -#line 2595 "dhcp6_parser.cc" +#line 2564 "dhcp6_parser.cc" break; - case 399: + case 399: // $@65: %empty #line 1505 "dhcp6_parser.yy" { ctx.unique("reservation-mode", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.RESERVATION_MODE); } -#line 2604 "dhcp6_parser.cc" +#line 2573 "dhcp6_parser.cc" break; - case 400: + case 400: // reservation_mode: "reservation-mode" $@65 ":" hr_mode #line 1508 "dhcp6_parser.yy" { ctx.stack_.back()->set("reservation-mode", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 2613 "dhcp6_parser.cc" +#line 2582 "dhcp6_parser.cc" break; - case 401: + case 401: // hr_mode: "disabled" #line 1513 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("disabled", ctx.loc2pos(yystack_[0].location))); } -#line 2619 "dhcp6_parser.cc" +#line 2588 "dhcp6_parser.cc" break; - case 402: + case 402: // hr_mode: "out-of-pool" #line 1514 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("out-of-pool", ctx.loc2pos(yystack_[0].location))); } -#line 2625 "dhcp6_parser.cc" +#line 2594 "dhcp6_parser.cc" break; - case 403: + case 403: // hr_mode: "global" #line 1515 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("global", ctx.loc2pos(yystack_[0].location))); } -#line 2631 "dhcp6_parser.cc" +#line 2600 "dhcp6_parser.cc" break; - case 404: + case 404: // hr_mode: "all" #line 1516 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("all", ctx.loc2pos(yystack_[0].location))); } -#line 2637 "dhcp6_parser.cc" +#line 2606 "dhcp6_parser.cc" break; - case 405: + case 405: // id: "id" ":" "integer" #line 1519 "dhcp6_parser.yy" { ctx.unique("id", ctx.loc2pos(yystack_[2].location)); ElementPtr id(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("id", id); } -#line 2647 "dhcp6_parser.cc" +#line 2616 "dhcp6_parser.cc" break; - case 406: + case 406: // rapid_commit: "rapid-commit" ":" "boolean" #line 1525 "dhcp6_parser.yy" { ctx.unique("rapid-commit", ctx.loc2pos(yystack_[2].location)); ElementPtr rc(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("rapid-commit", rc); } -#line 2657 "dhcp6_parser.cc" +#line 2626 "dhcp6_parser.cc" break; - case 407: + case 407: // $@66: %empty #line 1533 "dhcp6_parser.yy" { ctx.unique("shared-networks", ctx.loc2pos(yystack_[0].location)); @@ -2665,37 +2634,37 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.SHARED_NETWORK); } -#line 2669 "dhcp6_parser.cc" +#line 2638 "dhcp6_parser.cc" break; - case 408: + case 408: // shared_networks: "shared-networks" $@66 ":" "[" shared_networks_content "]" #line 1539 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2678 "dhcp6_parser.cc" +#line 2647 "dhcp6_parser.cc" break; - case 413: + case 413: // $@67: %empty #line 1554 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2688 "dhcp6_parser.cc" +#line 2657 "dhcp6_parser.cc" break; - case 414: + case 414: // shared_network: "{" $@67 shared_network_params "}" #line 1558 "dhcp6_parser.yy" { ctx.stack_.pop_back(); } -#line 2696 "dhcp6_parser.cc" +#line 2665 "dhcp6_parser.cc" break; - case 457: + case 457: // $@68: %empty #line 1612 "dhcp6_parser.yy" { ctx.unique("option-def", ctx.loc2pos(yystack_[0].location)); @@ -2704,46 +2673,46 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.OPTION_DEF); } -#line 2708 "dhcp6_parser.cc" +#line 2677 "dhcp6_parser.cc" break; - case 458: + case 458: // option_def_list: "option-def" $@68 ":" "[" option_def_list_content "]" #line 1618 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2717 "dhcp6_parser.cc" +#line 2686 "dhcp6_parser.cc" break; - case 459: + case 459: // $@69: %empty #line 1626 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2726 "dhcp6_parser.cc" +#line 2695 "dhcp6_parser.cc" break; - case 460: + case 460: // sub_option_def_list: "{" $@69 option_def_list "}" #line 1629 "dhcp6_parser.yy" { // parsing completed } -#line 2734 "dhcp6_parser.cc" +#line 2703 "dhcp6_parser.cc" break; - case 465: + case 465: // $@70: %empty #line 1645 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2744 "dhcp6_parser.cc" +#line 2713 "dhcp6_parser.cc" break; - case 466: + case 466: // option_def_entry: "{" $@70 option_def_params "}" #line 1649 "dhcp6_parser.yy" { // The name, code and type option def parameters are required. @@ -2752,20 +2721,20 @@ namespace isc { namespace dhcp { ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 2756 "dhcp6_parser.cc" +#line 2725 "dhcp6_parser.cc" break; - case 467: + case 467: // $@71: %empty #line 1660 "dhcp6_parser.yy" { // Parse the option-def list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2766 "dhcp6_parser.cc" +#line 2735 "dhcp6_parser.cc" break; - case 468: + case 468: // sub_option_def: "{" $@71 option_def_params "}" #line 1664 "dhcp6_parser.yy" { // The name, code and type option def parameters are required. @@ -2774,106 +2743,106 @@ namespace isc { namespace dhcp { ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 2778 "dhcp6_parser.cc" +#line 2747 "dhcp6_parser.cc" break; - case 484: + case 484: // code: "code" ":" "integer" #line 1696 "dhcp6_parser.yy" { ctx.unique("code", ctx.loc2pos(yystack_[2].location)); ElementPtr code(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("code", code); } -#line 2788 "dhcp6_parser.cc" +#line 2757 "dhcp6_parser.cc" break; - case 486: + case 486: // $@72: %empty #line 1704 "dhcp6_parser.yy" { ctx.unique("type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2797 "dhcp6_parser.cc" +#line 2766 "dhcp6_parser.cc" break; - case 487: + case 487: // option_def_type: "type" $@72 ":" "constant string" #line 1707 "dhcp6_parser.yy" { ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("type", prf); ctx.leave(); } -#line 2807 "dhcp6_parser.cc" +#line 2776 "dhcp6_parser.cc" break; - case 488: + case 488: // $@73: %empty #line 1713 "dhcp6_parser.yy" { ctx.unique("record-types", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2816 "dhcp6_parser.cc" +#line 2785 "dhcp6_parser.cc" break; - case 489: + case 489: // option_def_record_types: "record-types" $@73 ":" "constant string" #line 1716 "dhcp6_parser.yy" { 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 2826 "dhcp6_parser.cc" +#line 2795 "dhcp6_parser.cc" break; - case 490: + case 490: // $@74: %empty #line 1722 "dhcp6_parser.yy" { ctx.unique("space", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2835 "dhcp6_parser.cc" +#line 2804 "dhcp6_parser.cc" break; - case 491: + case 491: // space: "space" $@74 ":" "constant string" #line 1725 "dhcp6_parser.yy" { ElementPtr space(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("space", space); ctx.leave(); } -#line 2845 "dhcp6_parser.cc" +#line 2814 "dhcp6_parser.cc" break; - case 493: + case 493: // $@75: %empty #line 1733 "dhcp6_parser.yy" { ctx.unique("encapsulate", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2854 "dhcp6_parser.cc" +#line 2823 "dhcp6_parser.cc" break; - case 494: + case 494: // option_def_encapsulate: "encapsulate" $@75 ":" "constant string" #line 1736 "dhcp6_parser.yy" { ElementPtr encap(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("encapsulate", encap); ctx.leave(); } -#line 2864 "dhcp6_parser.cc" +#line 2833 "dhcp6_parser.cc" break; - case 495: + case 495: // option_def_array: "array" ":" "boolean" #line 1742 "dhcp6_parser.yy" { ctx.unique("array", ctx.loc2pos(yystack_[2].location)); ElementPtr array(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("array", array); } -#line 2874 "dhcp6_parser.cc" +#line 2843 "dhcp6_parser.cc" break; - case 496: + case 496: // $@76: %empty #line 1752 "dhcp6_parser.yy" { ctx.unique("option-data", ctx.loc2pos(yystack_[0].location)); @@ -2882,96 +2851,96 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.OPTION_DATA); } -#line 2886 "dhcp6_parser.cc" +#line 2855 "dhcp6_parser.cc" break; - case 497: + case 497: // option_data_list: "option-data" $@76 ":" "[" option_data_list_content "]" #line 1758 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2895 "dhcp6_parser.cc" +#line 2864 "dhcp6_parser.cc" break; - case 502: + case 502: // $@77: %empty #line 1777 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 2905 "dhcp6_parser.cc" +#line 2874 "dhcp6_parser.cc" break; - case 503: + case 503: // option_data_entry: "{" $@77 option_data_params "}" #line 1781 "dhcp6_parser.yy" { /// @todo: the code or name parameters are required. ctx.stack_.pop_back(); } -#line 2914 "dhcp6_parser.cc" +#line 2883 "dhcp6_parser.cc" break; - case 504: + case 504: // $@78: %empty #line 1789 "dhcp6_parser.yy" { // Parse the option-data list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 2924 "dhcp6_parser.cc" +#line 2893 "dhcp6_parser.cc" break; - case 505: + case 505: // sub_option_data: "{" $@78 option_data_params "}" #line 1793 "dhcp6_parser.yy" { /// @todo: the code or name parameters are required. // parsing completed } -#line 2933 "dhcp6_parser.cc" +#line 2902 "dhcp6_parser.cc" break; - case 520: + case 520: // $@79: %empty #line 1826 "dhcp6_parser.yy" { ctx.unique("data", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 2942 "dhcp6_parser.cc" +#line 2911 "dhcp6_parser.cc" break; - case 521: + case 521: // option_data_data: "data" $@79 ":" "constant string" #line 1829 "dhcp6_parser.yy" { ElementPtr data(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("data", data); ctx.leave(); } -#line 2952 "dhcp6_parser.cc" +#line 2921 "dhcp6_parser.cc" break; - case 524: + case 524: // option_data_csv_format: "csv-format" ":" "boolean" #line 1839 "dhcp6_parser.yy" { ctx.unique("csv-format", ctx.loc2pos(yystack_[2].location)); ElementPtr space(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("csv-format", space); } -#line 2962 "dhcp6_parser.cc" +#line 2931 "dhcp6_parser.cc" break; - case 525: + case 525: // option_data_always_send: "always-send" ":" "boolean" #line 1845 "dhcp6_parser.yy" { ctx.unique("always-send", ctx.loc2pos(yystack_[2].location)); ElementPtr persist(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("always-send", persist); } -#line 2972 "dhcp6_parser.cc" +#line 2941 "dhcp6_parser.cc" break; - case 526: + case 526: // $@80: %empty #line 1854 "dhcp6_parser.yy" { ctx.unique("pools", ctx.loc2pos(yystack_[0].location)); @@ -2980,86 +2949,86 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.POOLS); } -#line 2984 "dhcp6_parser.cc" +#line 2953 "dhcp6_parser.cc" break; - case 527: + case 527: // pools_list: "pools" $@80 ":" "[" pools_list_content "]" #line 1860 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 2993 "dhcp6_parser.cc" +#line 2962 "dhcp6_parser.cc" break; - case 532: + case 532: // $@81: %empty #line 1875 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3003 "dhcp6_parser.cc" +#line 2972 "dhcp6_parser.cc" break; - case 533: + case 533: // pool_list_entry: "{" $@81 pool_params "}" #line 1879 "dhcp6_parser.yy" { // The pool parameter is required. ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 3013 "dhcp6_parser.cc" +#line 2982 "dhcp6_parser.cc" break; - case 534: + case 534: // $@82: %empty #line 1885 "dhcp6_parser.yy" { // Parse the pool list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3023 "dhcp6_parser.cc" +#line 2992 "dhcp6_parser.cc" break; - case 535: + case 535: // sub_pool6: "{" $@82 pool_params "}" #line 1889 "dhcp6_parser.yy" { // The pool parameter is required. ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 3033 "dhcp6_parser.cc" +#line 3002 "dhcp6_parser.cc" break; - case 545: + case 545: // $@83: %empty #line 1908 "dhcp6_parser.yy" { ctx.unique("pool", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3042 "dhcp6_parser.cc" +#line 3011 "dhcp6_parser.cc" break; - case 546: + case 546: // pool_entry: "pool" $@83 ":" "constant string" #line 1911 "dhcp6_parser.yy" { ElementPtr pool(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("pool", pool); ctx.leave(); } -#line 3052 "dhcp6_parser.cc" +#line 3021 "dhcp6_parser.cc" break; - case 547: + case 547: // $@84: %empty #line 1917 "dhcp6_parser.yy" { ctx.enter(ctx.NO_KEYWORD); } -#line 3060 "dhcp6_parser.cc" +#line 3029 "dhcp6_parser.cc" break; - case 548: + case 548: // user_context: "user-context" $@84 ":" map_value #line 1919 "dhcp6_parser.yy" { ElementPtr parent = ctx.stack_.back(); @@ -3083,18 +3052,18 @@ namespace isc { namespace dhcp { parent->set("user-context", user_context); ctx.leave(); } -#line 3087 "dhcp6_parser.cc" +#line 3056 "dhcp6_parser.cc" break; - case 549: + case 549: // $@85: %empty #line 1942 "dhcp6_parser.yy" { ctx.enter(ctx.NO_KEYWORD); } -#line 3095 "dhcp6_parser.cc" +#line 3064 "dhcp6_parser.cc" break; - case 550: + case 550: // comment: "comment" $@85 ":" "constant string" #line 1944 "dhcp6_parser.yy" { ElementPtr parent = ctx.stack_.back(); @@ -3120,10 +3089,10 @@ namespace isc { namespace dhcp { parent->set("user-context", user_context); ctx.leave(); } -#line 3124 "dhcp6_parser.cc" +#line 3093 "dhcp6_parser.cc" break; - case 551: + case 551: // $@86: %empty #line 1972 "dhcp6_parser.yy" { ctx.unique("pd-pools", ctx.loc2pos(yystack_[0].location)); @@ -3132,29 +3101,29 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.PD_POOLS); } -#line 3136 "dhcp6_parser.cc" +#line 3105 "dhcp6_parser.cc" break; - case 552: + case 552: // pd_pools_list: "pd-pools" $@86 ":" "[" pd_pools_list_content "]" #line 1978 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3145 "dhcp6_parser.cc" +#line 3114 "dhcp6_parser.cc" break; - case 557: + case 557: // $@87: %empty #line 1993 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3155 "dhcp6_parser.cc" +#line 3124 "dhcp6_parser.cc" break; - case 558: + case 558: // pd_pool_entry: "{" $@87 pd_pool_params "}" #line 1997 "dhcp6_parser.yy" { // The prefix, prefix len and delegated len parameters are required. @@ -3163,20 +3132,20 @@ namespace isc { namespace dhcp { ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); ctx.stack_.pop_back(); } -#line 3167 "dhcp6_parser.cc" +#line 3136 "dhcp6_parser.cc" break; - case 559: + case 559: // $@88: %empty #line 2005 "dhcp6_parser.yy" { // Parse the pd-pool list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3177 "dhcp6_parser.cc" +#line 3146 "dhcp6_parser.cc" break; - case 560: + case 560: // sub_pd_pool: "{" $@88 pd_pool_params "}" #line 2009 "dhcp6_parser.yy" { // The prefix, prefix len and delegated len parameters are required. @@ -3185,78 +3154,78 @@ namespace isc { namespace dhcp { ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location)); // parsing completed } -#line 3189 "dhcp6_parser.cc" +#line 3158 "dhcp6_parser.cc" break; - case 574: + case 574: // $@89: %empty #line 2034 "dhcp6_parser.yy" { ctx.unique("prefix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3198 "dhcp6_parser.cc" +#line 3167 "dhcp6_parser.cc" break; - case 575: + case 575: // pd_prefix: "prefix" $@89 ":" "constant string" #line 2037 "dhcp6_parser.yy" { ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("prefix", prf); ctx.leave(); } -#line 3208 "dhcp6_parser.cc" +#line 3177 "dhcp6_parser.cc" break; - case 576: + case 576: // pd_prefix_len: "prefix-len" ":" "integer" #line 2043 "dhcp6_parser.yy" { ctx.unique("prefix-len", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("prefix-len", prf); } -#line 3218 "dhcp6_parser.cc" +#line 3187 "dhcp6_parser.cc" break; - case 577: + case 577: // $@90: %empty #line 2049 "dhcp6_parser.yy" { ctx.unique("excluded-prefix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3227 "dhcp6_parser.cc" +#line 3196 "dhcp6_parser.cc" break; - case 578: + case 578: // excluded_prefix: "excluded-prefix" $@90 ":" "constant string" #line 2052 "dhcp6_parser.yy" { 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 3237 "dhcp6_parser.cc" +#line 3206 "dhcp6_parser.cc" break; - case 579: + case 579: // excluded_prefix_len: "excluded-prefix-len" ":" "integer" #line 2058 "dhcp6_parser.yy" { ctx.unique("excluded-prefix-len", ctx.loc2pos(yystack_[2].location)); ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("excluded-prefix-len", prf); } -#line 3247 "dhcp6_parser.cc" +#line 3216 "dhcp6_parser.cc" break; - case 580: + case 580: // pd_delegated_len: "delegated-len" ":" "integer" #line 2064 "dhcp6_parser.yy" { ctx.unique("delegated-len", ctx.loc2pos(yystack_[2].location)); ElementPtr deleg(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("delegated-len", deleg); } -#line 3257 "dhcp6_parser.cc" +#line 3226 "dhcp6_parser.cc" break; - case 581: + case 581: // $@91: %empty #line 2073 "dhcp6_parser.yy" { ctx.unique("reservations", ctx.loc2pos(yystack_[0].location)); @@ -3265,57 +3234,57 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.RESERVATIONS); } -#line 3269 "dhcp6_parser.cc" +#line 3238 "dhcp6_parser.cc" break; - case 582: + case 582: // reservations: "reservations" $@91 ":" "[" reservations_list "]" #line 2079 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3278 "dhcp6_parser.cc" +#line 3247 "dhcp6_parser.cc" break; - case 587: + case 587: // $@92: %empty #line 2092 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3288 "dhcp6_parser.cc" +#line 3257 "dhcp6_parser.cc" break; - case 588: + case 588: // reservation: "{" $@92 reservation_params "}" #line 2096 "dhcp6_parser.yy" { /// @todo: an identifier parameter is required. ctx.stack_.pop_back(); } -#line 3297 "dhcp6_parser.cc" +#line 3266 "dhcp6_parser.cc" break; - case 589: + case 589: // $@93: %empty #line 2101 "dhcp6_parser.yy" { // Parse the reservations list entry map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3307 "dhcp6_parser.cc" +#line 3276 "dhcp6_parser.cc" break; - case 590: + case 590: // sub_reservation: "{" $@93 reservation_params "}" #line 2105 "dhcp6_parser.yy" { /// @todo: an identifier parameter is required. // parsing completed } -#line 3316 "dhcp6_parser.cc" +#line 3285 "dhcp6_parser.cc" break; - case 606: + case 606: // $@94: %empty #line 2132 "dhcp6_parser.yy" { ctx.unique("ip-addresses", ctx.loc2pos(yystack_[0].location)); @@ -3324,19 +3293,19 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.NO_KEYWORD); } -#line 3328 "dhcp6_parser.cc" +#line 3297 "dhcp6_parser.cc" break; - case 607: + case 607: // ip_addresses: "ip-addresses" $@94 ":" list_strings #line 2138 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3337 "dhcp6_parser.cc" +#line 3306 "dhcp6_parser.cc" break; - case 608: + case 608: // $@95: %empty #line 2143 "dhcp6_parser.yy" { ctx.unique("prefixes", ctx.loc2pos(yystack_[0].location)); @@ -3345,95 +3314,95 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.NO_KEYWORD); } -#line 3349 "dhcp6_parser.cc" +#line 3318 "dhcp6_parser.cc" break; - case 609: + case 609: // prefixes: "prefixes" $@95 ":" list_strings #line 2149 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3358 "dhcp6_parser.cc" +#line 3327 "dhcp6_parser.cc" break; - case 610: + case 610: // $@96: %empty #line 2154 "dhcp6_parser.yy" { ctx.unique("duid", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3367 "dhcp6_parser.cc" +#line 3336 "dhcp6_parser.cc" break; - case 611: + case 611: // duid: "duid" $@96 ":" "constant string" #line 2157 "dhcp6_parser.yy" { ElementPtr d(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("duid", d); ctx.leave(); } -#line 3377 "dhcp6_parser.cc" +#line 3346 "dhcp6_parser.cc" break; - case 612: + case 612: // $@97: %empty #line 2163 "dhcp6_parser.yy" { ctx.unique("hw-address", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3386 "dhcp6_parser.cc" +#line 3355 "dhcp6_parser.cc" break; - case 613: + case 613: // hw_address: "hw-address" $@97 ":" "constant string" #line 2166 "dhcp6_parser.yy" { 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 3396 "dhcp6_parser.cc" +#line 3365 "dhcp6_parser.cc" break; - case 614: + case 614: // $@98: %empty #line 2172 "dhcp6_parser.yy" { ctx.unique("hostname", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3405 "dhcp6_parser.cc" +#line 3374 "dhcp6_parser.cc" break; - case 615: + case 615: // hostname: "hostname" $@98 ":" "constant string" #line 2175 "dhcp6_parser.yy" { ElementPtr host(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("hostname", host); ctx.leave(); } -#line 3415 "dhcp6_parser.cc" +#line 3384 "dhcp6_parser.cc" break; - case 616: + case 616: // $@99: %empty #line 2181 "dhcp6_parser.yy" { ctx.unique("flex-id", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3424 "dhcp6_parser.cc" +#line 3393 "dhcp6_parser.cc" break; - case 617: + case 617: // flex_id_value: "flex-id" $@99 ":" "constant string" #line 2184 "dhcp6_parser.yy" { 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 3434 "dhcp6_parser.cc" +#line 3403 "dhcp6_parser.cc" break; - case 618: + case 618: // $@100: %empty #line 2190 "dhcp6_parser.yy" { ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location)); @@ -3442,19 +3411,19 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(c); ctx.enter(ctx.NO_KEYWORD); } -#line 3446 "dhcp6_parser.cc" +#line 3415 "dhcp6_parser.cc" break; - case 619: + case 619: // reservation_client_classes: "client-classes" $@100 ":" list_strings #line 2196 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3455 "dhcp6_parser.cc" +#line 3424 "dhcp6_parser.cc" break; - case 620: + case 620: // $@101: %empty #line 2204 "dhcp6_parser.yy" { ctx.unique("relay", ctx.loc2pos(yystack_[0].location)); @@ -3463,38 +3432,38 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.RELAY); } -#line 3467 "dhcp6_parser.cc" +#line 3436 "dhcp6_parser.cc" break; - case 621: + case 621: // relay: "relay" $@101 ":" "{" relay_map "}" #line 2210 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3476 "dhcp6_parser.cc" +#line 3445 "dhcp6_parser.cc" break; - case 624: + case 624: // $@102: %empty #line 2219 "dhcp6_parser.yy" { ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3485 "dhcp6_parser.cc" +#line 3454 "dhcp6_parser.cc" break; - case 625: + case 625: // ip_address: "ip-address" $@102 ":" "constant string" #line 2222 "dhcp6_parser.yy" { 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 3495 "dhcp6_parser.cc" +#line 3464 "dhcp6_parser.cc" break; - case 626: + case 626: // $@103: %empty #line 2231 "dhcp6_parser.yy" { ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location)); @@ -3503,68 +3472,68 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.CLIENT_CLASSES); } -#line 3507 "dhcp6_parser.cc" +#line 3476 "dhcp6_parser.cc" break; - case 627: + case 627: // client_classes: "client-classes" $@103 ":" "[" client_classes_list "]" #line 2237 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3516 "dhcp6_parser.cc" +#line 3485 "dhcp6_parser.cc" break; - case 630: + case 630: // $@104: %empty #line 2246 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 3526 "dhcp6_parser.cc" +#line 3495 "dhcp6_parser.cc" break; - case 631: + case 631: // client_class_entry: "{" $@104 client_class_params "}" #line 2250 "dhcp6_parser.yy" { // 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 3536 "dhcp6_parser.cc" +#line 3505 "dhcp6_parser.cc" break; - case 644: + case 644: // $@105: %empty #line 2275 "dhcp6_parser.yy" { ctx.unique("test", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3545 "dhcp6_parser.cc" +#line 3514 "dhcp6_parser.cc" break; - case 645: + case 645: // client_class_test: "test" $@105 ":" "constant string" #line 2278 "dhcp6_parser.yy" { ElementPtr test(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("test", test); ctx.leave(); } -#line 3555 "dhcp6_parser.cc" +#line 3524 "dhcp6_parser.cc" break; - case 646: + case 646: // only_if_required: "only-if-required" ":" "boolean" #line 2284 "dhcp6_parser.yy" { ctx.unique("only-if-required", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("only-if-required", b); } -#line 3565 "dhcp6_parser.cc" +#line 3534 "dhcp6_parser.cc" break; - case 647: + case 647: // $@106: %empty #line 2293 "dhcp6_parser.yy" { ctx.unique("server-id", ctx.loc2pos(yystack_[0].location)); @@ -3573,10 +3542,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.SERVER_ID); } -#line 3577 "dhcp6_parser.cc" +#line 3546 "dhcp6_parser.cc" break; - case 648: + case 648: // server_id: "server-id" $@106 ":" "{" server_id_params "}" #line 2299 "dhcp6_parser.yy" { // The type parameter is required. @@ -3584,105 +3553,105 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 3588 "dhcp6_parser.cc" +#line 3557 "dhcp6_parser.cc" break; - case 660: + case 660: // $@107: %empty #line 2321 "dhcp6_parser.yy" { ctx.unique("type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.DUID_TYPE); } -#line 3597 "dhcp6_parser.cc" +#line 3566 "dhcp6_parser.cc" break; - case 661: + case 661: // server_id_type: "type" $@107 ":" duid_type #line 2324 "dhcp6_parser.yy" { ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 3606 "dhcp6_parser.cc" +#line 3575 "dhcp6_parser.cc" break; - case 662: + case 662: // duid_type: "LLT" #line 2329 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("LLT", ctx.loc2pos(yystack_[0].location))); } -#line 3612 "dhcp6_parser.cc" +#line 3581 "dhcp6_parser.cc" break; - case 663: + case 663: // duid_type: "EN" #line 2330 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("EN", ctx.loc2pos(yystack_[0].location))); } -#line 3618 "dhcp6_parser.cc" +#line 3587 "dhcp6_parser.cc" break; - case 664: + case 664: // duid_type: "LL" #line 2331 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("LL", ctx.loc2pos(yystack_[0].location))); } -#line 3624 "dhcp6_parser.cc" +#line 3593 "dhcp6_parser.cc" break; - case 665: + case 665: // htype: "htype" ":" "integer" #line 2334 "dhcp6_parser.yy" { ctx.unique("htype", ctx.loc2pos(yystack_[2].location)); ElementPtr htype(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("htype", htype); } -#line 3634 "dhcp6_parser.cc" +#line 3603 "dhcp6_parser.cc" break; - case 666: + case 666: // $@108: %empty #line 2340 "dhcp6_parser.yy" { ctx.unique("identifier", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3643 "dhcp6_parser.cc" +#line 3612 "dhcp6_parser.cc" break; - case 667: + case 667: // identifier: "identifier" $@108 ":" "constant string" #line 2343 "dhcp6_parser.yy" { ElementPtr id(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("identifier", id); ctx.leave(); } -#line 3653 "dhcp6_parser.cc" +#line 3622 "dhcp6_parser.cc" break; - case 668: + case 668: // time: "time" ":" "integer" #line 2349 "dhcp6_parser.yy" { ctx.unique("time", ctx.loc2pos(yystack_[2].location)); ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("time", time); } -#line 3663 "dhcp6_parser.cc" +#line 3632 "dhcp6_parser.cc" break; - case 669: + case 669: // enterprise_id: "enterprise-id" ":" "integer" #line 2355 "dhcp6_parser.yy" { ctx.unique("enterprise-id", ctx.loc2pos(yystack_[2].location)); ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enterprise-id", time); } -#line 3673 "dhcp6_parser.cc" +#line 3642 "dhcp6_parser.cc" break; - case 670: + case 670: // dhcp4o6_port: "dhcp4o6-port" ":" "integer" #line 2363 "dhcp6_parser.yy" { ctx.unique("dhcp4o6-port", ctx.loc2pos(yystack_[2].location)); ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("dhcp4o6-port", time); } -#line 3683 "dhcp6_parser.cc" +#line 3652 "dhcp6_parser.cc" break; - case 671: + case 671: // $@109: %empty #line 2371 "dhcp6_parser.yy" { ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location)); @@ -3691,57 +3660,57 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.CONTROL_SOCKET); } -#line 3695 "dhcp6_parser.cc" +#line 3664 "dhcp6_parser.cc" break; - case 672: + case 672: // control_socket: "control-socket" $@109 ":" "{" control_socket_params "}" #line 2377 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 3704 "dhcp6_parser.cc" +#line 3673 "dhcp6_parser.cc" break; - case 680: + case 680: // $@110: %empty #line 2393 "dhcp6_parser.yy" { ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3713 "dhcp6_parser.cc" +#line 3682 "dhcp6_parser.cc" break; - case 681: + case 681: // socket_type: "socket-type" $@110 ":" "constant string" #line 2396 "dhcp6_parser.yy" { 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 3723 "dhcp6_parser.cc" +#line 3692 "dhcp6_parser.cc" break; - case 682: + case 682: // $@111: %empty #line 2402 "dhcp6_parser.yy" { ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3732 "dhcp6_parser.cc" +#line 3701 "dhcp6_parser.cc" break; - case 683: + case 683: // socket_name: "socket-name" $@111 ":" "constant string" #line 2405 "dhcp6_parser.yy" { 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 3742 "dhcp6_parser.cc" +#line 3711 "dhcp6_parser.cc" break; - case 684: + case 684: // $@112: %empty #line 2414 "dhcp6_parser.yy" { ctx.unique("dhcp-queue-control", ctx.loc2pos(yystack_[0].location)); @@ -3750,10 +3719,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(qc); ctx.enter(ctx.DHCP_QUEUE_CONTROL); } -#line 3754 "dhcp6_parser.cc" +#line 3723 "dhcp6_parser.cc" break; - case 685: + case 685: // dhcp_queue_control: "dhcp-queue-control" $@112 ":" "{" queue_control_params "}" #line 2420 "dhcp6_parser.yy" { // The enable queue parameter is required. @@ -3761,67 +3730,67 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 3765 "dhcp6_parser.cc" +#line 3734 "dhcp6_parser.cc" break; - case 694: + case 694: // enable_queue: "enable-queue" ":" "boolean" #line 2439 "dhcp6_parser.yy" { ctx.unique("enable-queue", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enable-queue", b); } -#line 3775 "dhcp6_parser.cc" +#line 3744 "dhcp6_parser.cc" break; - case 695: + case 695: // $@113: %empty #line 2445 "dhcp6_parser.yy" { ctx.unique("queue-type", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3784 "dhcp6_parser.cc" +#line 3753 "dhcp6_parser.cc" break; - case 696: + case 696: // queue_type: "queue-type" $@113 ":" "constant string" #line 2448 "dhcp6_parser.yy" { ElementPtr qt(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("queue-type", qt); ctx.leave(); } -#line 3794 "dhcp6_parser.cc" +#line 3763 "dhcp6_parser.cc" break; - case 697: + case 697: // capacity: "capacity" ":" "integer" #line 2454 "dhcp6_parser.yy" { ctx.unique("capacity", ctx.loc2pos(yystack_[2].location)); ElementPtr c(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("capacity", c); } -#line 3804 "dhcp6_parser.cc" +#line 3773 "dhcp6_parser.cc" break; - case 698: + case 698: // $@114: %empty #line 2460 "dhcp6_parser.yy" { ctx.unique(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3813 "dhcp6_parser.cc" +#line 3782 "dhcp6_parser.cc" break; - case 699: + case 699: // arbitrary_map_entry: "constant string" $@114 ":" value #line 2463 "dhcp6_parser.yy" { ctx.stack_.back()->set(yystack_[3].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 3822 "dhcp6_parser.cc" +#line 3791 "dhcp6_parser.cc" break; - case 700: + case 700: // $@115: %empty #line 2470 "dhcp6_parser.yy" { ctx.unique("dhcp-ddns", ctx.loc2pos(yystack_[0].location)); @@ -3830,10 +3799,10 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(m); ctx.enter(ctx.DHCP_DDNS); } -#line 3834 "dhcp6_parser.cc" +#line 3803 "dhcp6_parser.cc" break; - case 701: + case 701: // dhcp_ddns: "dhcp-ddns" $@115 ":" "{" dhcp_ddns_params "}" #line 2476 "dhcp6_parser.yy" { // The enable updates DHCP DDNS parameter is required. @@ -3841,271 +3810,271 @@ namespace isc { namespace dhcp { ctx.stack_.pop_back(); ctx.leave(); } -#line 3845 "dhcp6_parser.cc" +#line 3814 "dhcp6_parser.cc" break; - case 702: + case 702: // $@116: %empty #line 2483 "dhcp6_parser.yy" { // Parse the dhcp-ddns map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 3855 "dhcp6_parser.cc" +#line 3824 "dhcp6_parser.cc" break; - case 703: + case 703: // sub_dhcp_ddns: "{" $@116 dhcp_ddns_params "}" #line 2487 "dhcp6_parser.yy" { // 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 3865 "dhcp6_parser.cc" +#line 3834 "dhcp6_parser.cc" break; - case 724: + case 724: // enable_updates: "enable-updates" ":" "boolean" #line 2517 "dhcp6_parser.yy" { ctx.unique("enable-updates", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("enable-updates", b); } -#line 3875 "dhcp6_parser.cc" +#line 3844 "dhcp6_parser.cc" break; - case 725: + case 725: // $@117: %empty #line 2524 "dhcp6_parser.yy" { ctx.unique("qualifying-suffix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3884 "dhcp6_parser.cc" +#line 3853 "dhcp6_parser.cc" break; - case 726: + case 726: // dep_qualifying_suffix: "qualifying-suffix" $@117 ":" "constant string" #line 2527 "dhcp6_parser.yy" { 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 3894 "dhcp6_parser.cc" +#line 3863 "dhcp6_parser.cc" break; - case 727: + case 727: // $@118: %empty #line 2533 "dhcp6_parser.yy" { ctx.unique("server-ip", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3903 "dhcp6_parser.cc" +#line 3872 "dhcp6_parser.cc" break; - case 728: + case 728: // server_ip: "server-ip" $@118 ":" "constant string" #line 2536 "dhcp6_parser.yy" { 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 3913 "dhcp6_parser.cc" +#line 3882 "dhcp6_parser.cc" break; - case 729: + case 729: // server_port: "server-port" ":" "integer" #line 2542 "dhcp6_parser.yy" { ctx.unique("server-port", ctx.loc2pos(yystack_[2].location)); ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("server-port", i); } -#line 3923 "dhcp6_parser.cc" +#line 3892 "dhcp6_parser.cc" break; - case 730: + case 730: // $@119: %empty #line 2548 "dhcp6_parser.yy" { ctx.unique("sender-ip", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 3932 "dhcp6_parser.cc" +#line 3901 "dhcp6_parser.cc" break; - case 731: + case 731: // sender_ip: "sender-ip" $@119 ":" "constant string" #line 2551 "dhcp6_parser.yy" { 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 3942 "dhcp6_parser.cc" +#line 3911 "dhcp6_parser.cc" break; - case 732: + case 732: // sender_port: "sender-port" ":" "integer" #line 2557 "dhcp6_parser.yy" { ctx.unique("sender-port", ctx.loc2pos(yystack_[2].location)); ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("sender-port", i); } -#line 3952 "dhcp6_parser.cc" +#line 3921 "dhcp6_parser.cc" break; - case 733: + case 733: // max_queue_size: "max-queue-size" ":" "integer" #line 2563 "dhcp6_parser.yy" { ctx.unique("max-queue-size", ctx.loc2pos(yystack_[2].location)); ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("max-queue-size", i); } -#line 3962 "dhcp6_parser.cc" +#line 3931 "dhcp6_parser.cc" break; - case 734: + case 734: // $@120: %empty #line 2569 "dhcp6_parser.yy" { ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NCR_PROTOCOL); } -#line 3971 "dhcp6_parser.cc" +#line 3940 "dhcp6_parser.cc" break; - case 735: + case 735: // ncr_protocol: "ncr-protocol" $@120 ":" ncr_protocol_value #line 2572 "dhcp6_parser.yy" { ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 3980 "dhcp6_parser.cc" +#line 3949 "dhcp6_parser.cc" break; - case 736: + case 736: // ncr_protocol_value: "UDP" #line 2578 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); } -#line 3986 "dhcp6_parser.cc" +#line 3955 "dhcp6_parser.cc" break; - case 737: + case 737: // ncr_protocol_value: "TCP" #line 2579 "dhcp6_parser.yy" { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); } -#line 3992 "dhcp6_parser.cc" +#line 3961 "dhcp6_parser.cc" break; - case 738: + case 738: // $@121: %empty #line 2582 "dhcp6_parser.yy" { ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NCR_FORMAT); } -#line 4001 "dhcp6_parser.cc" +#line 3970 "dhcp6_parser.cc" break; - case 739: + case 739: // ncr_format: "ncr-format" $@121 ":" "JSON" #line 2585 "dhcp6_parser.yy" { ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("ncr-format", json); ctx.leave(); } -#line 4011 "dhcp6_parser.cc" +#line 3980 "dhcp6_parser.cc" break; - case 740: + case 740: // dep_override_no_update: "override-no-update" ":" "boolean" #line 2592 "dhcp6_parser.yy" { ctx.unique("override-no-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("override-no-update", b); } -#line 4021 "dhcp6_parser.cc" +#line 3990 "dhcp6_parser.cc" break; - case 741: + case 741: // dep_override_client_update: "override-client-update" ":" "boolean" #line 2599 "dhcp6_parser.yy" { ctx.unique("override-client-update", ctx.loc2pos(yystack_[2].location)); ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("override-client-update", b); } -#line 4031 "dhcp6_parser.cc" +#line 4000 "dhcp6_parser.cc" break; - case 742: + case 742: // $@122: %empty #line 2606 "dhcp6_parser.yy" { ctx.unique("replace-client-name", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.REPLACE_CLIENT_NAME); } -#line 4040 "dhcp6_parser.cc" +#line 4009 "dhcp6_parser.cc" break; - case 743: + case 743: // dep_replace_client_name: "replace-client-name" $@122 ":" ddns_replace_client_name_value #line 2609 "dhcp6_parser.yy" { ctx.stack_.back()->set("replace-client-name", yystack_[0].value.as < ElementPtr > ()); ctx.leave(); } -#line 4049 "dhcp6_parser.cc" +#line 4018 "dhcp6_parser.cc" break; - case 744: + case 744: // $@123: %empty #line 2615 "dhcp6_parser.yy" { ctx.unique("generated-prefix", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4058 "dhcp6_parser.cc" +#line 4027 "dhcp6_parser.cc" break; - case 745: + case 745: // dep_generated_prefix: "generated-prefix" $@123 ":" "constant string" #line 2618 "dhcp6_parser.yy" { 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 4068 "dhcp6_parser.cc" +#line 4037 "dhcp6_parser.cc" break; - case 746: + case 746: // $@124: %empty #line 2625 "dhcp6_parser.yy" { ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4077 "dhcp6_parser.cc" +#line 4046 "dhcp6_parser.cc" break; - case 747: + case 747: // dep_hostname_char_set: "hostname-char-set" $@124 ":" "constant string" #line 2628 "dhcp6_parser.yy" { 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 4087 "dhcp6_parser.cc" +#line 4056 "dhcp6_parser.cc" break; - case 748: + case 748: // $@125: %empty #line 2635 "dhcp6_parser.yy" { ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4096 "dhcp6_parser.cc" +#line 4065 "dhcp6_parser.cc" break; - case 749: + case 749: // dep_hostname_char_replacement: "hostname-char-replacement" $@125 ":" "constant string" #line 2638 "dhcp6_parser.yy" { 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 4106 "dhcp6_parser.cc" +#line 4075 "dhcp6_parser.cc" break; - case 750: + case 750: // $@126: %empty #line 2647 "dhcp6_parser.yy" { ctx.unique("config-control", ctx.loc2pos(yystack_[0].location)); @@ -4114,39 +4083,39 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(i); ctx.enter(ctx.CONFIG_CONTROL); } -#line 4118 "dhcp6_parser.cc" +#line 4087 "dhcp6_parser.cc" break; - case 751: + case 751: // config_control: "config-control" $@126 ":" "{" config_control_params "}" #line 2653 "dhcp6_parser.yy" { // No config control params are required ctx.stack_.pop_back(); ctx.leave(); } -#line 4128 "dhcp6_parser.cc" +#line 4097 "dhcp6_parser.cc" break; - case 752: + case 752: // $@127: %empty #line 2659 "dhcp6_parser.yy" { // Parse the config-control map ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.push_back(m); } -#line 4138 "dhcp6_parser.cc" +#line 4107 "dhcp6_parser.cc" break; - case 753: + case 753: // sub_config_control: "{" $@127 config_control_params "}" #line 2663 "dhcp6_parser.yy" { // No config_control params are required // parsing completed } -#line 4147 "dhcp6_parser.cc" +#line 4116 "dhcp6_parser.cc" break; - case 758: + case 758: // $@128: %empty #line 2678 "dhcp6_parser.yy" { ctx.unique("config-databases", ctx.loc2pos(yystack_[0].location)); @@ -4155,29 +4124,29 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.CONFIG_DATABASE); } -#line 4159 "dhcp6_parser.cc" +#line 4128 "dhcp6_parser.cc" break; - case 759: + case 759: // config_databases: "config-databases" $@128 ":" "[" database_list "]" #line 2684 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 4168 "dhcp6_parser.cc" +#line 4137 "dhcp6_parser.cc" break; - case 760: + case 760: // config_fetch_wait_time: "config-fetch-wait-time" ":" "integer" #line 2689 "dhcp6_parser.yy" { ctx.unique("config-fetch-wait-time", ctx.loc2pos(yystack_[2].location)); ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("config-fetch-wait-time", value); } -#line 4178 "dhcp6_parser.cc" +#line 4147 "dhcp6_parser.cc" break; - case 761: + case 761: // $@129: %empty #line 2697 "dhcp6_parser.yy" { ctx.unique("loggers", ctx.loc2pos(yystack_[0].location)); @@ -4186,66 +4155,66 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.LOGGERS); } -#line 4190 "dhcp6_parser.cc" +#line 4159 "dhcp6_parser.cc" break; - case 762: + case 762: // loggers: "loggers" $@129 ":" "[" loggers_entries "]" #line 2703 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 4199 "dhcp6_parser.cc" +#line 4168 "dhcp6_parser.cc" break; - case 765: + case 765: // $@130: %empty #line 2715 "dhcp6_parser.yy" { ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(l); ctx.stack_.push_back(l); } -#line 4209 "dhcp6_parser.cc" +#line 4178 "dhcp6_parser.cc" break; - case 766: + case 766: // logger_entry: "{" $@130 logger_params "}" #line 2719 "dhcp6_parser.yy" { ctx.stack_.pop_back(); } -#line 4217 "dhcp6_parser.cc" +#line 4186 "dhcp6_parser.cc" break; - case 776: + case 776: // debuglevel: "debuglevel" ":" "integer" #line 2736 "dhcp6_parser.yy" { ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location)); ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("debuglevel", dl); } -#line 4227 "dhcp6_parser.cc" +#line 4196 "dhcp6_parser.cc" break; - case 777: + case 777: // $@131: %empty #line 2742 "dhcp6_parser.yy" { ctx.unique("severity", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4236 "dhcp6_parser.cc" +#line 4205 "dhcp6_parser.cc" break; - case 778: + case 778: // severity: "severity" $@131 ":" "constant string" #line 2745 "dhcp6_parser.yy" { ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("severity", sev); ctx.leave(); } -#line 4246 "dhcp6_parser.cc" +#line 4215 "dhcp6_parser.cc" break; - case 779: + case 779: // $@132: %empty #line 2751 "dhcp6_parser.yy" { ctx.unique("output_options", ctx.loc2pos(yystack_[0].location)); @@ -4254,106 +4223,106 @@ namespace isc { namespace dhcp { ctx.stack_.push_back(l); ctx.enter(ctx.OUTPUT_OPTIONS); } -#line 4258 "dhcp6_parser.cc" +#line 4227 "dhcp6_parser.cc" break; - case 780: + case 780: // output_options_list: "output_options" $@132 ":" "[" output_options_list_content "]" #line 2757 "dhcp6_parser.yy" { ctx.stack_.pop_back(); ctx.leave(); } -#line 4267 "dhcp6_parser.cc" +#line 4236 "dhcp6_parser.cc" break; - case 783: + case 783: // $@133: %empty #line 2766 "dhcp6_parser.yy" { ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->add(m); ctx.stack_.push_back(m); } -#line 4277 "dhcp6_parser.cc" +#line 4246 "dhcp6_parser.cc" break; - case 784: + case 784: // output_entry: "{" $@133 output_params_list "}" #line 2770 "dhcp6_parser.yy" { ctx.stack_.pop_back(); } -#line 4285 "dhcp6_parser.cc" +#line 4254 "dhcp6_parser.cc" break; - case 792: + case 792: // $@134: %empty #line 2785 "dhcp6_parser.yy" { ctx.unique("output", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4294 "dhcp6_parser.cc" +#line 4263 "dhcp6_parser.cc" break; - case 793: + case 793: // output: "output" $@134 ":" "constant string" #line 2788 "dhcp6_parser.yy" { ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("output", sev); ctx.leave(); } -#line 4304 "dhcp6_parser.cc" +#line 4273 "dhcp6_parser.cc" break; - case 794: + case 794: // flush: "flush" ":" "boolean" #line 2794 "dhcp6_parser.yy" { ctx.unique("flush", ctx.loc2pos(yystack_[2].location)); ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("flush", flush); } -#line 4314 "dhcp6_parser.cc" +#line 4283 "dhcp6_parser.cc" break; - case 795: + case 795: // maxsize: "maxsize" ":" "integer" #line 2800 "dhcp6_parser.yy" { ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location)); ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("maxsize", maxsize); } -#line 4324 "dhcp6_parser.cc" +#line 4293 "dhcp6_parser.cc" break; - case 796: + case 796: // maxver: "maxver" ":" "integer" #line 2806 "dhcp6_parser.yy" { ctx.unique("maxver", ctx.loc2pos(yystack_[2].location)); ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("maxver", maxver); } -#line 4334 "dhcp6_parser.cc" +#line 4303 "dhcp6_parser.cc" break; - case 797: + case 797: // $@135: %empty #line 2812 "dhcp6_parser.yy" { ctx.unique("pattern", ctx.loc2pos(yystack_[0].location)); ctx.enter(ctx.NO_KEYWORD); } -#line 4343 "dhcp6_parser.cc" +#line 4312 "dhcp6_parser.cc" break; - case 798: + case 798: // pattern: "pattern" $@135 ":" "constant string" #line 2815 "dhcp6_parser.yy" { ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); ctx.stack_.back()->set("pattern", sev); ctx.leave(); } -#line 4353 "dhcp6_parser.cc" +#line 4322 "dhcp6_parser.cc" break; -#line 4357 "dhcp6_parser.cc" +#line 4326 "dhcp6_parser.cc" default: break; @@ -4370,7 +4339,6 @@ namespace isc { namespace dhcp { YY_SYMBOL_PRINT ("-> $$ =", yylhs); yypop_ (yylen); yylen = 0; - YY_STACK_PRINT (); // Shift the result of the reduction. yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); @@ -4386,7 +4354,9 @@ namespace isc { namespace dhcp { if (!yyerrstatus_) { ++yynerrs_; - error (yyla.location, yysyntax_error_ (yystack_[0].state, yyla)); + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (yyla.location, YY_MOVE (msg)); } @@ -4397,7 +4367,7 @@ namespace isc { namespace dhcp { error, discard it. */ // Return failure if at end of input. - if (yyla.type_get () == yyeof_) + if (yyla.kind () == symbol_kind::S_YYEOF) YYABORT; else if (!yyla.empty ()) { @@ -4423,6 +4393,7 @@ namespace isc { namespace dhcp { this YYERROR. */ yypop_ (yylen); yylen = 0; + YY_STACK_PRINT (); goto yyerrlab1; @@ -4431,31 +4402,33 @@ namespace isc { namespace dhcp { `-------------------------------------------------------------*/ yyerrlab1: yyerrstatus_ = 3; // Each real token shifted decrements this. - { - stack_symbol_type error_token; - for (;;) - { - yyn = yypact_[+yystack_[0].state]; - if (!yy_pact_value_is_default_ (yyn)) - { - yyn += yy_error_token_; - if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yy_error_token_) - { - yyn = yytable_[yyn]; - if (0 < yyn) - break; - } - } + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += symbol_kind::S_YYerror; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == symbol_kind::S_YYerror) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } - // Pop the current state because it cannot handle the error token. - if (yystack_.size () == 1) - YYABORT; + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; - yyerror_range[1].location = yystack_[0].location; - yy_destroy_ ("Error: popping", yystack_[0]); - yypop_ (); - YY_STACK_PRINT (); - } + yyerror_range[1].location = yystack_[0].location; + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; yyerror_range[2].location = yyla.location; YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); @@ -4493,6 +4466,7 @@ namespace isc { namespace dhcp { /* Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT. */ yypop_ (yylen); + YY_STACK_PRINT (); while (1 < yystack_.size ()) { yy_destroy_ ("Cleanup: popping", yystack_[0]); @@ -4526,18 +4500,100 @@ namespace isc { namespace dhcp { error (yyexc.location, yyexc.what ()); } - // Generate an error message. + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ std::string - Dhcp6Parser::yysyntax_error_ (state_type yystate, const symbol_type& yyla) const + Dhcp6Parser::yytnamerr_ (const char *yystr) { - // Number of reported tokens (one for the "unexpected", one per - // "expected"). - std::ptrdiff_t yycount = 0; - // Its maximum. - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - // Arguments of yyformat. - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + if (*yystr == '"') + { + std::string yyr; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + Dhcp6Parser::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } + + + + // Dhcp6Parser::context. + Dhcp6Parser::context::context (const Dhcp6Parser& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + Dhcp6Parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + + int yyn = yypact_[+yyparser_.yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } + + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = symbol_kind::S_YYEMPTY; + return yycount; + } + + + int + Dhcp6Parser::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then the only way this function was invoked is if the default action @@ -4562,35 +4618,26 @@ namespace isc { namespace dhcp { one exception: it will still contain any token that will not be accepted due to an error action in a later state. */ - if (!yyla.empty ()) - { - symbol_number_type yytoken = yyla.type_get (); - yyarg[yycount++] = yytname_[yytoken]; - int yyn = yypact_[+yystate]; - if (!yy_pact_value_is_default_ (yyn)) - { - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. In other words, skip the first -YYN actions for - this state because they are default actions. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - // Stay within bounds of both yycheck and yytname. - int yychecklim = yylast_ - yyn + 1; - int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; - for (int yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck_[yyx + yyn] == yyx && yyx != yy_error_token_ - && !yy_table_value_is_error_ (yytable_[yyx + yyn])) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - break; - } - else - yyarg[yycount++] = yytname_[yyx]; - } - } + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; } + return 0; + } + + // Generate an error message. + std::string + Dhcp6Parser::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); char const* yyformat = YY_NULLPTR; switch (yycount) @@ -4615,7 +4662,7 @@ namespace isc { namespace dhcp { for (char const* yyp = yyformat; *yyp; ++yyp) if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) { - yyres += yytnamerr_ (yyarg[yyi++]); + yyres += symbol_name (yyarg[yyi++]); ++yyp; } else @@ -4948,7 +4995,7 @@ namespace isc { namespace dhcp { const short Dhcp6Parser::yydefgoto_[] = { - -1, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 0, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 83, 39, 40, 69, 714, 87, 88, 41, 68, 84, 85, 738, 941, 1048, 1049, 801, 43, 70, 90, 423, 45, 71, 153, 154, @@ -5565,15 +5612,15 @@ namespace isc { namespace dhcp { }; - +#if PARSER6_DEBUG || 1 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - // First, the terminals, then, starting at \a yyntokens_, nonterminals. + // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. const char* const Dhcp6Parser::yytname_[] = { - "\"end of file\"", "error", "$undefined", "\",\"", "\":\"", "\"[\"", - "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"Dhcp6\"", "\"data-directory\"", - "\"config-control\"", "\"config-databases\"", + "\"end of file\"", "error", "\"invalid token\"", "\",\"", "\":\"", + "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"Dhcp6\"", + "\"data-directory\"", "\"config-control\"", "\"config-databases\"", "\"config-fetch-wait-time\"", "\"interfaces-config\"", "\"interfaces\"", "\"re-detect\"", "\"lease-database\"", "\"hosts-database\"", "\"hosts-databases\"", "\"type\"", "\"memfile\"", "\"mysql\"", @@ -5745,6 +5792,8 @@ namespace isc { namespace dhcp { "output_params_list", "output_params", "output", "$@134", "flush", "maxsize", "maxver", "pattern", "$@135", YY_NULLPTR }; +#endif + #if PARSER6_DEBUG const short @@ -5832,9 +5881,8 @@ namespace isc { namespace dhcp { 2781, 2782, 2785, 2785, 2794, 2800, 2806, 2812, 2812 }; - // Print the state stack on the debug stream. void - Dhcp6Parser::yystack_print_ () + Dhcp6Parser::yy_stack_print_ () const { *yycdebug_ << "Stack now"; for (stack_type::const_iterator @@ -5845,9 +5893,8 @@ namespace isc { namespace dhcp { *yycdebug_ << '\n'; } - // Report on the debug stream that the rule \a yyrule is going to be reduced. void - Dhcp6Parser::yy_reduce_print_ (int yyrule) + Dhcp6Parser::yy_reduce_print_ (int yyrule) const { int yylno = yyrline_[yyrule]; int yynrhs = yyr2_[yyrule]; @@ -5864,7 +5911,7 @@ namespace isc { namespace dhcp { #line 14 "dhcp6_parser.yy" } } // isc::dhcp -#line 5868 "dhcp6_parser.cc" +#line 5915 "dhcp6_parser.cc" #line 2821 "dhcp6_parser.yy" diff --git a/src/bin/dhcp6/dhcp6_parser.h b/src/bin/dhcp6/dhcp6_parser.h index 67a7487c29..a226f9cee8 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.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Skeleton interface for Bison LALR(1) parsers in C++ -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. +// Copyright (C) 2002-2015, 2018-2021 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 @@ -38,8 +38,9 @@ // 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. +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. #ifndef YY_PARSER6_DHCP6_PARSER_H_INCLUDED # define YY_PARSER6_DHCP6_PARSER_H_INCLUDED @@ -56,7 +57,7 @@ using namespace isc::dhcp; using namespace isc::data; using namespace std; -#line 60 "dhcp6_parser.h" +#line 61 "dhcp6_parser.h" # include # include // std::abort @@ -103,9 +104,9 @@ using namespace std; #endif # include "location.hh" #include -#ifndef YY_ASSERT +#ifndef PARSER6__ASSERT # include -# define YY_ASSERT assert +# define PARSER6__ASSERT assert #endif @@ -127,9 +128,9 @@ using namespace std; /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ -# define YYUSE(E) ((void) (E)) +# define YY_USE(E) ((void) (E)) #else -# define YYUSE(E) /* empty */ +# define YY_USE(E) /* empty */ #endif #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ @@ -199,7 +200,7 @@ using namespace std; #line 14 "dhcp6_parser.yy" namespace isc { namespace dhcp { -#line 203 "dhcp6_parser.h" +#line 204 "dhcp6_parser.h" @@ -231,14 +232,21 @@ namespace isc { namespace dhcp { semantic_type (YY_RVREF (T) t) : yytypeid_ (&typeid (T)) { - YY_ASSERT (sizeof (T) <= size); + PARSER6__ASSERT (sizeof (T) <= size); new (yyas_ ()) T (YY_MOVE (t)); } +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + semantic_type (const self_type&) = delete; + /// Non copyable. + self_type& operator= (const self_type&) = delete; +#endif + /// Destruction, allowed only if empty. ~semantic_type () YY_NOEXCEPT { - YY_ASSERT (!yytypeid_); + PARSER6__ASSERT (!yytypeid_); } # if 201103L <= YY_CPLUSPLUS @@ -247,8 +255,8 @@ namespace isc { namespace dhcp { T& emplace (U&&... u) { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); + PARSER6__ASSERT (!yytypeid_); + PARSER6__ASSERT (sizeof (T) <= size); yytypeid_ = & typeid (T); return *new (yyas_ ()) T (std::forward (u)...); } @@ -258,8 +266,8 @@ namespace isc { namespace dhcp { T& emplace () { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); + PARSER6__ASSERT (!yytypeid_); + PARSER6__ASSERT (sizeof (T) <= size); yytypeid_ = & typeid (T); return *new (yyas_ ()) T (); } @@ -269,8 +277,8 @@ namespace isc { namespace dhcp { T& emplace (const T& t) { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); + PARSER6__ASSERT (!yytypeid_); + PARSER6__ASSERT (sizeof (T) <= size); yytypeid_ = & typeid (T); return *new (yyas_ ()) T (t); } @@ -299,9 +307,9 @@ namespace isc { namespace dhcp { T& as () YY_NOEXCEPT { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == typeid (T)); - YY_ASSERT (sizeof (T) <= size); + PARSER6__ASSERT (yytypeid_); + PARSER6__ASSERT (*yytypeid_ == typeid (T)); + PARSER6__ASSERT (sizeof (T) <= size); return *yyas_ (); } @@ -310,9 +318,9 @@ namespace isc { namespace dhcp { const T& as () const YY_NOEXCEPT { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == typeid (T)); - YY_ASSERT (sizeof (T) <= size); + PARSER6__ASSERT (yytypeid_); + PARSER6__ASSERT (*yytypeid_ == typeid (T)); + PARSER6__ASSERT (sizeof (T) <= size); return *yyas_ (); } @@ -328,8 +336,8 @@ namespace isc { namespace dhcp { void swap (self_type& that) YY_NOEXCEPT { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == *that.yytypeid_); + PARSER6__ASSERT (yytypeid_); + PARSER6__ASSERT (*yytypeid_ == *that.yytypeid_); std::swap (as (), that.as ()); } @@ -378,9 +386,12 @@ namespace isc { namespace dhcp { } private: - /// Prohibit blind copies. - self_type& operator= (const self_type&); +#if YY_CPLUSPLUS < 201103L + /// Non copyable. semantic_type (const self_type&); + /// Non copyable. + self_type& operator= (const self_type&); +#endif /// Accessor to raw memory as \a T. template @@ -466,238 +477,896 @@ namespace isc { namespace dhcp { location_type location; }; - /// Tokens. + /// Token kinds. struct token { - enum yytokentype - { - TOKEN_END = 0, - TOKEN_COMMA = 258, - TOKEN_COLON = 259, - TOKEN_LSQUARE_BRACKET = 260, - TOKEN_RSQUARE_BRACKET = 261, - TOKEN_LCURLY_BRACKET = 262, - TOKEN_RCURLY_BRACKET = 263, - TOKEN_NULL_TYPE = 264, - TOKEN_DHCP6 = 265, - TOKEN_DATA_DIRECTORY = 266, - TOKEN_CONFIG_CONTROL = 267, - TOKEN_CONFIG_DATABASES = 268, - TOKEN_CONFIG_FETCH_WAIT_TIME = 269, - TOKEN_INTERFACES_CONFIG = 270, - TOKEN_INTERFACES = 271, - TOKEN_RE_DETECT = 272, - TOKEN_LEASE_DATABASE = 273, - TOKEN_HOSTS_DATABASE = 274, - TOKEN_HOSTS_DATABASES = 275, - TOKEN_TYPE = 276, - TOKEN_MEMFILE = 277, - TOKEN_MYSQL = 278, - TOKEN_POSTGRESQL = 279, - TOKEN_CQL = 280, - TOKEN_USER = 281, - TOKEN_PASSWORD = 282, - TOKEN_HOST = 283, - TOKEN_PORT = 284, - TOKEN_PERSIST = 285, - TOKEN_LFC_INTERVAL = 286, - TOKEN_READONLY = 287, - TOKEN_CONNECT_TIMEOUT = 288, - TOKEN_CONTACT_POINTS = 289, - TOKEN_MAX_RECONNECT_TRIES = 290, - TOKEN_RECONNECT_WAIT_TIME = 291, - TOKEN_ON_FAIL = 292, - TOKEN_STOP_RETRY_EXIT = 293, - TOKEN_SERVE_RETRY_EXIT = 294, - TOKEN_SERVE_RETRY_CONTINUE = 295, - TOKEN_KEYSPACE = 296, - TOKEN_CONSISTENCY = 297, - TOKEN_SERIAL_CONSISTENCY = 298, - TOKEN_REQUEST_TIMEOUT = 299, - TOKEN_TCP_KEEPALIVE = 300, - TOKEN_TCP_NODELAY = 301, - TOKEN_MAX_ROW_ERRORS = 302, - TOKEN_PREFERRED_LIFETIME = 303, - TOKEN_MIN_PREFERRED_LIFETIME = 304, - TOKEN_MAX_PREFERRED_LIFETIME = 305, - TOKEN_VALID_LIFETIME = 306, - TOKEN_MIN_VALID_LIFETIME = 307, - TOKEN_MAX_VALID_LIFETIME = 308, - TOKEN_RENEW_TIMER = 309, - TOKEN_REBIND_TIMER = 310, - TOKEN_CALCULATE_TEE_TIMES = 311, - TOKEN_T1_PERCENT = 312, - TOKEN_T2_PERCENT = 313, - TOKEN_CACHE_THRESHOLD = 314, - TOKEN_CACHE_MAX_AGE = 315, - TOKEN_DECLINE_PROBATION_PERIOD = 316, - TOKEN_SERVER_TAG = 317, - TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT = 318, - TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE = 319, - TOKEN_DDNS_SEND_UPDATES = 320, - TOKEN_DDNS_OVERRIDE_NO_UPDATE = 321, - TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE = 322, - TOKEN_DDNS_REPLACE_CLIENT_NAME = 323, - TOKEN_DDNS_GENERATED_PREFIX = 324, - TOKEN_DDNS_QUALIFYING_SUFFIX = 325, - TOKEN_DDNS_UPDATE_ON_RENEW = 326, - TOKEN_DDNS_USE_CONFLICT_RESOLUTION = 327, - TOKEN_STORE_EXTENDED_INFO = 328, - TOKEN_SUBNET6 = 329, - TOKEN_OPTION_DEF = 330, - TOKEN_OPTION_DATA = 331, - TOKEN_NAME = 332, - TOKEN_DATA = 333, - TOKEN_CODE = 334, - TOKEN_SPACE = 335, - TOKEN_CSV_FORMAT = 336, - TOKEN_ALWAYS_SEND = 337, - TOKEN_RECORD_TYPES = 338, - TOKEN_ENCAPSULATE = 339, - TOKEN_ARRAY = 340, - TOKEN_SHARED_NETWORKS = 341, - TOKEN_POOLS = 342, - TOKEN_POOL = 343, - TOKEN_PD_POOLS = 344, - TOKEN_PREFIX = 345, - TOKEN_PREFIX_LEN = 346, - TOKEN_EXCLUDED_PREFIX = 347, - TOKEN_EXCLUDED_PREFIX_LEN = 348, - TOKEN_DELEGATED_LEN = 349, - TOKEN_USER_CONTEXT = 350, - TOKEN_COMMENT = 351, - TOKEN_SUBNET = 352, - TOKEN_INTERFACE = 353, - TOKEN_INTERFACE_ID = 354, - TOKEN_ID = 355, - TOKEN_RAPID_COMMIT = 356, - TOKEN_RESERVATION_MODE = 357, - TOKEN_DISABLED = 358, - TOKEN_OUT_OF_POOL = 359, - TOKEN_GLOBAL = 360, - TOKEN_ALL = 361, - TOKEN_RESERVATIONS_GLOBAL = 362, - TOKEN_RESERVATIONS_IN_SUBNET = 363, - TOKEN_RESERVATIONS_OUT_OF_POOL = 364, - TOKEN_MAC_SOURCES = 365, - TOKEN_RELAY_SUPPLIED_OPTIONS = 366, - TOKEN_HOST_RESERVATION_IDENTIFIERS = 367, - TOKEN_SANITY_CHECKS = 368, - TOKEN_LEASE_CHECKS = 369, - TOKEN_CLIENT_CLASSES = 370, - TOKEN_REQUIRE_CLIENT_CLASSES = 371, - TOKEN_TEST = 372, - TOKEN_ONLY_IF_REQUIRED = 373, - TOKEN_CLIENT_CLASS = 374, - TOKEN_RESERVATIONS = 375, - TOKEN_IP_ADDRESSES = 376, - TOKEN_PREFIXES = 377, - TOKEN_DUID = 378, - TOKEN_HW_ADDRESS = 379, - TOKEN_HOSTNAME = 380, - TOKEN_FLEX_ID = 381, - TOKEN_RELAY = 382, - TOKEN_IP_ADDRESS = 383, - TOKEN_HOOKS_LIBRARIES = 384, - TOKEN_LIBRARY = 385, - TOKEN_PARAMETERS = 386, - TOKEN_EXPIRED_LEASES_PROCESSING = 387, - TOKEN_RECLAIM_TIMER_WAIT_TIME = 388, - TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 389, - TOKEN_HOLD_RECLAIMED_TIME = 390, - TOKEN_MAX_RECLAIM_LEASES = 391, - TOKEN_MAX_RECLAIM_TIME = 392, - TOKEN_UNWARNED_RECLAIM_CYCLES = 393, - TOKEN_SERVER_ID = 394, - TOKEN_LLT = 395, - TOKEN_EN = 396, - TOKEN_LL = 397, - TOKEN_IDENTIFIER = 398, - TOKEN_HTYPE = 399, - TOKEN_TIME = 400, - TOKEN_ENTERPRISE_ID = 401, - TOKEN_DHCP4O6_PORT = 402, - TOKEN_DHCP_MULTI_THREADING = 403, - TOKEN_ENABLE_MULTI_THREADING = 404, - TOKEN_THREAD_POOL_SIZE = 405, - TOKEN_PACKET_QUEUE_SIZE = 406, - TOKEN_CONTROL_SOCKET = 407, - TOKEN_SOCKET_TYPE = 408, - TOKEN_SOCKET_NAME = 409, - TOKEN_DHCP_QUEUE_CONTROL = 410, - TOKEN_ENABLE_QUEUE = 411, - TOKEN_QUEUE_TYPE = 412, - TOKEN_CAPACITY = 413, - TOKEN_DHCP_DDNS = 414, - TOKEN_ENABLE_UPDATES = 415, - TOKEN_QUALIFYING_SUFFIX = 416, - TOKEN_SERVER_IP = 417, - TOKEN_SERVER_PORT = 418, - TOKEN_SENDER_IP = 419, - TOKEN_SENDER_PORT = 420, - TOKEN_MAX_QUEUE_SIZE = 421, - TOKEN_NCR_PROTOCOL = 422, - TOKEN_NCR_FORMAT = 423, - TOKEN_OVERRIDE_NO_UPDATE = 424, - TOKEN_OVERRIDE_CLIENT_UPDATE = 425, - TOKEN_REPLACE_CLIENT_NAME = 426, - TOKEN_GENERATED_PREFIX = 427, - TOKEN_UDP = 428, - TOKEN_TCP = 429, - TOKEN_JSON = 430, - TOKEN_WHEN_PRESENT = 431, - TOKEN_NEVER = 432, - TOKEN_ALWAYS = 433, - TOKEN_WHEN_NOT_PRESENT = 434, - TOKEN_HOSTNAME_CHAR_SET = 435, - TOKEN_HOSTNAME_CHAR_REPLACEMENT = 436, - TOKEN_IP_RESERVATIONS_UNIQUE = 437, - TOKEN_LOGGERS = 438, - TOKEN_OUTPUT_OPTIONS = 439, - TOKEN_OUTPUT = 440, - TOKEN_DEBUGLEVEL = 441, - TOKEN_SEVERITY = 442, - TOKEN_FLUSH = 443, - TOKEN_MAXSIZE = 444, - TOKEN_MAXVER = 445, - TOKEN_PATTERN = 446, - TOKEN_TOPLEVEL_JSON = 447, - TOKEN_TOPLEVEL_DHCP6 = 448, - TOKEN_SUB_DHCP6 = 449, - TOKEN_SUB_INTERFACES6 = 450, - TOKEN_SUB_SUBNET6 = 451, - TOKEN_SUB_POOL6 = 452, - TOKEN_SUB_PD_POOL = 453, - TOKEN_SUB_RESERVATION = 454, - TOKEN_SUB_OPTION_DEFS = 455, - TOKEN_SUB_OPTION_DEF = 456, - TOKEN_SUB_OPTION_DATA = 457, - TOKEN_SUB_HOOKS_LIBRARY = 458, - TOKEN_SUB_DHCP_DDNS = 459, - TOKEN_SUB_CONFIG_CONTROL = 460, - TOKEN_STRING = 461, - TOKEN_INTEGER = 462, - TOKEN_FLOAT = 463, - TOKEN_BOOLEAN = 464 + enum token_kind_type + { + TOKEN_PARSER6_EMPTY = -2, + TOKEN_END = 0, // "end of file" + TOKEN_PARSER6_error = 256, // error + TOKEN_PARSER6_UNDEF = 257, // "invalid token" + TOKEN_COMMA = 258, // "," + TOKEN_COLON = 259, // ":" + TOKEN_LSQUARE_BRACKET = 260, // "[" + TOKEN_RSQUARE_BRACKET = 261, // "]" + TOKEN_LCURLY_BRACKET = 262, // "{" + TOKEN_RCURLY_BRACKET = 263, // "}" + TOKEN_NULL_TYPE = 264, // "null" + TOKEN_DHCP6 = 265, // "Dhcp6" + TOKEN_DATA_DIRECTORY = 266, // "data-directory" + TOKEN_CONFIG_CONTROL = 267, // "config-control" + TOKEN_CONFIG_DATABASES = 268, // "config-databases" + TOKEN_CONFIG_FETCH_WAIT_TIME = 269, // "config-fetch-wait-time" + TOKEN_INTERFACES_CONFIG = 270, // "interfaces-config" + TOKEN_INTERFACES = 271, // "interfaces" + TOKEN_RE_DETECT = 272, // "re-detect" + TOKEN_LEASE_DATABASE = 273, // "lease-database" + TOKEN_HOSTS_DATABASE = 274, // "hosts-database" + TOKEN_HOSTS_DATABASES = 275, // "hosts-databases" + TOKEN_TYPE = 276, // "type" + TOKEN_MEMFILE = 277, // "memfile" + TOKEN_MYSQL = 278, // "mysql" + TOKEN_POSTGRESQL = 279, // "postgresql" + TOKEN_CQL = 280, // "cql" + TOKEN_USER = 281, // "user" + TOKEN_PASSWORD = 282, // "password" + TOKEN_HOST = 283, // "host" + TOKEN_PORT = 284, // "port" + TOKEN_PERSIST = 285, // "persist" + TOKEN_LFC_INTERVAL = 286, // "lfc-interval" + TOKEN_READONLY = 287, // "readonly" + TOKEN_CONNECT_TIMEOUT = 288, // "connect-timeout" + TOKEN_CONTACT_POINTS = 289, // "contact-points" + TOKEN_MAX_RECONNECT_TRIES = 290, // "max-reconnect-tries" + TOKEN_RECONNECT_WAIT_TIME = 291, // "reconnect-wait-time" + TOKEN_ON_FAIL = 292, // "on-fail" + TOKEN_STOP_RETRY_EXIT = 293, // "stop-retry-exit" + TOKEN_SERVE_RETRY_EXIT = 294, // "serve-retry-exit" + TOKEN_SERVE_RETRY_CONTINUE = 295, // "serve-retry-continue" + TOKEN_KEYSPACE = 296, // "keyspace" + TOKEN_CONSISTENCY = 297, // "consistency" + TOKEN_SERIAL_CONSISTENCY = 298, // "serial-consistency" + TOKEN_REQUEST_TIMEOUT = 299, // "request-timeout" + TOKEN_TCP_KEEPALIVE = 300, // "tcp-keepalive" + TOKEN_TCP_NODELAY = 301, // "tcp-nodelay" + TOKEN_MAX_ROW_ERRORS = 302, // "max-row-errors" + TOKEN_PREFERRED_LIFETIME = 303, // "preferred-lifetime" + TOKEN_MIN_PREFERRED_LIFETIME = 304, // "min-preferred-lifetime" + TOKEN_MAX_PREFERRED_LIFETIME = 305, // "max-preferred-lifetime" + TOKEN_VALID_LIFETIME = 306, // "valid-lifetime" + TOKEN_MIN_VALID_LIFETIME = 307, // "min-valid-lifetime" + TOKEN_MAX_VALID_LIFETIME = 308, // "max-valid-lifetime" + TOKEN_RENEW_TIMER = 309, // "renew-timer" + TOKEN_REBIND_TIMER = 310, // "rebind-timer" + TOKEN_CALCULATE_TEE_TIMES = 311, // "calculate-tee-times" + TOKEN_T1_PERCENT = 312, // "t1-percent" + TOKEN_T2_PERCENT = 313, // "t2-percent" + TOKEN_CACHE_THRESHOLD = 314, // "cache-threshold" + TOKEN_CACHE_MAX_AGE = 315, // "cache-max-age" + TOKEN_DECLINE_PROBATION_PERIOD = 316, // "decline-probation-period" + TOKEN_SERVER_TAG = 317, // "server-tag" + TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT = 318, // "statistic-default-sample-count" + TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE = 319, // "statistic-default-sample-age" + TOKEN_DDNS_SEND_UPDATES = 320, // "ddns-send-updates" + TOKEN_DDNS_OVERRIDE_NO_UPDATE = 321, // "ddns-override-no-update" + TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE = 322, // "ddns-override-client-update" + TOKEN_DDNS_REPLACE_CLIENT_NAME = 323, // "ddns-replace-client-name" + TOKEN_DDNS_GENERATED_PREFIX = 324, // "ddns-generated-prefix" + TOKEN_DDNS_QUALIFYING_SUFFIX = 325, // "ddns-qualifying-suffix" + TOKEN_DDNS_UPDATE_ON_RENEW = 326, // "ddns-update-on-renew" + TOKEN_DDNS_USE_CONFLICT_RESOLUTION = 327, // "ddns-use-conflict-resolution" + TOKEN_STORE_EXTENDED_INFO = 328, // "store-extended-info" + TOKEN_SUBNET6 = 329, // "subnet6" + TOKEN_OPTION_DEF = 330, // "option-def" + TOKEN_OPTION_DATA = 331, // "option-data" + TOKEN_NAME = 332, // "name" + TOKEN_DATA = 333, // "data" + TOKEN_CODE = 334, // "code" + TOKEN_SPACE = 335, // "space" + TOKEN_CSV_FORMAT = 336, // "csv-format" + TOKEN_ALWAYS_SEND = 337, // "always-send" + TOKEN_RECORD_TYPES = 338, // "record-types" + TOKEN_ENCAPSULATE = 339, // "encapsulate" + TOKEN_ARRAY = 340, // "array" + TOKEN_SHARED_NETWORKS = 341, // "shared-networks" + TOKEN_POOLS = 342, // "pools" + TOKEN_POOL = 343, // "pool" + TOKEN_PD_POOLS = 344, // "pd-pools" + TOKEN_PREFIX = 345, // "prefix" + TOKEN_PREFIX_LEN = 346, // "prefix-len" + TOKEN_EXCLUDED_PREFIX = 347, // "excluded-prefix" + TOKEN_EXCLUDED_PREFIX_LEN = 348, // "excluded-prefix-len" + TOKEN_DELEGATED_LEN = 349, // "delegated-len" + TOKEN_USER_CONTEXT = 350, // "user-context" + TOKEN_COMMENT = 351, // "comment" + TOKEN_SUBNET = 352, // "subnet" + TOKEN_INTERFACE = 353, // "interface" + TOKEN_INTERFACE_ID = 354, // "interface-id" + TOKEN_ID = 355, // "id" + TOKEN_RAPID_COMMIT = 356, // "rapid-commit" + TOKEN_RESERVATION_MODE = 357, // "reservation-mode" + TOKEN_DISABLED = 358, // "disabled" + TOKEN_OUT_OF_POOL = 359, // "out-of-pool" + TOKEN_GLOBAL = 360, // "global" + TOKEN_ALL = 361, // "all" + TOKEN_RESERVATIONS_GLOBAL = 362, // "reservations-global" + TOKEN_RESERVATIONS_IN_SUBNET = 363, // "reservations-in-subnet" + TOKEN_RESERVATIONS_OUT_OF_POOL = 364, // "reservations-out-of-pool" + TOKEN_MAC_SOURCES = 365, // "mac-sources" + TOKEN_RELAY_SUPPLIED_OPTIONS = 366, // "relay-supplied-options" + TOKEN_HOST_RESERVATION_IDENTIFIERS = 367, // "host-reservation-identifiers" + TOKEN_SANITY_CHECKS = 368, // "sanity-checks" + TOKEN_LEASE_CHECKS = 369, // "lease-checks" + TOKEN_CLIENT_CLASSES = 370, // "client-classes" + TOKEN_REQUIRE_CLIENT_CLASSES = 371, // "require-client-classes" + TOKEN_TEST = 372, // "test" + TOKEN_ONLY_IF_REQUIRED = 373, // "only-if-required" + TOKEN_CLIENT_CLASS = 374, // "client-class" + TOKEN_RESERVATIONS = 375, // "reservations" + TOKEN_IP_ADDRESSES = 376, // "ip-addresses" + TOKEN_PREFIXES = 377, // "prefixes" + TOKEN_DUID = 378, // "duid" + TOKEN_HW_ADDRESS = 379, // "hw-address" + TOKEN_HOSTNAME = 380, // "hostname" + TOKEN_FLEX_ID = 381, // "flex-id" + TOKEN_RELAY = 382, // "relay" + TOKEN_IP_ADDRESS = 383, // "ip-address" + TOKEN_HOOKS_LIBRARIES = 384, // "hooks-libraries" + TOKEN_LIBRARY = 385, // "library" + TOKEN_PARAMETERS = 386, // "parameters" + TOKEN_EXPIRED_LEASES_PROCESSING = 387, // "expired-leases-processing" + TOKEN_RECLAIM_TIMER_WAIT_TIME = 388, // "reclaim-timer-wait-time" + TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 389, // "flush-reclaimed-timer-wait-time" + TOKEN_HOLD_RECLAIMED_TIME = 390, // "hold-reclaimed-time" + TOKEN_MAX_RECLAIM_LEASES = 391, // "max-reclaim-leases" + TOKEN_MAX_RECLAIM_TIME = 392, // "max-reclaim-time" + TOKEN_UNWARNED_RECLAIM_CYCLES = 393, // "unwarned-reclaim-cycles" + TOKEN_SERVER_ID = 394, // "server-id" + TOKEN_LLT = 395, // "LLT" + TOKEN_EN = 396, // "EN" + TOKEN_LL = 397, // "LL" + TOKEN_IDENTIFIER = 398, // "identifier" + TOKEN_HTYPE = 399, // "htype" + TOKEN_TIME = 400, // "time" + TOKEN_ENTERPRISE_ID = 401, // "enterprise-id" + TOKEN_DHCP4O6_PORT = 402, // "dhcp4o6-port" + TOKEN_DHCP_MULTI_THREADING = 403, // "multi-threading" + TOKEN_ENABLE_MULTI_THREADING = 404, // "enable-multi-threading" + TOKEN_THREAD_POOL_SIZE = 405, // "thread-pool-size" + TOKEN_PACKET_QUEUE_SIZE = 406, // "packet-queue-size" + TOKEN_CONTROL_SOCKET = 407, // "control-socket" + TOKEN_SOCKET_TYPE = 408, // "socket-type" + TOKEN_SOCKET_NAME = 409, // "socket-name" + TOKEN_DHCP_QUEUE_CONTROL = 410, // "dhcp-queue-control" + TOKEN_ENABLE_QUEUE = 411, // "enable-queue" + TOKEN_QUEUE_TYPE = 412, // "queue-type" + TOKEN_CAPACITY = 413, // "capacity" + TOKEN_DHCP_DDNS = 414, // "dhcp-ddns" + TOKEN_ENABLE_UPDATES = 415, // "enable-updates" + TOKEN_QUALIFYING_SUFFIX = 416, // "qualifying-suffix" + TOKEN_SERVER_IP = 417, // "server-ip" + TOKEN_SERVER_PORT = 418, // "server-port" + TOKEN_SENDER_IP = 419, // "sender-ip" + TOKEN_SENDER_PORT = 420, // "sender-port" + TOKEN_MAX_QUEUE_SIZE = 421, // "max-queue-size" + TOKEN_NCR_PROTOCOL = 422, // "ncr-protocol" + TOKEN_NCR_FORMAT = 423, // "ncr-format" + TOKEN_OVERRIDE_NO_UPDATE = 424, // "override-no-update" + TOKEN_OVERRIDE_CLIENT_UPDATE = 425, // "override-client-update" + TOKEN_REPLACE_CLIENT_NAME = 426, // "replace-client-name" + TOKEN_GENERATED_PREFIX = 427, // "generated-prefix" + TOKEN_UDP = 428, // "UDP" + TOKEN_TCP = 429, // "TCP" + TOKEN_JSON = 430, // "JSON" + TOKEN_WHEN_PRESENT = 431, // "when-present" + TOKEN_NEVER = 432, // "never" + TOKEN_ALWAYS = 433, // "always" + TOKEN_WHEN_NOT_PRESENT = 434, // "when-not-present" + TOKEN_HOSTNAME_CHAR_SET = 435, // "hostname-char-set" + TOKEN_HOSTNAME_CHAR_REPLACEMENT = 436, // "hostname-char-replacement" + TOKEN_IP_RESERVATIONS_UNIQUE = 437, // "ip-reservations-unique" + TOKEN_LOGGERS = 438, // "loggers" + TOKEN_OUTPUT_OPTIONS = 439, // "output_options" + TOKEN_OUTPUT = 440, // "output" + TOKEN_DEBUGLEVEL = 441, // "debuglevel" + TOKEN_SEVERITY = 442, // "severity" + TOKEN_FLUSH = 443, // "flush" + TOKEN_MAXSIZE = 444, // "maxsize" + TOKEN_MAXVER = 445, // "maxver" + TOKEN_PATTERN = 446, // "pattern" + TOKEN_TOPLEVEL_JSON = 447, // TOPLEVEL_JSON + TOKEN_TOPLEVEL_DHCP6 = 448, // TOPLEVEL_DHCP6 + TOKEN_SUB_DHCP6 = 449, // SUB_DHCP6 + TOKEN_SUB_INTERFACES6 = 450, // SUB_INTERFACES6 + TOKEN_SUB_SUBNET6 = 451, // SUB_SUBNET6 + TOKEN_SUB_POOL6 = 452, // SUB_POOL6 + TOKEN_SUB_PD_POOL = 453, // SUB_PD_POOL + TOKEN_SUB_RESERVATION = 454, // SUB_RESERVATION + TOKEN_SUB_OPTION_DEFS = 455, // SUB_OPTION_DEFS + TOKEN_SUB_OPTION_DEF = 456, // SUB_OPTION_DEF + TOKEN_SUB_OPTION_DATA = 457, // SUB_OPTION_DATA + TOKEN_SUB_HOOKS_LIBRARY = 458, // SUB_HOOKS_LIBRARY + TOKEN_SUB_DHCP_DDNS = 459, // SUB_DHCP_DDNS + TOKEN_SUB_CONFIG_CONTROL = 460, // SUB_CONFIG_CONTROL + TOKEN_STRING = 461, // "constant string" + TOKEN_INTEGER = 462, // "integer" + TOKEN_FLOAT = 463, // "floating point" + TOKEN_BOOLEAN = 464 // "boolean" }; + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type yytokentype; }; - /// (External) token type, as returned by yylex. - typedef token::yytokentype token_type; + /// Token kind, as returned by yylex. + typedef token::yytokentype token_kind_type; + + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type token_type; - /// Symbol type: an internal symbol number. - typedef int symbol_number_type; + /// Symbol kinds. + struct symbol_kind + { + enum symbol_kind_type + { + YYNTOKENS = 210, ///< Number of tokens. + S_YYEMPTY = -2, + S_YYEOF = 0, // "end of file" + S_YYerror = 1, // error + S_YYUNDEF = 2, // "invalid token" + S_COMMA = 3, // "," + S_COLON = 4, // ":" + S_LSQUARE_BRACKET = 5, // "[" + S_RSQUARE_BRACKET = 6, // "]" + S_LCURLY_BRACKET = 7, // "{" + S_RCURLY_BRACKET = 8, // "}" + S_NULL_TYPE = 9, // "null" + S_DHCP6 = 10, // "Dhcp6" + S_DATA_DIRECTORY = 11, // "data-directory" + S_CONFIG_CONTROL = 12, // "config-control" + S_CONFIG_DATABASES = 13, // "config-databases" + S_CONFIG_FETCH_WAIT_TIME = 14, // "config-fetch-wait-time" + S_INTERFACES_CONFIG = 15, // "interfaces-config" + S_INTERFACES = 16, // "interfaces" + S_RE_DETECT = 17, // "re-detect" + S_LEASE_DATABASE = 18, // "lease-database" + S_HOSTS_DATABASE = 19, // "hosts-database" + S_HOSTS_DATABASES = 20, // "hosts-databases" + S_TYPE = 21, // "type" + S_MEMFILE = 22, // "memfile" + S_MYSQL = 23, // "mysql" + S_POSTGRESQL = 24, // "postgresql" + S_CQL = 25, // "cql" + S_USER = 26, // "user" + S_PASSWORD = 27, // "password" + S_HOST = 28, // "host" + S_PORT = 29, // "port" + S_PERSIST = 30, // "persist" + S_LFC_INTERVAL = 31, // "lfc-interval" + S_READONLY = 32, // "readonly" + S_CONNECT_TIMEOUT = 33, // "connect-timeout" + S_CONTACT_POINTS = 34, // "contact-points" + S_MAX_RECONNECT_TRIES = 35, // "max-reconnect-tries" + S_RECONNECT_WAIT_TIME = 36, // "reconnect-wait-time" + S_ON_FAIL = 37, // "on-fail" + S_STOP_RETRY_EXIT = 38, // "stop-retry-exit" + S_SERVE_RETRY_EXIT = 39, // "serve-retry-exit" + S_SERVE_RETRY_CONTINUE = 40, // "serve-retry-continue" + S_KEYSPACE = 41, // "keyspace" + S_CONSISTENCY = 42, // "consistency" + S_SERIAL_CONSISTENCY = 43, // "serial-consistency" + S_REQUEST_TIMEOUT = 44, // "request-timeout" + S_TCP_KEEPALIVE = 45, // "tcp-keepalive" + S_TCP_NODELAY = 46, // "tcp-nodelay" + S_MAX_ROW_ERRORS = 47, // "max-row-errors" + S_PREFERRED_LIFETIME = 48, // "preferred-lifetime" + S_MIN_PREFERRED_LIFETIME = 49, // "min-preferred-lifetime" + S_MAX_PREFERRED_LIFETIME = 50, // "max-preferred-lifetime" + S_VALID_LIFETIME = 51, // "valid-lifetime" + S_MIN_VALID_LIFETIME = 52, // "min-valid-lifetime" + S_MAX_VALID_LIFETIME = 53, // "max-valid-lifetime" + S_RENEW_TIMER = 54, // "renew-timer" + S_REBIND_TIMER = 55, // "rebind-timer" + S_CALCULATE_TEE_TIMES = 56, // "calculate-tee-times" + S_T1_PERCENT = 57, // "t1-percent" + S_T2_PERCENT = 58, // "t2-percent" + S_CACHE_THRESHOLD = 59, // "cache-threshold" + S_CACHE_MAX_AGE = 60, // "cache-max-age" + S_DECLINE_PROBATION_PERIOD = 61, // "decline-probation-period" + S_SERVER_TAG = 62, // "server-tag" + S_STATISTIC_DEFAULT_SAMPLE_COUNT = 63, // "statistic-default-sample-count" + S_STATISTIC_DEFAULT_SAMPLE_AGE = 64, // "statistic-default-sample-age" + S_DDNS_SEND_UPDATES = 65, // "ddns-send-updates" + S_DDNS_OVERRIDE_NO_UPDATE = 66, // "ddns-override-no-update" + S_DDNS_OVERRIDE_CLIENT_UPDATE = 67, // "ddns-override-client-update" + S_DDNS_REPLACE_CLIENT_NAME = 68, // "ddns-replace-client-name" + S_DDNS_GENERATED_PREFIX = 69, // "ddns-generated-prefix" + S_DDNS_QUALIFYING_SUFFIX = 70, // "ddns-qualifying-suffix" + S_DDNS_UPDATE_ON_RENEW = 71, // "ddns-update-on-renew" + S_DDNS_USE_CONFLICT_RESOLUTION = 72, // "ddns-use-conflict-resolution" + S_STORE_EXTENDED_INFO = 73, // "store-extended-info" + S_SUBNET6 = 74, // "subnet6" + S_OPTION_DEF = 75, // "option-def" + S_OPTION_DATA = 76, // "option-data" + S_NAME = 77, // "name" + S_DATA = 78, // "data" + S_CODE = 79, // "code" + S_SPACE = 80, // "space" + S_CSV_FORMAT = 81, // "csv-format" + S_ALWAYS_SEND = 82, // "always-send" + S_RECORD_TYPES = 83, // "record-types" + S_ENCAPSULATE = 84, // "encapsulate" + S_ARRAY = 85, // "array" + S_SHARED_NETWORKS = 86, // "shared-networks" + S_POOLS = 87, // "pools" + S_POOL = 88, // "pool" + S_PD_POOLS = 89, // "pd-pools" + S_PREFIX = 90, // "prefix" + S_PREFIX_LEN = 91, // "prefix-len" + S_EXCLUDED_PREFIX = 92, // "excluded-prefix" + S_EXCLUDED_PREFIX_LEN = 93, // "excluded-prefix-len" + S_DELEGATED_LEN = 94, // "delegated-len" + S_USER_CONTEXT = 95, // "user-context" + S_COMMENT = 96, // "comment" + S_SUBNET = 97, // "subnet" + S_INTERFACE = 98, // "interface" + S_INTERFACE_ID = 99, // "interface-id" + S_ID = 100, // "id" + S_RAPID_COMMIT = 101, // "rapid-commit" + S_RESERVATION_MODE = 102, // "reservation-mode" + S_DISABLED = 103, // "disabled" + S_OUT_OF_POOL = 104, // "out-of-pool" + S_GLOBAL = 105, // "global" + S_ALL = 106, // "all" + S_RESERVATIONS_GLOBAL = 107, // "reservations-global" + S_RESERVATIONS_IN_SUBNET = 108, // "reservations-in-subnet" + S_RESERVATIONS_OUT_OF_POOL = 109, // "reservations-out-of-pool" + S_MAC_SOURCES = 110, // "mac-sources" + S_RELAY_SUPPLIED_OPTIONS = 111, // "relay-supplied-options" + S_HOST_RESERVATION_IDENTIFIERS = 112, // "host-reservation-identifiers" + S_SANITY_CHECKS = 113, // "sanity-checks" + S_LEASE_CHECKS = 114, // "lease-checks" + S_CLIENT_CLASSES = 115, // "client-classes" + S_REQUIRE_CLIENT_CLASSES = 116, // "require-client-classes" + S_TEST = 117, // "test" + S_ONLY_IF_REQUIRED = 118, // "only-if-required" + S_CLIENT_CLASS = 119, // "client-class" + S_RESERVATIONS = 120, // "reservations" + S_IP_ADDRESSES = 121, // "ip-addresses" + S_PREFIXES = 122, // "prefixes" + S_DUID = 123, // "duid" + S_HW_ADDRESS = 124, // "hw-address" + S_HOSTNAME = 125, // "hostname" + S_FLEX_ID = 126, // "flex-id" + S_RELAY = 127, // "relay" + S_IP_ADDRESS = 128, // "ip-address" + S_HOOKS_LIBRARIES = 129, // "hooks-libraries" + S_LIBRARY = 130, // "library" + S_PARAMETERS = 131, // "parameters" + S_EXPIRED_LEASES_PROCESSING = 132, // "expired-leases-processing" + S_RECLAIM_TIMER_WAIT_TIME = 133, // "reclaim-timer-wait-time" + S_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 134, // "flush-reclaimed-timer-wait-time" + S_HOLD_RECLAIMED_TIME = 135, // "hold-reclaimed-time" + S_MAX_RECLAIM_LEASES = 136, // "max-reclaim-leases" + S_MAX_RECLAIM_TIME = 137, // "max-reclaim-time" + S_UNWARNED_RECLAIM_CYCLES = 138, // "unwarned-reclaim-cycles" + S_SERVER_ID = 139, // "server-id" + S_LLT = 140, // "LLT" + S_EN = 141, // "EN" + S_LL = 142, // "LL" + S_IDENTIFIER = 143, // "identifier" + S_HTYPE = 144, // "htype" + S_TIME = 145, // "time" + S_ENTERPRISE_ID = 146, // "enterprise-id" + S_DHCP4O6_PORT = 147, // "dhcp4o6-port" + S_DHCP_MULTI_THREADING = 148, // "multi-threading" + S_ENABLE_MULTI_THREADING = 149, // "enable-multi-threading" + S_THREAD_POOL_SIZE = 150, // "thread-pool-size" + S_PACKET_QUEUE_SIZE = 151, // "packet-queue-size" + S_CONTROL_SOCKET = 152, // "control-socket" + S_SOCKET_TYPE = 153, // "socket-type" + S_SOCKET_NAME = 154, // "socket-name" + S_DHCP_QUEUE_CONTROL = 155, // "dhcp-queue-control" + S_ENABLE_QUEUE = 156, // "enable-queue" + S_QUEUE_TYPE = 157, // "queue-type" + S_CAPACITY = 158, // "capacity" + S_DHCP_DDNS = 159, // "dhcp-ddns" + S_ENABLE_UPDATES = 160, // "enable-updates" + S_QUALIFYING_SUFFIX = 161, // "qualifying-suffix" + S_SERVER_IP = 162, // "server-ip" + S_SERVER_PORT = 163, // "server-port" + S_SENDER_IP = 164, // "sender-ip" + S_SENDER_PORT = 165, // "sender-port" + S_MAX_QUEUE_SIZE = 166, // "max-queue-size" + S_NCR_PROTOCOL = 167, // "ncr-protocol" + S_NCR_FORMAT = 168, // "ncr-format" + S_OVERRIDE_NO_UPDATE = 169, // "override-no-update" + S_OVERRIDE_CLIENT_UPDATE = 170, // "override-client-update" + S_REPLACE_CLIENT_NAME = 171, // "replace-client-name" + S_GENERATED_PREFIX = 172, // "generated-prefix" + S_UDP = 173, // "UDP" + S_TCP = 174, // "TCP" + S_JSON = 175, // "JSON" + S_WHEN_PRESENT = 176, // "when-present" + S_NEVER = 177, // "never" + S_ALWAYS = 178, // "always" + S_WHEN_NOT_PRESENT = 179, // "when-not-present" + S_HOSTNAME_CHAR_SET = 180, // "hostname-char-set" + S_HOSTNAME_CHAR_REPLACEMENT = 181, // "hostname-char-replacement" + S_IP_RESERVATIONS_UNIQUE = 182, // "ip-reservations-unique" + S_LOGGERS = 183, // "loggers" + S_OUTPUT_OPTIONS = 184, // "output_options" + S_OUTPUT = 185, // "output" + S_DEBUGLEVEL = 186, // "debuglevel" + S_SEVERITY = 187, // "severity" + S_FLUSH = 188, // "flush" + S_MAXSIZE = 189, // "maxsize" + S_MAXVER = 190, // "maxver" + S_PATTERN = 191, // "pattern" + S_TOPLEVEL_JSON = 192, // TOPLEVEL_JSON + S_TOPLEVEL_DHCP6 = 193, // TOPLEVEL_DHCP6 + S_SUB_DHCP6 = 194, // SUB_DHCP6 + S_SUB_INTERFACES6 = 195, // SUB_INTERFACES6 + S_SUB_SUBNET6 = 196, // SUB_SUBNET6 + S_SUB_POOL6 = 197, // SUB_POOL6 + S_SUB_PD_POOL = 198, // SUB_PD_POOL + S_SUB_RESERVATION = 199, // SUB_RESERVATION + S_SUB_OPTION_DEFS = 200, // SUB_OPTION_DEFS + S_SUB_OPTION_DEF = 201, // SUB_OPTION_DEF + S_SUB_OPTION_DATA = 202, // SUB_OPTION_DATA + S_SUB_HOOKS_LIBRARY = 203, // SUB_HOOKS_LIBRARY + S_SUB_DHCP_DDNS = 204, // SUB_DHCP_DDNS + S_SUB_CONFIG_CONTROL = 205, // SUB_CONFIG_CONTROL + S_STRING = 206, // "constant string" + S_INTEGER = 207, // "integer" + S_FLOAT = 208, // "floating point" + S_BOOLEAN = 209, // "boolean" + S_YYACCEPT = 210, // $accept + S_start = 211, // start + S_212_1 = 212, // $@1 + S_213_2 = 213, // $@2 + S_214_3 = 214, // $@3 + S_215_4 = 215, // $@4 + S_216_5 = 216, // $@5 + S_217_6 = 217, // $@6 + S_218_7 = 218, // $@7 + S_219_8 = 219, // $@8 + S_220_9 = 220, // $@9 + S_221_10 = 221, // $@10 + S_222_11 = 222, // $@11 + S_223_12 = 223, // $@12 + S_224_13 = 224, // $@13 + S_225_14 = 225, // $@14 + S_value = 226, // value + S_sub_json = 227, // sub_json + S_map2 = 228, // map2 + S_229_15 = 229, // $@15 + S_map_value = 230, // map_value + S_map_content = 231, // map_content + S_not_empty_map = 232, // not_empty_map + S_list_generic = 233, // list_generic + S_234_16 = 234, // $@16 + S_list_content = 235, // list_content + S_not_empty_list = 236, // not_empty_list + S_list_strings = 237, // list_strings + S_238_17 = 238, // $@17 + S_list_strings_content = 239, // list_strings_content + S_not_empty_list_strings = 240, // not_empty_list_strings + S_unknown_map_entry = 241, // unknown_map_entry + S_syntax_map = 242, // syntax_map + S_243_18 = 243, // $@18 + S_global_object = 244, // global_object + S_245_19 = 245, // $@19 + S_sub_dhcp6 = 246, // sub_dhcp6 + S_247_20 = 247, // $@20 + S_global_params = 248, // global_params + S_global_param = 249, // global_param + S_data_directory = 250, // data_directory + S_251_21 = 251, // $@21 + S_preferred_lifetime = 252, // preferred_lifetime + S_min_preferred_lifetime = 253, // min_preferred_lifetime + S_max_preferred_lifetime = 254, // max_preferred_lifetime + S_valid_lifetime = 255, // valid_lifetime + S_min_valid_lifetime = 256, // min_valid_lifetime + S_max_valid_lifetime = 257, // max_valid_lifetime + S_renew_timer = 258, // renew_timer + S_rebind_timer = 259, // rebind_timer + S_calculate_tee_times = 260, // calculate_tee_times + S_t1_percent = 261, // t1_percent + S_t2_percent = 262, // t2_percent + S_cache_threshold = 263, // cache_threshold + S_cache_max_age = 264, // cache_max_age + S_decline_probation_period = 265, // decline_probation_period + S_ddns_send_updates = 266, // ddns_send_updates + S_ddns_override_no_update = 267, // ddns_override_no_update + S_ddns_override_client_update = 268, // ddns_override_client_update + S_ddns_replace_client_name = 269, // ddns_replace_client_name + S_270_22 = 270, // $@22 + S_ddns_replace_client_name_value = 271, // ddns_replace_client_name_value + S_ddns_generated_prefix = 272, // ddns_generated_prefix + S_273_23 = 273, // $@23 + S_ddns_qualifying_suffix = 274, // ddns_qualifying_suffix + S_275_24 = 275, // $@24 + S_ddns_update_on_renew = 276, // ddns_update_on_renew + S_ddns_use_conflict_resolution = 277, // ddns_use_conflict_resolution + S_hostname_char_set = 278, // hostname_char_set + S_279_25 = 279, // $@25 + S_hostname_char_replacement = 280, // hostname_char_replacement + S_281_26 = 281, // $@26 + S_store_extended_info = 282, // store_extended_info + S_statistic_default_sample_count = 283, // statistic_default_sample_count + S_statistic_default_sample_age = 284, // statistic_default_sample_age + S_server_tag = 285, // server_tag + S_286_27 = 286, // $@27 + S_ip_reservations_unique = 287, // ip_reservations_unique + S_interfaces_config = 288, // interfaces_config + S_289_28 = 289, // $@28 + S_sub_interfaces6 = 290, // sub_interfaces6 + S_291_29 = 291, // $@29 + S_interfaces_config_params = 292, // interfaces_config_params + S_interfaces_config_param = 293, // interfaces_config_param + S_interfaces_list = 294, // interfaces_list + S_295_30 = 295, // $@30 + S_re_detect = 296, // re_detect + S_lease_database = 297, // lease_database + S_298_31 = 298, // $@31 + S_hosts_database = 299, // hosts_database + S_300_32 = 300, // $@32 + S_hosts_databases = 301, // hosts_databases + S_302_33 = 302, // $@33 + S_database_list = 303, // database_list + S_not_empty_database_list = 304, // not_empty_database_list + S_database = 305, // database + S_306_34 = 306, // $@34 + S_database_map_params = 307, // database_map_params + S_database_map_param = 308, // database_map_param + S_database_type = 309, // database_type + S_310_35 = 310, // $@35 + S_db_type = 311, // db_type + S_user = 312, // user + S_313_36 = 313, // $@36 + S_password = 314, // password + S_315_37 = 315, // $@37 + S_host = 316, // host + S_317_38 = 317, // $@38 + S_port = 318, // port + S_name = 319, // name + S_320_39 = 320, // $@39 + S_persist = 321, // persist + S_lfc_interval = 322, // lfc_interval + S_readonly = 323, // readonly + S_connect_timeout = 324, // connect_timeout + S_reconnect_wait_time = 325, // reconnect_wait_time + S_on_fail = 326, // on_fail + S_327_40 = 327, // $@40 + S_on_fail_mode = 328, // on_fail_mode + S_max_row_errors = 329, // max_row_errors + S_request_timeout = 330, // request_timeout + S_tcp_keepalive = 331, // tcp_keepalive + S_tcp_nodelay = 332, // tcp_nodelay + S_contact_points = 333, // contact_points + S_334_41 = 334, // $@41 + S_max_reconnect_tries = 335, // max_reconnect_tries + S_keyspace = 336, // keyspace + S_337_42 = 337, // $@42 + S_consistency = 338, // consistency + S_339_43 = 339, // $@43 + S_serial_consistency = 340, // serial_consistency + S_341_44 = 341, // $@44 + S_sanity_checks = 342, // sanity_checks + S_343_45 = 343, // $@45 + S_sanity_checks_params = 344, // sanity_checks_params + S_sanity_checks_param = 345, // sanity_checks_param + S_lease_checks = 346, // lease_checks + S_347_46 = 347, // $@46 + S_mac_sources = 348, // mac_sources + S_349_47 = 349, // $@47 + S_mac_sources_list = 350, // mac_sources_list + S_mac_sources_value = 351, // mac_sources_value + S_duid_id = 352, // duid_id + S_string_id = 353, // string_id + S_host_reservation_identifiers = 354, // host_reservation_identifiers + S_355_48 = 355, // $@48 + S_host_reservation_identifiers_list = 356, // host_reservation_identifiers_list + S_host_reservation_identifier = 357, // host_reservation_identifier + S_hw_address_id = 358, // hw_address_id + S_flex_id = 359, // flex_id + S_relay_supplied_options = 360, // relay_supplied_options + S_361_49 = 361, // $@49 + S_dhcp_multi_threading = 362, // dhcp_multi_threading + S_363_50 = 363, // $@50 + S_multi_threading_params = 364, // multi_threading_params + S_multi_threading_param = 365, // multi_threading_param + S_enable_multi_threading = 366, // enable_multi_threading + S_thread_pool_size = 367, // thread_pool_size + S_packet_queue_size = 368, // packet_queue_size + S_hooks_libraries = 369, // hooks_libraries + S_370_51 = 370, // $@51 + S_hooks_libraries_list = 371, // hooks_libraries_list + S_not_empty_hooks_libraries_list = 372, // not_empty_hooks_libraries_list + S_hooks_library = 373, // hooks_library + S_374_52 = 374, // $@52 + S_sub_hooks_library = 375, // sub_hooks_library + S_376_53 = 376, // $@53 + S_hooks_params = 377, // hooks_params + S_hooks_param = 378, // hooks_param + S_library = 379, // library + S_380_54 = 380, // $@54 + S_parameters = 381, // parameters + S_382_55 = 382, // $@55 + S_expired_leases_processing = 383, // expired_leases_processing + S_384_56 = 384, // $@56 + S_expired_leases_params = 385, // expired_leases_params + S_expired_leases_param = 386, // expired_leases_param + S_reclaim_timer_wait_time = 387, // reclaim_timer_wait_time + S_flush_reclaimed_timer_wait_time = 388, // flush_reclaimed_timer_wait_time + S_hold_reclaimed_time = 389, // hold_reclaimed_time + S_max_reclaim_leases = 390, // max_reclaim_leases + S_max_reclaim_time = 391, // max_reclaim_time + S_unwarned_reclaim_cycles = 392, // unwarned_reclaim_cycles + S_subnet6_list = 393, // subnet6_list + S_394_57 = 394, // $@57 + S_subnet6_list_content = 395, // subnet6_list_content + S_not_empty_subnet6_list = 396, // not_empty_subnet6_list + S_subnet6 = 397, // subnet6 + S_398_58 = 398, // $@58 + S_sub_subnet6 = 399, // sub_subnet6 + S_400_59 = 400, // $@59 + S_subnet6_params = 401, // subnet6_params + S_subnet6_param = 402, // subnet6_param + S_subnet = 403, // subnet + S_404_60 = 404, // $@60 + S_interface = 405, // interface + S_406_61 = 406, // $@61 + S_interface_id = 407, // interface_id + S_408_62 = 408, // $@62 + S_client_class = 409, // client_class + S_410_63 = 410, // $@63 + S_require_client_classes = 411, // require_client_classes + S_412_64 = 412, // $@64 + S_reservations_global = 413, // reservations_global + S_reservations_in_subnet = 414, // reservations_in_subnet + S_reservations_out_of_pool = 415, // reservations_out_of_pool + S_reservation_mode = 416, // reservation_mode + S_417_65 = 417, // $@65 + S_hr_mode = 418, // hr_mode + S_id = 419, // id + S_rapid_commit = 420, // rapid_commit + S_shared_networks = 421, // shared_networks + S_422_66 = 422, // $@66 + S_shared_networks_content = 423, // shared_networks_content + S_shared_networks_list = 424, // shared_networks_list + S_shared_network = 425, // shared_network + S_426_67 = 426, // $@67 + S_shared_network_params = 427, // shared_network_params + S_shared_network_param = 428, // shared_network_param + S_option_def_list = 429, // option_def_list + S_430_68 = 430, // $@68 + S_sub_option_def_list = 431, // sub_option_def_list + S_432_69 = 432, // $@69 + S_option_def_list_content = 433, // option_def_list_content + S_not_empty_option_def_list = 434, // not_empty_option_def_list + S_option_def_entry = 435, // option_def_entry + S_436_70 = 436, // $@70 + S_sub_option_def = 437, // sub_option_def + S_438_71 = 438, // $@71 + S_option_def_params = 439, // option_def_params + S_not_empty_option_def_params = 440, // not_empty_option_def_params + S_option_def_param = 441, // option_def_param + S_option_def_name = 442, // option_def_name + S_code = 443, // code + S_option_def_code = 444, // option_def_code + S_option_def_type = 445, // option_def_type + S_446_72 = 446, // $@72 + S_option_def_record_types = 447, // option_def_record_types + S_448_73 = 448, // $@73 + S_space = 449, // space + S_450_74 = 450, // $@74 + S_option_def_space = 451, // option_def_space + S_option_def_encapsulate = 452, // option_def_encapsulate + S_453_75 = 453, // $@75 + S_option_def_array = 454, // option_def_array + S_option_data_list = 455, // option_data_list + S_456_76 = 456, // $@76 + S_option_data_list_content = 457, // option_data_list_content + S_not_empty_option_data_list = 458, // not_empty_option_data_list + S_option_data_entry = 459, // option_data_entry + S_460_77 = 460, // $@77 + S_sub_option_data = 461, // sub_option_data + S_462_78 = 462, // $@78 + S_option_data_params = 463, // option_data_params + S_not_empty_option_data_params = 464, // not_empty_option_data_params + S_option_data_param = 465, // option_data_param + S_option_data_name = 466, // option_data_name + S_option_data_data = 467, // option_data_data + S_468_79 = 468, // $@79 + S_option_data_code = 469, // option_data_code + S_option_data_space = 470, // option_data_space + S_option_data_csv_format = 471, // option_data_csv_format + S_option_data_always_send = 472, // option_data_always_send + S_pools_list = 473, // pools_list + S_474_80 = 474, // $@80 + S_pools_list_content = 475, // pools_list_content + S_not_empty_pools_list = 476, // not_empty_pools_list + S_pool_list_entry = 477, // pool_list_entry + S_478_81 = 478, // $@81 + S_sub_pool6 = 479, // sub_pool6 + S_480_82 = 480, // $@82 + S_pool_params = 481, // pool_params + S_pool_param = 482, // pool_param + S_pool_entry = 483, // pool_entry + S_484_83 = 484, // $@83 + S_user_context = 485, // user_context + S_486_84 = 486, // $@84 + S_comment = 487, // comment + S_488_85 = 488, // $@85 + S_pd_pools_list = 489, // pd_pools_list + S_490_86 = 490, // $@86 + S_pd_pools_list_content = 491, // pd_pools_list_content + S_not_empty_pd_pools_list = 492, // not_empty_pd_pools_list + S_pd_pool_entry = 493, // pd_pool_entry + S_494_87 = 494, // $@87 + S_sub_pd_pool = 495, // sub_pd_pool + S_496_88 = 496, // $@88 + S_pd_pool_params = 497, // pd_pool_params + S_pd_pool_param = 498, // pd_pool_param + S_pd_prefix = 499, // pd_prefix + S_500_89 = 500, // $@89 + S_pd_prefix_len = 501, // pd_prefix_len + S_excluded_prefix = 502, // excluded_prefix + S_503_90 = 503, // $@90 + S_excluded_prefix_len = 504, // excluded_prefix_len + S_pd_delegated_len = 505, // pd_delegated_len + S_reservations = 506, // reservations + S_507_91 = 507, // $@91 + S_reservations_list = 508, // reservations_list + S_not_empty_reservations_list = 509, // not_empty_reservations_list + S_reservation = 510, // reservation + S_511_92 = 511, // $@92 + S_sub_reservation = 512, // sub_reservation + S_513_93 = 513, // $@93 + S_reservation_params = 514, // reservation_params + S_not_empty_reservation_params = 515, // not_empty_reservation_params + S_reservation_param = 516, // reservation_param + S_ip_addresses = 517, // ip_addresses + S_518_94 = 518, // $@94 + S_prefixes = 519, // prefixes + S_520_95 = 520, // $@95 + S_duid = 521, // duid + S_522_96 = 522, // $@96 + S_hw_address = 523, // hw_address + S_524_97 = 524, // $@97 + S_hostname = 525, // hostname + S_526_98 = 526, // $@98 + S_flex_id_value = 527, // flex_id_value + S_528_99 = 528, // $@99 + S_reservation_client_classes = 529, // reservation_client_classes + S_530_100 = 530, // $@100 + S_relay = 531, // relay + S_532_101 = 532, // $@101 + S_relay_map = 533, // relay_map + S_ip_address = 534, // ip_address + S_535_102 = 535, // $@102 + S_client_classes = 536, // client_classes + S_537_103 = 537, // $@103 + S_client_classes_list = 538, // client_classes_list + S_client_class_entry = 539, // client_class_entry + S_540_104 = 540, // $@104 + S_client_class_params = 541, // client_class_params + S_not_empty_client_class_params = 542, // not_empty_client_class_params + S_client_class_param = 543, // client_class_param + S_client_class_name = 544, // client_class_name + S_client_class_test = 545, // client_class_test + S_546_105 = 546, // $@105 + S_only_if_required = 547, // only_if_required + S_server_id = 548, // server_id + S_549_106 = 549, // $@106 + S_server_id_params = 550, // server_id_params + S_server_id_param = 551, // server_id_param + S_server_id_type = 552, // server_id_type + S_553_107 = 553, // $@107 + S_duid_type = 554, // duid_type + S_htype = 555, // htype + S_identifier = 556, // identifier + S_557_108 = 557, // $@108 + S_time = 558, // time + S_enterprise_id = 559, // enterprise_id + S_dhcp4o6_port = 560, // dhcp4o6_port + S_control_socket = 561, // control_socket + S_562_109 = 562, // $@109 + S_control_socket_params = 563, // control_socket_params + S_control_socket_param = 564, // control_socket_param + S_socket_type = 565, // socket_type + S_566_110 = 566, // $@110 + S_socket_name = 567, // socket_name + S_568_111 = 568, // $@111 + S_dhcp_queue_control = 569, // dhcp_queue_control + S_570_112 = 570, // $@112 + S_queue_control_params = 571, // queue_control_params + S_queue_control_param = 572, // queue_control_param + S_enable_queue = 573, // enable_queue + S_queue_type = 574, // queue_type + S_575_113 = 575, // $@113 + S_capacity = 576, // capacity + S_arbitrary_map_entry = 577, // arbitrary_map_entry + S_578_114 = 578, // $@114 + S_dhcp_ddns = 579, // dhcp_ddns + S_580_115 = 580, // $@115 + S_sub_dhcp_ddns = 581, // sub_dhcp_ddns + S_582_116 = 582, // $@116 + S_dhcp_ddns_params = 583, // dhcp_ddns_params + S_dhcp_ddns_param = 584, // dhcp_ddns_param + S_enable_updates = 585, // enable_updates + S_dep_qualifying_suffix = 586, // dep_qualifying_suffix + S_587_117 = 587, // $@117 + S_server_ip = 588, // server_ip + S_589_118 = 589, // $@118 + S_server_port = 590, // server_port + S_sender_ip = 591, // sender_ip + S_592_119 = 592, // $@119 + S_sender_port = 593, // sender_port + S_max_queue_size = 594, // max_queue_size + S_ncr_protocol = 595, // ncr_protocol + S_596_120 = 596, // $@120 + S_ncr_protocol_value = 597, // ncr_protocol_value + S_ncr_format = 598, // ncr_format + S_599_121 = 599, // $@121 + S_dep_override_no_update = 600, // dep_override_no_update + S_dep_override_client_update = 601, // dep_override_client_update + S_dep_replace_client_name = 602, // dep_replace_client_name + S_603_122 = 603, // $@122 + S_dep_generated_prefix = 604, // dep_generated_prefix + S_605_123 = 605, // $@123 + S_dep_hostname_char_set = 606, // dep_hostname_char_set + S_607_124 = 607, // $@124 + S_dep_hostname_char_replacement = 608, // dep_hostname_char_replacement + S_609_125 = 609, // $@125 + S_config_control = 610, // config_control + S_611_126 = 611, // $@126 + S_sub_config_control = 612, // sub_config_control + S_613_127 = 613, // $@127 + S_config_control_params = 614, // config_control_params + S_config_control_param = 615, // config_control_param + S_config_databases = 616, // config_databases + S_617_128 = 617, // $@128 + S_config_fetch_wait_time = 618, // config_fetch_wait_time + S_loggers = 619, // loggers + S_620_129 = 620, // $@129 + S_loggers_entries = 621, // loggers_entries + S_logger_entry = 622, // logger_entry + S_623_130 = 623, // $@130 + S_logger_params = 624, // logger_params + S_logger_param = 625, // logger_param + S_debuglevel = 626, // debuglevel + S_severity = 627, // severity + S_628_131 = 628, // $@131 + S_output_options_list = 629, // output_options_list + S_630_132 = 630, // $@132 + S_output_options_list_content = 631, // output_options_list_content + S_output_entry = 632, // output_entry + S_633_133 = 633, // $@133 + S_output_params_list = 634, // output_params_list + S_output_params = 635, // output_params + S_output = 636, // output + S_637_134 = 637, // $@134 + S_flush = 638, // flush + S_maxsize = 639, // maxsize + S_maxver = 640, // maxver + S_pattern = 641, // pattern + S_642_135 = 642 // $@135 + }; + }; - /// The symbol type number to denote an empty symbol. - enum { empty_symbol = -2 }; + /// (Internal) symbol kind. + typedef symbol_kind::symbol_kind_type symbol_kind_type; - /// Internal symbol number for tokens (subsumed by symbol_number_type). - typedef unsigned char token_number_type; + /// The number of tokens. + static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; /// A complete symbol. /// - /// Expects its Base type to provide access to the symbol type - /// via type_get (). + /// Expects its Base type to provide access to the symbol kind + /// via kind (). /// /// Provide access to semantic value and location. template @@ -714,13 +1383,51 @@ namespace isc { namespace dhcp { #if 201103L <= YY_CPLUSPLUS /// Move constructor. - basic_symbol (basic_symbol&& that); + basic_symbol (basic_symbol&& that) + : Base (std::move (that)) + , value () + , location (std::move (that.location)) + { + switch (this->kind ()) + { + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value + value.move< ElementPtr > (std::move (that.value)); + break; + + case symbol_kind::S_BOOLEAN: // "boolean" + value.move< bool > (std::move (that.value)); + break; + + case symbol_kind::S_FLOAT: // "floating point" + value.move< double > (std::move (that.value)); + break; + + case symbol_kind::S_INTEGER: // "integer" + value.move< int64_t > (std::move (that.value)); + break; + + case symbol_kind::S_STRING: // "constant string" + value.move< std::string > (std::move (that.value)); + break; + + default: + break; + } + + } #endif /// Copy constructor. basic_symbol (const basic_symbol& that); - /// Constructor for valueless symbols, and symbols from each type. + /// Constructors for typed symbols. #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, location_type&& l) : Base (t) @@ -732,6 +1439,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, ElementPtr&& v, location_type&& l) : Base (t) @@ -745,6 +1453,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, bool&& v, location_type&& l) : Base (t) @@ -758,6 +1467,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, double&& v, location_type&& l) : Base (t) @@ -771,6 +1481,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, int64_t&& v, location_type&& l) : Base (t) @@ -784,6 +1495,7 @@ namespace isc { namespace dhcp { , location (l) {} #endif + #if 201103L <= YY_CPLUSPLUS basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l) : Base (t) @@ -805,45 +1517,45 @@ namespace isc { namespace dhcp { } /// Destroy contents, and record that is empty. - void clear () + void clear () YY_NOEXCEPT { // User destructor. - symbol_number_type yytype = this->type_get (); + symbol_kind_type yykind = this->kind (); basic_symbol& yysym = *this; (void) yysym; - switch (yytype) + switch (yykind) { default: break; } - // Type destructor. -switch (yytype) + // Value type destructor. +switch (yykind) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.template destroy< ElementPtr > (); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.template destroy< bool > (); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.template destroy< double > (); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.template destroy< int64_t > (); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.template destroy< std::string > (); break; @@ -854,6 +1566,15 @@ switch (yytype) Base::clear (); } + /// The user-facing name of this symbol. + std::string name () const YY_NOEXCEPT + { + return Dhcp6Parser::symbol_name (this->kind ()); + } + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + /// Whether empty. bool empty () const YY_NOEXCEPT; @@ -874,46 +1595,51 @@ switch (yytype) }; /// Type access provider for token (enum) based symbols. - struct by_type + struct by_kind { /// Default constructor. - by_type (); + by_kind (); #if 201103L <= YY_CPLUSPLUS /// Move constructor. - by_type (by_type&& that); + by_kind (by_kind&& that); #endif /// Copy constructor. - by_type (const by_type& that); + by_kind (const by_kind& that); - /// The symbol type as needed by the constructor. - typedef token_type kind_type; + /// The symbol kind as needed by the constructor. + typedef token_kind_type kind_type; /// Constructor from (external) token numbers. - by_type (kind_type t); + by_kind (kind_type t); /// Record that this symbol is empty. - void clear (); + void clear () YY_NOEXCEPT; - /// Steal the symbol type from \a that. - void move (by_type& that); + /// Steal the symbol kind from \a that. + void move (by_kind& that); /// The (internal) type number (corresponding to \a type). /// \a empty when empty. - symbol_number_type type_get () const YY_NOEXCEPT; + symbol_kind_type kind () const YY_NOEXCEPT; - /// The symbol type. - /// \a empty_symbol when empty. - /// An int, not token_number_type, to be able to store empty_symbol. - int type; + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + + /// The symbol kind. + /// \a S_YYEMPTY when empty. + symbol_kind_type kind_; }; + /// Backward compatibility for a private implementation detail (Bison 3.6). + typedef by_kind by_type; + /// "External" symbols: returned by the scanner. - struct symbol_type : basic_symbol + struct symbol_type : basic_symbol { /// Superclass. - typedef basic_symbol super_type; + typedef basic_symbol super_type; /// Empty symbol. symbol_type () {} @@ -922,74 +1648,67 @@ switch (yytype) #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, location_type l) : super_type(token_type (tok), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_END || tok == token::TOKEN_COMMA || tok == token::TOKEN_COLON || tok == token::TOKEN_LSQUARE_BRACKET || tok == token::TOKEN_RSQUARE_BRACKET || tok == token::TOKEN_LCURLY_BRACKET || tok == token::TOKEN_RCURLY_BRACKET || tok == token::TOKEN_NULL_TYPE || tok == token::TOKEN_DHCP6 || tok == token::TOKEN_DATA_DIRECTORY || tok == token::TOKEN_CONFIG_CONTROL || tok == token::TOKEN_CONFIG_DATABASES || tok == token::TOKEN_CONFIG_FETCH_WAIT_TIME || tok == token::TOKEN_INTERFACES_CONFIG || tok == token::TOKEN_INTERFACES || tok == token::TOKEN_RE_DETECT || tok == token::TOKEN_LEASE_DATABASE || tok == token::TOKEN_HOSTS_DATABASE || tok == token::TOKEN_HOSTS_DATABASES || tok == token::TOKEN_TYPE || tok == token::TOKEN_MEMFILE || tok == token::TOKEN_MYSQL || tok == token::TOKEN_POSTGRESQL || tok == token::TOKEN_CQL || tok == token::TOKEN_USER || tok == token::TOKEN_PASSWORD || tok == token::TOKEN_HOST || tok == token::TOKEN_PORT || tok == token::TOKEN_PERSIST || tok == token::TOKEN_LFC_INTERVAL || tok == token::TOKEN_READONLY || tok == token::TOKEN_CONNECT_TIMEOUT || tok == token::TOKEN_CONTACT_POINTS || tok == token::TOKEN_MAX_RECONNECT_TRIES || tok == token::TOKEN_RECONNECT_WAIT_TIME || tok == token::TOKEN_ON_FAIL || tok == token::TOKEN_STOP_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_CONTINUE || tok == token::TOKEN_KEYSPACE || tok == token::TOKEN_CONSISTENCY || tok == token::TOKEN_SERIAL_CONSISTENCY || tok == token::TOKEN_REQUEST_TIMEOUT || tok == token::TOKEN_TCP_KEEPALIVE || tok == token::TOKEN_TCP_NODELAY || tok == token::TOKEN_MAX_ROW_ERRORS || tok == token::TOKEN_PREFERRED_LIFETIME || tok == token::TOKEN_MIN_PREFERRED_LIFETIME || tok == token::TOKEN_MAX_PREFERRED_LIFETIME || tok == token::TOKEN_VALID_LIFETIME || tok == token::TOKEN_MIN_VALID_LIFETIME || tok == token::TOKEN_MAX_VALID_LIFETIME || tok == token::TOKEN_RENEW_TIMER || tok == token::TOKEN_REBIND_TIMER || tok == token::TOKEN_CALCULATE_TEE_TIMES || tok == token::TOKEN_T1_PERCENT || tok == token::TOKEN_T2_PERCENT || tok == token::TOKEN_CACHE_THRESHOLD || tok == token::TOKEN_CACHE_MAX_AGE || tok == token::TOKEN_DECLINE_PROBATION_PERIOD || tok == token::TOKEN_SERVER_TAG || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE || tok == token::TOKEN_DDNS_SEND_UPDATES || tok == token::TOKEN_DDNS_OVERRIDE_NO_UPDATE || tok == token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_DDNS_REPLACE_CLIENT_NAME || tok == token::TOKEN_DDNS_GENERATED_PREFIX || tok == token::TOKEN_DDNS_QUALIFYING_SUFFIX || tok == token::TOKEN_DDNS_UPDATE_ON_RENEW || tok == token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION || tok == token::TOKEN_STORE_EXTENDED_INFO || tok == token::TOKEN_SUBNET6 || tok == token::TOKEN_OPTION_DEF || tok == token::TOKEN_OPTION_DATA || tok == token::TOKEN_NAME || tok == token::TOKEN_DATA || tok == token::TOKEN_CODE || tok == token::TOKEN_SPACE || tok == token::TOKEN_CSV_FORMAT || tok == token::TOKEN_ALWAYS_SEND || tok == token::TOKEN_RECORD_TYPES || tok == token::TOKEN_ENCAPSULATE || tok == token::TOKEN_ARRAY || tok == token::TOKEN_SHARED_NETWORKS || tok == token::TOKEN_POOLS || tok == token::TOKEN_POOL || tok == token::TOKEN_PD_POOLS || tok == token::TOKEN_PREFIX || tok == token::TOKEN_PREFIX_LEN || tok == token::TOKEN_EXCLUDED_PREFIX || tok == token::TOKEN_EXCLUDED_PREFIX_LEN || tok == token::TOKEN_DELEGATED_LEN || tok == token::TOKEN_USER_CONTEXT || tok == token::TOKEN_COMMENT || tok == token::TOKEN_SUBNET || tok == token::TOKEN_INTERFACE || tok == token::TOKEN_INTERFACE_ID || tok == token::TOKEN_ID || tok == token::TOKEN_RAPID_COMMIT || tok == token::TOKEN_RESERVATION_MODE || tok == token::TOKEN_DISABLED || tok == token::TOKEN_OUT_OF_POOL || tok == token::TOKEN_GLOBAL || tok == token::TOKEN_ALL || tok == token::TOKEN_RESERVATIONS_GLOBAL || tok == token::TOKEN_RESERVATIONS_IN_SUBNET || tok == token::TOKEN_RESERVATIONS_OUT_OF_POOL || tok == token::TOKEN_MAC_SOURCES || tok == token::TOKEN_RELAY_SUPPLIED_OPTIONS || tok == token::TOKEN_HOST_RESERVATION_IDENTIFIERS || tok == token::TOKEN_SANITY_CHECKS || tok == token::TOKEN_LEASE_CHECKS || tok == token::TOKEN_CLIENT_CLASSES || tok == token::TOKEN_REQUIRE_CLIENT_CLASSES || tok == token::TOKEN_TEST || tok == token::TOKEN_ONLY_IF_REQUIRED || tok == token::TOKEN_CLIENT_CLASS || tok == token::TOKEN_RESERVATIONS || tok == token::TOKEN_IP_ADDRESSES || tok == token::TOKEN_PREFIXES || tok == token::TOKEN_DUID || tok == token::TOKEN_HW_ADDRESS || tok == token::TOKEN_HOSTNAME || tok == token::TOKEN_FLEX_ID || tok == token::TOKEN_RELAY || tok == token::TOKEN_IP_ADDRESS || tok == token::TOKEN_HOOKS_LIBRARIES || tok == token::TOKEN_LIBRARY || tok == token::TOKEN_PARAMETERS || tok == token::TOKEN_EXPIRED_LEASES_PROCESSING || tok == token::TOKEN_RECLAIM_TIMER_WAIT_TIME || tok == token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME || tok == token::TOKEN_HOLD_RECLAIMED_TIME || tok == token::TOKEN_MAX_RECLAIM_LEASES || tok == token::TOKEN_MAX_RECLAIM_TIME || tok == token::TOKEN_UNWARNED_RECLAIM_CYCLES || tok == token::TOKEN_SERVER_ID || tok == token::TOKEN_LLT || tok == token::TOKEN_EN || tok == token::TOKEN_LL || tok == token::TOKEN_IDENTIFIER || tok == token::TOKEN_HTYPE || tok == token::TOKEN_TIME || tok == token::TOKEN_ENTERPRISE_ID || tok == token::TOKEN_DHCP4O6_PORT || tok == token::TOKEN_DHCP_MULTI_THREADING || tok == token::TOKEN_ENABLE_MULTI_THREADING || tok == token::TOKEN_THREAD_POOL_SIZE || tok == token::TOKEN_PACKET_QUEUE_SIZE || tok == token::TOKEN_CONTROL_SOCKET || tok == token::TOKEN_SOCKET_TYPE || tok == token::TOKEN_SOCKET_NAME || tok == token::TOKEN_DHCP_QUEUE_CONTROL || tok == token::TOKEN_ENABLE_QUEUE || tok == token::TOKEN_QUEUE_TYPE || tok == token::TOKEN_CAPACITY || tok == token::TOKEN_DHCP_DDNS || tok == token::TOKEN_ENABLE_UPDATES || tok == token::TOKEN_QUALIFYING_SUFFIX || tok == token::TOKEN_SERVER_IP || tok == token::TOKEN_SERVER_PORT || tok == token::TOKEN_SENDER_IP || tok == token::TOKEN_SENDER_PORT || tok == token::TOKEN_MAX_QUEUE_SIZE || tok == token::TOKEN_NCR_PROTOCOL || tok == token::TOKEN_NCR_FORMAT || tok == token::TOKEN_OVERRIDE_NO_UPDATE || tok == token::TOKEN_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_REPLACE_CLIENT_NAME || tok == token::TOKEN_GENERATED_PREFIX || tok == token::TOKEN_UDP || tok == token::TOKEN_TCP || tok == token::TOKEN_JSON || tok == token::TOKEN_WHEN_PRESENT || tok == token::TOKEN_NEVER || tok == token::TOKEN_ALWAYS || tok == token::TOKEN_WHEN_NOT_PRESENT || tok == token::TOKEN_HOSTNAME_CHAR_SET || tok == token::TOKEN_HOSTNAME_CHAR_REPLACEMENT || tok == token::TOKEN_IP_RESERVATIONS_UNIQUE || tok == token::TOKEN_LOGGERS || tok == token::TOKEN_OUTPUT_OPTIONS || tok == token::TOKEN_OUTPUT || tok == token::TOKEN_DEBUGLEVEL || tok == token::TOKEN_SEVERITY || tok == token::TOKEN_FLUSH || tok == token::TOKEN_MAXSIZE || tok == token::TOKEN_MAXVER || tok == token::TOKEN_PATTERN || tok == token::TOKEN_TOPLEVEL_JSON || tok == token::TOKEN_TOPLEVEL_DHCP6 || tok == token::TOKEN_SUB_DHCP6 || tok == token::TOKEN_SUB_INTERFACES6 || tok == token::TOKEN_SUB_SUBNET6 || tok == token::TOKEN_SUB_POOL6 || tok == token::TOKEN_SUB_PD_POOL || tok == token::TOKEN_SUB_RESERVATION || tok == token::TOKEN_SUB_OPTION_DEFS || tok == token::TOKEN_SUB_OPTION_DEF || tok == token::TOKEN_SUB_OPTION_DATA || tok == token::TOKEN_SUB_HOOKS_LIBRARY || tok == token::TOKEN_SUB_DHCP_DDNS || tok == token::TOKEN_SUB_CONFIG_CONTROL); - } #else symbol_type (int tok, const location_type& l) : super_type(token_type (tok), l) +#endif { - YY_ASSERT (tok == token::TOKEN_END || tok == token::TOKEN_COMMA || tok == token::TOKEN_COLON || tok == token::TOKEN_LSQUARE_BRACKET || tok == token::TOKEN_RSQUARE_BRACKET || tok == token::TOKEN_LCURLY_BRACKET || tok == token::TOKEN_RCURLY_BRACKET || tok == token::TOKEN_NULL_TYPE || tok == token::TOKEN_DHCP6 || tok == token::TOKEN_DATA_DIRECTORY || tok == token::TOKEN_CONFIG_CONTROL || tok == token::TOKEN_CONFIG_DATABASES || tok == token::TOKEN_CONFIG_FETCH_WAIT_TIME || tok == token::TOKEN_INTERFACES_CONFIG || tok == token::TOKEN_INTERFACES || tok == token::TOKEN_RE_DETECT || tok == token::TOKEN_LEASE_DATABASE || tok == token::TOKEN_HOSTS_DATABASE || tok == token::TOKEN_HOSTS_DATABASES || tok == token::TOKEN_TYPE || tok == token::TOKEN_MEMFILE || tok == token::TOKEN_MYSQL || tok == token::TOKEN_POSTGRESQL || tok == token::TOKEN_CQL || tok == token::TOKEN_USER || tok == token::TOKEN_PASSWORD || tok == token::TOKEN_HOST || tok == token::TOKEN_PORT || tok == token::TOKEN_PERSIST || tok == token::TOKEN_LFC_INTERVAL || tok == token::TOKEN_READONLY || tok == token::TOKEN_CONNECT_TIMEOUT || tok == token::TOKEN_CONTACT_POINTS || tok == token::TOKEN_MAX_RECONNECT_TRIES || tok == token::TOKEN_RECONNECT_WAIT_TIME || tok == token::TOKEN_ON_FAIL || tok == token::TOKEN_STOP_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_EXIT || tok == token::TOKEN_SERVE_RETRY_CONTINUE || tok == token::TOKEN_KEYSPACE || tok == token::TOKEN_CONSISTENCY || tok == token::TOKEN_SERIAL_CONSISTENCY || tok == token::TOKEN_REQUEST_TIMEOUT || tok == token::TOKEN_TCP_KEEPALIVE || tok == token::TOKEN_TCP_NODELAY || tok == token::TOKEN_MAX_ROW_ERRORS || tok == token::TOKEN_PREFERRED_LIFETIME || tok == token::TOKEN_MIN_PREFERRED_LIFETIME || tok == token::TOKEN_MAX_PREFERRED_LIFETIME || tok == token::TOKEN_VALID_LIFETIME || tok == token::TOKEN_MIN_VALID_LIFETIME || tok == token::TOKEN_MAX_VALID_LIFETIME || tok == token::TOKEN_RENEW_TIMER || tok == token::TOKEN_REBIND_TIMER || tok == token::TOKEN_CALCULATE_TEE_TIMES || tok == token::TOKEN_T1_PERCENT || tok == token::TOKEN_T2_PERCENT || tok == token::TOKEN_CACHE_THRESHOLD || tok == token::TOKEN_CACHE_MAX_AGE || tok == token::TOKEN_DECLINE_PROBATION_PERIOD || tok == token::TOKEN_SERVER_TAG || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT || tok == token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE || tok == token::TOKEN_DDNS_SEND_UPDATES || tok == token::TOKEN_DDNS_OVERRIDE_NO_UPDATE || tok == token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_DDNS_REPLACE_CLIENT_NAME || tok == token::TOKEN_DDNS_GENERATED_PREFIX || tok == token::TOKEN_DDNS_QUALIFYING_SUFFIX || tok == token::TOKEN_DDNS_UPDATE_ON_RENEW || tok == token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION || tok == token::TOKEN_STORE_EXTENDED_INFO || tok == token::TOKEN_SUBNET6 || tok == token::TOKEN_OPTION_DEF || tok == token::TOKEN_OPTION_DATA || tok == token::TOKEN_NAME || tok == token::TOKEN_DATA || tok == token::TOKEN_CODE || tok == token::TOKEN_SPACE || tok == token::TOKEN_CSV_FORMAT || tok == token::TOKEN_ALWAYS_SEND || tok == token::TOKEN_RECORD_TYPES || tok == token::TOKEN_ENCAPSULATE || tok == token::TOKEN_ARRAY || tok == token::TOKEN_SHARED_NETWORKS || tok == token::TOKEN_POOLS || tok == token::TOKEN_POOL || tok == token::TOKEN_PD_POOLS || tok == token::TOKEN_PREFIX || tok == token::TOKEN_PREFIX_LEN || tok == token::TOKEN_EXCLUDED_PREFIX || tok == token::TOKEN_EXCLUDED_PREFIX_LEN || tok == token::TOKEN_DELEGATED_LEN || tok == token::TOKEN_USER_CONTEXT || tok == token::TOKEN_COMMENT || tok == token::TOKEN_SUBNET || tok == token::TOKEN_INTERFACE || tok == token::TOKEN_INTERFACE_ID || tok == token::TOKEN_ID || tok == token::TOKEN_RAPID_COMMIT || tok == token::TOKEN_RESERVATION_MODE || tok == token::TOKEN_DISABLED || tok == token::TOKEN_OUT_OF_POOL || tok == token::TOKEN_GLOBAL || tok == token::TOKEN_ALL || tok == token::TOKEN_RESERVATIONS_GLOBAL || tok == token::TOKEN_RESERVATIONS_IN_SUBNET || tok == token::TOKEN_RESERVATIONS_OUT_OF_POOL || tok == token::TOKEN_MAC_SOURCES || tok == token::TOKEN_RELAY_SUPPLIED_OPTIONS || tok == token::TOKEN_HOST_RESERVATION_IDENTIFIERS || tok == token::TOKEN_SANITY_CHECKS || tok == token::TOKEN_LEASE_CHECKS || tok == token::TOKEN_CLIENT_CLASSES || tok == token::TOKEN_REQUIRE_CLIENT_CLASSES || tok == token::TOKEN_TEST || tok == token::TOKEN_ONLY_IF_REQUIRED || tok == token::TOKEN_CLIENT_CLASS || tok == token::TOKEN_RESERVATIONS || tok == token::TOKEN_IP_ADDRESSES || tok == token::TOKEN_PREFIXES || tok == token::TOKEN_DUID || tok == token::TOKEN_HW_ADDRESS || tok == token::TOKEN_HOSTNAME || tok == token::TOKEN_FLEX_ID || tok == token::TOKEN_RELAY || tok == token::TOKEN_IP_ADDRESS || tok == token::TOKEN_HOOKS_LIBRARIES || tok == token::TOKEN_LIBRARY || tok == token::TOKEN_PARAMETERS || tok == token::TOKEN_EXPIRED_LEASES_PROCESSING || tok == token::TOKEN_RECLAIM_TIMER_WAIT_TIME || tok == token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME || tok == token::TOKEN_HOLD_RECLAIMED_TIME || tok == token::TOKEN_MAX_RECLAIM_LEASES || tok == token::TOKEN_MAX_RECLAIM_TIME || tok == token::TOKEN_UNWARNED_RECLAIM_CYCLES || tok == token::TOKEN_SERVER_ID || tok == token::TOKEN_LLT || tok == token::TOKEN_EN || tok == token::TOKEN_LL || tok == token::TOKEN_IDENTIFIER || tok == token::TOKEN_HTYPE || tok == token::TOKEN_TIME || tok == token::TOKEN_ENTERPRISE_ID || tok == token::TOKEN_DHCP4O6_PORT || tok == token::TOKEN_DHCP_MULTI_THREADING || tok == token::TOKEN_ENABLE_MULTI_THREADING || tok == token::TOKEN_THREAD_POOL_SIZE || tok == token::TOKEN_PACKET_QUEUE_SIZE || tok == token::TOKEN_CONTROL_SOCKET || tok == token::TOKEN_SOCKET_TYPE || tok == token::TOKEN_SOCKET_NAME || tok == token::TOKEN_DHCP_QUEUE_CONTROL || tok == token::TOKEN_ENABLE_QUEUE || tok == token::TOKEN_QUEUE_TYPE || tok == token::TOKEN_CAPACITY || tok == token::TOKEN_DHCP_DDNS || tok == token::TOKEN_ENABLE_UPDATES || tok == token::TOKEN_QUALIFYING_SUFFIX || tok == token::TOKEN_SERVER_IP || tok == token::TOKEN_SERVER_PORT || tok == token::TOKEN_SENDER_IP || tok == token::TOKEN_SENDER_PORT || tok == token::TOKEN_MAX_QUEUE_SIZE || tok == token::TOKEN_NCR_PROTOCOL || tok == token::TOKEN_NCR_FORMAT || tok == token::TOKEN_OVERRIDE_NO_UPDATE || tok == token::TOKEN_OVERRIDE_CLIENT_UPDATE || tok == token::TOKEN_REPLACE_CLIENT_NAME || tok == token::TOKEN_GENERATED_PREFIX || tok == token::TOKEN_UDP || tok == token::TOKEN_TCP || tok == token::TOKEN_JSON || tok == token::TOKEN_WHEN_PRESENT || tok == token::TOKEN_NEVER || tok == token::TOKEN_ALWAYS || tok == token::TOKEN_WHEN_NOT_PRESENT || tok == token::TOKEN_HOSTNAME_CHAR_SET || tok == token::TOKEN_HOSTNAME_CHAR_REPLACEMENT || tok == token::TOKEN_IP_RESERVATIONS_UNIQUE || tok == token::TOKEN_LOGGERS || tok == token::TOKEN_OUTPUT_OPTIONS || tok == token::TOKEN_OUTPUT || tok == token::TOKEN_DEBUGLEVEL || tok == token::TOKEN_SEVERITY || tok == token::TOKEN_FLUSH || tok == token::TOKEN_MAXSIZE || tok == token::TOKEN_MAXVER || tok == token::TOKEN_PATTERN || tok == token::TOKEN_TOPLEVEL_JSON || tok == token::TOKEN_TOPLEVEL_DHCP6 || tok == token::TOKEN_SUB_DHCP6 || tok == token::TOKEN_SUB_INTERFACES6 || tok == token::TOKEN_SUB_SUBNET6 || tok == token::TOKEN_SUB_POOL6 || tok == token::TOKEN_SUB_PD_POOL || tok == token::TOKEN_SUB_RESERVATION || tok == token::TOKEN_SUB_OPTION_DEFS || tok == token::TOKEN_SUB_OPTION_DEF || tok == token::TOKEN_SUB_OPTION_DATA || tok == token::TOKEN_SUB_HOOKS_LIBRARY || tok == token::TOKEN_SUB_DHCP_DDNS || tok == token::TOKEN_SUB_CONFIG_CONTROL); + PARSER6__ASSERT (tok == token::TOKEN_END + || (token::TOKEN_PARSER6_error <= tok && tok <= token::TOKEN_SUB_CONFIG_CONTROL)); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, bool v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_BOOLEAN); - } #else symbol_type (int tok, const bool& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_BOOLEAN); + PARSER6__ASSERT (tok == token::TOKEN_BOOLEAN); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, double v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_FLOAT); - } #else symbol_type (int tok, const double& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_FLOAT); + PARSER6__ASSERT (tok == token::TOKEN_FLOAT); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, int64_t v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_INTEGER); - } #else symbol_type (int tok, const int64_t& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_INTEGER); + PARSER6__ASSERT (tok == token::TOKEN_INTEGER); } -#endif #if 201103L <= YY_CPLUSPLUS symbol_type (int tok, std::string v, location_type l) : super_type(token_type (tok), std::move (v), std::move (l)) - { - YY_ASSERT (tok == token::TOKEN_STRING); - } #else symbol_type (int tok, const std::string& v, const location_type& l) : super_type(token_type (tok), v, l) +#endif { - YY_ASSERT (tok == token::TOKEN_STRING); + PARSER6__ASSERT (tok == token::TOKEN_STRING); } -#endif }; /// Build a parser object. Dhcp6Parser (isc::dhcp::Parser6Context& ctx_yyarg); virtual ~Dhcp6Parser (); +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + Dhcp6Parser (const Dhcp6Parser&) = delete; + /// Non copyable. + Dhcp6Parser& operator= (const Dhcp6Parser&) = delete; +#endif + /// Parse. An alias for parse (). /// \returns 0 iff parsing succeeded. int operator() (); @@ -1020,6 +1739,10 @@ switch (yytype) /// Report a syntax error. void error (const syntax_error& err); + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static std::string symbol_name (symbol_kind_type yysymbol); + // Implementation of make_symbol for each symbol type. #if 201103L <= YY_CPLUSPLUS static @@ -1036,6 +1759,36 @@ switch (yytype) return symbol_type (token::TOKEN_END, l); } #endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_PARSER6_error (location_type l) + { + return symbol_type (token::TOKEN_PARSER6_error, std::move (l)); + } +#else + static + symbol_type + make_PARSER6_error (const location_type& l) + { + return symbol_type (token::TOKEN_PARSER6_error, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_PARSER6_UNDEF (location_type l) + { + return symbol_type (token::TOKEN_PARSER6_UNDEF, std::move (l)); + } +#else + static + symbol_type + make_PARSER6_UNDEF (const location_type& l) + { + return symbol_type (token::TOKEN_PARSER6_UNDEF, l); + } +#endif #if 201103L <= YY_CPLUSPLUS static symbol_type @@ -4143,20 +4896,43 @@ switch (yytype) #endif + class context + { + public: + context (const Dhcp6Parser& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); } + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } + + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const Dhcp6Parser& yyparser_; + const symbol_type& yyla_; + }; + private: - /// This class is not copyable. +#if YY_CPLUSPLUS < 201103L + /// Non copyable. Dhcp6Parser (const Dhcp6Parser&); + /// Non copyable. Dhcp6Parser& operator= (const Dhcp6Parser&); +#endif + /// Stored state numbers (used for stacks). typedef short state_type; - /// Generate an error message. - /// \param yystate the state where the error occurred. - /// \param yyla the lookahead token. - virtual std::string yysyntax_error_ (state_type yystate, - const symbol_type& yyla) const; + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const; /// Compute post-reduction state. /// \param yystate the current state /// \param yysym the nonterminal to push on the stack @@ -4173,10 +4949,17 @@ switch (yytype) static const short yypact_ninf_; static const signed char yytable_ninf_; - /// Convert a scanner token number \a t to a symbol number. - /// In theory \a t should be a token_type, but character literals + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals /// are valid, yet not members of the token_type enum. - static token_number_type yytranslate_ (int t); + static symbol_kind_type yytranslate_ (int t); + + /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + + /// For a symbol, its name in clear. + static const char* const yytname_[]; + // Tables. // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing @@ -4212,26 +4995,20 @@ switch (yytype) static const signed char yyr2_[]; - /// Convert the symbol name \a n to a form suitable for a diagnostic. - static std::string yytnamerr_ (const char *n); - - - /// For a symbol, its name in clear. - static const char* const yytname_[]; #if PARSER6_DEBUG // YYRLINE[YYN] -- Source line where rule number YYN was defined. static const short yyrline_[]; /// Report on the debug stream that the rule \a r is going to be reduced. - virtual void yy_reduce_print_ (int r); + virtual void yy_reduce_print_ (int r) const; /// Print the state stack on the debug stream. - virtual void yystack_print_ (); + virtual void yy_stack_print_ () const; /// Debugging level. int yydebug_; /// Debug stream. std::ostream* yycdebug_; - /// \brief Display a symbol type, value and location. + /// \brief Display a symbol kind, value and location. /// \param yyo The output stream. /// \param yysym The symbol. template @@ -4252,7 +5029,7 @@ switch (yytype) /// Default constructor. by_state () YY_NOEXCEPT; - /// The symbol type as needed by the constructor. + /// The symbol kind as needed by the constructor. typedef state_type kind_type; /// Constructor. @@ -4264,12 +5041,12 @@ switch (yytype) /// Record that this symbol is empty. void clear () YY_NOEXCEPT; - /// Steal the symbol type from \a that. + /// Steal the symbol kind from \a that. void move (by_state& that); - /// The (internal) type number (corresponding to \a state). - /// \a empty_symbol when empty. - symbol_number_type type_get () const YY_NOEXCEPT; + /// The symbol kind (corresponding to \a state). + /// \a symbol_kind::S_YYEMPTY when empty. + symbol_kind_type kind () const YY_NOEXCEPT; /// The state number used to denote an empty symbol. /// We use the initial state, as it does not have a value. @@ -4308,8 +5085,8 @@ switch (yytype) { public: // Hide our reversed order. - typedef typename S::reverse_iterator iterator; - typedef typename S::const_reverse_iterator const_iterator; + typedef typename S::iterator iterator; + typedef typename S::const_iterator const_iterator; typedef typename S::size_type size_type; typedef typename std::ptrdiff_t index_type; @@ -4317,6 +5094,13 @@ switch (yytype) : seq_ (n) {} +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + stack (const stack&) = delete; + /// Non copyable. + stack& operator= (const stack&) = delete; +#endif + /// Random access. /// /// Index 0 returns the topmost element. @@ -4367,24 +5151,18 @@ switch (yytype) return index_type (seq_.size ()); } - std::ptrdiff_t - ssize () const YY_NOEXCEPT - { - return std::ptrdiff_t (size ()); - } - /// Iterator on top of the stack (going downwards). const_iterator begin () const YY_NOEXCEPT { - return seq_.rbegin (); + return seq_.begin (); } /// Bottom of the stack. const_iterator end () const YY_NOEXCEPT { - return seq_.rend (); + return seq_.end (); } /// Present a slice of the top of a stack. @@ -4408,8 +5186,12 @@ switch (yytype) }; private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. stack (const stack&); + /// Non copyable. stack& operator= (const stack&); +#endif /// The wrapped container. S seq_; }; @@ -4439,33 +5221,28 @@ switch (yytype) /// Pop \a n symbols from the stack. void yypop_ (int n = 1); - /// Some specific tokens. - static const token_number_type yy_error_token_ = 1; - static const token_number_type yy_undef_token_ = 2; - /// Constants. enum { - yyeof_ = 0, yylast_ = 1273, ///< Last index in yytable_. yynnts_ = 433, ///< Number of nonterminal symbols. - yyfinal_ = 30, ///< Termination state number. - yyntokens_ = 210 ///< Number of tokens. + yyfinal_ = 30 ///< Termination state number. }; // User arguments. isc::dhcp::Parser6Context& ctx; + }; inline - Dhcp6Parser::token_number_type + Dhcp6Parser::symbol_kind_type Dhcp6Parser::yytranslate_ (int t) { // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to // TOKEN-NUM as returned by yylex. static - const token_number_type + const unsigned char translate_table[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -4516,92 +5293,50 @@ switch (yytype) 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209 }; - const int user_token_number_max_ = 464; + // Last valid token kind. + const int code_max = 464; if (t <= 0) - return yyeof_; - else if (t <= user_token_number_max_) - return translate_table[t]; + return symbol_kind::S_YYEOF; + else if (t <= code_max) + return YY_CAST (symbol_kind_type, translate_table[t]); else - return yy_undef_token_; + return symbol_kind::S_YYUNDEF; } // basic_symbol. -#if 201103L <= YY_CPLUSPLUS - template - Dhcp6Parser::basic_symbol::basic_symbol (basic_symbol&& that) - : Base (std::move (that)) - , value () - , location (std::move (that.location)) - { - switch (this->type_get ()) - { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value - value.move< ElementPtr > (std::move (that.value)); - break; - - case 209: // "boolean" - value.move< bool > (std::move (that.value)); - break; - - case 208: // "floating point" - value.move< double > (std::move (that.value)); - break; - - case 207: // "integer" - value.move< int64_t > (std::move (that.value)); - break; - - case 206: // "constant string" - value.move< std::string > (std::move (that.value)); - break; - - default: - break; - } - - } -#endif - template Dhcp6Parser::basic_symbol::basic_symbol (const basic_symbol& that) : Base (that) , value () , location (that.location) { - switch (this->type_get ()) + switch (this->kind ()) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.copy< ElementPtr > (YY_MOVE (that.value)); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.copy< bool > (YY_MOVE (that.value)); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.copy< double > (YY_MOVE (that.value)); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.copy< int64_t > (YY_MOVE (that.value)); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.copy< std::string > (YY_MOVE (that.value)); break; @@ -4613,11 +5348,18 @@ switch (yytype) + template + Dhcp6Parser::symbol_kind_type + Dhcp6Parser::basic_symbol::type_get () const YY_NOEXCEPT + { + return this->kind (); + } + template bool Dhcp6Parser::basic_symbol::empty () const YY_NOEXCEPT { - return Base::type_get () == empty_symbol; + return this->kind () == symbol_kind::S_YYEMPTY; } template @@ -4625,32 +5367,32 @@ switch (yytype) Dhcp6Parser::basic_symbol::move (basic_symbol& s) { super_type::move (s); - switch (this->type_get ()) + switch (this->kind ()) { - case 226: // value - case 230: // map_value - case 271: // ddns_replace_client_name_value - case 311: // db_type - case 328: // on_fail_mode - case 418: // hr_mode - case 554: // duid_type - case 597: // ncr_protocol_value + case symbol_kind::S_value: // value + case symbol_kind::S_map_value: // map_value + case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value + case symbol_kind::S_db_type: // db_type + case symbol_kind::S_on_fail_mode: // on_fail_mode + case symbol_kind::S_hr_mode: // hr_mode + case symbol_kind::S_duid_type: // duid_type + case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value value.move< ElementPtr > (YY_MOVE (s.value)); break; - case 209: // "boolean" + case symbol_kind::S_BOOLEAN: // "boolean" value.move< bool > (YY_MOVE (s.value)); break; - case 208: // "floating point" + case symbol_kind::S_FLOAT: // "floating point" value.move< double > (YY_MOVE (s.value)); break; - case 207: // "integer" + case symbol_kind::S_INTEGER: // "integer" value.move< int64_t > (YY_MOVE (s.value)); break; - case 206: // "constant string" + case symbol_kind::S_STRING: // "constant string" value.move< std::string > (YY_MOVE (s.value)); break; @@ -4661,57 +5403,63 @@ switch (yytype) location = YY_MOVE (s.location); } - // by_type. + // by_kind. inline - Dhcp6Parser::by_type::by_type () - : type (empty_symbol) + Dhcp6Parser::by_kind::by_kind () + : kind_ (symbol_kind::S_YYEMPTY) {} #if 201103L <= YY_CPLUSPLUS inline - Dhcp6Parser::by_type::by_type (by_type&& that) - : type (that.type) + Dhcp6Parser::by_kind::by_kind (by_kind&& that) + : kind_ (that.kind_) { that.clear (); } #endif inline - Dhcp6Parser::by_type::by_type (const by_type& that) - : type (that.type) + Dhcp6Parser::by_kind::by_kind (const by_kind& that) + : kind_ (that.kind_) {} inline - Dhcp6Parser::by_type::by_type (token_type t) - : type (yytranslate_ (t)) + Dhcp6Parser::by_kind::by_kind (token_kind_type t) + : kind_ (yytranslate_ (t)) {} inline void - Dhcp6Parser::by_type::clear () + Dhcp6Parser::by_kind::clear () YY_NOEXCEPT { - type = empty_symbol; + kind_ = symbol_kind::S_YYEMPTY; } inline void - Dhcp6Parser::by_type::move (by_type& that) + Dhcp6Parser::by_kind::move (by_kind& that) { - type = that.type; + kind_ = that.kind_; that.clear (); } inline - int - Dhcp6Parser::by_type::type_get () const YY_NOEXCEPT + Dhcp6Parser::symbol_kind_type + Dhcp6Parser::by_kind::kind () const YY_NOEXCEPT { - return type; + return kind_; + } + + inline + Dhcp6Parser::symbol_kind_type + Dhcp6Parser::by_kind::type_get () const YY_NOEXCEPT + { + return this->kind (); } #line 14 "dhcp6_parser.yy" } } // isc::dhcp -#line 4714 "dhcp6_parser.h" - +#line 5463 "dhcp6_parser.h" diff --git a/src/bin/dhcp6/location.hh b/src/bin/dhcp6/location.hh index bf5ebc3716..1a8f74170c 100644 --- a/src/bin/dhcp6/location.hh +++ b/src/bin/dhcp6/location.hh @@ -1,8 +1,8 @@ -// A Bison parser, made by GNU Bison 3.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Locations for Bison parsers in C++ -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. +// Copyright (C) 2002-2015, 2018-2021 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 @@ -61,11 +61,13 @@ namespace isc { namespace dhcp { class position { public: + /// Type for file name. + typedef const std::string filename_type; /// Type for line and column numbers. typedef int counter_type; /// Construct a position. - explicit position (std::string* f = YY_NULLPTR, + explicit position (filename_type* f = YY_NULLPTR, counter_type l = 1, counter_type c = 1) : filename (f) @@ -75,7 +77,7 @@ namespace isc { namespace dhcp { /// Initialization. - void initialize (std::string* fn = YY_NULLPTR, + void initialize (filename_type* fn = YY_NULLPTR, counter_type l = 1, counter_type c = 1) { @@ -104,7 +106,7 @@ namespace isc { namespace dhcp { /** \} */ /// File name to which this position refers. - std::string* filename; + filename_type* filename; /// Current line number. counter_type line; /// Current column number. @@ -147,24 +149,6 @@ namespace isc { namespace dhcp { 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 @@ -182,6 +166,8 @@ namespace isc { namespace dhcp { class location { public: + /// Type for file name. + typedef position::filename_type filename_type; /// Type for line and column numbers. typedef position::counter_type counter_type; @@ -198,7 +184,7 @@ namespace isc { namespace dhcp { {} /// Construct a 0-width location in \a f, \a l, \a c. - explicit location (std::string* f, + explicit location (filename_type* f, counter_type l = 1, counter_type c = 1) : begin (f, l, c) @@ -207,7 +193,7 @@ namespace isc { namespace dhcp { /// Initialization. - void initialize (std::string* f = YY_NULLPTR, + void initialize (filename_type* f = YY_NULLPTR, counter_type l = 1, counter_type c = 1) { @@ -289,20 +275,6 @@ namespace isc { namespace dhcp { return res -= width; } - /// Compare two location objects. - inline bool - operator== (const location& loc1, const location& loc2) - { - return loc1.begin == loc2.begin && loc1.end == loc2.end; - } - - /// Compare two location objects. - inline bool - operator!= (const location& loc1, const location& loc2) - { - return !(loc1 == loc2); - } - /** \brief Intercept output stream redirection. ** \param ostr the destination output stream ** \param loc a reference to the location to redirect @@ -329,6 +301,6 @@ namespace isc { namespace dhcp { #line 14 "dhcp6_parser.yy" } } // isc::dhcp -#line 333 "location.hh" +#line 305 "location.hh" #endif // !YY_PARSER6_LOCATION_HH_INCLUDED diff --git a/src/bin/dhcp6/position.hh b/src/bin/dhcp6/position.hh index bf34c1c57a..2d3317f224 100644 --- a/src/bin/dhcp6/position.hh +++ b/src/bin/dhcp6/position.hh @@ -1,4 +1,4 @@ -// A Bison parser, made by GNU Bison 3.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Starting with Bison 3.2, this file is useless: the structure it // used to define is now defined in "location.hh". diff --git a/src/bin/dhcp6/stack.hh b/src/bin/dhcp6/stack.hh index c15d84c73d..fe7f93f75b 100644 --- a/src/bin/dhcp6/stack.hh +++ b/src/bin/dhcp6/stack.hh @@ -1,4 +1,4 @@ -// A Bison parser, made by GNU Bison 3.5.1. +// A Bison parser, made by GNU Bison 3.7.5. // Starting with Bison 3.2, this file is useless: the structure it // used to define is now defined with the parser itself.