45#ifndef YY_D2_PARSER_D2_PARSER_H_INCLUDED 
   46# define YY_D2_PARSER_D2_PARSER_H_INCLUDED 
   48#line 17 "d2_parser.yy" 
   54#include <boost/lexical_cast.hpp> 
   70#if defined __cplusplus 
   71# define YY_CPLUSPLUS __cplusplus 
   73# define YY_CPLUSPLUS 199711L 
   77#if 201103L <= YY_CPLUSPLUS 
   78# define YY_MOVE           std::move 
   79# define YY_MOVE_OR_COPY   move 
   80# define YY_MOVE_REF(Type) Type&& 
   81# define YY_RVREF(Type)    Type&& 
   82# define YY_COPY(Type)     Type 
   85# define YY_MOVE_OR_COPY   copy 
   86# define YY_MOVE_REF(Type) Type& 
   87# define YY_RVREF(Type)    const Type& 
   88# define YY_COPY(Type)     const Type& 
   92#if 201103L <= YY_CPLUSPLUS 
   93# define YY_NOEXCEPT noexcept 
   97# define YY_NOTHROW throw () 
  101#if 201703 <= YY_CPLUSPLUS 
  102# define YY_CONSTEXPR constexpr 
  106# include "location.hh" 
  108#ifndef D2_PARSER__ASSERT 
  110# define D2_PARSER__ASSERT assert 
  114#ifndef YY_ATTRIBUTE_PURE 
  115# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 
  116#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 
  118#  define YY_ATTRIBUTE_PURE 
  122#ifndef YY_ATTRIBUTE_UNUSED 
  123# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 
  124#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 
  126#  define YY_ATTRIBUTE_UNUSED 
  131#if ! defined lint || defined __GNUC__ 
  132# define YY_USE(E) ((void) (E)) 
  138#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 
  139# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 
  140#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \ 
  141    _Pragma ("GCC diagnostic push")                                     \ 
  142    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 
  144#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \ 
  145    _Pragma ("GCC diagnostic push")                                     \ 
  146    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \ 
  147    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 
  149# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \ 
  150    _Pragma ("GCC diagnostic pop") 
  152# define YY_INITIAL_VALUE(Value) Value 
  154#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 
  155# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 
  156# define YY_IGNORE_MAYBE_UNINITIALIZED_END 
  158#ifndef YY_INITIAL_VALUE 
  159# define YY_INITIAL_VALUE(Value)  
  162#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 
  163# define YY_IGNORE_USELESS_CAST_BEGIN                          \ 
  164    _Pragma ("GCC diagnostic push")                            \ 
  165    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 
  166# define YY_IGNORE_USELESS_CAST_END            \ 
  167    _Pragma ("GCC diagnostic pop") 
  169#ifndef YY_IGNORE_USELESS_CAST_BEGIN 
  170# define YY_IGNORE_USELESS_CAST_BEGIN 
  171# define YY_IGNORE_USELESS_CAST_END 
  176#   define YY_CAST(Type, Val) static_cast<Type> (Val) 
  177#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 
  179#   define YY_CAST(Type, Val) ((Type) (Val)) 
  180#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 
  184#  if defined __cplusplus 
  185#   if 201103L <= __cplusplus 
  186#    define YY_NULLPTR nullptr 
  191#   define YY_NULLPTR ((void*)0) 
  196#ifndef D2_PARSER_DEBUG 
  199#   define D2_PARSER_DEBUG 1 
  201#   define D2_PARSER_DEBUG 0 
  204#  define D2_PARSER_DEBUG 1 
  208#line 14 "d2_parser.yy" 
  209namespace isc { 
namespace d2 {
 
  210#line 211 "d2_parser.h" 
  219#ifdef D2_PARSER_STYPE 
  221#  pragma GCC message "bison: do not #define D2_PARSER_STYPE in C++, use %define api.value.type" 
  239      , yytypeid_ (YY_NULLPTR)
 
 
  243    template <
typename T>
 
  245      : yytypeid_ (&typeid (T))
 
  248      new (yyas_<T> ()) T (
YY_MOVE (t));
 
 
  251#if 201103L <= YY_CPLUSPLUS 
  264# if 201103L <= YY_CPLUSPLUS 
  266    template <
typename T, 
typename... U>
 
  272      yytypeid_ = & 
typeid (T);
 
  273      return *
new (yyas_<T> ()) T (std::forward <U>(u)...);
 
  277    template <
typename T>
 
  283      yytypeid_ = & 
typeid (T);
 
  284      return *
new (yyas_<T> ()) T ();
 
 
  288    template <
typename T>
 
  294      yytypeid_ = & 
typeid (T);
 
  295      return *
new (yyas_<T> ()) T (t);
 
 
  301    template <
typename T>
 
  310    template <
typename T>
 
  318    template <
typename T>
 
  329    template <
typename T>
 
  347    template <
typename T>
 
  353      std::swap (
as<T> (), that.as<T> ());
 
 
  359    template <
typename T>
 
  363# if 201103L <= YY_CPLUSPLUS 
 
  372# if 201103L <= YY_CPLUSPLUS 
  374    template <
typename T>
 
  384    template <
typename T>
 
  392    template <
typename T>
 
  397      yytypeid_ = YY_NULLPTR;
 
 
  401#if YY_CPLUSPLUS < 201103L 
  409    template <
typename T>
 
  414      return static_cast<T*
> (yyp);
 
  418    template <
typename T>
 
  423      return static_cast<const T*
> (yyp);
 
  437      char dummy2[
sizeof (bool)];
 
  440      char dummy3[
sizeof (double)];
 
  443      char dummy4[
sizeof (int64_t)];
 
  446      char dummy5[
sizeof (std::string)];
 
  450    enum { size = 
sizeof (union_type) };
 
  462    const std::type_info *yytypeid_;
 
 
  476        : std::runtime_error (m)
 
 
  481        : std::runtime_error (s.what ())
 
 
 
  891    template <
typename Base>
 
  903#if 201103L <= YY_CPLUSPLUS 
  906        : Base (std::move (that))
 
  908        , location (std::move (that.location))
 
  910        switch (this->kind ())
 
  917        value.move< 
ElementPtr > (std::move (that.value));
 
  921        value.move< 
bool > (std::move (that.value));
 
  925        value.move< 
double > (std::move (that.value));
 
  929        value.move< int64_t > (std::move (that.value));
 
  933        value.move< std::string > (std::move (that.value));
 
  947#if 201103L <= YY_CPLUSPLUS 
  959#if 201103L <= YY_CPLUSPLUS 
  962        , value (std::move (v))
 
  963        , location (std::move (l))
 
  973#if 201103L <= YY_CPLUSPLUS 
  976        , value (std::move (v))
 
  977        , location (std::move (l))
 
  987#if 201103L <= YY_CPLUSPLUS 
  990        , value (std::move (v))
 
  991        , location (std::move (l))
 
 1001#if 201103L <= YY_CPLUSPLUS 
 1004        , value (std::move (v))
 
 1005        , location (std::move (l))
 
 1015#if 201103L <= YY_CPLUSPLUS 
 1018        , value (std::move (v))
 
 1019        , location (std::move (l))
 
 1058        value.template destroy< ElementPtr > ();
 
 1062        value.template destroy< bool > ();
 
 1066        value.template destroy< double > ();
 
 1070        value.template destroy< int64_t > ();
 
 1074        value.template destroy< std::string > ();
 
 
 1106#if YY_CPLUSPLUS < 201103L 
 
 1121#if 201103L <= YY_CPLUSPLUS 
 
 1165#if 201103L <= YY_CPLUSPLUS 
 1173#if !defined _MSC_VER || defined __clang__ 
 
 1178#if 201103L <= YY_CPLUSPLUS 
 1186#if !defined _MSC_VER || defined __clang__ 
 
 1190#if 201103L <= YY_CPLUSPLUS 
 1198#if !defined _MSC_VER || defined __clang__ 
 
 1202#if 201103L <= YY_CPLUSPLUS 
 1210#if !defined _MSC_VER || defined __clang__ 
 
 1214#if 201103L <= YY_CPLUSPLUS 
 1222#if !defined _MSC_VER || defined __clang__ 
 
 
 1232#if 201103L <= YY_CPLUSPLUS 
 1245    virtual int parse ();
 
 1251    void set_debug_stream (std::ostream &);
 
 1254    typedef 
int debug_level_type;
 
 1258    void set_debug_level (debug_level_type l);
 
 1264    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1267    void error (
const syntax_error& err);
 
 1271    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1274#if 201103L <= YY_CPLUSPLUS 
 1277      make_END (location_type l)
 
 1279        return symbol_type (token::TOKEN_END, std::move (l));
 
 1289#if 201103L <= YY_CPLUSPLUS 
 1292      make_D2_PARSER_error (location_type l)
 
 1294        return symbol_type (token::TOKEN_D2_PARSER_error, std::move (l));
 
 1304#if 201103L <= YY_CPLUSPLUS 
 1307      make_D2_PARSER_UNDEF (location_type l)
 
 1309        return symbol_type (token::TOKEN_D2_PARSER_UNDEF, std::move (l));
 
 1319#if 201103L <= YY_CPLUSPLUS 
 1322      make_COMMA (location_type l)
 
 1324        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1334#if 201103L <= YY_CPLUSPLUS 
 1337      make_COLON (location_type l)
 
 1339        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1349#if 201103L <= YY_CPLUSPLUS 
 1352      make_LSQUARE_BRACKET (location_type l)
 
 1354        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 1364#if 201103L <= YY_CPLUSPLUS 
 1367      make_RSQUARE_BRACKET (location_type l)
 
 1369        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 1379#if 201103L <= YY_CPLUSPLUS 
 1382      make_LCURLY_BRACKET (location_type l)
 
 1384        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 1394#if 201103L <= YY_CPLUSPLUS 
 1397      make_RCURLY_BRACKET (location_type l)
 
 1399        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 1409#if 201103L <= YY_CPLUSPLUS 
 1412      make_NULL_TYPE (location_type l)
 
 1414        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 1424#if 201103L <= YY_CPLUSPLUS 
 1427      make_DHCPDDNS (location_type l)
 
 1429        return symbol_type (token::TOKEN_DHCPDDNS, std::move (l));
 
 1439#if 201103L <= YY_CPLUSPLUS 
 1442      make_IP_ADDRESS (location_type l)
 
 1444        return symbol_type (token::TOKEN_IP_ADDRESS, std::move (l));
 
 1454#if 201103L <= YY_CPLUSPLUS 
 1457      make_PORT (location_type l)
 
 1459        return symbol_type (token::TOKEN_PORT, std::move (l));
 
 1469#if 201103L <= YY_CPLUSPLUS 
 1472      make_DNS_SERVER_TIMEOUT (location_type l)
 
 1474        return symbol_type (token::TOKEN_DNS_SERVER_TIMEOUT, std::move (l));
 
 1484#if 201103L <= YY_CPLUSPLUS 
 1487      make_NCR_PROTOCOL (location_type l)
 
 1489        return symbol_type (token::TOKEN_NCR_PROTOCOL, std::move (l));
 
 1499#if 201103L <= YY_CPLUSPLUS 
 1502      make_UDP (location_type l)
 
 1504        return symbol_type (token::TOKEN_UDP, std::move (l));
 
 1514#if 201103L <= YY_CPLUSPLUS 
 1517      make_TCP (location_type l)
 
 1519        return symbol_type (token::TOKEN_TCP, std::move (l));
 
 1529#if 201103L <= YY_CPLUSPLUS 
 1532      make_NCR_FORMAT (location_type l)
 
 1534        return symbol_type (token::TOKEN_NCR_FORMAT, std::move (l));
 
 1544#if 201103L <= YY_CPLUSPLUS 
 1547      make_JSON (location_type l)
 
 1549        return symbol_type (token::TOKEN_JSON, std::move (l));
 
 1559#if 201103L <= YY_CPLUSPLUS 
 1562      make_USER_CONTEXT (location_type l)
 
 1564        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 1574#if 201103L <= YY_CPLUSPLUS 
 1577      make_COMMENT (location_type l)
 
 1579        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 1589#if 201103L <= YY_CPLUSPLUS 
 1592      make_FORWARD_DDNS (location_type l)
 
 1594        return symbol_type (token::TOKEN_FORWARD_DDNS, std::move (l));
 
 1604#if 201103L <= YY_CPLUSPLUS 
 1607      make_REVERSE_DDNS (location_type l)
 
 1609        return symbol_type (token::TOKEN_REVERSE_DDNS, std::move (l));
 
 1619#if 201103L <= YY_CPLUSPLUS 
 1622      make_DDNS_DOMAINS (location_type l)
 
 1624        return symbol_type (token::TOKEN_DDNS_DOMAINS, std::move (l));
 
 1634#if 201103L <= YY_CPLUSPLUS 
 1637      make_KEY_NAME (location_type l)
 
 1639        return symbol_type (token::TOKEN_KEY_NAME, std::move (l));
 
 1649#if 201103L <= YY_CPLUSPLUS 
 1652      make_DNS_SERVERS (location_type l)
 
 1654        return symbol_type (token::TOKEN_DNS_SERVERS, std::move (l));
 
 1664#if 201103L <= YY_CPLUSPLUS 
 1667      make_HOSTNAME (location_type l)
 
 1669        return symbol_type (token::TOKEN_HOSTNAME, std::move (l));
 
 1679#if 201103L <= YY_CPLUSPLUS 
 1682      make_TSIG_KEYS (location_type l)
 
 1684        return symbol_type (token::TOKEN_TSIG_KEYS, std::move (l));
 
 1694#if 201103L <= YY_CPLUSPLUS 
 1697      make_ALGORITHM (location_type l)
 
 1699        return symbol_type (token::TOKEN_ALGORITHM, std::move (l));
 
 1709#if 201103L <= YY_CPLUSPLUS 
 1712      make_DIGEST_BITS (location_type l)
 
 1714        return symbol_type (token::TOKEN_DIGEST_BITS, std::move (l));
 
 1724#if 201103L <= YY_CPLUSPLUS 
 1727      make_SECRET (location_type l)
 
 1729        return symbol_type (token::TOKEN_SECRET, std::move (l));
 
 1739#if 201103L <= YY_CPLUSPLUS 
 1742      make_SECRET_FILE (location_type l)
 
 1744        return symbol_type (token::TOKEN_SECRET_FILE, std::move (l));
 
 1754#if 201103L <= YY_CPLUSPLUS 
 1757      make_CONTROL_SOCKET (location_type l)
 
 1759        return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
 
 1769#if 201103L <= YY_CPLUSPLUS 
 1772      make_CONTROL_SOCKETS (location_type l)
 
 1774        return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
 
 1784#if 201103L <= YY_CPLUSPLUS 
 1787      make_SOCKET_TYPE (location_type l)
 
 1789        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 1799#if 201103L <= YY_CPLUSPLUS 
 1802      make_UNIX (location_type l)
 
 1804        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 1814#if 201103L <= YY_CPLUSPLUS 
 1817      make_HTTP (location_type l)
 
 1819        return symbol_type (token::TOKEN_HTTP, std::move (l));
 
 1829#if 201103L <= YY_CPLUSPLUS 
 1832      make_HTTPS (location_type l)
 
 1834        return symbol_type (token::TOKEN_HTTPS, std::move (l));
 
 1844#if 201103L <= YY_CPLUSPLUS 
 1847      make_SOCKET_NAME (location_type l)
 
 1849        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 1859#if 201103L <= YY_CPLUSPLUS 
 1862      make_SOCKET_ADDRESS (location_type l)
 
 1864        return symbol_type (token::TOKEN_SOCKET_ADDRESS, std::move (l));
 
 1874#if 201103L <= YY_CPLUSPLUS 
 1877      make_SOCKET_PORT (location_type l)
 
 1879        return symbol_type (token::TOKEN_SOCKET_PORT, std::move (l));
 
 1889#if 201103L <= YY_CPLUSPLUS 
 1892      make_AUTHENTICATION (location_type l)
 
 1894        return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
 
 1904#if 201103L <= YY_CPLUSPLUS 
 1907      make_TYPE (location_type l)
 
 1909        return symbol_type (token::TOKEN_TYPE, std::move (l));
 
 1919#if 201103L <= YY_CPLUSPLUS 
 1922      make_BASIC (location_type l)
 
 1924        return symbol_type (token::TOKEN_BASIC, std::move (l));
 
 1934#if 201103L <= YY_CPLUSPLUS 
 1937      make_REALM (location_type l)
 
 1939        return symbol_type (token::TOKEN_REALM, std::move (l));
 
 1949#if 201103L <= YY_CPLUSPLUS 
 1952      make_DIRECTORY (location_type l)
 
 1954        return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
 
 1964#if 201103L <= YY_CPLUSPLUS 
 1967      make_CLIENTS (location_type l)
 
 1969        return symbol_type (token::TOKEN_CLIENTS, std::move (l));
 
 1979#if 201103L <= YY_CPLUSPLUS 
 1982      make_USER (location_type l)
 
 1984        return symbol_type (token::TOKEN_USER, std::move (l));
 
 1994#if 201103L <= YY_CPLUSPLUS 
 1997      make_USER_FILE (location_type l)
 
 1999        return symbol_type (token::TOKEN_USER_FILE, std::move (l));
 
 2009#if 201103L <= YY_CPLUSPLUS 
 2012      make_PASSWORD (location_type l)
 
 2014        return symbol_type (token::TOKEN_PASSWORD, std::move (l));
 
 2024#if 201103L <= YY_CPLUSPLUS 
 2027      make_PASSWORD_FILE (location_type l)
 
 2029        return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
 
 2039#if 201103L <= YY_CPLUSPLUS 
 2042      make_TRUST_ANCHOR (location_type l)
 
 2044        return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
 
 2054#if 201103L <= YY_CPLUSPLUS 
 2057      make_CERT_FILE (location_type l)
 
 2059        return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
 
 2069#if 201103L <= YY_CPLUSPLUS 
 2072      make_KEY_FILE (location_type l)
 
 2074        return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
 
 2084#if 201103L <= YY_CPLUSPLUS 
 2087      make_CERT_REQUIRED (location_type l)
 
 2089        return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
 
 2099#if 201103L <= YY_CPLUSPLUS 
 2102      make_HOOKS_LIBRARIES (location_type l)
 
 2104        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 2114#if 201103L <= YY_CPLUSPLUS 
 2117      make_LIBRARY (location_type l)
 
 2119        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 2129#if 201103L <= YY_CPLUSPLUS 
 2132      make_PARAMETERS (location_type l)
 
 2134        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 2144#if 201103L <= YY_CPLUSPLUS 
 2147      make_LOGGERS (location_type l)
 
 2149        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 2159#if 201103L <= YY_CPLUSPLUS 
 2162      make_NAME (location_type l)
 
 2164        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 2174#if 201103L <= YY_CPLUSPLUS 
 2177      make_OUTPUT_OPTIONS (location_type l)
 
 2179        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 2189#if 201103L <= YY_CPLUSPLUS 
 2192      make_OUTPUT (location_type l)
 
 2194        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 2204#if 201103L <= YY_CPLUSPLUS 
 2207      make_DEBUGLEVEL (location_type l)
 
 2209        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 2219#if 201103L <= YY_CPLUSPLUS 
 2222      make_SEVERITY (location_type l)
 
 2224        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 2234#if 201103L <= YY_CPLUSPLUS 
 2237      make_FLUSH (location_type l)
 
 2239        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 2249#if 201103L <= YY_CPLUSPLUS 
 2252      make_MAXSIZE (location_type l)
 
 2254        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 2264#if 201103L <= YY_CPLUSPLUS 
 2267      make_MAXVER (location_type l)
 
 2269        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 2279#if 201103L <= YY_CPLUSPLUS 
 2282      make_PATTERN (location_type l)
 
 2284        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 2294#if 201103L <= YY_CPLUSPLUS 
 2297      make_TOPLEVEL_JSON (location_type l)
 
 2299        return symbol_type (token::TOKEN_TOPLEVEL_JSON, std::move (l));
 
 2309#if 201103L <= YY_CPLUSPLUS 
 2312      make_TOPLEVEL_DHCPDDNS (location_type l)
 
 2314        return symbol_type (token::TOKEN_TOPLEVEL_DHCPDDNS, std::move (l));
 
 2324#if 201103L <= YY_CPLUSPLUS 
 2327      make_SUB_DHCPDDNS (location_type l)
 
 2329        return symbol_type (token::TOKEN_SUB_DHCPDDNS, std::move (l));
 
 2339#if 201103L <= YY_CPLUSPLUS 
 2342      make_SUB_TSIG_KEY (location_type l)
 
 2344        return symbol_type (token::TOKEN_SUB_TSIG_KEY, std::move (l));
 
 2354#if 201103L <= YY_CPLUSPLUS 
 2357      make_SUB_TSIG_KEYS (location_type l)
 
 2359        return symbol_type (token::TOKEN_SUB_TSIG_KEYS, std::move (l));
 
 2369#if 201103L <= YY_CPLUSPLUS 
 2372      make_SUB_DDNS_DOMAIN (location_type l)
 
 2374        return symbol_type (token::TOKEN_SUB_DDNS_DOMAIN, std::move (l));
 
 2384#if 201103L <= YY_CPLUSPLUS 
 2387      make_SUB_DDNS_DOMAINS (location_type l)
 
 2389        return symbol_type (token::TOKEN_SUB_DDNS_DOMAINS, std::move (l));
 
 2399#if 201103L <= YY_CPLUSPLUS 
 2402      make_SUB_DNS_SERVER (location_type l)
 
 2404        return symbol_type (token::TOKEN_SUB_DNS_SERVER, std::move (l));
 
 2414#if 201103L <= YY_CPLUSPLUS 
 2417      make_SUB_DNS_SERVERS (location_type l)
 
 2419        return symbol_type (token::TOKEN_SUB_DNS_SERVERS, std::move (l));
 
 2429#if 201103L <= YY_CPLUSPLUS 
 2432      make_SUB_HOOKS_LIBRARY (location_type l)
 
 2434        return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, std::move (l));
 
 2444#if 201103L <= YY_CPLUSPLUS 
 2447      make_STRING (std::string v, location_type l)
 
 2449        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 2459#if 201103L <= YY_CPLUSPLUS 
 2462      make_INTEGER (int64_t v, location_type l)
 
 2464        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 2474#if 201103L <= YY_CPLUSPLUS 
 2477      make_FLOAT (
double v, location_type l)
 
 2479        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 2489#if 201103L <= YY_CPLUSPLUS 
 2492      make_BOOLEAN (
bool v, location_type l)
 
 2494        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 2525#if YY_CPLUSPLUS < 201103L 
 2534    typedef short state_type;
 
 2537    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 2538                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 2542    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 2546    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 2550    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 2554    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 2556    static const short yypact_ninf_;
 
 2557    static const signed char yytable_ninf_;
 
 2562    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 2565    static std::string yytnamerr_ (
const char *yystr);
 
 2568    static const char* 
const yytname_[];
 
 2574    static const short yypact_[];
 
 2579    static const short yydefact_[];
 
 2582    static const short yypgoto_[];
 
 2585    static const short yydefgoto_[];
 
 2590    static const short yytable_[];
 
 2592    static const short yycheck_[];
 
 2596    static const short yystos_[];
 
 2599    static const short yyr1_[];
 
 2602    static const signed char yyr2_[];
 
 2607    static const short yyrline_[];
 
 2609    virtual void yy_reduce_print_ (
int r) 
const;
 
 2611    virtual void yy_stack_print_ () 
const;
 
 2616    std::ostream* yycdebug_;
 
 2621    template <
typename Base>
 
 2622    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 2629    template <
typename Base>
 
 2630    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 2640      typedef state_type kind_type;
 
 2652      void move (by_state& that);
 
 2660      enum { empty_state = 0 };
 
 2668    struct stack_symbol_type : basic_symbol<by_state>
 
 2671      typedef basic_symbol<by_state> super_type;
 
 2673      stack_symbol_type ();
 
 2675      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 2677      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 2678#if YY_CPLUSPLUS < 201103L 
 2681      stack_symbol_type& operator= (stack_symbol_type& that);
 
 2685      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 2690    template <
typename T, 
typename S = std::vector<T> >
 
 2695      typedef typename S::iterator iterator;
 
 2696      typedef typename S::const_iterator const_iterator;
 
 2697      typedef typename S::size_type size_type;
 
 2698      typedef typename std::ptrdiff_t index_type;
 
 2704#if 201103L <= YY_CPLUSPLUS 
 2706      stack (
const stack&) = 
delete;
 
 2708      stack& operator= (
const stack&) = 
delete;
 
 2715      operator[] (index_type i)
 const 
 2717        return seq_[size_type (size () - 1 - i)];
 
 2724      operator[] (index_type i)
 
 2726        return seq_[size_type (size () - 1 - i)];
 
 2735        seq_.push_back (T ());
 
 2736        operator[] (0).move (t);
 
 2758        return index_type (seq_.size ());
 
 2765        return seq_.begin ();
 
 2785        operator[] (index_type i)
 const 
 2787          return stack_[range_ - i];
 
 
 2791        const stack& stack_;
 
 
 2796#if YY_CPLUSPLUS < 201103L 
 2798      stack (
const stack&);
 
 2800      stack& operator= (
const stack&);
 
 2808    typedef stack<stack_symbol_type> stack_type;
 
 2811    stack_type yystack_;
 
 2818    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 2826    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 
 2855       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2856       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2857       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2858       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2859       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2860       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2861       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2862       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2863       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2864       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2865       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2866       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2867       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2868       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2869       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2870       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2871       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2872       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2873       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2874       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2875       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2876       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2877       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2878       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2879       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2880       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 
 2881       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 
 2882      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 
 2883      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 
 2884      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 
 2885      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
 
 2886      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
 
 2887      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
 
 2888      75,    76,    77,    78,    79,    80,    81
 
 2891    const int code_max = 336;
 
 2895    else if (t <= code_max)
 
 2902  template <
typename Base>
 
 2908    switch (this->kind ())
 
 
 2943  template <
typename Base>
 
 2947    return this->kind ();
 
 
 2951  template <
typename Base>
 
 2958  template <
typename Base>
 
 2962    super_type::move (s);
 
 2963    switch (this->kind ())
 
 
 3002#if 201103L <= YY_CPLUSPLUS 
 3005    : kind_ (that.kind_)
 
 3013    : 
kind_ (that.kind_)
 
 
 3018    : 
kind_ (yytranslate_ (t))
 
 
 3050    return this->
kind ();
 
 
 3054#line 14 "d2_parser.yy" 
 3056#line 3057 "d2_parser.h" 
#define YY_MOVE_REF(Type)
#define YY_ATTRIBUTE_PURE
Evaluation context, an interface to the expression evaluation.
context(const D2Parser &yyparser, const symbol_type &yyla)
const symbol_type & lookahead() const YY_NOEXCEPT
symbol_kind_type token() const YY_NOEXCEPT
const location_type & location() const YY_NOEXCEPT
slice(const stack &stack, index_type range) YY_NOEXCEPT
A buffer to store and retrieve objects.
value_type self_type
Type of *this.
T & emplace(const T &t)
Instantiate a T in here from t.
T & emplace()
Instantiate an empty T in here.
T & build()
Instantiate an empty T in here.
void copy(const self_type &that)
Copy the content of that to this.
long double yyalign_me_
Strongest alignment constraints.
T & as() YY_NOEXCEPT
Accessor to a built T.
value_type(YY_RVREF(T) t)
Construct and fill.
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
T & build(const T &t)
Instantiate a T in here from t.
void destroy()
Destroy the stored T.
char yyraw_[size]
A buffer large enough to store any of the semantic values.
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
void move(self_type &that)
Move the content of that to this.
value_type() YY_NOEXCEPT
Empty construction.
static symbol_type make_COMMENT(const location_type &l)
static symbol_type make_AUTHENTICATION(const location_type &l)
static symbol_type make_STRING(const std::string &v, const location_type &l)
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
static symbol_type make_SUB_DDNS_DOMAIN(const location_type &l)
static symbol_type make_SUB_HOOKS_LIBRARY(const location_type &l)
static symbol_type make_LOGGERS(const location_type &l)
static symbol_type make_KEY_NAME(const location_type &l)
static symbol_type make_PARAMETERS(const location_type &l)
static symbol_type make_SUB_TSIG_KEYS(const location_type &l)
static symbol_type make_FORWARD_DDNS(const location_type &l)
static symbol_type make_SUB_DNS_SERVERS(const location_type &l)
static symbol_type make_TOPLEVEL_DHCPDDNS(const location_type &l)
static symbol_type make_SOCKET_TYPE(const location_type &l)
D2Parser(isc::d2::D2ParserContext &ctx_yyarg)
Build a parser object.
static symbol_type make_SUB_DDNS_DOMAINS(const location_type &l)
static symbol_type make_TCP(const location_type &l)
static symbol_type make_NAME(const location_type &l)
location location_type
Symbol locations.
static symbol_type make_MAXSIZE(const location_type &l)
static symbol_type make_PASSWORD_FILE(const location_type &l)
static symbol_type make_D2_PARSER_UNDEF(const location_type &l)
static symbol_type make_HTTPS(const location_type &l)
static symbol_type make_OUTPUT_OPTIONS(const location_type &l)
static symbol_type make_LSQUARE_BRACKET(const location_type &l)
static symbol_type make_PASSWORD(const location_type &l)
static symbol_type make_DEBUGLEVEL(const location_type &l)
static symbol_type make_LCURLY_BRACKET(const location_type &l)
static symbol_type make_DIGEST_BITS(const location_type &l)
static symbol_type make_SOCKET_ADDRESS(const location_type &l)
static symbol_type make_CERT_FILE(const location_type &l)
static symbol_type make_TOPLEVEL_JSON(const location_type &l)
static symbol_type make_SOCKET_NAME(const location_type &l)
static symbol_type make_DNS_SERVER_TIMEOUT(const location_type &l)
static symbol_type make_NULL_TYPE(const location_type &l)
static symbol_type make_LIBRARY(const location_type &l)
static symbol_type make_UDP(const location_type &l)
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
static symbol_type make_COLON(const location_type &l)
static symbol_type make_COMMA(const location_type &l)
static symbol_type make_SECRET(const location_type &l)
static symbol_type make_SUB_TSIG_KEY(const location_type &l)
static symbol_type make_RCURLY_BRACKET(const location_type &l)
static symbol_type make_UNIX(const location_type &l)
static symbol_type make_OUTPUT(const location_type &l)
value_type semantic_type
Backward compatibility (Bison 3.8).
static symbol_type make_SUB_DHCPDDNS(const location_type &l)
static const symbol_kind_type YYNTOKENS
The number of tokens.
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
static symbol_type make_DHCPDDNS(const location_type &l)
by_kind by_type
Backward compatibility for a private implementation detail (Bison 3.6).
static symbol_type make_D2_PARSER_error(const location_type &l)
static symbol_type make_CONTROL_SOCKETS(const location_type &l)
static symbol_type make_SUB_DNS_SERVER(const location_type &l)
static symbol_type make_MAXVER(const location_type &l)
static symbol_type make_SECRET_FILE(const location_type &l)
static symbol_type make_DDNS_DOMAINS(const location_type &l)
static symbol_type make_SEVERITY(const location_type &l)
static symbol_type make_REALM(const location_type &l)
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_HTTP(const location_type &l)
static symbol_type make_HOSTNAME(const location_type &l)
static symbol_type make_USER_CONTEXT(const location_type &l)
static symbol_type make_USER(const location_type &l)
static symbol_type make_SOCKET_PORT(const location_type &l)
static symbol_type make_BASIC(const location_type &l)
static symbol_type make_FLUSH(const location_type &l)
static symbol_type make_REVERSE_DDNS(const location_type &l)
static symbol_type make_PATTERN(const location_type &l)
static symbol_type make_KEY_FILE(const location_type &l)
static symbol_type make_ALGORITHM(const location_type &l)
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
static symbol_type make_IP_ADDRESS(const location_type &l)
static symbol_type make_PORT(const location_type &l)
static symbol_type make_CLIENTS(const location_type &l)
static symbol_type make_CERT_REQUIRED(const location_type &l)
static std::string symbol_name(symbol_kind_type yysymbol)
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
static symbol_type make_TYPE(const location_type &l)
static symbol_type make_TRUST_ANCHOR(const location_type &l)
static symbol_type make_FLOAT(const double &v, const location_type &l)
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
static symbol_type make_DIRECTORY(const location_type &l)
static symbol_type make_JSON(const location_type &l)
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
static symbol_type make_END(const location_type &l)
static symbol_type make_CONTROL_SOCKET(const location_type &l)
static symbol_type make_NCR_PROTOCOL(const location_type &l)
static symbol_type make_DNS_SERVERS(const location_type &l)
static symbol_type make_USER_FILE(const location_type &l)
static symbol_type make_TSIG_KEYS(const location_type &l)
static symbol_type make_NCR_FORMAT(const location_type &l)
Forward declaration of the ParserContext class.
A collection of classes for housing and parsing the application configuration necessary for the DHCP-...
#define D2_PARSER__ASSERT
boost::shared_ptr< Element > ElementPtr
Defines the logger used by the top-level component of kea-lfc.
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
basic_symbol() YY_NOEXCEPT
Default constructor.
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
bool empty() const YY_NOEXCEPT
Base super_type
Alias to Base.
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
~basic_symbol()
Destroy the symbol.
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
void move(basic_symbol &s)
basic_symbol(const basic_symbol &that)
Copy constructor.
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
Type access provider for token (enum) based symbols.
void clear() YY_NOEXCEPT
Record that this symbol is empty.
by_kind() YY_NOEXCEPT
Default constructor.
token_kind_type kind_type
The symbol kind as needed by the constructor.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
void move(by_kind &that)
Steal the symbol kind from that.
symbol_kind_type kind_
The symbol kind.
@ S_not_empty_tsig_keys_list
@ S_dns_server_ip_address
@ S_control_socket_address
@ S_control_socket_type_value
@ S_not_empty_ddns_mgr_params
@ S_not_empty_hooks_libraries_list
@ YYNTOKENS
Number of tokens.
@ S_not_empty_clients_list
@ S_control_socket_params
@ S_output_options_list_content
@ S_not_empty_control_socket_list
@ S_not_empty_ddns_domain_list
"External" symbols: returned by the scanner.
basic_symbol< by_kind > super_type
Superclass.
symbol_type() YY_NOEXCEPT
Empty symbol.
syntax_error(const location_type &l, const std::string &m)
~syntax_error() YY_NOEXCEPT YY_NOTHROW
syntax_error(const syntax_error &s)
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
@ TOKEN_SUB_HOOKS_LIBRARY
@ TOKEN_TOPLEVEL_DHCPDDNS
@ TOKEN_DNS_SERVER_TIMEOUT