45#ifndef YY_AGENT_AGENT_PARSER_H_INCLUDED 
   46# define YY_AGENT_AGENT_PARSER_H_INCLUDED 
   48#line 17 "agent_parser.yy" 
   52#include <boost/lexical_cast.hpp> 
   59#line 60 "agent_parser.h" 
   68#if defined __cplusplus 
   69# define YY_CPLUSPLUS __cplusplus 
   71# define YY_CPLUSPLUS 199711L 
   75#if 201103L <= YY_CPLUSPLUS 
   76# define YY_MOVE           std::move 
   77# define YY_MOVE_OR_COPY   move 
   78# define YY_MOVE_REF(Type) Type&& 
   79# define YY_RVREF(Type)    Type&& 
   80# define YY_COPY(Type)     Type 
   83# define YY_MOVE_OR_COPY   copy 
   84# define YY_MOVE_REF(Type) Type& 
   85# define YY_RVREF(Type)    const Type& 
   86# define YY_COPY(Type)     const Type& 
   90#if 201103L <= YY_CPLUSPLUS 
   91# define YY_NOEXCEPT noexcept 
   95# define YY_NOTHROW throw () 
   99#if 201703 <= YY_CPLUSPLUS 
  100# define YY_CONSTEXPR constexpr 
  104# include "location.hh" 
  108# define AGENT__ASSERT assert 
  112#ifndef YY_ATTRIBUTE_PURE 
  113# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 
  114#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 
  116#  define YY_ATTRIBUTE_PURE 
  120#ifndef YY_ATTRIBUTE_UNUSED 
  121# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 
  122#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 
  124#  define YY_ATTRIBUTE_UNUSED 
  129#if ! defined lint || defined __GNUC__ 
  130# define YY_USE(E) ((void) (E)) 
  136#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 
  137# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 
  138#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \ 
  139    _Pragma ("GCC diagnostic push")                                     \ 
  140    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 
  142#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \ 
  143    _Pragma ("GCC diagnostic push")                                     \ 
  144    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \ 
  145    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 
  147# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \ 
  148    _Pragma ("GCC diagnostic pop") 
  150# define YY_INITIAL_VALUE(Value) Value 
  152#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 
  153# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 
  154# define YY_IGNORE_MAYBE_UNINITIALIZED_END 
  156#ifndef YY_INITIAL_VALUE 
  157# define YY_INITIAL_VALUE(Value)  
  160#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 
  161# define YY_IGNORE_USELESS_CAST_BEGIN                          \ 
  162    _Pragma ("GCC diagnostic push")                            \ 
  163    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 
  164# define YY_IGNORE_USELESS_CAST_END            \ 
  165    _Pragma ("GCC diagnostic pop") 
  167#ifndef YY_IGNORE_USELESS_CAST_BEGIN 
  168# define YY_IGNORE_USELESS_CAST_BEGIN 
  169# define YY_IGNORE_USELESS_CAST_END 
  174#   define YY_CAST(Type, Val) static_cast<Type> (Val) 
  175#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 
  177#   define YY_CAST(Type, Val) ((Type) (Val)) 
  178#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 
  182#  if defined __cplusplus 
  183#   if 201103L <= __cplusplus 
  184#    define YY_NULLPTR nullptr 
  189#   define YY_NULLPTR ((void*)0) 
  197#   define AGENT_DEBUG 1 
  199#   define AGENT_DEBUG 0 
  202#  define AGENT_DEBUG 1 
  206#line 14 "agent_parser.yy" 
  208#line 209 "agent_parser.h" 
  219#  pragma GCC message "bison: do not #define AGENT_STYPE in C++, use %define api.value.type" 
  237      , yytypeid_ (YY_NULLPTR)
 
 
  241    template <
typename T>
 
  243      : yytypeid_ (&typeid (T))
 
  246      new (yyas_<T> ()) T (
YY_MOVE (t));
 
 
  249#if 201103L <= YY_CPLUSPLUS 
  262# if 201103L <= YY_CPLUSPLUS 
  264    template <
typename T, 
typename... U>
 
  270      yytypeid_ = & 
typeid (T);
 
  271      return *
new (yyas_<T> ()) T (std::forward <U>(u)...);
 
  275    template <
typename T>
 
  281      yytypeid_ = & 
typeid (T);
 
  282      return *
new (yyas_<T> ()) T ();
 
 
  286    template <
typename T>
 
  292      yytypeid_ = & 
typeid (T);
 
  293      return *
new (yyas_<T> ()) T (t);
 
 
  299    template <
typename T>
 
  308    template <
typename T>
 
  316    template <
typename T>
 
  327    template <
typename T>
 
  345    template <
typename T>
 
  351      std::swap (
as<T> (), that.as<T> ());
 
 
  357    template <
typename T>
 
  361# if 201103L <= YY_CPLUSPLUS 
 
  370# if 201103L <= YY_CPLUSPLUS 
  372    template <
typename T>
 
  382    template <
typename T>
 
  390    template <
typename T>
 
  395      yytypeid_ = YY_NULLPTR;
 
 
  399#if YY_CPLUSPLUS < 201103L 
  407    template <
typename T>
 
  412      return static_cast<T*
> (yyp);
 
  416    template <
typename T>
 
  421      return static_cast<const T*
> (yyp);
 
  434      char dummy2[
sizeof (bool)];
 
  437      char dummy3[
sizeof (double)];
 
  440      char dummy4[
sizeof (int64_t)];
 
  443      char dummy5[
sizeof (std::string)];
 
  447    enum { size = 
sizeof (union_type) };
 
  459    const std::type_info *yytypeid_;
 
 
  473        : std::runtime_error (m)
 
 
  478        : std::runtime_error (s.what ())
 
 
 
  774    template <
typename Base>
 
  786#if 201103L <= YY_CPLUSPLUS 
  789        : Base (std::move (that))
 
  791        , location (std::move (that.location))
 
  793        switch (this->kind ())
 
  799        value.move< 
ElementPtr > (std::move (that.value));
 
  803        value.move< 
bool > (std::move (that.value));
 
  807        value.move< 
double > (std::move (that.value));
 
  811        value.move< int64_t > (std::move (that.value));
 
  815        value.move< std::string > (std::move (that.value));
 
  829#if 201103L <= YY_CPLUSPLUS 
  841#if 201103L <= YY_CPLUSPLUS 
  844        , value (std::move (v))
 
  845        , location (std::move (l))
 
  855#if 201103L <= YY_CPLUSPLUS 
  858        , value (std::move (v))
 
  859        , location (std::move (l))
 
  869#if 201103L <= YY_CPLUSPLUS 
  872        , value (std::move (v))
 
  873        , location (std::move (l))
 
  883#if 201103L <= YY_CPLUSPLUS 
  886        , value (std::move (v))
 
  887        , location (std::move (l))
 
  897#if 201103L <= YY_CPLUSPLUS 
  900        , value (std::move (v))
 
  901        , location (std::move (l))
 
  939        value.template destroy< ElementPtr > ();
 
  943        value.template destroy< bool > ();
 
  947        value.template destroy< double > ();
 
  951        value.template destroy< int64_t > ();
 
  955        value.template destroy< std::string > ();
 
 
  987#if YY_CPLUSPLUS < 201103L 
 
 1002#if 201103L <= YY_CPLUSPLUS 
 
 1046#if 201103L <= YY_CPLUSPLUS 
 1054#if !defined _MSC_VER || defined __clang__ 
 
 1059#if 201103L <= YY_CPLUSPLUS 
 1067#if !defined _MSC_VER || defined __clang__ 
 
 1071#if 201103L <= YY_CPLUSPLUS 
 1079#if !defined _MSC_VER || defined __clang__ 
 
 1083#if 201103L <= YY_CPLUSPLUS 
 1091#if !defined _MSC_VER || defined __clang__ 
 
 1095#if 201103L <= YY_CPLUSPLUS 
 1103#if !defined _MSC_VER || defined __clang__ 
 
 
 1113#if 201103L <= YY_CPLUSPLUS 
 1126    virtual int parse ();
 
 1132    void set_debug_stream (std::ostream &);
 
 1135    typedef 
int debug_level_type;
 
 1139    void set_debug_level (debug_level_type l);
 
 1145    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1148    void error (
const syntax_error& err);
 
 1152    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1155#if 201103L <= YY_CPLUSPLUS 
 1158      make_END (location_type l)
 
 1160        return symbol_type (token::TOKEN_END, std::move (l));
 
 1170#if 201103L <= YY_CPLUSPLUS 
 1173      make_AGENT_error (location_type l)
 
 1175        return symbol_type (token::TOKEN_AGENT_error, std::move (l));
 
 1185#if 201103L <= YY_CPLUSPLUS 
 1188      make_AGENT_UNDEF (location_type l)
 
 1190        return symbol_type (token::TOKEN_AGENT_UNDEF, std::move (l));
 
 1200#if 201103L <= YY_CPLUSPLUS 
 1203      make_COMMA (location_type l)
 
 1205        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1215#if 201103L <= YY_CPLUSPLUS 
 1218      make_COLON (location_type l)
 
 1220        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1230#if 201103L <= YY_CPLUSPLUS 
 1233      make_LSQUARE_BRACKET (location_type l)
 
 1235        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 1245#if 201103L <= YY_CPLUSPLUS 
 1248      make_RSQUARE_BRACKET (location_type l)
 
 1250        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 1260#if 201103L <= YY_CPLUSPLUS 
 1263      make_LCURLY_BRACKET (location_type l)
 
 1265        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 1275#if 201103L <= YY_CPLUSPLUS 
 1278      make_RCURLY_BRACKET (location_type l)
 
 1280        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 1290#if 201103L <= YY_CPLUSPLUS 
 1293      make_NULL_TYPE (location_type l)
 
 1295        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 1305#if 201103L <= YY_CPLUSPLUS 
 1308      make_CONTROL_AGENT (location_type l)
 
 1310        return symbol_type (token::TOKEN_CONTROL_AGENT, std::move (l));
 
 1320#if 201103L <= YY_CPLUSPLUS 
 1323      make_HTTP_HOST (location_type l)
 
 1325        return symbol_type (token::TOKEN_HTTP_HOST, std::move (l));
 
 1335#if 201103L <= YY_CPLUSPLUS 
 1338      make_HTTP_PORT (location_type l)
 
 1340        return symbol_type (token::TOKEN_HTTP_PORT, std::move (l));
 
 1350#if 201103L <= YY_CPLUSPLUS 
 1353      make_HTTP_HEADERS (location_type l)
 
 1355        return symbol_type (token::TOKEN_HTTP_HEADERS, std::move (l));
 
 1365#if 201103L <= YY_CPLUSPLUS 
 1368      make_USER_CONTEXT (location_type l)
 
 1370        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 1380#if 201103L <= YY_CPLUSPLUS 
 1383      make_COMMENT (location_type l)
 
 1385        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 1395#if 201103L <= YY_CPLUSPLUS 
 1398      make_NAME (location_type l)
 
 1400        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 1410#if 201103L <= YY_CPLUSPLUS 
 1413      make_VALUE (location_type l)
 
 1415        return symbol_type (token::TOKEN_VALUE, std::move (l));
 
 1425#if 201103L <= YY_CPLUSPLUS 
 1428      make_AUTHENTICATION (location_type l)
 
 1430        return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
 
 1440#if 201103L <= YY_CPLUSPLUS 
 1443      make_TYPE (location_type l)
 
 1445        return symbol_type (token::TOKEN_TYPE, std::move (l));
 
 1455#if 201103L <= YY_CPLUSPLUS 
 1458      make_BASIC (location_type l)
 
 1460        return symbol_type (token::TOKEN_BASIC, std::move (l));
 
 1470#if 201103L <= YY_CPLUSPLUS 
 1473      make_REALM (location_type l)
 
 1475        return symbol_type (token::TOKEN_REALM, std::move (l));
 
 1485#if 201103L <= YY_CPLUSPLUS 
 1488      make_DIRECTORY (location_type l)
 
 1490        return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
 
 1500#if 201103L <= YY_CPLUSPLUS 
 1503      make_CLIENTS (location_type l)
 
 1505        return symbol_type (token::TOKEN_CLIENTS, std::move (l));
 
 1515#if 201103L <= YY_CPLUSPLUS 
 1518      make_USER (location_type l)
 
 1520        return symbol_type (token::TOKEN_USER, std::move (l));
 
 1530#if 201103L <= YY_CPLUSPLUS 
 1533      make_USER_FILE (location_type l)
 
 1535        return symbol_type (token::TOKEN_USER_FILE, std::move (l));
 
 1545#if 201103L <= YY_CPLUSPLUS 
 1548      make_PASSWORD (location_type l)
 
 1550        return symbol_type (token::TOKEN_PASSWORD, std::move (l));
 
 1560#if 201103L <= YY_CPLUSPLUS 
 1563      make_PASSWORD_FILE (location_type l)
 
 1565        return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
 
 1575#if 201103L <= YY_CPLUSPLUS 
 1578      make_TRUST_ANCHOR (location_type l)
 
 1580        return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
 
 1590#if 201103L <= YY_CPLUSPLUS 
 1593      make_CERT_FILE (location_type l)
 
 1595        return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
 
 1605#if 201103L <= YY_CPLUSPLUS 
 1608      make_KEY_FILE (location_type l)
 
 1610        return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
 
 1620#if 201103L <= YY_CPLUSPLUS 
 1623      make_CERT_REQUIRED (location_type l)
 
 1625        return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
 
 1635#if 201103L <= YY_CPLUSPLUS 
 1638      make_CONTROL_SOCKETS (location_type l)
 
 1640        return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
 
 1650#if 201103L <= YY_CPLUSPLUS 
 1653      make_DHCP4_SERVER (location_type l)
 
 1655        return symbol_type (token::TOKEN_DHCP4_SERVER, std::move (l));
 
 1665#if 201103L <= YY_CPLUSPLUS 
 1668      make_DHCP6_SERVER (location_type l)
 
 1670        return symbol_type (token::TOKEN_DHCP6_SERVER, std::move (l));
 
 1680#if 201103L <= YY_CPLUSPLUS 
 1683      make_D2_SERVER (location_type l)
 
 1685        return symbol_type (token::TOKEN_D2_SERVER, std::move (l));
 
 1695#if 201103L <= YY_CPLUSPLUS 
 1698      make_SOCKET_NAME (location_type l)
 
 1700        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 1710#if 201103L <= YY_CPLUSPLUS 
 1713      make_SOCKET_TYPE (location_type l)
 
 1715        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 1725#if 201103L <= YY_CPLUSPLUS 
 1728      make_UNIX (location_type l)
 
 1730        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 1740#if 201103L <= YY_CPLUSPLUS 
 1743      make_HOOKS_LIBRARIES (location_type l)
 
 1745        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 1755#if 201103L <= YY_CPLUSPLUS 
 1758      make_LIBRARY (location_type l)
 
 1760        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 1770#if 201103L <= YY_CPLUSPLUS 
 1773      make_PARAMETERS (location_type l)
 
 1775        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 1785#if 201103L <= YY_CPLUSPLUS 
 1788      make_LOGGERS (location_type l)
 
 1790        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 1800#if 201103L <= YY_CPLUSPLUS 
 1803      make_OUTPUT_OPTIONS (location_type l)
 
 1805        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 1815#if 201103L <= YY_CPLUSPLUS 
 1818      make_OUTPUT (location_type l)
 
 1820        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 1830#if 201103L <= YY_CPLUSPLUS 
 1833      make_DEBUGLEVEL (location_type l)
 
 1835        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 1845#if 201103L <= YY_CPLUSPLUS 
 1848      make_SEVERITY (location_type l)
 
 1850        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 1860#if 201103L <= YY_CPLUSPLUS 
 1863      make_FLUSH (location_type l)
 
 1865        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 1875#if 201103L <= YY_CPLUSPLUS 
 1878      make_MAXSIZE (location_type l)
 
 1880        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 1890#if 201103L <= YY_CPLUSPLUS 
 1893      make_MAXVER (location_type l)
 
 1895        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 1905#if 201103L <= YY_CPLUSPLUS 
 1908      make_PATTERN (location_type l)
 
 1910        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 1920#if 201103L <= YY_CPLUSPLUS 
 1923      make_START_JSON (location_type l)
 
 1925        return symbol_type (token::TOKEN_START_JSON, std::move (l));
 
 1935#if 201103L <= YY_CPLUSPLUS 
 1938      make_START_AGENT (location_type l)
 
 1940        return symbol_type (token::TOKEN_START_AGENT, std::move (l));
 
 1950#if 201103L <= YY_CPLUSPLUS 
 1953      make_START_SUB_AGENT (location_type l)
 
 1955        return symbol_type (token::TOKEN_START_SUB_AGENT, std::move (l));
 
 1965#if 201103L <= YY_CPLUSPLUS 
 1968      make_STRING (std::string v, location_type l)
 
 1970        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 1980#if 201103L <= YY_CPLUSPLUS 
 1983      make_INTEGER (int64_t v, location_type l)
 
 1985        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 1995#if 201103L <= YY_CPLUSPLUS 
 1998      make_FLOAT (
double v, location_type l)
 
 2000        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 2010#if 201103L <= YY_CPLUSPLUS 
 2013      make_BOOLEAN (
bool v, location_type l)
 
 2015        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 2046#if YY_CPLUSPLUS < 201103L 
 2055    typedef short state_type;
 
 2058    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 2059                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 2063    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 2067    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 2071    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 2075    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 2077    static const short yypact_ninf_;
 
 2078    static const signed char yytable_ninf_;
 
 2083    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 2086    static std::string yytnamerr_ (
const char *yystr);
 
 2089    static const char* 
const yytname_[];
 
 2095    static const short yypact_[];
 
 2100    static const unsigned char yydefact_[];
 
 2103    static const short yypgoto_[];
 
 2106    static const short yydefgoto_[];
 
 2111    static const short yytable_[];
 
 2113    static const short yycheck_[];
 
 2117    static const unsigned char yystos_[];
 
 2120    static const unsigned char yyr1_[];
 
 2123    static const signed char yyr2_[];
 
 2128    static const short yyrline_[];
 
 2130    virtual void yy_reduce_print_ (
int r) 
const;
 
 2132    virtual void yy_stack_print_ () 
const;
 
 2137    std::ostream* yycdebug_;
 
 2142    template <
typename Base>
 
 2143    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 2150    template <
typename Base>
 
 2151    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 2161      typedef state_type kind_type;
 
 2173      void move (by_state& that);
 
 2181      enum { empty_state = 0 };
 
 2189    struct stack_symbol_type : basic_symbol<by_state>
 
 2192      typedef basic_symbol<by_state> super_type;
 
 2194      stack_symbol_type ();
 
 2196      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 2198      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 2199#if YY_CPLUSPLUS < 201103L 
 2202      stack_symbol_type& operator= (stack_symbol_type& that);
 
 2206      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 2211    template <
typename T, 
typename S = std::vector<T> >
 
 2216      typedef typename S::iterator iterator;
 
 2217      typedef typename S::const_iterator const_iterator;
 
 2218      typedef typename S::size_type size_type;
 
 2219      typedef typename std::ptrdiff_t index_type;
 
 2225#if 201103L <= YY_CPLUSPLUS 
 2227      stack (
const stack&) = 
delete;
 
 2229      stack& operator= (
const stack&) = 
delete;
 
 2236      operator[] (index_type i)
 const 
 2238        return seq_[size_type (size () - 1 - i)];
 
 2245      operator[] (index_type i)
 
 2247        return seq_[size_type (size () - 1 - i)];
 
 2256        seq_.push_back (T ());
 
 2257        operator[] (0).move (t);
 
 2279        return index_type (seq_.size ());
 
 2286        return seq_.begin ();
 
 2306        operator[] (index_type i)
 const 
 2308          return stack_[range_ - i];
 
 
 2312        const stack& stack_;
 
 
 2317#if YY_CPLUSPLUS < 201103L 
 2319      stack (
const stack&);
 
 2321      stack& operator= (
const stack&);
 
 2329    typedef stack<stack_symbol_type> stack_type;
 
 2332    stack_type yystack_;
 
 2339    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 2347    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 
 2376       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2377       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2378       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2379       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2380       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2381       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2382       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2383       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2384       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2385       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2386       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2387       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2388       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2389       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2390       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2391       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2392       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2393       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2394       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2395       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2396       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2397       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2398       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2399       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2400       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2401       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 
 2402       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 
 2403      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 
 2404      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 
 2405      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 
 2406      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
 
 2410    const int code_max = 312;
 
 2414    else if (t <= code_max)
 
 2421  template <
typename Base>
 
 2427    switch (this->kind ())
 
 
 2461  template <
typename Base>
 
 2465    return this->kind ();
 
 
 2469  template <
typename Base>
 
 2476  template <
typename Base>
 
 2480    super_type::move (s);
 
 2481    switch (this->kind ())
 
 
 2519#if 201103L <= YY_CPLUSPLUS 
 2522    : kind_ (that.kind_)
 
 2530    : 
kind_ (that.kind_)
 
 
 2535    : 
kind_ (yytranslate_ (t))
 
 
 2567    return this->
kind ();
 
 
 2571#line 14 "agent_parser.yy" 
 2573#line 2574 "agent_parser.h" 
Forward declaration of the ParserContext class.
#define YY_MOVE_REF(Type)
#define YY_ATTRIBUTE_PURE
context(const AgentParser &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.
T & emplace()
Instantiate an empty T in here.
void destroy()
Destroy the stored T.
void copy(const self_type &that)
Copy the content of that to this.
value_type(YY_RVREF(T) t)
Construct and fill.
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
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.
T & as() YY_NOEXCEPT
Accessor to a built T.
value_type self_type
Type of *this.
value_type() YY_NOEXCEPT
Empty construction.
void move(self_type &that)
Move the content of that to this.
long double yyalign_me_
Strongest alignment constraints.
T & emplace(const T &t)
Instantiate a T in here from t.
T & build(const T &t)
Instantiate a T in here from t.
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
T & build()
Instantiate an empty T in here.
static symbol_type make_D2_SERVER(const location_type &l)
static symbol_type make_PASSWORD_FILE(const location_type &l)
static symbol_type make_SOCKET_TYPE(const location_type &l)
static symbol_type make_HTTP_HOST(const location_type &l)
static symbol_type make_END(const location_type &l)
static symbol_type make_COMMENT(const location_type &l)
static symbol_type make_NULL_TYPE(const location_type &l)
static symbol_type make_AUTHENTICATION(const location_type &l)
value_type semantic_type
Backward compatibility (Bison 3.8).
static symbol_type make_CERT_FILE(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_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_COLON(const location_type &l)
AgentParser(isc::agent::ParserContext &ctx_yyarg)
Build a parser object.
static symbol_type make_BASIC(const location_type &l)
static symbol_type make_PATTERN(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_FLOAT(const double &v, const location_type &l)
static symbol_type make_STRING(const std::string &v, const location_type &l)
static symbol_type make_LOGGERS(const location_type &l)
static symbol_type make_SOCKET_NAME(const location_type &l)
location location_type
Symbol locations.
static symbol_type make_CONTROL_AGENT(const location_type &l)
static symbol_type make_AGENT_error(const location_type &l)
static symbol_type make_RCURLY_BRACKET(const location_type &l)
static symbol_type make_HTTP_HEADERS(const location_type &l)
static symbol_type make_DEBUGLEVEL(const location_type &l)
static symbol_type make_START_AGENT(const location_type &l)
static symbol_type make_LCURLY_BRACKET(const location_type &l)
static symbol_type make_FLUSH(const location_type &l)
static symbol_type make_CERT_REQUIRED(const location_type &l)
static symbol_type make_MAXVER(const location_type &l)
static symbol_type make_PASSWORD(const location_type &l)
static symbol_type make_START_JSON(const location_type &l)
static symbol_type make_CONTROL_SOCKETS(const location_type &l)
by_kind by_type
Backward compatibility for a private implementation detail (Bison 3.6).
static symbol_type make_NAME(const location_type &l)
static symbol_type make_COMMA(const location_type &l)
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
static const symbol_kind_type YYNTOKENS
The number of tokens.
static symbol_type make_OUTPUT(const location_type &l)
static symbol_type make_CLIENTS(const location_type &l)
static symbol_type make_DHCP4_SERVER(const location_type &l)
static symbol_type make_DHCP6_SERVER(const location_type &l)
static symbol_type make_REALM(const location_type &l)
static symbol_type make_TRUST_ANCHOR(const location_type &l)
static symbol_type make_HTTP_PORT(const location_type &l)
static symbol_type make_PARAMETERS(const location_type &l)
static symbol_type make_SEVERITY(const location_type &l)
static symbol_type make_USER(const location_type &l)
static symbol_type make_USER_FILE(const location_type &l)
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
static symbol_type make_LIBRARY(const location_type &l)
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
static symbol_type make_KEY_FILE(const location_type &l)
static symbol_type make_AGENT_UNDEF(const location_type &l)
static symbol_type make_START_SUB_AGENT(const location_type &l)
static symbol_type make_DIRECTORY(const location_type &l)
static symbol_type make_VALUE(const location_type &l)
static symbol_type make_UNIX(const location_type &l)
static symbol_type make_MAXSIZE(const location_type &l)
static symbol_type make_USER_CONTEXT(const location_type &l)
static symbol_type make_TYPE(const location_type &l)
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
Parser context is a wrapper around flex/bison instances dedicated to Control-agent config file parser...
boost::shared_ptr< Element > ElementPtr
Defines the logger used by the top-level component of kea-lfc.
Base super_type
Alias to Base.
basic_symbol(const basic_symbol &that)
Copy constructor.
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
basic_symbol() YY_NOEXCEPT
Default constructor.
void move(basic_symbol &s)
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
bool empty() const YY_NOEXCEPT
~basic_symbol()
Destroy the symbol.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
Type access provider for token (enum) based symbols.
by_kind() YY_NOEXCEPT
Default constructor.
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
token_kind_type kind_type
The symbol kind as needed by the constructor.
symbol_kind_type kind_
The symbol kind.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
void clear() YY_NOEXCEPT
Record that this symbol is empty.
void move(by_kind &that)
Steal the symbol kind from that.
@ S_not_empty_clients_list
@ S_output_options_list_content
@ S_not_empty_http_header_list
@ YYNTOKENS
Number of tokens.
@ S_control_socket_params
@ S_control_sockets_params
@ S_not_empty_hooks_libraries_list
"External" symbols: returned by the scanner.
symbol_type() YY_NOEXCEPT
Empty symbol.
basic_symbol< by_kind > super_type
Superclass.
~syntax_error() YY_NOEXCEPT YY_NOTHROW
syntax_error(const syntax_error &s)
syntax_error(const location_type &l, const std::string &m)
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).