diff options
Diffstat (limited to '')
| -rw-r--r-- | src/lib/eval/parser.cc | 2227 |
1 files changed, 2227 insertions, 0 deletions
diff --git a/src/lib/eval/parser.cc b/src/lib/eval/parser.cc new file mode 100644 index 0000000..e73d694 --- /dev/null +++ b/src/lib/eval/parser.cc @@ -0,0 +1,2227 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Skeleton implementation for Bison LALR(1) parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <https://www.gnu.org/licenses/>. + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. + + +// Take the name prefix into account. +#define yylex evallex + + + +#include "parser.h" + + +// Unqualified %code blocks. +#line 33 "parser.yy" + +# include "eval_context.h" + +// Avoid warnings with the error counter. +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif + +#line 57 "parser.cc" + + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE. +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (false) +# endif + + +// Enable debugging if requested. +#if EVALDEBUG + +// A pseudo ostream that takes yydebug_ into account. +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ + } while (false) + +# define YY_STACK_PRINT() \ + do { \ + if (yydebug_) \ + yy_stack_print_ (); \ + } while (false) + +#else // !EVALDEBUG + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) +# define YY_REDUCE_PRINT(Rule) static_cast<void> (0) +# define YY_STACK_PRINT() static_cast<void> (0) + +#endif // !EVALDEBUG + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yyla.clear ()) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +#line 14 "parser.yy" +namespace isc { namespace eval { +#line 150 "parser.cc" + + /// Build a parser object. + EvalParser::EvalParser (EvalContext& ctx_yyarg) +#if EVALDEBUG + : yydebug_ (false), + yycdebug_ (&std::cerr), +#else + : +#endif + ctx (ctx_yyarg) + {} + + EvalParser::~EvalParser () + {} + + EvalParser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + /*---------. + | symbol. | + `---------*/ + + + + // by_state. + EvalParser::by_state::by_state () YY_NOEXCEPT + : state (empty_state) + {} + + EvalParser::by_state::by_state (const by_state& that) YY_NOEXCEPT + : state (that.state) + {} + + void + EvalParser::by_state::clear () YY_NOEXCEPT + { + state = empty_state; + } + + void + EvalParser::by_state::move (by_state& that) + { + state = that.state; + that.clear (); + } + + EvalParser::by_state::by_state (state_type s) YY_NOEXCEPT + : state (s) + {} + + EvalParser::symbol_kind_type + EvalParser::by_state::kind () const YY_NOEXCEPT + { + if (state == empty_state) + return symbol_kind::S_YYEMPTY; + else + return YY_CAST (symbol_kind_type, yystos_[+state]); + } + + EvalParser::stack_symbol_type::stack_symbol_type () + {} + + EvalParser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) + : super_type (YY_MOVE (that.state), YY_MOVE (that.location)) + { + switch (that.kind ()) + { + case symbol_kind::S_option_repr_type: // option_repr_type + value.YY_MOVE_OR_COPY< TokenOption::RepresentationType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_pkt4_field: // pkt4_field + value.YY_MOVE_OR_COPY< TokenPkt4::FieldType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_pkt6_field: // pkt6_field + value.YY_MOVE_OR_COPY< TokenPkt6::FieldType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_pkt_metadata: // pkt_metadata + value.YY_MOVE_OR_COPY< TokenPkt::MetadataType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_relay6_field: // relay6_field + value.YY_MOVE_OR_COPY< TokenRelay6Field::FieldType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_nest_level: // nest_level + value.YY_MOVE_OR_COPY< int8_t > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_STRING: // "constant string" + case symbol_kind::S_INTEGER: // "integer" + case symbol_kind::S_HEXSTRING: // "constant hexstring" + case symbol_kind::S_OPTION_NAME: // "option name" + case symbol_kind::S_IP_ADDRESS: // "ip address" + value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_option_code: // option_code + case symbol_kind::S_sub_option_code: // sub_option_code + value.YY_MOVE_OR_COPY< uint16_t > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_integer_expr: // integer_expr + case symbol_kind::S_enterprise_id: // enterprise_id + value.YY_MOVE_OR_COPY< uint32_t > (YY_MOVE (that.value)); + break; + + default: + break; + } + +#if 201103L <= YY_CPLUSPLUS + // that is emptied. + that.state = empty_state; +#endif + } + + EvalParser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) + : super_type (s, YY_MOVE (that.location)) + { + switch (that.kind ()) + { + case symbol_kind::S_option_repr_type: // option_repr_type + value.move< TokenOption::RepresentationType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_pkt4_field: // pkt4_field + value.move< TokenPkt4::FieldType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_pkt6_field: // pkt6_field + value.move< TokenPkt6::FieldType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_pkt_metadata: // pkt_metadata + value.move< TokenPkt::MetadataType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_relay6_field: // relay6_field + value.move< TokenRelay6Field::FieldType > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_nest_level: // nest_level + value.move< int8_t > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_STRING: // "constant string" + case symbol_kind::S_INTEGER: // "integer" + case symbol_kind::S_HEXSTRING: // "constant hexstring" + case symbol_kind::S_OPTION_NAME: // "option name" + case symbol_kind::S_IP_ADDRESS: // "ip address" + value.move< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_option_code: // option_code + case symbol_kind::S_sub_option_code: // sub_option_code + value.move< uint16_t > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_integer_expr: // integer_expr + case symbol_kind::S_enterprise_id: // enterprise_id + value.move< uint32_t > (YY_MOVE (that.value)); + break; + + default: + break; + } + + // that is emptied. + that.kind_ = symbol_kind::S_YYEMPTY; + } + +#if YY_CPLUSPLUS < 201103L + EvalParser::stack_symbol_type& + EvalParser::stack_symbol_type::operator= (const stack_symbol_type& that) + { + state = that.state; + switch (that.kind ()) + { + case symbol_kind::S_option_repr_type: // option_repr_type + value.copy< TokenOption::RepresentationType > (that.value); + break; + + case symbol_kind::S_pkt4_field: // pkt4_field + value.copy< TokenPkt4::FieldType > (that.value); + break; + + case symbol_kind::S_pkt6_field: // pkt6_field + value.copy< TokenPkt6::FieldType > (that.value); + break; + + case symbol_kind::S_pkt_metadata: // pkt_metadata + value.copy< TokenPkt::MetadataType > (that.value); + break; + + case symbol_kind::S_relay6_field: // relay6_field + value.copy< TokenRelay6Field::FieldType > (that.value); + break; + + case symbol_kind::S_nest_level: // nest_level + value.copy< int8_t > (that.value); + break; + + case symbol_kind::S_STRING: // "constant string" + case symbol_kind::S_INTEGER: // "integer" + case symbol_kind::S_HEXSTRING: // "constant hexstring" + case symbol_kind::S_OPTION_NAME: // "option name" + case symbol_kind::S_IP_ADDRESS: // "ip address" + value.copy< std::string > (that.value); + break; + + case symbol_kind::S_option_code: // option_code + case symbol_kind::S_sub_option_code: // sub_option_code + value.copy< uint16_t > (that.value); + break; + + case symbol_kind::S_integer_expr: // integer_expr + case symbol_kind::S_enterprise_id: // enterprise_id + value.copy< uint32_t > (that.value); + break; + + default: + break; + } + + location = that.location; + return *this; + } + + EvalParser::stack_symbol_type& + EvalParser::stack_symbol_type::operator= (stack_symbol_type& that) + { + state = that.state; + switch (that.kind ()) + { + case symbol_kind::S_option_repr_type: // option_repr_type + value.move< TokenOption::RepresentationType > (that.value); + break; + + case symbol_kind::S_pkt4_field: // pkt4_field + value.move< TokenPkt4::FieldType > (that.value); + break; + + case symbol_kind::S_pkt6_field: // pkt6_field + value.move< TokenPkt6::FieldType > (that.value); + break; + + case symbol_kind::S_pkt_metadata: // pkt_metadata + value.move< TokenPkt::MetadataType > (that.value); + break; + + case symbol_kind::S_relay6_field: // relay6_field + value.move< TokenRelay6Field::FieldType > (that.value); + break; + + case symbol_kind::S_nest_level: // nest_level + value.move< int8_t > (that.value); + break; + + case symbol_kind::S_STRING: // "constant string" + case symbol_kind::S_INTEGER: // "integer" + case symbol_kind::S_HEXSTRING: // "constant hexstring" + case symbol_kind::S_OPTION_NAME: // "option name" + case symbol_kind::S_IP_ADDRESS: // "ip address" + value.move< std::string > (that.value); + break; + + case symbol_kind::S_option_code: // option_code + case symbol_kind::S_sub_option_code: // sub_option_code + value.move< uint16_t > (that.value); + break; + + case symbol_kind::S_integer_expr: // integer_expr + case symbol_kind::S_enterprise_id: // enterprise_id + value.move< uint32_t > (that.value); + break; + + default: + break; + } + + location = that.location; + // that is emptied. + that.state = empty_state; + return *this; + } +#endif + + template <typename Base> + void + EvalParser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const + { + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yysym); + } + +#if EVALDEBUG + template <typename Base> + void + EvalParser::yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const + { + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + if (yysym.empty ()) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " (" + << yysym.location << ": "; + switch (yykind) + { + case symbol_kind::S_STRING: // "constant string" +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < std::string > (); } +#line 469 "parser.cc" + break; + + case symbol_kind::S_INTEGER: // "integer" +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < std::string > (); } +#line 475 "parser.cc" + break; + + case symbol_kind::S_HEXSTRING: // "constant hexstring" +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < std::string > (); } +#line 481 "parser.cc" + break; + + case symbol_kind::S_OPTION_NAME: // "option name" +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < std::string > (); } +#line 487 "parser.cc" + break; + + case symbol_kind::S_IP_ADDRESS: // "ip address" +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < std::string > (); } +#line 493 "parser.cc" + break; + + case symbol_kind::S_integer_expr: // integer_expr +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < uint32_t > (); } +#line 499 "parser.cc" + break; + + case symbol_kind::S_option_code: // option_code +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < uint16_t > (); } +#line 505 "parser.cc" + break; + + case symbol_kind::S_sub_option_code: // sub_option_code +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < uint16_t > (); } +#line 511 "parser.cc" + break; + + case symbol_kind::S_option_repr_type: // option_repr_type +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < TokenOption::RepresentationType > (); } +#line 517 "parser.cc" + break; + + case symbol_kind::S_nest_level: // nest_level +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < int8_t > (); } +#line 523 "parser.cc" + break; + + case symbol_kind::S_pkt_metadata: // pkt_metadata +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < TokenPkt::MetadataType > (); } +#line 529 "parser.cc" + break; + + case symbol_kind::S_enterprise_id: // enterprise_id +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < uint32_t > (); } +#line 535 "parser.cc" + break; + + case symbol_kind::S_pkt4_field: // pkt4_field +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < TokenPkt4::FieldType > (); } +#line 541 "parser.cc" + break; + + case symbol_kind::S_pkt6_field: // pkt6_field +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < TokenPkt6::FieldType > (); } +#line 547 "parser.cc" + break; + + case symbol_kind::S_relay6_field: // relay6_field +#line 127 "parser.yy" + { yyoutput << yysym.value.template as < TokenRelay6Field::FieldType > (); } +#line 553 "parser.cc" + break; + + default: + break; + } + yyo << ')'; + } + } +#endif + + void + EvalParser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) + { + if (m) + YY_SYMBOL_PRINT (m, sym); + yystack_.push (YY_MOVE (sym)); + } + + void + EvalParser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) + { +#if 201103L <= YY_CPLUSPLUS + yypush_ (m, stack_symbol_type (s, std::move (sym))); +#else + stack_symbol_type ss (s, sym); + yypush_ (m, ss); +#endif + } + + void + EvalParser::yypop_ (int n) YY_NOEXCEPT + { + yystack_.pop (n); + } + +#if EVALDEBUG + std::ostream& + EvalParser::debug_stream () const + { + return *yycdebug_; + } + + void + EvalParser::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + EvalParser::debug_level_type + EvalParser::debug_level () const + { + return yydebug_; + } + + void + EvalParser::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif // EVALDEBUG + + EvalParser::state_type + EvalParser::yy_lr_goto_state_ (state_type yystate, int yysym) + { + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS]; + } + + bool + EvalParser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yypact_ninf_; + } + + bool + EvalParser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yytable_ninf_; + } + + int + EvalParser::operator() () + { + return parse (); + } + + int + EvalParser::parse () + { + int yyn; + /// Length of the RHS of the rule being reduced. + int yylen = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// The lookahead symbol. + symbol_type yyla; + + /// The locations where the error started and ended. + stack_symbol_type yyerror_range[3]; + + /// The return value of parse (). + int yyresult; + +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + YYCDEBUG << "Starting parse\n"; + + + /* Initialize the stack. The initial state will be set in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystack_.clear (); + yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); + + /*-----------------------------------------------. + | yynewstate -- push a new symbol on the stack. | + `-----------------------------------------------*/ + yynewstate: + YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); + + // Accept? + if (yystack_[0].state == yyfinal_) + YYACCEPT; + + goto yybackup; + + + /*-----------. + | yybackup. | + `-----------*/ + yybackup: + // Try to take a decision without lookahead. + yyn = yypact_[+yystack_[0].state]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + // Read a lookahead token. + if (yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + symbol_type yylookahead (yylex (ctx)); + yyla.move (yylookahead); + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + goto yyerrlab1; + } +#endif // YY_EXCEPTIONS + } + YY_SYMBOL_PRINT ("Next token is", yyla); + + if (yyla.kind () == symbol_kind::S_YYerror) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = symbol_kind::S_YYUNDEF; + goto yyerrlab1; + } + + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) + { + goto yydefault; + } + + // Reduce or error. + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + // Count tokens shifted since error; after three, turn off error status. + if (yyerrstatus_) + --yyerrstatus_; + + // Shift the lookahead token. + yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla)); + goto yynewstate; + + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[+yystack_[0].state]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + + /*-----------------------------. + | yyreduce -- do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + { + stack_symbol_type yylhs; + yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]); + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + switch (yyr1_[yyn]) + { + case symbol_kind::S_option_repr_type: // option_repr_type + yylhs.value.emplace< TokenOption::RepresentationType > (); + break; + + case symbol_kind::S_pkt4_field: // pkt4_field + yylhs.value.emplace< TokenPkt4::FieldType > (); + break; + + case symbol_kind::S_pkt6_field: // pkt6_field + yylhs.value.emplace< TokenPkt6::FieldType > (); + break; + + case symbol_kind::S_pkt_metadata: // pkt_metadata + yylhs.value.emplace< TokenPkt::MetadataType > (); + break; + + case symbol_kind::S_relay6_field: // relay6_field + yylhs.value.emplace< TokenRelay6Field::FieldType > (); + break; + + case symbol_kind::S_nest_level: // nest_level + yylhs.value.emplace< int8_t > (); + break; + + case symbol_kind::S_STRING: // "constant string" + case symbol_kind::S_INTEGER: // "integer" + case symbol_kind::S_HEXSTRING: // "constant hexstring" + case symbol_kind::S_OPTION_NAME: // "option name" + case symbol_kind::S_IP_ADDRESS: // "ip address" + yylhs.value.emplace< std::string > (); + break; + + case symbol_kind::S_option_code: // option_code + case symbol_kind::S_sub_option_code: // sub_option_code + yylhs.value.emplace< uint16_t > (); + break; + + case symbol_kind::S_integer_expr: // integer_expr + case symbol_kind::S_enterprise_id: // enterprise_id + yylhs.value.emplace< uint32_t > (); + break; + + default: + break; + } + + + // Default location. + { + stack_type::slice range (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, range, yylen); + yyerror_range[1].location = yylhs.location; + } + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + switch (yyn) + { + case 6: // bool_expr: "not" bool_expr +#line 147 "parser.yy" + { + TokenPtr neg(new TokenNot()); + ctx.expression.push_back(neg); + } +#line 851 "parser.cc" + break; + + case 7: // bool_expr: bool_expr "and" bool_expr +#line 152 "parser.yy" + { + TokenPtr neg(new TokenAnd()); + ctx.expression.push_back(neg); + } +#line 860 "parser.cc" + break; + + case 8: // bool_expr: bool_expr "or" bool_expr +#line 157 "parser.yy" + { + TokenPtr neg(new TokenOr()); + ctx.expression.push_back(neg); + } +#line 869 "parser.cc" + break; + + case 9: // bool_expr: string_expr "==" string_expr +#line 162 "parser.yy" + { + TokenPtr eq(new TokenEqual()); + ctx.expression.push_back(eq); + } +#line 878 "parser.cc" + break; + + case 10: // bool_expr: "option" "[" option_code "]" "." "exists" +#line 167 "parser.yy" + { + TokenPtr opt(new TokenOption(yystack_[3].value.as < uint16_t > (), TokenOption::EXISTS)); + ctx.expression.push_back(opt); + } +#line 887 "parser.cc" + break; + + case 11: // bool_expr: "option" "[" option_code "]" "." "option" "[" sub_option_code "]" "." "exists" +#line 172 "parser.yy" + { + TokenPtr opt(new TokenSubOption(yystack_[8].value.as < uint16_t > (), yystack_[3].value.as < uint16_t > (), TokenOption::EXISTS)); + ctx.expression.push_back(opt); + } +#line 896 "parser.cc" + break; + + case 12: // bool_expr: "relay4" "[" sub_option_code "]" "." "exists" +#line 177 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V4: + { + TokenPtr opt(new TokenRelay4Option(yystack_[3].value.as < uint16_t > (), TokenOption::EXISTS)); + ctx.expression.push_back(opt); + break; + } + case Option::V6: + // We will have relay6[123] for the DHCPv6. + // In a very distant future we'll possibly be able + // to mix both if we have DHCPv4-over-DHCPv6, so it + // has some sense to make it explicit whether we + // talk about DHCPv4 relay or DHCPv6 relay. However, + // for the time being relay4 can be used in DHCPv4 + // only. + error(yystack_[5].location, "relay4 can only be used in DHCPv4."); + } + } +#line 920 "parser.cc" + break; + + case 13: // bool_expr: "relay6" "[" nest_level "]" "." "option" "[" sub_option_code "]" "." "exists" +#line 197 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V6: + { + TokenPtr opt(new TokenRelay6Option(yystack_[8].value.as < int8_t > (), yystack_[3].value.as < uint16_t > (), TokenOption::EXISTS)); + ctx.expression.push_back(opt); + break; + } + case Option::V4: + // For now we only use relay6 in DHCPv6. + error(yystack_[10].location, "relay6 can only be used in DHCPv6."); + } + } +#line 938 "parser.cc" + break; + + case 14: // bool_expr: "vendor-class" "[" enterprise_id "]" "." "exists" +#line 211 "parser.yy" + { + // Expression: vendor-class[1234].exists + // + // This token will find option 124 (DHCPv4) or 16 (DHCPv6), + // and will check if enterprise-id equals specified value. + TokenPtr exist(new TokenVendorClass(ctx.getUniverse(), yystack_[3].value.as < uint32_t > (), TokenOption::EXISTS)); + ctx.expression.push_back(exist); + } +#line 951 "parser.cc" + break; + + case 15: // bool_expr: "vendor" "[" enterprise_id "]" "." "exists" +#line 220 "parser.yy" + { + // Expression: vendor[1234].exists + // + // This token will find option 125 (DHCPv4) or 17 (DHCPv6), + // and will check if enterprise-id equals specified value. + TokenPtr exist(new TokenVendor(ctx.getUniverse(), yystack_[3].value.as < uint32_t > (), TokenOption::EXISTS)); + ctx.expression.push_back(exist); + } +#line 964 "parser.cc" + break; + + case 16: // bool_expr: "vendor" "[" enterprise_id "]" "." "option" "[" sub_option_code "]" "." "exists" +#line 229 "parser.yy" + { + // Expression vendor[1234].option[123].exists + // + // This token will check if specified vendor option + // exists, has specified enterprise-id and if has + // specified suboption. + TokenPtr exist(new TokenVendor(ctx.getUniverse(), yystack_[8].value.as < uint32_t > (), TokenOption::EXISTS, yystack_[3].value.as < uint16_t > ())); + ctx.expression.push_back(exist); + } +#line 978 "parser.cc" + break; + + case 17: // bool_expr: "member" "(" "constant string" ")" +#line 239 "parser.yy" + { + // Expression member('foo') + // + // This token will check if the packet is a member of + // the specified client class. + // To avoid loops at evaluation only already defined and + // built-in classes are allowed. + std::string cc = yystack_[1].value.as < std::string > (); + if (!ctx.isClientClassDefined(cc)) { + error(yystack_[1].location, "Not defined client class '" + cc + "'"); + } + TokenPtr member(new TokenMember(cc)); + ctx.expression.push_back(member); + } +#line 997 "parser.cc" + break; + + case 18: // string_expr: "constant string" +#line 256 "parser.yy" + { + TokenPtr str(new TokenString(yystack_[0].value.as < std::string > ())); + ctx.expression.push_back(str); + } +#line 1006 "parser.cc" + break; + + case 19: // string_expr: "constant hexstring" +#line 261 "parser.yy" + { + TokenPtr hex(new TokenHexString(yystack_[0].value.as < std::string > ())); + ctx.expression.push_back(hex); + } +#line 1015 "parser.cc" + break; + + case 20: // string_expr: "ip address" +#line 266 "parser.yy" + { + TokenPtr ip(new TokenIpAddress(yystack_[0].value.as < std::string > ())); + ctx.expression.push_back(ip); + } +#line 1024 "parser.cc" + break; + + case 21: // string_expr: "option" "[" option_code "]" "." option_repr_type +#line 271 "parser.yy" + { + TokenPtr opt(new TokenOption(yystack_[3].value.as < uint16_t > (), yystack_[0].value.as < TokenOption::RepresentationType > ())); + ctx.expression.push_back(opt); + } +#line 1033 "parser.cc" + break; + + case 22: // string_expr: "option" "[" option_code "]" "." "option" "[" sub_option_code "]" "." option_repr_type +#line 276 "parser.yy" + { + TokenPtr opt(new TokenSubOption(yystack_[8].value.as < uint16_t > (), yystack_[3].value.as < uint16_t > (), yystack_[0].value.as < TokenOption::RepresentationType > ())); + ctx.expression.push_back(opt); + } +#line 1042 "parser.cc" + break; + + case 23: // string_expr: "relay4" "[" sub_option_code "]" "." option_repr_type +#line 281 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V4: + { + TokenPtr opt(new TokenRelay4Option(yystack_[3].value.as < uint16_t > (), yystack_[0].value.as < TokenOption::RepresentationType > ())); + ctx.expression.push_back(opt); + break; + } + case Option::V6: + // We will have relay6[123] for the DHCPv6. + // In a very distant future we'll possibly be able + // to mix both if we have DHCPv4-over-DHCPv6, so it + // has some sense to make it explicit whether we + // talk about DHCPv4 relay or DHCPv6 relay. However, + // for the time being relay4 can be used in DHCPv4 + // only. + error(yystack_[5].location, "relay4 can only be used in DHCPv4."); + } + } +#line 1066 "parser.cc" + break; + + case 24: // string_expr: "relay6" "[" nest_level "]" "." "option" "[" sub_option_code "]" "." option_repr_type +#line 302 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V6: + { + TokenPtr opt(new TokenRelay6Option(yystack_[8].value.as < int8_t > (), yystack_[3].value.as < uint16_t > (), yystack_[0].value.as < TokenOption::RepresentationType > ())); + ctx.expression.push_back(opt); + break; + } + case Option::V4: + // For now we only use relay6 in DHCPv6. + error(yystack_[10].location, "relay6 can only be used in DHCPv6."); + } + } +#line 1084 "parser.cc" + break; + + case 25: // string_expr: "pkt" "." pkt_metadata +#line 317 "parser.yy" + { + TokenPtr pkt_metadata(new TokenPkt(yystack_[0].value.as < TokenPkt::MetadataType > ())); + ctx.expression.push_back(pkt_metadata); + } +#line 1093 "parser.cc" + break; + + case 26: // string_expr: "pkt4" "." pkt4_field +#line 322 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V4: + { + TokenPtr pkt4_field(new TokenPkt4(yystack_[0].value.as < TokenPkt4::FieldType > ())); + ctx.expression.push_back(pkt4_field); + break; + } + case Option::V6: + // For now we only use pkt4 in DHCPv4. + error(yystack_[2].location, "pkt4 can only be used in DHCPv4."); + } + } +#line 1111 "parser.cc" + break; + + case 27: // string_expr: "pkt6" "." pkt6_field +#line 336 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V6: + { + TokenPtr pkt6_field(new TokenPkt6(yystack_[0].value.as < TokenPkt6::FieldType > ())); + ctx.expression.push_back(pkt6_field); + break; + } + case Option::V4: + // For now we only use pkt6 in DHCPv6. + error(yystack_[2].location, "pkt6 can only be used in DHCPv6."); + } + } +#line 1129 "parser.cc" + break; + + case 28: // string_expr: "relay6" "[" nest_level "]" "." relay6_field +#line 350 "parser.yy" + { + switch (ctx.getUniverse()) { + case Option::V6: + { + TokenPtr relay6field(new TokenRelay6Field(yystack_[3].value.as < int8_t > (), yystack_[0].value.as < TokenRelay6Field::FieldType > ())); + ctx.expression.push_back(relay6field); + break; + } + case Option::V4: + // For now we only use relay6 in DHCPv6. + error(yystack_[5].location, "relay6 can only be used in DHCPv6."); + } + } +#line 1147 "parser.cc" + break; + + case 29: // string_expr: "substring" "(" string_expr "," start_expr "," length_expr ")" +#line 365 "parser.yy" + { + TokenPtr sub(new TokenSubstring()); + ctx.expression.push_back(sub); + } +#line 1156 "parser.cc" + break; + + case 30: // string_expr: "split" "(" string_expr "," string_expr "," int_expr ")" +#line 370 "parser.yy" + { + TokenPtr split(new TokenSplit()); + ctx.expression.push_back(split); + } +#line 1165 "parser.cc" + break; + + case 31: // string_expr: "concat" "(" string_expr "," string_expr ")" +#line 375 "parser.yy" + { + TokenPtr conc(new TokenConcat()); + ctx.expression.push_back(conc); + } +#line 1174 "parser.cc" + break; + + case 32: // string_expr: string_expr "+" string_expr +#line 380 "parser.yy" + { + TokenPtr conc(new TokenConcat()); + ctx.expression.push_back(conc); + } +#line 1183 "parser.cc" + break; + + case 33: // string_expr: "ifelse" "(" bool_expr "," string_expr "," string_expr ")" +#line 385 "parser.yy" + { + TokenPtr cond(new TokenIfElse()); + ctx.expression.push_back(cond); + } +#line 1192 "parser.cc" + break; + + case 34: // string_expr: "hexstring" "(" string_expr "," string_expr ")" +#line 390 "parser.yy" + { + TokenPtr tohex(new TokenToHexString()); + ctx.expression.push_back(tohex); + } +#line 1201 "parser.cc" + break; + + case 35: // string_expr: "addrtotext" "(" string_expr ")" +#line 395 "parser.yy" + { + TokenPtr addrtotext(new TokenIpAddressToText()); + ctx.expression.push_back(addrtotext); + } +#line 1210 "parser.cc" + break; + + case 36: // string_expr: "int8totext" "(" string_expr ")" +#line 400 "parser.yy" + { + TokenPtr int8totext(new TokenInt8ToText()); + ctx.expression.push_back(int8totext); + } +#line 1219 "parser.cc" + break; + + case 37: // string_expr: "int16totext" "(" string_expr ")" +#line 405 "parser.yy" + { + TokenPtr int16totext(new TokenInt16ToText()); + ctx.expression.push_back(int16totext); + } +#line 1228 "parser.cc" + break; + + case 38: // string_expr: "int32totext" "(" string_expr ")" +#line 410 "parser.yy" + { + TokenPtr int32totext(new TokenInt32ToText()); + ctx.expression.push_back(int32totext); + } +#line 1237 "parser.cc" + break; + + case 39: // string_expr: "uint8totext" "(" string_expr ")" +#line 415 "parser.yy" + { + TokenPtr uint8totext(new TokenUInt8ToText()); + ctx.expression.push_back(uint8totext); + } +#line 1246 "parser.cc" + break; + + case 40: // string_expr: "uint16totext" "(" string_expr ")" +#line 420 "parser.yy" + { + TokenPtr uint16totext(new TokenUInt16ToText()); + ctx.expression.push_back(uint16totext); + } +#line 1255 "parser.cc" + break; + + case 41: // string_expr: "uint32totext" "(" string_expr ")" +#line 425 "parser.yy" + { + TokenPtr uint32totext(new TokenUInt32ToText()); + ctx.expression.push_back(uint32totext); + } +#line 1264 "parser.cc" + break; + + case 42: // string_expr: "vendor" "." "enterprise" +#line 430 "parser.yy" + { + // expression: vendor.enterprise + // + // This token will return enterprise-id number of + // received vendor option. + TokenPtr vendor(new TokenVendor(ctx.getUniverse(), 0, TokenVendor::ENTERPRISE_ID)); + ctx.expression.push_back(vendor); + } +#line 1277 "parser.cc" + break; + + case 43: // string_expr: "vendor-class" "." "enterprise" +#line 439 "parser.yy" + { + // expression: vendor-class.enterprise + // + // This token will return enterprise-id number of + // received vendor class option. + TokenPtr vendor(new TokenVendorClass(ctx.getUniverse(), 0, + TokenVendor::ENTERPRISE_ID)); + ctx.expression.push_back(vendor); + } +#line 1291 "parser.cc" + break; + + case 44: // string_expr: "vendor" "[" enterprise_id "]" "." "option" "[" sub_option_code "]" "." option_repr_type +#line 449 "parser.yy" + { + // This token will search for vendor option with + // specified enterprise-id. If found, will search + // for specified suboption and finally will return + // its content. + TokenPtr opt(new TokenVendor(ctx.getUniverse(), yystack_[8].value.as < uint32_t > (), yystack_[0].value.as < TokenOption::RepresentationType > (), yystack_[3].value.as < uint16_t > ())); + ctx.expression.push_back(opt); + } +#line 1304 "parser.cc" + break; + + case 45: // string_expr: "vendor-class" "[" enterprise_id "]" "." "data" +#line 458 "parser.yy" + { + // expression: vendor-class[1234].data + // + // Vendor class option does not have suboptions, + // but chunks of data (typically 1, but the option + // structure allows multiple of them). If chunk + // offset is not specified, we assume the first (0th) + // is requested. + TokenPtr vendor_class(new TokenVendorClass(ctx.getUniverse(), yystack_[3].value.as < uint32_t > (), + TokenVendor::DATA, 0)); + ctx.expression.push_back(vendor_class); + } +#line 1321 "parser.cc" + break; + + case 46: // string_expr: "vendor-class" "[" enterprise_id "]" "." "data" "[" "integer" "]" +#line 471 "parser.yy" + { + // expression: vendor-class[1234].data[5] + // + // Vendor class option does not have suboptions, + // but chunks of data (typically 1, but the option + // structure allows multiple of them). This syntax + // specifies which data chunk (tuple) we want. + uint8_t index = ctx.convertUint8(yystack_[1].value.as < std::string > (), yystack_[1].location); + TokenPtr vendor_class(new TokenVendorClass(ctx.getUniverse(), yystack_[6].value.as < uint32_t > (), + TokenVendor::DATA, index)); + ctx.expression.push_back(vendor_class); + } +#line 1338 "parser.cc" + break; + + case 47: // string_expr: integer_expr +#line 484 "parser.yy" + { + TokenPtr integer(new TokenInteger(yystack_[0].value.as < uint32_t > ())); + ctx.expression.push_back(integer); + } +#line 1347 "parser.cc" + break; + + case 49: // integer_expr: "integer" +#line 492 "parser.yy" + { + yylhs.value.as < uint32_t > () = ctx.convertUint32(yystack_[0].value.as < std::string > (), yystack_[0].location); + } +#line 1355 "parser.cc" + break; + + case 50: // option_code: "integer" +#line 498 "parser.yy" + { + yylhs.value.as < uint16_t > () = ctx.convertOptionCode(yystack_[0].value.as < std::string > (), yystack_[0].location); + } +#line 1363 "parser.cc" + break; + + case 51: // option_code: "option name" +#line 502 "parser.yy" + { + yylhs.value.as < uint16_t > () = ctx.convertOptionName(yystack_[0].value.as < std::string > (), yystack_[0].location); + } +#line 1371 "parser.cc" + break; + + case 52: // sub_option_code: "integer" +#line 508 "parser.yy" + { + yylhs.value.as < uint16_t > () = ctx.convertOptionCode(yystack_[0].value.as < std::string > (), yystack_[0].location); + } +#line 1379 "parser.cc" + break; + + case 53: // option_repr_type: "text" +#line 514 "parser.yy" + { + yylhs.value.as < TokenOption::RepresentationType > () = TokenOption::TEXTUAL; + } +#line 1387 "parser.cc" + break; + + case 54: // option_repr_type: "hex" +#line 518 "parser.yy" + { + yylhs.value.as < TokenOption::RepresentationType > () = TokenOption::HEXADECIMAL; + } +#line 1395 "parser.cc" + break; + + case 55: // nest_level: "integer" +#line 524 "parser.yy" + { + yylhs.value.as < int8_t > () = ctx.convertNestLevelNumber(yystack_[0].value.as < std::string > (), yystack_[0].location); + } +#line 1403 "parser.cc" + break; + + case 56: // pkt_metadata: "iface" +#line 533 "parser.yy" + { + yylhs.value.as < TokenPkt::MetadataType > () = TokenPkt::IFACE; + } +#line 1411 "parser.cc" + break; + + case 57: // pkt_metadata: "src" +#line 537 "parser.yy" + { + yylhs.value.as < TokenPkt::MetadataType > () = TokenPkt::SRC; + } +#line 1419 "parser.cc" + break; + + case 58: // pkt_metadata: "dst" +#line 541 "parser.yy" + { + yylhs.value.as < TokenPkt::MetadataType > () = TokenPkt::DST; + } +#line 1427 "parser.cc" + break; + + case 59: // pkt_metadata: "len" +#line 545 "parser.yy" + { + yylhs.value.as < TokenPkt::MetadataType > () = TokenPkt::LEN; + } +#line 1435 "parser.cc" + break; + + case 60: // enterprise_id: "integer" +#line 551 "parser.yy" + { + yylhs.value.as < uint32_t > () = ctx.convertUint32(yystack_[0].value.as < std::string > (), yystack_[0].location); + } +#line 1443 "parser.cc" + break; + + case 61: // enterprise_id: "*" +#line 555 "parser.yy" + { + yylhs.value.as < uint32_t > () = 0; + } +#line 1451 "parser.cc" + break; + + case 62: // pkt4_field: "mac" +#line 561 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::CHADDR; + } +#line 1459 "parser.cc" + break; + + case 63: // pkt4_field: "hlen" +#line 565 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::HLEN; + } +#line 1467 "parser.cc" + break; + + case 64: // pkt4_field: "htype" +#line 569 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::HTYPE; + } +#line 1475 "parser.cc" + break; + + case 65: // pkt4_field: "ciaddr" +#line 573 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::CIADDR; + } +#line 1483 "parser.cc" + break; + + case 66: // pkt4_field: "giaddr" +#line 577 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::GIADDR; + } +#line 1491 "parser.cc" + break; + + case 67: // pkt4_field: "yiaddr" +#line 581 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::YIADDR; + } +#line 1499 "parser.cc" + break; + + case 68: // pkt4_field: "siaddr" +#line 585 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::SIADDR; + } +#line 1507 "parser.cc" + break; + + case 69: // pkt4_field: "msgtype" +#line 589 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::MSGTYPE; + } +#line 1515 "parser.cc" + break; + + case 70: // pkt4_field: "transid" +#line 593 "parser.yy" + { + yylhs.value.as < TokenPkt4::FieldType > () = TokenPkt4::TRANSID; + } +#line 1523 "parser.cc" + break; + + case 71: // pkt6_field: "msgtype" +#line 599 "parser.yy" + { + yylhs.value.as < TokenPkt6::FieldType > () = TokenPkt6::MSGTYPE; + } +#line 1531 "parser.cc" + break; + + case 72: // pkt6_field: "transid" +#line 603 "parser.yy" + { + yylhs.value.as < TokenPkt6::FieldType > () = TokenPkt6::TRANSID; + } +#line 1539 "parser.cc" + break; + + case 73: // relay6_field: "peeraddr" +#line 609 "parser.yy" + { + yylhs.value.as < TokenRelay6Field::FieldType > () = TokenRelay6Field::PEERADDR; + } +#line 1547 "parser.cc" + break; + + case 74: // relay6_field: "linkaddr" +#line 613 "parser.yy" + { + yylhs.value.as < TokenRelay6Field::FieldType > () = TokenRelay6Field::LINKADDR; + } +#line 1555 "parser.cc" + break; + + case 75: // start_expr: "integer" +#line 619 "parser.yy" + { + TokenPtr str(new TokenString(yystack_[0].value.as < std::string > ())); + ctx.expression.push_back(str); + } +#line 1564 "parser.cc" + break; + + case 76: // length_expr: "integer" +#line 626 "parser.yy" + { + TokenPtr str(new TokenString(yystack_[0].value.as < std::string > ())); + ctx.expression.push_back(str); + } +#line 1573 "parser.cc" + break; + + case 77: // length_expr: "all" +#line 631 "parser.yy" + { + TokenPtr str(new TokenString("all")); + ctx.expression.push_back(str); + } +#line 1582 "parser.cc" + break; + + case 78: // int_expr: "integer" +#line 637 "parser.yy" + { + TokenPtr str(new TokenString(yystack_[0].value.as < std::string > ())); + ctx.expression.push_back(str); + } +#line 1591 "parser.cc" + break; + + +#line 1595 "parser.cc" + + default: + break; + } + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + YYERROR; + } +#endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhs); + yypop_ (yylen); + yylen = 0; + + // Shift the result of the reduction. + yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); + } + goto yynewstate; + + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + yyerrlab: + // If not already recovering from an error, report this error. + if (!yyerrstatus_) + { + ++yynerrs_; + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (yyla.location, YY_MOVE (msg)); + } + + + yyerror_range[1].location = yyla.location; + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + // Return failure if at end of input. + if (yyla.kind () == symbol_kind::S_YYEOF) + YYABORT; + else if (!yyla.empty ()) + { + yy_destroy_ ("Error: discarding", yyla); + yyla.clear (); + } + } + + // Else will try to reuse lookahead token after shifting the error token. + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and + the label yyerrorlab therefore never appears in user code. */ + if (false) + YYERROR; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + goto yyerrlab1; + + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; // Each real token shifted decrements this. + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += symbol_kind::S_YYerror; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == symbol_kind::S_YYerror) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; + + yyerror_range[1].location = yystack_[0].location; + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; + + yyerror_range[2].location = yyla.location; + YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); + + // Shift the error token. + error_token.state = state_type (yyn); + yypush_ ("Shifting", YY_MOVE (error_token)); + } + goto yynewstate; + + + /*-------------------------------------. + | yyacceptlab -- YYACCEPT comes here. | + `-------------------------------------*/ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + + /*-----------------------------------. + | yyabortlab -- YYABORT comes here. | + `-----------------------------------*/ + yyabortlab: + yyresult = 1; + goto yyreturn; + + + /*-----------------------------------------------------. + | yyreturn -- parsing is finished, return the result. | + `-----------------------------------------------------*/ + yyreturn: + if (!yyla.empty ()) + yy_destroy_ ("Cleanup: discarding lookahead", yyla); + + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + YY_STACK_PRINT (); + while (1 < yystack_.size ()) + { + yy_destroy_ ("Cleanup: popping", yystack_[0]); + yypop_ (); + } + + return yyresult; + } +#if YY_EXCEPTIONS + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; + // Do not try to display the values of the reclaimed symbols, + // as their printers might throw an exception. + if (!yyla.empty ()) + yy_destroy_ (YY_NULLPTR, yyla); + + while (1 < yystack_.size ()) + { + yy_destroy_ (YY_NULLPTR, yystack_[0]); + yypop_ (); + } + throw; + } +#endif // YY_EXCEPTIONS + } + + void + EvalParser::error (const syntax_error& yyexc) + { + error (yyexc.location, yyexc.what ()); + } + + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + EvalParser::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + EvalParser::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } + + + + // EvalParser::context. + EvalParser::context::context (const EvalParser& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + EvalParser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + + const int yyn = yypact_[+yyparser_.yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + const int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + const int yychecklim = yylast_ - yyn + 1; + const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } + + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = symbol_kind::S_YYEMPTY; + return yycount; + } + + + + + + + int + EvalParser::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + EvalParser::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + } + + + const short EvalParser::yypact_ninf_ = -156; + + const signed char EvalParser::yytable_ninf_ = -1; + + const short + EvalParser::yypact_[] = + { + 43, 109, 156, 20, 109, 109, 73, 94, 98, 90, + 79, 111, 133, 142, 157, 168, 177, 180, 185, 189, + 190, 192, 211, 219, 207, 112, 131, -156, -156, -156, + -156, -156, 135, 29, -156, 156, 210, 212, 213, 161, + 164, 187, -156, 104, 0, -156, -34, 169, 170, 172, + 82, 52, 156, 156, 156, 109, 156, 156, 156, 156, + 156, 156, 156, 156, 113, -39, 176, -39, 178, 109, + 109, 156, 156, 1, -34, 169, 170, -39, -39, -156, + -156, -156, -156, 217, -156, 220, -156, 221, 231, -156, + -156, -156, -156, -156, -156, -156, -156, -156, -156, -156, + -156, -156, -156, -156, 147, 150, 173, 10, 174, 2, + 3, 5, 6, 7, 14, 23, -156, -156, -156, -156, + -156, 222, -156, 223, -156, -156, 234, 187, -156, 225, + 226, 227, 228, 229, 230, 232, 233, -156, 186, 156, + 156, 156, 156, -156, -156, -156, -156, -156, -156, -156, + 235, 236, 237, 238, 239, 240, 241, 16, 4, 78, + -156, 214, 181, 25, 184, 26, 11, 77, 80, 188, + 81, 193, 250, 245, -156, -156, -156, -156, -156, -156, + 246, -156, -156, -156, -17, 202, -156, 156, -156, -156, + 248, 249, -156, 251, 252, 253, 169, 169, -156, -156, + 261, -156, 265, 28, 215, 169, 169, 169, 169, 254, + 255, -156, -156, -156, 256, 257, 258, 260, 262, 263, + 264, -156, 266, 267, 268, 269, 97, 106, 155, 188, + 188, 188, -156, -156, -156, -156, -156, -156 + }; + + const signed char + EvalParser::yydefact_[] = + { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 18, 49, 19, + 20, 2, 4, 0, 47, 0, 0, 0, 0, 0, + 0, 3, 1, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 48, 50, 51, 0, 52, 0, 55, 0, 0, 56, + 57, 58, 59, 25, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 26, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 71, 72, 27, 61, + 60, 0, 43, 0, 42, 7, 8, 9, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, + 0, 0, 0, 35, 36, 37, 38, 39, 40, 41, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 53, 54, 10, 21, 12, 23, + 0, 73, 74, 28, 0, 0, 31, 0, 34, 14, + 45, 0, 15, 0, 0, 0, 0, 0, 77, 76, + 0, 78, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 29, 30, 33, 0, 0, 0, 0, 0, 0, + 0, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 22, 13, 24, 16, 44 + }; + + const short + EvalParser::yypgoto_[] = + { + -156, -156, -156, 8, -2, -156, 203, -74, -155, 206, + -156, -29, -156, -156, -156, -156, -156, -156 + }; + + const unsigned char + EvalParser::yydefgoto_[] = + { + 0, 3, 31, 32, 33, 34, 83, 85, 177, 87, + 93, 121, 103, 118, 183, 161, 200, 202 + }; + + const unsigned char + EvalParser::yytable_[] = + { + 41, 130, 44, 179, 80, 80, 143, 144, 71, 145, + 146, 147, 43, 45, 179, 119, 69, 70, 148, 198, + 42, 120, 174, 175, 178, 173, 81, 149, 82, 186, + 188, 189, 213, 73, 174, 175, 176, 71, 123, 72, + 72, 72, 72, 199, 72, 72, 72, 141, 132, 133, + 104, 105, 106, 72, 108, 109, 110, 111, 112, 113, + 114, 115, 72, 107, 72, 72, 190, 72, 72, 127, + 128, 233, 235, 237, 233, 235, 237, 125, 126, 94, + 95, 96, 97, 98, 99, 100, 191, 180, 46, 193, + 194, 181, 182, 49, 181, 182, 50, 192, 174, 175, + 1, 2, 101, 102, 89, 90, 91, 92, 79, 47, + 69, 70, 4, 48, 5, 174, 175, 232, 6, 7, + 8, 9, 209, 210, 174, 175, 234, 65, 51, 66, + 10, 215, 216, 217, 218, 11, 52, 162, 163, 164, + 165, 69, 70, 12, 13, 53, 67, 14, 68, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 35, + 54, 25, 26, 116, 117, 36, 37, 38, 27, 28, + 29, 55, 30, 174, 175, 236, 77, 10, 66, 78, + 56, 68, 11, 57, 138, 203, 72, 139, 58, 72, + 12, 13, 59, 60, 14, 61, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 174, 175, 39, 40, + 140, 142, 72, 72, 62, 27, 28, 29, 185, 30, + 72, 187, 63, 72, 64, 74, 72, 75, 76, 84, + 86, 88, 122, 134, 124, 137, 135, 136, 150, 151, + 69, 152, 153, 154, 155, 156, 160, 157, 190, 158, + 159, 184, 166, 167, 168, 169, 170, 171, 172, 195, + 196, 197, 201, 204, 205, 211, 206, 207, 208, 212, + 219, 220, 221, 222, 223, 214, 224, 129, 225, 0, + 226, 227, 131, 228, 229, 230, 231 + }; + + const short + EvalParser::yycheck_[] = + { + 2, 75, 4, 158, 4, 4, 4, 4, 8, 4, + 4, 4, 4, 5, 169, 54, 6, 7, 4, 36, + 0, 60, 18, 19, 20, 9, 60, 4, 62, 4, + 4, 20, 4, 35, 18, 19, 20, 8, 67, 39, + 39, 39, 39, 60, 39, 39, 39, 37, 77, 78, + 52, 53, 54, 39, 56, 57, 58, 59, 60, 61, + 62, 63, 39, 55, 39, 39, 55, 39, 39, 71, + 72, 226, 227, 228, 229, 230, 231, 69, 70, 27, + 28, 29, 30, 31, 32, 33, 9, 9, 15, 9, + 9, 13, 14, 3, 13, 14, 17, 20, 18, 19, + 57, 58, 50, 51, 22, 23, 24, 25, 4, 15, + 6, 7, 3, 15, 5, 18, 19, 20, 9, 10, + 11, 12, 196, 197, 18, 19, 20, 15, 17, 17, + 21, 205, 206, 207, 208, 26, 3, 139, 140, 141, + 142, 6, 7, 34, 35, 3, 15, 38, 17, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 3, + 3, 52, 53, 50, 51, 9, 10, 11, 59, 60, + 61, 3, 63, 18, 19, 20, 15, 21, 17, 15, + 3, 17, 26, 3, 37, 187, 39, 37, 3, 39, + 34, 35, 3, 3, 38, 3, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 18, 19, 52, 53, + 37, 37, 39, 39, 3, 59, 60, 61, 37, 63, + 39, 37, 3, 39, 17, 15, 39, 15, 15, 60, + 60, 59, 56, 16, 56, 4, 16, 16, 16, 16, + 6, 16, 16, 16, 16, 16, 60, 17, 55, 17, + 17, 37, 17, 17, 17, 17, 17, 17, 17, 9, + 15, 15, 60, 15, 15, 4, 15, 15, 15, 4, + 16, 16, 16, 16, 16, 60, 16, 74, 16, -1, + 17, 17, 76, 17, 17, 17, 17 + }; + + const signed char + EvalParser::yystos_[] = + { + 0, 57, 58, 65, 3, 5, 9, 10, 11, 12, + 21, 26, 34, 35, 38, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 52, 53, 59, 60, 61, + 63, 66, 67, 68, 69, 3, 9, 10, 11, 52, + 53, 68, 0, 67, 68, 67, 15, 15, 15, 3, + 17, 17, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 17, 15, 17, 15, 17, 6, + 7, 8, 39, 68, 15, 15, 15, 15, 15, 4, + 4, 60, 62, 70, 60, 71, 60, 73, 59, 22, + 23, 24, 25, 74, 27, 28, 29, 30, 31, 32, + 33, 50, 51, 76, 68, 68, 68, 67, 68, 68, + 68, 68, 68, 68, 68, 68, 50, 51, 77, 54, + 60, 75, 56, 75, 56, 67, 67, 68, 68, 70, + 71, 73, 75, 75, 16, 16, 16, 4, 37, 37, + 37, 37, 37, 4, 4, 4, 4, 4, 4, 4, + 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, + 60, 79, 68, 68, 68, 68, 17, 17, 17, 17, + 17, 17, 17, 9, 18, 19, 20, 72, 20, 72, + 9, 13, 14, 78, 37, 37, 4, 37, 4, 20, + 55, 9, 20, 9, 9, 9, 15, 15, 36, 60, + 80, 60, 81, 68, 15, 15, 15, 15, 15, 71, + 71, 4, 4, 4, 60, 71, 71, 71, 71, 16, + 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, + 17, 17, 20, 72, 20, 72, 20, 72 + }; + + const signed char + EvalParser::yyr1_[] = + { + 0, 64, 65, 65, 66, 67, 67, 67, 67, 67, + 67, 67, 67, 67, 67, 67, 67, 67, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 69, + 70, 70, 71, 72, 72, 73, 74, 74, 74, 74, + 75, 75, 76, 76, 76, 76, 76, 76, 76, 76, + 76, 77, 77, 78, 78, 79, 80, 80, 81 + }; + + const signed char + EvalParser::yyr2_[] = + { + 0, 2, 2, 2, 1, 3, 2, 3, 3, 3, + 6, 11, 6, 11, 6, 6, 11, 4, 1, 1, + 1, 6, 11, 6, 11, 3, 3, 3, 6, 8, + 8, 6, 3, 8, 6, 4, 4, 4, 4, 4, + 4, 4, 3, 3, 11, 6, 9, 1, 3, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + + +#if EVALDEBUG || 1 + // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. + const char* + const EvalParser::yytname_[] = + { + "\"end of file\"", "error", "\"invalid token\"", "\"(\"", "\")\"", + "\"not\"", "\"and\"", "\"or\"", "\"==\"", "\"option\"", "\"relay4\"", + "\"relay6\"", "\"member\"", "\"peeraddr\"", "\"linkaddr\"", "\"[\"", + "\"]\"", "\".\"", "\"text\"", "\"hex\"", "\"exists\"", "\"pkt\"", + "\"iface\"", "\"src\"", "\"dst\"", "\"len\"", "\"pkt4\"", "\"mac\"", + "\"hlen\"", "\"htype\"", "\"ciaddr\"", "\"giaddr\"", "\"yiaddr\"", + "\"siaddr\"", "\"substring\"", "\"split\"", "\"all\"", "\",\"", + "\"concat\"", "\"+\"", "\"ifelse\"", "\"hexstring\"", "\"addrtotext\"", + "\"int8totext\"", "\"int16totext\"", "\"int32totext\"", + "\"uint8totext\"", "\"uint16totext\"", "\"uint32totext\"", "\"pkt6\"", + "\"msgtype\"", "\"transid\"", "\"vendor-class\"", "\"vendor\"", "\"*\"", + "\"data\"", "\"enterprise\"", "\"top-level bool\"", + "\"top-level string\"", "\"constant string\"", "\"integer\"", + "\"constant hexstring\"", "\"option name\"", "\"ip address\"", "$accept", + "start", "expression", "bool_expr", "string_expr", "integer_expr", + "option_code", "sub_option_code", "option_repr_type", "nest_level", + "pkt_metadata", "enterprise_id", "pkt4_field", "pkt6_field", + "relay6_field", "start_expr", "length_expr", "int_expr", YY_NULLPTR + }; +#endif + + +#if EVALDEBUG + const short + EvalParser::yyrline_[] = + { + 0, 136, 136, 137, 142, 145, 146, 151, 156, 161, + 166, 171, 176, 196, 210, 219, 228, 238, 255, 260, + 265, 270, 275, 280, 301, 316, 321, 335, 349, 364, + 369, 374, 379, 384, 389, 394, 399, 404, 409, 414, + 419, 424, 429, 438, 448, 457, 470, 483, 488, 491, + 497, 501, 507, 513, 517, 523, 532, 536, 540, 544, + 550, 554, 560, 564, 568, 572, 576, 580, 584, 588, + 592, 598, 602, 608, 612, 618, 625, 630, 636 + }; + + void + EvalParser::yy_stack_print_ () const + { + *yycdebug_ << "Stack now"; + for (stack_type::const_iterator + i = yystack_.begin (), + i_end = yystack_.end (); + i != i_end; ++i) + *yycdebug_ << ' ' << int (i->state); + *yycdebug_ << '\n'; + } + + void + EvalParser::yy_reduce_print_ (int yyrule) const + { + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + // Print the symbols being reduced, and their result. + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):\n"; + // The symbols being reduced. + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + yystack_[(yynrhs) - (yyi + 1)]); + } +#endif // EVALDEBUG + + +#line 14 "parser.yy" +} } // isc::eval +#line 2219 "parser.cc" + +#line 643 "parser.yy" + +void +isc::eval::EvalParser::error(const location_type& loc, + const std::string& what) +{ + ctx.error(loc, what); +} |