45#ifndef YY_NETCONF_NETCONF_PARSER_H_INCLUDED 
   46# define YY_NETCONF_NETCONF_PARSER_H_INCLUDED 
   48#line 17 "netconf_parser.yy" 
   53#include <boost/lexical_cast.hpp> 
   62#line 63 "netconf_parser.h" 
   71#if defined __cplusplus 
   72# define YY_CPLUSPLUS __cplusplus 
   74# define YY_CPLUSPLUS 199711L 
   78#if 201103L <= YY_CPLUSPLUS 
   79# define YY_MOVE           std::move 
   80# define YY_MOVE_OR_COPY   move 
   81# define YY_MOVE_REF(Type) Type&& 
   82# define YY_RVREF(Type)    Type&& 
   83# define YY_COPY(Type)     Type 
   86# define YY_MOVE_OR_COPY   copy 
   87# define YY_MOVE_REF(Type) Type& 
   88# define YY_RVREF(Type)    const Type& 
   89# define YY_COPY(Type)     const Type& 
   93#if 201103L <= YY_CPLUSPLUS 
   94# define YY_NOEXCEPT noexcept 
   98# define YY_NOTHROW throw () 
  102#if 201703 <= YY_CPLUSPLUS 
  103# define YY_CONSTEXPR constexpr 
  107# include "location.hh" 
  109#ifndef NETCONF__ASSERT 
  111# define NETCONF__ASSERT assert 
  115#ifndef YY_ATTRIBUTE_PURE 
  116# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 
  117#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 
  119#  define YY_ATTRIBUTE_PURE 
  123#ifndef YY_ATTRIBUTE_UNUSED 
  124# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 
  125#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 
  127#  define YY_ATTRIBUTE_UNUSED 
  132#if ! defined lint || defined __GNUC__ 
  133# define YY_USE(E) ((void) (E)) 
  139#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 
  140# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 
  141#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \ 
  142    _Pragma ("GCC diagnostic push")                                     \ 
  143    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 
  145#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \ 
  146    _Pragma ("GCC diagnostic push")                                     \ 
  147    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \ 
  148    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 
  150# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \ 
  151    _Pragma ("GCC diagnostic pop") 
  153# define YY_INITIAL_VALUE(Value) Value 
  155#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 
  156# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 
  157# define YY_IGNORE_MAYBE_UNINITIALIZED_END 
  159#ifndef YY_INITIAL_VALUE 
  160# define YY_INITIAL_VALUE(Value)  
  163#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 
  164# define YY_IGNORE_USELESS_CAST_BEGIN                          \ 
  165    _Pragma ("GCC diagnostic push")                            \ 
  166    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 
  167# define YY_IGNORE_USELESS_CAST_END            \ 
  168    _Pragma ("GCC diagnostic pop") 
  170#ifndef YY_IGNORE_USELESS_CAST_BEGIN 
  171# define YY_IGNORE_USELESS_CAST_BEGIN 
  172# define YY_IGNORE_USELESS_CAST_END 
  177#   define YY_CAST(Type, Val) static_cast<Type> (Val) 
  178#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 
  180#   define YY_CAST(Type, Val) ((Type) (Val)) 
  181#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 
  185#  if defined __cplusplus 
  186#   if 201103L <= __cplusplus 
  187#    define YY_NULLPTR nullptr 
  192#   define YY_NULLPTR ((void*)0) 
  200#   define NETCONF_DEBUG 1 
  202#   define NETCONF_DEBUG 0 
  205#  define NETCONF_DEBUG 1 
  209#line 14 "netconf_parser.yy" 
  211#line 212 "netconf_parser.h" 
  222#  pragma GCC message "bison: do not #define NETCONF_STYPE in C++, use %define api.value.type" 
  240      , yytypeid_ (YY_NULLPTR)
 
 
  244    template <
typename T>
 
  246      : yytypeid_ (&typeid (T))
 
  249      new (yyas_<T> ()) T (
YY_MOVE (t));
 
 
  252#if 201103L <= YY_CPLUSPLUS 
  265# if 201103L <= YY_CPLUSPLUS 
  267    template <
typename T, 
typename... U>
 
  273      yytypeid_ = & 
typeid (T);
 
  274      return *
new (yyas_<T> ()) T (std::forward <U>(u)...);
 
  278    template <
typename T>
 
  284      yytypeid_ = & 
typeid (T);
 
  285      return *
new (yyas_<T> ()) T ();
 
 
  289    template <
typename T>
 
  295      yytypeid_ = & 
typeid (T);
 
  296      return *
new (yyas_<T> ()) T (t);
 
 
  302    template <
typename T>
 
  311    template <
typename T>
 
  319    template <
typename T>
 
  330    template <
typename T>
 
  348    template <
typename T>
 
  354      std::swap (
as<T> (), that.as<T> ());
 
 
  360    template <
typename T>
 
  364# if 201103L <= YY_CPLUSPLUS 
 
  373# if 201103L <= YY_CPLUSPLUS 
  375    template <
typename T>
 
  385    template <
typename T>
 
  393    template <
typename T>
 
  398      yytypeid_ = YY_NULLPTR;
 
 
  402#if YY_CPLUSPLUS < 201103L 
  410    template <
typename T>
 
  415      return static_cast<T*
> (yyp);
 
  419    template <
typename T>
 
  424      return static_cast<const T*
> (yyp);
 
  436      char dummy2[
sizeof (bool)];
 
  439      char dummy3[
sizeof (double)];
 
  442      char dummy4[
sizeof (int64_t)];
 
  445      char dummy5[
sizeof (string)];
 
  449    enum { size = 
sizeof (union_type) };
 
  461    const std::type_info *yytypeid_;
 
 
  475        : std::runtime_error (m)
 
 
  480        : std::runtime_error (s.what ())
 
 
 
  726    template <
typename Base>
 
  738#if 201103L <= YY_CPLUSPLUS 
  741        : Base (std::move (that))
 
  743        , location (std::move (that.location))
 
  745        switch (this->kind ())
 
  750        value.move< 
ElementPtr > (std::move (that.value));
 
  754        value.move< 
bool > (std::move (that.value));
 
  758        value.move< 
double > (std::move (that.value));
 
  762        value.move< int64_t > (std::move (that.value));
 
  766        value.move< 
string > (std::move (that.value));
 
  780#if 201103L <= YY_CPLUSPLUS 
  792#if 201103L <= YY_CPLUSPLUS 
  795        , value (std::move (v))
 
  796        , location (std::move (l))
 
  806#if 201103L <= YY_CPLUSPLUS 
  809        , value (std::move (v))
 
  810        , location (std::move (l))
 
  820#if 201103L <= YY_CPLUSPLUS 
  823        , value (std::move (v))
 
  824        , location (std::move (l))
 
  834#if 201103L <= YY_CPLUSPLUS 
  837        , value (std::move (v))
 
  838        , location (std::move (l))
 
  848#if 201103L <= YY_CPLUSPLUS 
  851        , value (std::move (v))
 
  852        , location (std::move (l))
 
  889        value.template destroy< ElementPtr > ();
 
  893        value.template destroy< bool > ();
 
  897        value.template destroy< double > ();
 
  901        value.template destroy< int64_t > ();
 
  905        value.template destroy< string > ();
 
 
  937#if YY_CPLUSPLUS < 201103L 
 
  952#if 201103L <= YY_CPLUSPLUS 
 
  996#if 201103L <= YY_CPLUSPLUS 
 1004#if !defined _MSC_VER || defined __clang__ 
 
 1009#if 201103L <= YY_CPLUSPLUS 
 1017#if !defined _MSC_VER || defined __clang__ 
 
 1021#if 201103L <= YY_CPLUSPLUS 
 1029#if !defined _MSC_VER || defined __clang__ 
 
 1033#if 201103L <= YY_CPLUSPLUS 
 1041#if !defined _MSC_VER || defined __clang__ 
 
 1045#if 201103L <= YY_CPLUSPLUS 
 1053#if !defined _MSC_VER || defined __clang__ 
 
 
 1063#if 201103L <= YY_CPLUSPLUS 
 1076    virtual int parse ();
 
 1082    void set_debug_stream (std::ostream &);
 
 1085    typedef 
int debug_level_type;
 
 1089    void set_debug_level (debug_level_type l);
 
 1095    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1098    void error (
const syntax_error& err);
 
 1102    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1105#if 201103L <= YY_CPLUSPLUS 
 1108      make_END (location_type l)
 
 1110        return symbol_type (token::TOKEN_END, std::move (l));
 
 1120#if 201103L <= YY_CPLUSPLUS 
 1123      make_NETCONF_error (location_type l)
 
 1125        return symbol_type (token::TOKEN_NETCONF_error, std::move (l));
 
 1135#if 201103L <= YY_CPLUSPLUS 
 1138      make_NETCONF_UNDEF (location_type l)
 
 1140        return symbol_type (token::TOKEN_NETCONF_UNDEF, std::move (l));
 
 1150#if 201103L <= YY_CPLUSPLUS 
 1153      make_COMMA (location_type l)
 
 1155        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1165#if 201103L <= YY_CPLUSPLUS 
 1168      make_COLON (location_type l)
 
 1170        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1180#if 201103L <= YY_CPLUSPLUS 
 1183      make_LSQUARE_BRACKET (location_type l)
 
 1185        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 1195#if 201103L <= YY_CPLUSPLUS 
 1198      make_RSQUARE_BRACKET (location_type l)
 
 1200        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 1210#if 201103L <= YY_CPLUSPLUS 
 1213      make_LCURLY_BRACKET (location_type l)
 
 1215        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 1225#if 201103L <= YY_CPLUSPLUS 
 1228      make_RCURLY_BRACKET (location_type l)
 
 1230        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 1240#if 201103L <= YY_CPLUSPLUS 
 1243      make_NULL_TYPE (location_type l)
 
 1245        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 1255#if 201103L <= YY_CPLUSPLUS 
 1258      make_NETCONF (location_type l)
 
 1260        return symbol_type (token::TOKEN_NETCONF, std::move (l));
 
 1270#if 201103L <= YY_CPLUSPLUS 
 1273      make_USER_CONTEXT (location_type l)
 
 1275        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 1285#if 201103L <= YY_CPLUSPLUS 
 1288      make_COMMENT (location_type l)
 
 1290        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 1300#if 201103L <= YY_CPLUSPLUS 
 1303      make_BOOT_UPDATE (location_type l)
 
 1305        return symbol_type (token::TOKEN_BOOT_UPDATE, std::move (l));
 
 1315#if 201103L <= YY_CPLUSPLUS 
 1318      make_SUBSCRIBE_CHANGES (location_type l)
 
 1320        return symbol_type (token::TOKEN_SUBSCRIBE_CHANGES, std::move (l));
 
 1330#if 201103L <= YY_CPLUSPLUS 
 1333      make_VALIDATE_CHANGES (location_type l)
 
 1335        return symbol_type (token::TOKEN_VALIDATE_CHANGES, std::move (l));
 
 1345#if 201103L <= YY_CPLUSPLUS 
 1348      make_MANAGED_SERVERS (location_type l)
 
 1350        return symbol_type (token::TOKEN_MANAGED_SERVERS, std::move (l));
 
 1360#if 201103L <= YY_CPLUSPLUS 
 1363      make_DHCP4_SERVER (location_type l)
 
 1365        return symbol_type (token::TOKEN_DHCP4_SERVER, std::move (l));
 
 1375#if 201103L <= YY_CPLUSPLUS 
 1378      make_DHCP6_SERVER (location_type l)
 
 1380        return symbol_type (token::TOKEN_DHCP6_SERVER, std::move (l));
 
 1390#if 201103L <= YY_CPLUSPLUS 
 1393      make_D2_SERVER (location_type l)
 
 1395        return symbol_type (token::TOKEN_D2_SERVER, std::move (l));
 
 1405#if 201103L <= YY_CPLUSPLUS 
 1408      make_CA_SERVER (location_type l)
 
 1410        return symbol_type (token::TOKEN_CA_SERVER, std::move (l));
 
 1420#if 201103L <= YY_CPLUSPLUS 
 1423      make_MODEL (location_type l)
 
 1425        return symbol_type (token::TOKEN_MODEL, std::move (l));
 
 1435#if 201103L <= YY_CPLUSPLUS 
 1438      make_CONTROL_SOCKET (location_type l)
 
 1440        return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
 
 1450#if 201103L <= YY_CPLUSPLUS 
 1453      make_SOCKET_TYPE (location_type l)
 
 1455        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 1465#if 201103L <= YY_CPLUSPLUS 
 1468      make_UNIX (location_type l)
 
 1470        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 1480#if 201103L <= YY_CPLUSPLUS 
 1483      make_HTTP (location_type l)
 
 1485        return symbol_type (token::TOKEN_HTTP, std::move (l));
 
 1495#if 201103L <= YY_CPLUSPLUS 
 1498      make_STDOUT (location_type l)
 
 1500        return symbol_type (token::TOKEN_STDOUT, std::move (l));
 
 1510#if 201103L <= YY_CPLUSPLUS 
 1513      make_SOCKET_NAME (location_type l)
 
 1515        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 1525#if 201103L <= YY_CPLUSPLUS 
 1528      make_SOCKET_URL (location_type l)
 
 1530        return symbol_type (token::TOKEN_SOCKET_URL, std::move (l));
 
 1540#if 201103L <= YY_CPLUSPLUS 
 1543      make_HOOKS_LIBRARIES (location_type l)
 
 1545        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 1555#if 201103L <= YY_CPLUSPLUS 
 1558      make_LIBRARY (location_type l)
 
 1560        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 1570#if 201103L <= YY_CPLUSPLUS 
 1573      make_PARAMETERS (location_type l)
 
 1575        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 1585#if 201103L <= YY_CPLUSPLUS 
 1588      make_LOGGERS (location_type l)
 
 1590        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 1600#if 201103L <= YY_CPLUSPLUS 
 1603      make_NAME (location_type l)
 
 1605        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 1615#if 201103L <= YY_CPLUSPLUS 
 1618      make_OUTPUT_OPTIONS (location_type l)
 
 1620        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 1630#if 201103L <= YY_CPLUSPLUS 
 1633      make_OUTPUT (location_type l)
 
 1635        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 1645#if 201103L <= YY_CPLUSPLUS 
 1648      make_DEBUGLEVEL (location_type l)
 
 1650        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 1660#if 201103L <= YY_CPLUSPLUS 
 1663      make_SEVERITY (location_type l)
 
 1665        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 1675#if 201103L <= YY_CPLUSPLUS 
 1678      make_FLUSH (location_type l)
 
 1680        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 1690#if 201103L <= YY_CPLUSPLUS 
 1693      make_MAXSIZE (location_type l)
 
 1695        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 1705#if 201103L <= YY_CPLUSPLUS 
 1708      make_MAXVER (location_type l)
 
 1710        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 1720#if 201103L <= YY_CPLUSPLUS 
 1723      make_PATTERN (location_type l)
 
 1725        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 1735#if 201103L <= YY_CPLUSPLUS 
 1738      make_START_JSON (location_type l)
 
 1740        return symbol_type (token::TOKEN_START_JSON, std::move (l));
 
 1750#if 201103L <= YY_CPLUSPLUS 
 1753      make_START_NETCONF (location_type l)
 
 1755        return symbol_type (token::TOKEN_START_NETCONF, std::move (l));
 
 1765#if 201103L <= YY_CPLUSPLUS 
 1768      make_START_SUB_NETCONF (location_type l)
 
 1770        return symbol_type (token::TOKEN_START_SUB_NETCONF, std::move (l));
 
 1780#if 201103L <= YY_CPLUSPLUS 
 1783      make_STRING (
string v, location_type l)
 
 1785        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 1795#if 201103L <= YY_CPLUSPLUS 
 1798      make_INTEGER (int64_t v, location_type l)
 
 1800        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 1810#if 201103L <= YY_CPLUSPLUS 
 1813      make_FLOAT (
double v, location_type l)
 
 1815        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 1825#if 201103L <= YY_CPLUSPLUS 
 1828      make_BOOLEAN (
bool v, location_type l)
 
 1830        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 1861#if YY_CPLUSPLUS < 201103L 
 1870    typedef short state_type;
 
 1873    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 1874                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 1878    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 1882    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 1886    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 1890    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 1892    static const signed char yypact_ninf_;
 
 1893    static const signed char yytable_ninf_;
 
 1898    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 1901    static std::string yytnamerr_ (
const char *yystr);
 
 1904    static const char* 
const yytname_[];
 
 1910    static const short yypact_[];
 
 1915    static const unsigned char yydefact_[];
 
 1918    static const signed char yypgoto_[];
 
 1921    static const short yydefgoto_[];
 
 1926    static const short yytable_[];
 
 1928    static const short yycheck_[];
 
 1932    static const unsigned char yystos_[];
 
 1935    static const unsigned char yyr1_[];
 
 1938    static const signed char yyr2_[];
 
 1943    static const short yyrline_[];
 
 1945    virtual void yy_reduce_print_ (
int r) 
const;
 
 1947    virtual void yy_stack_print_ () 
const;
 
 1952    std::ostream* yycdebug_;
 
 1957    template <
typename Base>
 
 1958    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 1965    template <
typename Base>
 
 1966    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 1976      typedef state_type kind_type;
 
 1988      void move (by_state& that);
 
 1996      enum { empty_state = 0 };
 
 2004    struct stack_symbol_type : basic_symbol<by_state>
 
 2007      typedef basic_symbol<by_state> super_type;
 
 2009      stack_symbol_type ();
 
 2011      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 2013      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 2014#if YY_CPLUSPLUS < 201103L 
 2017      stack_symbol_type& operator= (stack_symbol_type& that);
 
 2021      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 2026    template <
typename T, 
typename S = std::vector<T> >
 
 2031      typedef typename S::iterator iterator;
 
 2032      typedef typename S::const_iterator const_iterator;
 
 2033      typedef typename S::size_type size_type;
 
 2034      typedef typename std::ptrdiff_t index_type;
 
 2040#if 201103L <= YY_CPLUSPLUS 
 2042      stack (
const stack&) = 
delete;
 
 2044      stack& operator= (
const stack&) = 
delete;
 
 2051      operator[] (index_type i)
 const 
 2053        return seq_[size_type (size () - 1 - i)];
 
 2060      operator[] (index_type i)
 
 2062        return seq_[size_type (size () - 1 - i)];
 
 2071        seq_.push_back (T ());
 
 2072        operator[] (0).move (t);
 
 2094        return index_type (seq_.size ());
 
 2101        return seq_.begin ();
 
 2121        operator[] (index_type i)
 const 
 2123          return stack_[range_ - i];
 
 
 2127        const stack& stack_;
 
 
 2132#if YY_CPLUSPLUS < 201103L 
 2134      stack (
const stack&);
 
 2136      stack& operator= (
const stack&);
 
 2144    typedef stack<stack_symbol_type> stack_type;
 
 2147    stack_type yystack_;
 
 2154    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 2162    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 
 2191       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2192       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2193       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2194       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2195       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2196       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2197       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2198       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2199       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2200       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2201       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2202       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2203       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2204       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2205       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2206       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2207       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2208       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2209       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2210       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2211       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2212       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2213       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2214       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2215       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2216       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 
 2217       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 
 2218      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 
 2219      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 
 2220      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 
 2224    const int code_max = 303;
 
 2228    else if (t <= code_max)
 
 2235  template <
typename Base>
 
 2241    switch (this->kind ())
 
 
 2274  template <
typename Base>
 
 2278    return this->kind ();
 
 
 2282  template <
typename Base>
 
 2289  template <
typename Base>
 
 2293    super_type::move (s);
 
 2294    switch (this->kind ())
 
 
 2331#if 201103L <= YY_CPLUSPLUS 
 2334    : kind_ (that.kind_)
 
 2342    : 
kind_ (that.kind_)
 
 
 2347    : 
kind_ (yytranslate_ (t))
 
 
 2379    return this->
kind ();
 
 
 2383#line 14 "netconf_parser.yy" 
 2385#line 2386 "netconf_parser.h" 
#define YY_MOVE_REF(Type)
#define YY_ATTRIBUTE_PURE
const location_type & location() const YY_NOEXCEPT
symbol_kind_type token() const YY_NOEXCEPT
context(const NetconfParser &yyparser, const symbol_type &yyla)
const symbol_type & lookahead() const YY_NOEXCEPT
slice(const stack &stack, index_type range) YY_NOEXCEPT
A buffer to store and retrieve objects.
long double yyalign_me_
Strongest alignment constraints.
void move(self_type &that)
Move the content of that to this.
T & build(const T &t)
Instantiate a T in here from t.
value_type(YY_RVREF(T) t)
Construct and fill.
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
char yyraw_[size]
A buffer large enough to store any of the semantic values.
value_type self_type
Type of *this.
T & as() YY_NOEXCEPT
Accessor to a built T.
void copy(const self_type &that)
Copy the content of that to this.
T & build()
Instantiate an empty T in here.
void destroy()
Destroy the stored T.
T & emplace(const T &t)
Instantiate a T in here from t.
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
T & emplace()
Instantiate an empty T in here.
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
value_type() YY_NOEXCEPT
Empty construction.
static symbol_type make_NETCONF(const location_type &l)
static symbol_type make_SOCKET_URL(const location_type &l)
static symbol_type make_MAXVER(const location_type &l)
static symbol_type make_OUTPUT_OPTIONS(const location_type &l)
static symbol_type make_MAXSIZE(const location_type &l)
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
static symbol_type make_CONTROL_SOCKET(const location_type &l)
static symbol_type make_OUTPUT(const location_type &l)
static symbol_type make_DHCP6_SERVER(const location_type &l)
static symbol_type make_BOOT_UPDATE(const location_type &l)
static symbol_type make_NETCONF_UNDEF(const location_type &l)
static symbol_type make_NULL_TYPE(const location_type &l)
static symbol_type make_DEBUGLEVEL(const location_type &l)
static symbol_type make_HTTP(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_VALIDATE_CHANGES(const location_type &l)
static symbol_type make_END(const location_type &l)
static symbol_type make_LIBRARY(const location_type &l)
static symbol_type make_LOGGERS(const location_type &l)
static symbol_type make_NETCONF_error(const location_type &l)
static symbol_type make_LCURLY_BRACKET(const location_type &l)
static symbol_type make_STRING(const string &v, const location_type &l)
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
NetconfParser(isc::netconf::ParserContext &ctx_yyarg)
Build a parser object.
static symbol_type make_STDOUT(const location_type &l)
value_type semantic_type
Backward compatibility (Bison 3.8).
static symbol_type make_SOCKET_TYPE(const location_type &l)
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
static symbol_type make_LSQUARE_BRACKET(const location_type &l)
static symbol_type make_DHCP4_SERVER(const location_type &l)
static symbol_type make_D2_SERVER(const location_type &l)
static symbol_type make_PARAMETERS(const location_type &l)
static symbol_type make_NAME(const location_type &l)
static symbol_type make_FLUSH(const location_type &l)
static symbol_type make_START_JSON(const location_type &l)
static symbol_type make_UNIX(const location_type &l)
static symbol_type make_PATTERN(const location_type &l)
static const symbol_kind_type YYNTOKENS
The number of tokens.
static symbol_type make_COMMENT(const location_type &l)
static symbol_type make_SEVERITY(const location_type &l)
static symbol_type make_MANAGED_SERVERS(const location_type &l)
location location_type
Symbol locations.
static symbol_type make_SUBSCRIBE_CHANGES(const location_type &l)
by_kind by_type
Backward compatibility for a private implementation detail (Bison 3.6).
static symbol_type make_CA_SERVER(const location_type &l)
static symbol_type make_COLON(const location_type &l)
static symbol_type make_RCURLY_BRACKET(const location_type &l)
static symbol_type make_USER_CONTEXT(const location_type &l)
static symbol_type make_COMMA(const location_type &l)
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_START_NETCONF(const location_type &l)
static symbol_type make_MODEL(const location_type &l)
static symbol_type make_START_SUB_NETCONF(const location_type &l)
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
static symbol_type make_FLOAT(const double &v, const location_type &l)
static symbol_type make_SOCKET_NAME(const location_type &l)
Parser context is a wrapper around flex/bison instances dedicated to Netconf-agent config file parser...
boost::shared_ptr< Element > ElementPtr
Defines the logger used by the top-level component of kea-lfc.
Forward declaration of the ParserContext class.
bool empty() const YY_NOEXCEPT
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
basic_symbol() YY_NOEXCEPT
Default constructor.
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
void move(basic_symbol &s)
Base super_type
Alias to Base.
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
basic_symbol(const basic_symbol &that)
Copy constructor.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const string &v, const location_type &l)
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
~basic_symbol()
Destroy the symbol.
Type access provider for token (enum) based symbols.
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).
by_kind() YY_NOEXCEPT
Default constructor.
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
symbol_kind_type kind_
The symbol kind.
void move(by_kind &that)
Steal the symbol kind from that.
void clear() YY_NOEXCEPT
Record that this symbol is empty.
@ S_not_empty_hooks_libraries_list
@ S_control_socket_params
@ YYNTOKENS
Number of tokens.
@ S_managed_server_params
@ S_not_empty_servers_entries
@ S_not_empty_global_params
@ S_output_options_list_content
"External" symbols: returned by the scanner.
symbol_type() YY_NOEXCEPT
Empty symbol.
basic_symbol< by_kind > super_type
Superclass.
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_SUBSCRIBE_CHANGES
@ TOKEN_START_SUB_NETCONF