45#ifndef YY_EVAL_PARSER_H_INCLUDED 
   46# define YY_EVAL_PARSER_H_INCLUDED 
   54#include <boost/lexical_cast.hpp> 
   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 EVAL_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) 
  207namespace isc { 
namespace eval {
 
  219#  pragma GCC message "bison: do not #define EVALSTYPE 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);
 
  443      char dummy6[
sizeof (int8_t)];
 
  450      char dummy7[
sizeof (std::string)];
 
  454      char dummy8[
sizeof (uint16_t)];
 
  458      char dummy9[
sizeof (uint32_t)];
 
  462    enum { size = 
sizeof (union_type) };
 
  474    const std::type_info *yytypeid_;
 
 
  488        : std::runtime_error (m)
 
 
  493        : std::runtime_error (s.what ())
 
 
 
  703    template <
typename Base>
 
  715#if 201103L <= YY_CPLUSPLUS 
  718        : Base (std::move (that))
 
  720        , location (std::move (that.location))
 
  722        switch (this->kind ())
 
  745        value.move< int8_t > (std::move (that.value));
 
  753        value.move< std::string > (std::move (that.value));
 
  758        value.move< uint16_t > (std::move (that.value));
 
  763        value.move< uint32_t > (std::move (that.value));
 
  777#if 201103L <= YY_CPLUSPLUS 
  789#if 201103L <= YY_CPLUSPLUS 
  792        , value (std::move (v))
 
  793        , location (std::move (l))
 
  803#if 201103L <= YY_CPLUSPLUS 
  806        , value (std::move (v))
 
  807        , location (std::move (l))
 
  817#if 201103L <= YY_CPLUSPLUS 
  820        , value (std::move (v))
 
  821        , location (std::move (l))
 
  831#if 201103L <= YY_CPLUSPLUS 
  834        , value (std::move (v))
 
  835        , location (std::move (l))
 
  845#if 201103L <= YY_CPLUSPLUS 
  848        , value (std::move (v))
 
  849        , location (std::move (l))
 
  859#if 201103L <= YY_CPLUSPLUS 
  862        , value (std::move (v))
 
  863        , location (std::move (l))
 
  873#if 201103L <= YY_CPLUSPLUS 
  876        , value (std::move (v))
 
  877        , location (std::move (l))
 
  887#if 201103L <= YY_CPLUSPLUS 
  890        , value (std::move (v))
 
  891        , location (std::move (l))
 
  901#if 201103L <= YY_CPLUSPLUS 
  904        , value (std::move (v))
 
  905        , location (std::move (l))
 
  940        value.template destroy< TokenOption::RepresentationType > ();
 
  944        value.template destroy< TokenPkt4::FieldType > ();
 
  948        value.template destroy< TokenPkt6::FieldType > ();
 
  952        value.template destroy< TokenPkt::MetadataType > ();
 
  956        value.template destroy< TokenRelay6Field::FieldType > ();
 
  960        value.template destroy< int8_t > ();
 
  968        value.template destroy< std::string > ();
 
  973        value.template destroy< uint16_t > ();
 
  978        value.template destroy< uint32_t > ();
 
 
 1010#if YY_CPLUSPLUS < 201103L 
 
 1025#if 201103L <= YY_CPLUSPLUS 
 
 1069#if 201103L <= YY_CPLUSPLUS 
 1077#if !defined _MSC_VER || defined __clang__ 
 
 1082#if 201103L <= YY_CPLUSPLUS 
 1090#if !defined _MSC_VER || defined __clang__ 
 
 
 1100#if 201103L <= YY_CPLUSPLUS 
 1113    virtual int parse ();
 
 1119    void set_debug_stream (std::ostream &);
 
 1122    typedef 
int debug_level_type;
 
 1126    void set_debug_level (debug_level_type l);
 
 1132    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1135    void error (
const syntax_error& err);
 
 1139    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1142#if 201103L <= YY_CPLUSPLUS 
 1145      make_END (location_type l)
 
 1147        return symbol_type (token::TOKEN_END, std::move (l));
 
 1157#if 201103L <= YY_CPLUSPLUS 
 1160      make_EVALerror (location_type l)
 
 1162        return symbol_type (token::TOKEN_EVALerror, std::move (l));
 
 1172#if 201103L <= YY_CPLUSPLUS 
 1175      make_EVALUNDEF (location_type l)
 
 1177        return symbol_type (token::TOKEN_EVALUNDEF, std::move (l));
 
 1187#if 201103L <= YY_CPLUSPLUS 
 1190      make_LPAREN (location_type l)
 
 1192        return symbol_type (token::TOKEN_LPAREN, std::move (l));
 
 1202#if 201103L <= YY_CPLUSPLUS 
 1205      make_RPAREN (location_type l)
 
 1207        return symbol_type (token::TOKEN_RPAREN, std::move (l));
 
 1217#if 201103L <= YY_CPLUSPLUS 
 1220      make_NOT (location_type l)
 
 1222        return symbol_type (token::TOKEN_NOT, std::move (l));
 
 1232#if 201103L <= YY_CPLUSPLUS 
 1235      make_AND (location_type l)
 
 1237        return symbol_type (token::TOKEN_AND, std::move (l));
 
 1247#if 201103L <= YY_CPLUSPLUS 
 1250      make_SAND (location_type l)
 
 1252        return symbol_type (token::TOKEN_SAND, std::move (l));
 
 1262#if 201103L <= YY_CPLUSPLUS 
 1265      make_OR (location_type l)
 
 1267        return symbol_type (token::TOKEN_OR, std::move (l));
 
 1277#if 201103L <= YY_CPLUSPLUS 
 1280      make_SOR (location_type l)
 
 1282        return symbol_type (token::TOKEN_SOR, std::move (l));
 
 1292#if 201103L <= YY_CPLUSPLUS 
 1295      make_EQUAL (location_type l)
 
 1297        return symbol_type (token::TOKEN_EQUAL, std::move (l));
 
 1307#if 201103L <= YY_CPLUSPLUS 
 1310      make_OPTION (location_type l)
 
 1312        return symbol_type (token::TOKEN_OPTION, std::move (l));
 
 1322#if 201103L <= YY_CPLUSPLUS 
 1325      make_RELAY4 (location_type l)
 
 1327        return symbol_type (token::TOKEN_RELAY4, std::move (l));
 
 1337#if 201103L <= YY_CPLUSPLUS 
 1340      make_RELAY6 (location_type l)
 
 1342        return symbol_type (token::TOKEN_RELAY6, std::move (l));
 
 1352#if 201103L <= YY_CPLUSPLUS 
 1355      make_MEMBER (location_type l)
 
 1357        return symbol_type (token::TOKEN_MEMBER, std::move (l));
 
 1367#if 201103L <= YY_CPLUSPLUS 
 1370      make_PEERADDR (location_type l)
 
 1372        return symbol_type (token::TOKEN_PEERADDR, std::move (l));
 
 1382#if 201103L <= YY_CPLUSPLUS 
 1385      make_LINKADDR (location_type l)
 
 1387        return symbol_type (token::TOKEN_LINKADDR, std::move (l));
 
 1397#if 201103L <= YY_CPLUSPLUS 
 1400      make_LBRACKET (location_type l)
 
 1402        return symbol_type (token::TOKEN_LBRACKET, std::move (l));
 
 1412#if 201103L <= YY_CPLUSPLUS 
 1415      make_RBRACKET (location_type l)
 
 1417        return symbol_type (token::TOKEN_RBRACKET, std::move (l));
 
 1427#if 201103L <= YY_CPLUSPLUS 
 1430      make_DOT (location_type l)
 
 1432        return symbol_type (token::TOKEN_DOT, std::move (l));
 
 1442#if 201103L <= YY_CPLUSPLUS 
 1445      make_TEXT (location_type l)
 
 1447        return symbol_type (token::TOKEN_TEXT, std::move (l));
 
 1457#if 201103L <= YY_CPLUSPLUS 
 1460      make_HEX (location_type l)
 
 1462        return symbol_type (token::TOKEN_HEX, std::move (l));
 
 1472#if 201103L <= YY_CPLUSPLUS 
 1475      make_EXISTS (location_type l)
 
 1477        return symbol_type (token::TOKEN_EXISTS, std::move (l));
 
 1487#if 201103L <= YY_CPLUSPLUS 
 1490      make_PKT (location_type l)
 
 1492        return symbol_type (token::TOKEN_PKT, std::move (l));
 
 1502#if 201103L <= YY_CPLUSPLUS 
 1505      make_IFACE (location_type l)
 
 1507        return symbol_type (token::TOKEN_IFACE, std::move (l));
 
 1517#if 201103L <= YY_CPLUSPLUS 
 1520      make_SRC (location_type l)
 
 1522        return symbol_type (token::TOKEN_SRC, std::move (l));
 
 1532#if 201103L <= YY_CPLUSPLUS 
 1535      make_DST (location_type l)
 
 1537        return symbol_type (token::TOKEN_DST, std::move (l));
 
 1547#if 201103L <= YY_CPLUSPLUS 
 1550      make_LEN (location_type l)
 
 1552        return symbol_type (token::TOKEN_LEN, std::move (l));
 
 1562#if 201103L <= YY_CPLUSPLUS 
 1565      make_PKT4 (location_type l)
 
 1567        return symbol_type (token::TOKEN_PKT4, std::move (l));
 
 1577#if 201103L <= YY_CPLUSPLUS 
 1580      make_CHADDR (location_type l)
 
 1582        return symbol_type (token::TOKEN_CHADDR, std::move (l));
 
 1592#if 201103L <= YY_CPLUSPLUS 
 1595      make_HLEN (location_type l)
 
 1597        return symbol_type (token::TOKEN_HLEN, std::move (l));
 
 1607#if 201103L <= YY_CPLUSPLUS 
 1610      make_HTYPE (location_type l)
 
 1612        return symbol_type (token::TOKEN_HTYPE, std::move (l));
 
 1622#if 201103L <= YY_CPLUSPLUS 
 1625      make_CIADDR (location_type l)
 
 1627        return symbol_type (token::TOKEN_CIADDR, std::move (l));
 
 1637#if 201103L <= YY_CPLUSPLUS 
 1640      make_GIADDR (location_type l)
 
 1642        return symbol_type (token::TOKEN_GIADDR, std::move (l));
 
 1652#if 201103L <= YY_CPLUSPLUS 
 1655      make_YIADDR (location_type l)
 
 1657        return symbol_type (token::TOKEN_YIADDR, std::move (l));
 
 1667#if 201103L <= YY_CPLUSPLUS 
 1670      make_SIADDR (location_type l)
 
 1672        return symbol_type (token::TOKEN_SIADDR, std::move (l));
 
 1682#if 201103L <= YY_CPLUSPLUS 
 1685      make_SUBSTRING (location_type l)
 
 1687        return symbol_type (token::TOKEN_SUBSTRING, std::move (l));
 
 1697#if 201103L <= YY_CPLUSPLUS 
 1700      make_SPLIT (location_type l)
 
 1702        return symbol_type (token::TOKEN_SPLIT, std::move (l));
 
 1712#if 201103L <= YY_CPLUSPLUS 
 1715      make_ALL (location_type l)
 
 1717        return symbol_type (token::TOKEN_ALL, std::move (l));
 
 1727#if 201103L <= YY_CPLUSPLUS 
 1730      make_COMA (location_type l)
 
 1732        return symbol_type (token::TOKEN_COMA, std::move (l));
 
 1742#if 201103L <= YY_CPLUSPLUS 
 1745      make_CONCAT (location_type l)
 
 1747        return symbol_type (token::TOKEN_CONCAT, std::move (l));
 
 1757#if 201103L <= YY_CPLUSPLUS 
 1760      make_PLUS (location_type l)
 
 1762        return symbol_type (token::TOKEN_PLUS, std::move (l));
 
 1772#if 201103L <= YY_CPLUSPLUS 
 1775      make_IFELSE (location_type l)
 
 1777        return symbol_type (token::TOKEN_IFELSE, std::move (l));
 
 1787#if 201103L <= YY_CPLUSPLUS 
 1790      make_SIFELSE (location_type l)
 
 1792        return symbol_type (token::TOKEN_SIFELSE, std::move (l));
 
 1802#if 201103L <= YY_CPLUSPLUS 
 1805      make_TOHEXSTRING (location_type l)
 
 1807        return symbol_type (token::TOKEN_TOHEXSTRING, std::move (l));
 
 1817#if 201103L <= YY_CPLUSPLUS 
 1820      make_ADDRTOTEXT (location_type l)
 
 1822        return symbol_type (token::TOKEN_ADDRTOTEXT, std::move (l));
 
 1832#if 201103L <= YY_CPLUSPLUS 
 1835      make_INT8TOTEXT (location_type l)
 
 1837        return symbol_type (token::TOKEN_INT8TOTEXT, std::move (l));
 
 1847#if 201103L <= YY_CPLUSPLUS 
 1850      make_INT16TOTEXT (location_type l)
 
 1852        return symbol_type (token::TOKEN_INT16TOTEXT, std::move (l));
 
 1862#if 201103L <= YY_CPLUSPLUS 
 1865      make_INT32TOTEXT (location_type l)
 
 1867        return symbol_type (token::TOKEN_INT32TOTEXT, std::move (l));
 
 1877#if 201103L <= YY_CPLUSPLUS 
 1880      make_UINT8TOTEXT (location_type l)
 
 1882        return symbol_type (token::TOKEN_UINT8TOTEXT, std::move (l));
 
 1892#if 201103L <= YY_CPLUSPLUS 
 1895      make_UINT16TOTEXT (location_type l)
 
 1897        return symbol_type (token::TOKEN_UINT16TOTEXT, std::move (l));
 
 1907#if 201103L <= YY_CPLUSPLUS 
 1910      make_UINT32TOTEXT (location_type l)
 
 1912        return symbol_type (token::TOKEN_UINT32TOTEXT, std::move (l));
 
 1922#if 201103L <= YY_CPLUSPLUS 
 1925      make_LCASE (location_type l)
 
 1927        return symbol_type (token::TOKEN_LCASE, std::move (l));
 
 1937#if 201103L <= YY_CPLUSPLUS 
 1940      make_UCASE (location_type l)
 
 1942        return symbol_type (token::TOKEN_UCASE, std::move (l));
 
 1952#if 201103L <= YY_CPLUSPLUS 
 1955      make_PKT6 (location_type l)
 
 1957        return symbol_type (token::TOKEN_PKT6, std::move (l));
 
 1967#if 201103L <= YY_CPLUSPLUS 
 1970      make_MSGTYPE (location_type l)
 
 1972        return symbol_type (token::TOKEN_MSGTYPE, std::move (l));
 
 1982#if 201103L <= YY_CPLUSPLUS 
 1985      make_TRANSID (location_type l)
 
 1987        return symbol_type (token::TOKEN_TRANSID, std::move (l));
 
 1997#if 201103L <= YY_CPLUSPLUS 
 2000      make_VENDOR_CLASS (location_type l)
 
 2002        return symbol_type (token::TOKEN_VENDOR_CLASS, std::move (l));
 
 2012#if 201103L <= YY_CPLUSPLUS 
 2015      make_VENDOR (location_type l)
 
 2017        return symbol_type (token::TOKEN_VENDOR, std::move (l));
 
 2027#if 201103L <= YY_CPLUSPLUS 
 2030      make_ANY (location_type l)
 
 2032        return symbol_type (token::TOKEN_ANY, std::move (l));
 
 2042#if 201103L <= YY_CPLUSPLUS 
 2045      make_DATA (location_type l)
 
 2047        return symbol_type (token::TOKEN_DATA, std::move (l));
 
 2057#if 201103L <= YY_CPLUSPLUS 
 2060      make_ENTERPRISE (location_type l)
 
 2062        return symbol_type (token::TOKEN_ENTERPRISE, std::move (l));
 
 2072#if 201103L <= YY_CPLUSPLUS 
 2075      make_MATCH (location_type l)
 
 2077        return symbol_type (token::TOKEN_MATCH, std::move (l));
 
 2087#if 201103L <= YY_CPLUSPLUS 
 2090      make_TOPLEVEL_BOOL (location_type l)
 
 2092        return symbol_type (token::TOKEN_TOPLEVEL_BOOL, std::move (l));
 
 2102#if 201103L <= YY_CPLUSPLUS 
 2105      make_TOPLEVEL_STRING (location_type l)
 
 2107        return symbol_type (token::TOKEN_TOPLEVEL_STRING, std::move (l));
 
 2117#if 201103L <= YY_CPLUSPLUS 
 2120      make_STRING (std::string v, location_type l)
 
 2122        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 2132#if 201103L <= YY_CPLUSPLUS 
 2135      make_INTEGER (std::string v, location_type l)
 
 2137        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 2147#if 201103L <= YY_CPLUSPLUS 
 2150      make_HEXSTRING (std::string v, location_type l)
 
 2152        return symbol_type (token::TOKEN_HEXSTRING, std::move (v), std::move (l));
 
 2162#if 201103L <= YY_CPLUSPLUS 
 2165      make_OPTION_NAME (std::string v, location_type l)
 
 2167        return symbol_type (token::TOKEN_OPTION_NAME, std::move (v), std::move (l));
 
 2177#if 201103L <= YY_CPLUSPLUS 
 2180      make_IP_ADDRESS (std::string v, location_type l)
 
 2182        return symbol_type (token::TOKEN_IP_ADDRESS, std::move (v), std::move (l));
 
 2213#if YY_CPLUSPLUS < 201103L 
 2222    typedef short state_type;
 
 2225    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 2226                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 2230    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 2234    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 2238    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 2242    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 2244    static const short yypact_ninf_;
 
 2245    static const signed char yytable_ninf_;
 
 2250    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 2253    static std::string yytnamerr_ (
const char *yystr);
 
 2256    static const char* 
const yytname_[];
 
 2262    static const short yypact_[];
 
 2267    static const signed char yydefact_[];
 
 2270    static const short yypgoto_[];
 
 2273    static const unsigned char yydefgoto_[];
 
 2278    static const short yytable_[];
 
 2280    static const short yycheck_[];
 
 2284    static const signed char yystos_[];
 
 2287    static const signed char yyr1_[];
 
 2290    static const signed char yyr2_[];
 
 2295    static const short yyrline_[];
 
 2297    virtual void yy_reduce_print_ (
int r) 
const;
 
 2299    virtual void yy_stack_print_ () 
const;
 
 2304    std::ostream* yycdebug_;
 
 2309    template <
typename Base>
 
 2310    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 2317    template <
typename Base>
 
 2318    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 2328      typedef state_type kind_type;
 
 2340      void move (by_state& that);
 
 2348      enum { empty_state = 0 };
 
 2356    struct stack_symbol_type : basic_symbol<by_state>
 
 2359      typedef basic_symbol<by_state> super_type;
 
 2361      stack_symbol_type ();
 
 2363      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 2365      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 2366#if YY_CPLUSPLUS < 201103L 
 2369      stack_symbol_type& operator= (stack_symbol_type& that);
 
 2373      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 2378    template <
typename T, 
typename S = std::vector<T> >
 
 2383      typedef typename S::iterator iterator;
 
 2384      typedef typename S::const_iterator const_iterator;
 
 2385      typedef typename S::size_type size_type;
 
 2386      typedef typename std::ptrdiff_t index_type;
 
 2392#if 201103L <= YY_CPLUSPLUS 
 2394      stack (
const stack&) = 
delete;
 
 2396      stack& operator= (
const stack&) = 
delete;
 
 2403      operator[] (index_type i)
 const 
 2405        return seq_[size_type (size () - 1 - i)];
 
 2412      operator[] (index_type i)
 
 2414        return seq_[size_type (size () - 1 - i)];
 
 2423        seq_.push_back (T ());
 
 2424        operator[] (0).move (t);
 
 2446        return index_type (seq_.size ());
 
 2453        return seq_.begin ();
 
 2473        operator[] (index_type i)
 const 
 2475          return stack_[range_ - i];
 
 
 2479        const stack& stack_;
 
 
 2484#if YY_CPLUSPLUS < 201103L 
 2486      stack (
const stack&);
 
 2488      stack& operator= (
const stack&);
 
 2496    typedef stack<stack_symbol_type> stack_type;
 
 2499    stack_type yystack_;
 
 2506    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 2514    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 
 2543       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2544       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2545       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2546       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2547       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2548       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2549       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2550       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2551       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2552       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2553       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2554       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2555       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2556       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2557       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2558       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2559       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2560       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2561       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2562       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2563       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2564       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2565       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2566       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2567       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 
 2568       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 
 2569       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 
 2570      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 
 2571      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 
 2572      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 
 2573      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
 
 2574      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
 
 2578    const int code_max = 324;
 
 2582    else if (t <= code_max)
 
 2589  template <
typename Base>
 
 2595    switch (this->kind ())
 
 
 2648  template <
typename Base>
 
 2652    return this->kind ();
 
 
 2656  template <
typename Base>
 
 2663  template <
typename Base>
 
 2667    super_type::move (s);
 
 2668    switch (this->kind ())
 
 
 2725#if 201103L <= YY_CPLUSPLUS 
 2728    : kind_ (that.kind_)
 
 2736    : 
kind_ (that.kind_)
 
 
 2741    : 
kind_ (yytranslate_ (t))
 
 
 2773    return this->
kind ();
 
 
 2779#line 2780 "parser.h" 
#define YY_MOVE_REF(Type)
#define YY_ATTRIBUTE_PURE
RepresentationType
Token representation type.
FieldType
enum value that determines the field.
FieldType
enum value that determines the field.
MetadataType
enum value that determines the field.
FieldType
enum value that determines the field.
Evaluation context, an interface to the expression evaluation.
const location_type & location() const YY_NOEXCEPT
const symbol_type & lookahead() const YY_NOEXCEPT
context(const EvalParser &yyparser, const symbol_type &yyla)
symbol_kind_type token() const YY_NOEXCEPT
slice(const stack &stack, index_type range) YY_NOEXCEPT
A buffer to store and retrieve objects.
T & emplace(const T &t)
Instantiate a T in here from t.
T & as() YY_NOEXCEPT
Accessor to a built T.
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.
long double yyalign_me_
Strongest alignment constraints.
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
T & build()
Instantiate an empty T in here.
void copy(const self_type &that)
Copy the content of that to this.
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
void destroy()
Destroy the stored T.
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
T & emplace()
Instantiate an empty T in here.
char yyraw_[size]
A buffer large enough to store any of the semantic values.
value_type() YY_NOEXCEPT
Empty construction.
value_type self_type
Type of *this.
static symbol_type make_RELAY6(const location_type &l)
static symbol_type make_INT8TOTEXT(const location_type &l)
static symbol_type make_CONCAT(const location_type &l)
static symbol_type make_TEXT(const location_type &l)
static symbol_type make_OPTION(const location_type &l)
static symbol_type make_AND(const location_type &l)
static symbol_type make_HTYPE(const location_type &l)
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
static symbol_type make_MSGTYPE(const location_type &l)
static symbol_type make_LINKADDR(const location_type &l)
static symbol_type make_TOHEXSTRING(const location_type &l)
static symbol_type make_EVALerror(const location_type &l)
static symbol_type make_PKT6(const location_type &l)
static symbol_type make_END(const location_type &l)
static symbol_type make_DST(const location_type &l)
static symbol_type make_OR(const location_type &l)
static symbol_type make_PLUS(const location_type &l)
static symbol_type make_RBRACKET(const location_type &l)
static symbol_type make_NOT(const location_type &l)
static symbol_type make_INT32TOTEXT(const location_type &l)
static symbol_type make_SIADDR(const location_type &l)
static symbol_type make_PKT4(const location_type &l)
static symbol_type make_SOR(const location_type &l)
static symbol_type make_IP_ADDRESS(const std::string &v, const location_type &l)
static symbol_type make_UINT16TOTEXT(const location_type &l)
static symbol_type make_STRING(const std::string &v, const location_type &l)
static symbol_type make_TOPLEVEL_BOOL(const location_type &l)
static symbol_type make_LPAREN(const location_type &l)
static symbol_type make_TOPLEVEL_STRING(const location_type &l)
static symbol_type make_GIADDR(const location_type &l)
static symbol_type make_MATCH(const location_type &l)
static symbol_type make_DATA(const location_type &l)
static symbol_type make_CHADDR(const location_type &l)
static symbol_type make_INT16TOTEXT(const location_type &l)
static symbol_type make_LBRACKET(const location_type &l)
static symbol_type make_LEN(const location_type &l)
static symbol_type make_IFACE(const location_type &l)
static symbol_type make_SAND(const location_type &l)
static symbol_type make_ANY(const location_type &l)
static symbol_type make_DOT(const location_type &l)
by_kind by_type
Backward compatibility for a private implementation detail (Bison 3.6).
static symbol_type make_HLEN(const location_type &l)
static symbol_type make_ALL(const location_type &l)
static symbol_type make_UCASE(const location_type &l)
static symbol_type make_COMA(const location_type &l)
static symbol_type make_IFELSE(const location_type &l)
location location_type
Symbol locations.
static symbol_type make_YIADDR(const location_type &l)
static symbol_type make_SRC(const location_type &l)
static symbol_type make_INTEGER(const std::string &v, const location_type &l)
static symbol_type make_EQUAL(const location_type &l)
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
static symbol_type make_EXISTS(const location_type &l)
static symbol_type make_TRANSID(const location_type &l)
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
static symbol_type make_SIFELSE(const location_type &l)
static symbol_type make_ADDRTOTEXT(const location_type &l)
static symbol_type make_LCASE(const location_type &l)
static symbol_type make_RELAY4(const location_type &l)
static symbol_type make_PKT(const location_type &l)
static symbol_type make_CIADDR(const location_type &l)
static symbol_type make_HEXSTRING(const std::string &v, const location_type &l)
static symbol_type make_EVALUNDEF(const location_type &l)
static symbol_type make_OPTION_NAME(const std::string &v, const location_type &l)
static symbol_type make_MEMBER(const location_type &l)
static symbol_type make_UINT32TOTEXT(const location_type &l)
EvalParser(EvalContext &ctx_yyarg)
Build a parser object.
static symbol_type make_SPLIT(const location_type &l)
static symbol_type make_ENTERPRISE(const location_type &l)
static symbol_type make_VENDOR(const location_type &l)
value_type semantic_type
Backward compatibility (Bison 3.8).
static symbol_type make_RPAREN(const location_type &l)
static symbol_type make_PEERADDR(const location_type &l)
static const symbol_kind_type YYNTOKENS
The number of tokens.
static symbol_type make_SUBSTRING(const location_type &l)
static symbol_type make_VENDOR_CLASS(const location_type &l)
static symbol_type make_HEX(const location_type &l)
static symbol_type make_UINT8TOTEXT(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.
Forward declaration of the EvalContext class.
Defines the logger used by the top-level component of kea-lfc.
void move(basic_symbol &s)
basic_symbol(const basic_symbol &that)
Copy constructor.
Base super_type
Alias to Base.
basic_symbol(typename Base::kind_type t, const TokenPkt4::FieldType &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const uint32_t &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const TokenPkt6::FieldType &v, const location_type &l)
~basic_symbol()
Destroy the symbol.
bool empty() const YY_NOEXCEPT
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
basic_symbol(typename Base::kind_type t, const uint16_t &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const TokenPkt::MetadataType &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 TokenOption::RepresentationType &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
basic_symbol() YY_NOEXCEPT
Default constructor.
basic_symbol(typename Base::kind_type t, const TokenRelay6Field::FieldType &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 int8_t &v, const location_type &l)
Type access provider for token (enum) based symbols.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
token_kind_type kind_type
The symbol kind as needed by the constructor.
by_kind() YY_NOEXCEPT
Default constructor.
symbol_kind_type kind_
The symbol kind.
void clear() YY_NOEXCEPT
Record that this symbol is empty.
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.
@ YYNTOKENS
Number of tokens.
"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(const syntax_error &s)
~syntax_error() YY_NOEXCEPT YY_NOTHROW
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).