// 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   d2_parser_lex



#include "d2_parser.h"


// Unqualified %code blocks.
#line 35 "d2_parser.yy"

#include <d2/parser_context.h>

// Avoid warnings with the error counter.
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif

#line 57 "d2_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 D2_PARSER_DEBUG

// 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 // !D2_PARSER_DEBUG

# 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 // !D2_PARSER_DEBUG

#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 "d2_parser.yy"
namespace isc { namespace d2 {
#line 150 "d2_parser.cc"

  /// Build a parser object.
  D2Parser::D2Parser (isc::d2::D2ParserContext& ctx_yyarg)
#if D2_PARSER_DEBUG
    : yydebug_ (false),
      yycdebug_ (&std::cerr),
#else
    :
#endif
      ctx (ctx_yyarg)
  {}

  D2Parser::~D2Parser ()
  {}

  D2Parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW
  {}

  /*---------.
  | symbol.  |
  `---------*/



  // by_state.
  D2Parser::by_state::by_state () YY_NOEXCEPT
    : state (empty_state)
  {}

  D2Parser::by_state::by_state (const by_state& that) YY_NOEXCEPT
    : state (that.state)
  {}

  void
  D2Parser::by_state::clear () YY_NOEXCEPT
  {
    state = empty_state;
  }

  void
  D2Parser::by_state::move (by_state& that)
  {
    state = that.state;
    that.clear ();
  }

  D2Parser::by_state::by_state (state_type s) YY_NOEXCEPT
    : state (s)
  {}

  D2Parser::symbol_kind_type
  D2Parser::by_state::kind () const YY_NOEXCEPT
  {
    if (state == empty_state)
      return symbol_kind::S_YYEMPTY;
    else
      return YY_CAST (symbol_kind_type, yystos_[+state]);
  }

  D2Parser::stack_symbol_type::stack_symbol_type ()
  {}

  D2Parser::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_value: // value
      case symbol_kind::S_map_value: // map_value
      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
      case symbol_kind::S_control_socket_type_value: // control_socket_type_value
      case symbol_kind::S_auth_type_value: // auth_type_value
        value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_BOOLEAN: // "boolean"
        value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_FLOAT: // "floating point"
        value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_INTEGER: // "integer"
        value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_STRING: // "constant string"
        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
        break;

      default:
        break;
    }

#if 201103L <= YY_CPLUSPLUS
    // that is emptied.
    that.state = empty_state;
#endif
  }

  D2Parser::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_value: // value
      case symbol_kind::S_map_value: // map_value
      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
      case symbol_kind::S_control_socket_type_value: // control_socket_type_value
      case symbol_kind::S_auth_type_value: // auth_type_value
        value.move< ElementPtr > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_BOOLEAN: // "boolean"
        value.move< bool > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_FLOAT: // "floating point"
        value.move< double > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_INTEGER: // "integer"
        value.move< int64_t > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_STRING: // "constant string"
        value.move< std::string > (YY_MOVE (that.value));
        break;

      default:
        break;
    }

    // that is emptied.
    that.kind_ = symbol_kind::S_YYEMPTY;
  }

#if YY_CPLUSPLUS < 201103L
  D2Parser::stack_symbol_type&
  D2Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
  {
    state = that.state;
    switch (that.kind ())
    {
      case symbol_kind::S_value: // value
      case symbol_kind::S_map_value: // map_value
      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
      case symbol_kind::S_control_socket_type_value: // control_socket_type_value
      case symbol_kind::S_auth_type_value: // auth_type_value
        value.copy< ElementPtr > (that.value);
        break;

      case symbol_kind::S_BOOLEAN: // "boolean"
        value.copy< bool > (that.value);
        break;

      case symbol_kind::S_FLOAT: // "floating point"
        value.copy< double > (that.value);
        break;

      case symbol_kind::S_INTEGER: // "integer"
        value.copy< int64_t > (that.value);
        break;

      case symbol_kind::S_STRING: // "constant string"
        value.copy< std::string > (that.value);
        break;

      default:
        break;
    }

    location = that.location;
    return *this;
  }

  D2Parser::stack_symbol_type&
  D2Parser::stack_symbol_type::operator= (stack_symbol_type& that)
  {
    state = that.state;
    switch (that.kind ())
    {
      case symbol_kind::S_value: // value
      case symbol_kind::S_map_value: // map_value
      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
      case symbol_kind::S_control_socket_type_value: // control_socket_type_value
      case symbol_kind::S_auth_type_value: // auth_type_value
        value.move< ElementPtr > (that.value);
        break;

      case symbol_kind::S_BOOLEAN: // "boolean"
        value.move< bool > (that.value);
        break;

      case symbol_kind::S_FLOAT: // "floating point"
        value.move< double > (that.value);
        break;

      case symbol_kind::S_INTEGER: // "integer"
        value.move< int64_t > (that.value);
        break;

      case symbol_kind::S_STRING: // "constant string"
        value.move< std::string > (that.value);
        break;

      default:
        break;
    }

    location = that.location;
    // that is emptied.
    that.state = empty_state;
    return *this;
  }
#endif

  template <typename Base>
  void
  D2Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
  {
    if (yymsg)
      YY_SYMBOL_PRINT (yymsg, yysym);
  }

#if D2_PARSER_DEBUG
  template <typename Base>
  void
  D2Parser::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 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < std::string > (); }
#line 397 "d2_parser.cc"
        break;

      case symbol_kind::S_INTEGER: // "integer"
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < int64_t > (); }
#line 403 "d2_parser.cc"
        break;

      case symbol_kind::S_FLOAT: // "floating point"
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < double > (); }
#line 409 "d2_parser.cc"
        break;

      case symbol_kind::S_BOOLEAN: // "boolean"
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < bool > (); }
#line 415 "d2_parser.cc"
        break;

      case symbol_kind::S_value: // value
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < ElementPtr > (); }
#line 421 "d2_parser.cc"
        break;

      case symbol_kind::S_map_value: // map_value
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < ElementPtr > (); }
#line 427 "d2_parser.cc"
        break;

      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < ElementPtr > (); }
#line 433 "d2_parser.cc"
        break;

      case symbol_kind::S_control_socket_type_value: // control_socket_type_value
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < ElementPtr > (); }
#line 439 "d2_parser.cc"
        break;

      case symbol_kind::S_auth_type_value: // auth_type_value
#line 145 "d2_parser.yy"
                 { yyoutput << yysym.value.template as < ElementPtr > (); }
#line 445 "d2_parser.cc"
        break;

      default:
        break;
    }
        yyo << ')';
      }
  }
#endif

  void
  D2Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
  {
    if (m)
      YY_SYMBOL_PRINT (m, sym);
    yystack_.push (YY_MOVE (sym));
  }

  void
  D2Parser::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
  D2Parser::yypop_ (int n) YY_NOEXCEPT
  {
    yystack_.pop (n);
  }

#if D2_PARSER_DEBUG
  std::ostream&
  D2Parser::debug_stream () const
  {
    return *yycdebug_;
  }

  void
  D2Parser::set_debug_stream (std::ostream& o)
  {
    yycdebug_ = &o;
  }


  D2Parser::debug_level_type
  D2Parser::debug_level () const
  {
    return yydebug_;
  }

  void
  D2Parser::set_debug_level (debug_level_type l)
  {
    yydebug_ = l;
  }
#endif // D2_PARSER_DEBUG

  D2Parser::state_type
  D2Parser::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
  D2Parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT
  {
    return yyvalue == yypact_ninf_;
  }

  bool
  D2Parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT
  {
    return yyvalue == yytable_ninf_;
  }

  int
  D2Parser::operator() ()
  {
    return parse ();
  }

  int
  D2Parser::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_value: // value
      case symbol_kind::S_map_value: // map_value
      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
      case symbol_kind::S_control_socket_type_value: // control_socket_type_value
      case symbol_kind::S_auth_type_value: // auth_type_value
        yylhs.value.emplace< ElementPtr > ();
        break;

      case symbol_kind::S_BOOLEAN: // "boolean"
        yylhs.value.emplace< bool > ();
        break;

      case symbol_kind::S_FLOAT: // "floating point"
        yylhs.value.emplace< double > ();
        break;

      case symbol_kind::S_INTEGER: // "integer"
        yylhs.value.emplace< int64_t > ();
        break;

      case symbol_kind::S_STRING: // "constant string"
        yylhs.value.emplace< std::string > ();
        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 2: // $@1: %empty
#line 154 "d2_parser.yy"
                     { ctx.ctx_ = ctx.NO_KEYWORD; }
#line 722 "d2_parser.cc"
    break;

  case 4: // $@2: %empty
#line 155 "d2_parser.yy"
                         { ctx.ctx_ = ctx.CONFIG; }
#line 728 "d2_parser.cc"
    break;

  case 6: // $@3: %empty
#line 156 "d2_parser.yy"
                    { ctx.ctx_ = ctx.DHCPDDNS; }
#line 734 "d2_parser.cc"
    break;

  case 8: // $@4: %empty
#line 157 "d2_parser.yy"
                    { ctx.ctx_ = ctx.TSIG_KEY; }
#line 740 "d2_parser.cc"
    break;

  case 10: // $@5: %empty
#line 158 "d2_parser.yy"
                     { ctx.ctx_ = ctx.TSIG_KEYS; }
#line 746 "d2_parser.cc"
    break;

  case 12: // $@6: %empty
#line 159 "d2_parser.yy"
                       { ctx.ctx_ = ctx.DDNS_DOMAIN; }
#line 752 "d2_parser.cc"
    break;

  case 14: // $@7: %empty
#line 160 "d2_parser.yy"
                        { ctx.ctx_ = ctx.DDNS_DOMAINS; }
#line 758 "d2_parser.cc"
    break;

  case 16: // $@8: %empty
#line 161 "d2_parser.yy"
                      { ctx.ctx_ = ctx.DNS_SERVERS; }
#line 764 "d2_parser.cc"
    break;

  case 18: // $@9: %empty
#line 162 "d2_parser.yy"
                       { ctx.ctx_ = ctx.DNS_SERVERS; }
#line 770 "d2_parser.cc"
    break;

  case 20: // $@10: %empty
#line 163 "d2_parser.yy"
                         { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
#line 776 "d2_parser.cc"
    break;

  case 22: // value: "integer"
#line 171 "d2_parser.yy"
               { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); }
#line 782 "d2_parser.cc"
    break;

  case 23: // value: "floating point"
#line 172 "d2_parser.yy"
             { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); }
#line 788 "d2_parser.cc"
    break;

  case 24: // value: "boolean"
#line 173 "d2_parser.yy"
               { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); }
#line 794 "d2_parser.cc"
    break;

  case 25: // value: "constant string"
#line 174 "d2_parser.yy"
              { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); }
#line 800 "d2_parser.cc"
    break;

  case 26: // value: "null"
#line 175 "d2_parser.yy"
                 { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
#line 806 "d2_parser.cc"
    break;

  case 27: // value: map2
#line 176 "d2_parser.yy"
            { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
#line 812 "d2_parser.cc"
    break;

  case 28: // value: list_generic
#line 177 "d2_parser.yy"
                    { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
#line 818 "d2_parser.cc"
    break;

  case 29: // sub_json: value
#line 180 "d2_parser.yy"
                {
    // Push back the JSON value on the stack
    ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ());
}
#line 827 "d2_parser.cc"
    break;

  case 30: // $@11: %empty
#line 185 "d2_parser.yy"
                     {
    // This code is executed when we're about to start parsing
    // the content of the map
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 838 "d2_parser.cc"
    break;

  case 31: // map2: "{" $@11 map_content "}"
#line 190 "d2_parser.yy"
                             {
    // map parsing completed. If we ever want to do any wrap up
    // (maybe some sanity checking), this would be the best place
    // for it.
}
#line 848 "d2_parser.cc"
    break;

  case 32: // map_value: map2
#line 196 "d2_parser.yy"
                { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
#line 854 "d2_parser.cc"
    break;

  case 35: // not_empty_map: "constant string" ":" value
#line 203 "d2_parser.yy"
                                  {
                  // map containing a single entry
                  ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
                  ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
                  }
#line 864 "d2_parser.cc"
    break;

  case 36: // not_empty_map: not_empty_map "," "constant string" ":" value
#line 208 "d2_parser.yy"
                                                      {
                  // map consisting of a shorter map followed by
                  // comma and string:value
                  ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
                  ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
                  }
#line 875 "d2_parser.cc"
    break;

  case 37: // not_empty_map: not_empty_map ","
#line 214 "d2_parser.yy"
                                   {
                  ctx.warnAboutExtraCommas(yystack_[0].location);
                  }
#line 883 "d2_parser.cc"
    break;

  case 38: // $@12: %empty
#line 219 "d2_parser.yy"
                              {
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(l);
}
#line 892 "d2_parser.cc"
    break;

  case 39: // list_generic: "[" $@12 list_content "]"
#line 222 "d2_parser.yy"
                               {
    // list parsing complete. Put any sanity checking here
}
#line 900 "d2_parser.cc"
    break;

  case 42: // not_empty_list: value
#line 230 "d2_parser.yy"
                      {
                  // List consisting of a single element.
                  ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
                  }
#line 909 "d2_parser.cc"
    break;

  case 43: // not_empty_list: not_empty_list "," value
#line 234 "d2_parser.yy"
                                           {
                  // List ending with , and a value.
                  ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
                  }
#line 918 "d2_parser.cc"
    break;

  case 44: // not_empty_list: not_empty_list ","
#line 238 "d2_parser.yy"
                                     {
                  ctx.warnAboutExtraCommas(yystack_[0].location);
                  }
#line 926 "d2_parser.cc"
    break;

  case 45: // unknown_map_entry: "constant string" ":"
#line 248 "d2_parser.yy"
                                {
    const std::string& where = ctx.contextName();
    const std::string& keyword = yystack_[1].value.as < std::string > ();
    error(yystack_[1].location,
          "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
}
#line 937 "d2_parser.cc"
    break;

  case 46: // $@13: %empty
#line 257 "d2_parser.yy"
                           {
    // This code is executed when we're about to start parsing
    // the content of the map
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 948 "d2_parser.cc"
    break;

  case 47: // syntax_map: "{" $@13 global_object "}"
#line 262 "d2_parser.yy"
                               {
    // map parsing completed. If we ever want to do any wrap up
    // (maybe some sanity checking), this would be the best place
    // for it.
}
#line 958 "d2_parser.cc"
    break;

  case 48: // $@14: %empty
#line 270 "d2_parser.yy"
                        {
    ctx.unique("DhcpDdns", ctx.loc2pos(yystack_[0].location));
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("DhcpDdns", m);
    ctx.stack_.push_back(m);
    ctx.enter(ctx.DHCPDDNS);
}
#line 970 "d2_parser.cc"
    break;

  case 49: // global_object: "DhcpDdns" $@14 ":" "{" dhcpddns_params "}"
#line 276 "d2_parser.yy"
                                                      {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 979 "d2_parser.cc"
    break;

  case 51: // global_object_comma: global_object ","
#line 283 "d2_parser.yy"
                                         {
    ctx.warnAboutExtraCommas(yystack_[0].location);
}
#line 987 "d2_parser.cc"
    break;

  case 52: // $@15: %empty
#line 287 "d2_parser.yy"
                             {
    // Parse the dhcpddns map
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 997 "d2_parser.cc"
    break;

  case 53: // sub_dhcpddns: "{" $@15 dhcpddns_params "}"
#line 291 "d2_parser.yy"
                                 {
    // parsing completed
}
#line 1005 "d2_parser.cc"
    break;

  case 56: // dhcpddns_params: dhcpddns_params ","
#line 297 "d2_parser.yy"
                                       {
                   ctx.warnAboutExtraCommas(yystack_[0].location);
                   }
#line 1013 "d2_parser.cc"
    break;

  case 72: // $@16: %empty
#line 320 "d2_parser.yy"
                       {
    ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1022 "d2_parser.cc"
    break;

  case 73: // ip_address: "ip-address" $@16 ":" "constant string"
#line 323 "d2_parser.yy"
               {
    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("ip-address", s);
    ctx.leave();
}
#line 1032 "d2_parser.cc"
    break;

  case 74: // port: "port" ":" "integer"
#line 329 "d2_parser.yy"
                         {
    ctx.unique("port", ctx.loc2pos(yystack_[2].location));
    if (yystack_[0].value.as < int64_t > () <= 0 || yystack_[0].value.as < int64_t > () >= 65536 ) {
        error(yystack_[0].location, "port must be greater than zero but less than 65536");
    }
    ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("port", i);
}
#line 1045 "d2_parser.cc"
    break;

  case 75: // dns_server_timeout: "dns-server-timeout" ":" "integer"
#line 338 "d2_parser.yy"
                                                     {
    ctx.unique("dns-server-timeout", ctx.loc2pos(yystack_[2].location));
    if (yystack_[0].value.as < int64_t > () <= 0) {
        error(yystack_[0].location, "dns-server-timeout must be greater than zero");
    } else {
        ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
        ctx.stack_.back()->set("dns-server-timeout", i);
    }
}
#line 1059 "d2_parser.cc"
    break;

  case 76: // $@17: %empty
#line 348 "d2_parser.yy"
                           {
    ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NCR_PROTOCOL);
}
#line 1068 "d2_parser.cc"
    break;

  case 77: // ncr_protocol: "ncr-protocol" $@17 ":" ncr_protocol_value
#line 351 "d2_parser.yy"
                           {
    ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ());
    ctx.leave();
}
#line 1077 "d2_parser.cc"
    break;

  case 78: // ncr_protocol_value: "UDP"
#line 357 "d2_parser.yy"
        { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
#line 1083 "d2_parser.cc"
    break;

  case 79: // ncr_protocol_value: "TCP"
#line 358 "d2_parser.yy"
        { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
#line 1089 "d2_parser.cc"
    break;

  case 80: // $@18: %empty
#line 361 "d2_parser.yy"
                       {
    ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NCR_FORMAT);
}
#line 1098 "d2_parser.cc"
    break;

  case 81: // ncr_format: "ncr-format" $@18 ":" "JSON"
#line 364 "d2_parser.yy"
             {
    ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("ncr-format", json);
    ctx.leave();
}
#line 1108 "d2_parser.cc"
    break;

  case 82: // $@19: %empty
#line 370 "d2_parser.yy"
                           {
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1116 "d2_parser.cc"
    break;

  case 83: // user_context: "user-context" $@19 ":" map_value
#line 372 "d2_parser.yy"
                  {
    ElementPtr parent = ctx.stack_.back();
    ElementPtr user_context = yystack_[0].value.as < ElementPtr > ();
    ConstElementPtr old = parent->get("user-context");

    // Handle already existing user context
    if (old) {
        // Check if it was a comment or a duplicate
        if ((old->size() != 1) || !old->contains("comment")) {
            std::stringstream msg;
            msg << "duplicate user-context entries (previous at "
                << old->getPosition().str() << ")";
            error(yystack_[3].location, msg.str());
        }
        // Merge the comment
        user_context->set("comment", old->get("comment"));
    }

    // Set the user context
    parent->set("user-context", user_context);
    ctx.leave();
}
#line 1143 "d2_parser.cc"
    break;

  case 84: // $@20: %empty
#line 395 "d2_parser.yy"
                 {
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1151 "d2_parser.cc"
    break;

  case 85: // comment: "comment" $@20 ":" "constant string"
#line 397 "d2_parser.yy"
               {
    ElementPtr parent = ctx.stack_.back();
    ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
    ElementPtr comment(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    user_context->set("comment", comment);

    // Handle already existing user context
    ConstElementPtr old = parent->get("user-context");
    if (old) {
        // Check for duplicate comment
        if (old->contains("comment")) {
            std::stringstream msg;
            msg << "duplicate user-context/comment entries (previous at "
                << old->getPosition().str() << ")";
            error(yystack_[3].location, msg.str());
        }
        // Merge the user context in the comment
        merge(user_context, old);
    }

    // Set the user context
    parent->set("user-context", user_context);
    ctx.leave();
}
#line 1180 "d2_parser.cc"
    break;

  case 86: // $@21: %empty
#line 422 "d2_parser.yy"
                            {
    ctx.unique("forward-ddns", ctx.loc2pos(yystack_[0].location));
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("forward-ddns", m);
    ctx.stack_.push_back(m);
    ctx.enter(ctx.FORWARD_DDNS);
}
#line 1192 "d2_parser.cc"
    break;

  case 87: // forward_ddns: "forward-ddns" $@21 ":" "{" ddns_mgr_params "}"
#line 428 "d2_parser.yy"
                                                      {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1201 "d2_parser.cc"
    break;

  case 88: // $@22: %empty
#line 433 "d2_parser.yy"
                            {
    ctx.unique("reverse-ddns", ctx.loc2pos(yystack_[0].location));
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("reverse-ddns", m);
    ctx.stack_.push_back(m);
    ctx.enter(ctx.REVERSE_DDNS);
}
#line 1213 "d2_parser.cc"
    break;

  case 89: // reverse_ddns: "reverse-ddns" $@22 ":" "{" ddns_mgr_params "}"
#line 439 "d2_parser.yy"
                                                      {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1222 "d2_parser.cc"
    break;

  case 94: // not_empty_ddns_mgr_params: ddns_mgr_params ","
#line 450 "d2_parser.yy"
                                                 {
                             ctx.warnAboutExtraCommas(yystack_[0].location);
                             }
#line 1230 "d2_parser.cc"
    break;

  case 97: // $@23: %empty
#line 461 "d2_parser.yy"
                           {
    ctx.unique("ddns-domains", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("ddns-domains", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.DDNS_DOMAINS);
}
#line 1242 "d2_parser.cc"
    break;

  case 98: // ddns_domains: "ddns-domains" $@23 ":" "[" ddns_domain_list "]"
#line 467 "d2_parser.yy"
                                                         {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1251 "d2_parser.cc"
    break;

  case 99: // $@24: %empty
#line 472 "d2_parser.yy"
                                  {
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(l);
}
#line 1260 "d2_parser.cc"
    break;

  case 100: // sub_ddns_domains: "[" $@24 ddns_domain_list "]"
#line 475 "d2_parser.yy"
                                   {
    // parsing completed
}
#line 1268 "d2_parser.cc"
    break;

  case 105: // not_empty_ddns_domain_list: not_empty_ddns_domain_list ","
#line 485 "d2_parser.yy"
                                                           {
                            ctx.warnAboutExtraCommas(yystack_[0].location);
                            }
#line 1276 "d2_parser.cc"
    break;

  case 106: // $@25: %empty
#line 490 "d2_parser.yy"
                            {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 1286 "d2_parser.cc"
    break;

  case 107: // ddns_domain: "{" $@25 ddns_domain_params "}"
#line 494 "d2_parser.yy"
                                    {
    ctx.stack_.pop_back();
}
#line 1294 "d2_parser.cc"
    break;

  case 108: // $@26: %empty
#line 498 "d2_parser.yy"
                                {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 1303 "d2_parser.cc"
    break;

  case 109: // sub_ddns_domain: "{" $@26 ddns_domain_params "}"
#line 501 "d2_parser.yy"
                                    {
    // parsing completed
}
#line 1311 "d2_parser.cc"
    break;

  case 112: // ddns_domain_params: ddns_domain_params ","
#line 507 "d2_parser.yy"
                                             {
                      ctx.warnAboutExtraCommas(yystack_[0].location);
                      }
#line 1319 "d2_parser.cc"
    break;

  case 119: // $@27: %empty
#line 521 "d2_parser.yy"
                       {
    ctx.unique("name", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1328 "d2_parser.cc"
    break;

  case 120: // ddns_domain_name: "name" $@27 ":" "constant string"
#line 524 "d2_parser.yy"
               {
    if (yystack_[0].value.as < std::string > () == "") {
        error(yystack_[1].location, "Ddns domain name cannot be blank");
    }
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("name", name);
    ctx.leave();
}
#line 1342 "d2_parser.cc"
    break;

  case 121: // $@28: %empty
#line 534 "d2_parser.yy"
                        {
    ctx.unique("key-name", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1351 "d2_parser.cc"
    break;

  case 122: // ddns_key_name: "key-name" $@28 ":" "constant string"
#line 537 "d2_parser.yy"
               {
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("key-name", name);
    ctx.leave();
}
#line 1362 "d2_parser.cc"
    break;

  case 123: // $@29: %empty
#line 547 "d2_parser.yy"
                         {
    ctx.unique("dns-servers", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("dns-servers", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.DNS_SERVERS);
}
#line 1374 "d2_parser.cc"
    break;

  case 124: // dns_servers: "dns-servers" $@29 ":" "[" dns_server_list "]"
#line 553 "d2_parser.yy"
                                                        {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1383 "d2_parser.cc"
    break;

  case 125: // $@30: %empty
#line 558 "d2_parser.yy"
                                 {
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(l);
}
#line 1392 "d2_parser.cc"
    break;

  case 126: // sub_dns_servers: "[" $@30 dns_server_list "]"
#line 561 "d2_parser.yy"
                                  {
    // parsing completed
}
#line 1400 "d2_parser.cc"
    break;

  case 129: // dns_server_list: dns_server_list ","
#line 567 "d2_parser.yy"
                                       {
                   ctx.warnAboutExtraCommas(yystack_[0].location);
                   }
#line 1408 "d2_parser.cc"
    break;

  case 130: // $@31: %empty
#line 572 "d2_parser.yy"
                           {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 1418 "d2_parser.cc"
    break;

  case 131: // dns_server: "{" $@31 dns_server_params "}"
#line 576 "d2_parser.yy"
                                   {
    ctx.stack_.pop_back();
}
#line 1426 "d2_parser.cc"
    break;

  case 132: // $@32: %empty
#line 580 "d2_parser.yy"
                               {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 1435 "d2_parser.cc"
    break;

  case 133: // sub_dns_server: "{" $@32 dns_server_params "}"
#line 583 "d2_parser.yy"
                                   {
    // parsing completed
}
#line 1443 "d2_parser.cc"
    break;

  case 136: // dns_server_params: dns_server_params ","
#line 589 "d2_parser.yy"
                                         {
                   ctx.warnAboutExtraCommas(yystack_[0].location);
                   }
#line 1451 "d2_parser.cc"
    break;

  case 144: // $@33: %empty
#line 603 "d2_parser.yy"
                              {
    ctx.unique("hostname", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1460 "d2_parser.cc"
    break;

  case 145: // dns_server_hostname: "hostname" $@33 ":" "constant string"
#line 606 "d2_parser.yy"
               {
    if (yystack_[0].value.as < std::string > () != "") {
        error(yystack_[1].location, "hostname is not yet supported");
    }
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("hostname", name);
    ctx.leave();
}
#line 1474 "d2_parser.cc"
    break;

  case 146: // $@34: %empty
#line 616 "d2_parser.yy"
                                  {
    ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1483 "d2_parser.cc"
    break;

  case 147: // dns_server_ip_address: "ip-address" $@34 ":" "constant string"
#line 619 "d2_parser.yy"
               {
    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("ip-address", s);
    ctx.leave();
}
#line 1493 "d2_parser.cc"
    break;

  case 148: // dns_server_port: "port" ":" "integer"
#line 625 "d2_parser.yy"
                                    {
    ctx.unique("port", ctx.loc2pos(yystack_[2].location));
    if (yystack_[0].value.as < int64_t > () <= 0 || yystack_[0].value.as < int64_t > () >= 65536 ) {
        error(yystack_[0].location, "port must be greater than zero but less than 65536");
    }
    ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("port", i);
}
#line 1506 "d2_parser.cc"
    break;

  case 149: // $@35: %empty
#line 640 "d2_parser.yy"
                     {
    ctx.unique("tsig-keys", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("tsig-keys", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.TSIG_KEYS);
}
#line 1518 "d2_parser.cc"
    break;

  case 150: // tsig_keys: "tsig-keys" $@35 ":" "[" tsig_keys_list "]"
#line 646 "d2_parser.yy"
                                                       {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1527 "d2_parser.cc"
    break;

  case 151: // $@36: %empty
#line 651 "d2_parser.yy"
                               {
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(l);
}
#line 1536 "d2_parser.cc"
    break;

  case 152: // sub_tsig_keys: "[" $@36 tsig_keys_list "]"
#line 654 "d2_parser.yy"
                                 {
    // parsing completed
}
#line 1544 "d2_parser.cc"
    break;

  case 157: // not_empty_tsig_keys_list: not_empty_tsig_keys_list ","
#line 664 "d2_parser.yy"
                                                         {
                            ctx.warnAboutExtraCommas(yystack_[0].location);
                            }
#line 1552 "d2_parser.cc"
    break;

  case 158: // $@37: %empty
#line 669 "d2_parser.yy"
                         {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 1562 "d2_parser.cc"
    break;

  case 159: // tsig_key: "{" $@37 tsig_key_params "}"
#line 673 "d2_parser.yy"
                                 {
    ctx.stack_.pop_back();
}
#line 1570 "d2_parser.cc"
    break;

  case 160: // $@38: %empty
#line 677 "d2_parser.yy"
                             {
    // Parse tsig key list entry map
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 1580 "d2_parser.cc"
    break;

  case 161: // sub_tsig_key: "{" $@38 tsig_key_params "}"
#line 681 "d2_parser.yy"
                                 {
    // parsing completed
}
#line 1588 "d2_parser.cc"
    break;

  case 164: // tsig_key_params: tsig_key_params ","
#line 688 "d2_parser.yy"
                                       {
                   ctx.warnAboutExtraCommas(yystack_[0].location);
                   }
#line 1596 "d2_parser.cc"
    break;

  case 173: // $@39: %empty
#line 703 "d2_parser.yy"
                    {
    ctx.unique("name", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1605 "d2_parser.cc"
    break;

  case 174: // tsig_key_name: "name" $@39 ":" "constant string"
#line 706 "d2_parser.yy"
               {
    if (yystack_[0].value.as < std::string > () == "") {
        error(yystack_[1].location, "TSIG key name cannot be blank");
    }
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("name", name);
    ctx.leave();
}
#line 1619 "d2_parser.cc"
    break;

  case 175: // $@40: %empty
#line 716 "d2_parser.yy"
                              {
    ctx.unique("algorithm", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1628 "d2_parser.cc"
    break;

  case 176: // tsig_key_algorithm: "algorithm" $@40 ":" "constant string"
#line 719 "d2_parser.yy"
               {
    if (yystack_[0].value.as < std::string > () == "") {
        error(yystack_[1].location, "TSIG key algorithm cannot be blank");
    }
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("algorithm", elem);
    ctx.leave();
}
#line 1641 "d2_parser.cc"
    break;

  case 177: // tsig_key_digest_bits: "digest-bits" ":" "integer"
#line 728 "d2_parser.yy"
                                                {
    ctx.unique("digest-bits", ctx.loc2pos(yystack_[2].location));
    if (yystack_[0].value.as < int64_t > () < 0 || (yystack_[0].value.as < int64_t > () > 0  && (yystack_[0].value.as < int64_t > () % 8 != 0))) {
        error(yystack_[0].location, "TSIG key digest-bits must either be zero or a positive, multiple of eight");
    }
    ElementPtr elem(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("digest-bits", elem);
}
#line 1654 "d2_parser.cc"
    break;

  case 178: // $@41: %empty
#line 737 "d2_parser.yy"
                        {
    ctx.unique("secret", ctx.loc2pos(yystack_[0].location));
    ctx.unique("secret-file", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1664 "d2_parser.cc"
    break;

  case 179: // tsig_key_secret: "secret" $@41 ":" "constant string"
#line 741 "d2_parser.yy"
               {
    if (yystack_[0].value.as < std::string > () == "") {
        error(yystack_[1].location, "TSIG key secret cannot be blank");
    }
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("secret", elem);
    ctx.leave();
}
#line 1677 "d2_parser.cc"
    break;

  case 180: // $@42: %empty
#line 750 "d2_parser.yy"
                                  {
    ctx.unique("secret", ctx.loc2pos(yystack_[0].location));
    ctx.unique("secret-file", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1687 "d2_parser.cc"
    break;

  case 181: // tsig_key_secret_file: "secret-file" $@42 ":" "constant string"
#line 754 "d2_parser.yy"
               {
    if (yystack_[0].value.as < std::string > () == "") {
        error(yystack_[1].location, "TSIG key secret file name cannot be blank");
    }
    ElementPtr elem(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("secret-file", elem);
    ctx.leave();
}
#line 1700 "d2_parser.cc"
    break;

  case 182: // $@43: %empty
#line 768 "d2_parser.yy"
                               {
    ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location));
    ctx.unique("control-sockets", ctx.loc2pos(yystack_[0].location));
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("control-socket", m);
    ctx.stack_.push_back(m);
    ctx.enter(ctx.CONTROL_SOCKET);
}
#line 1713 "d2_parser.cc"
    break;

  case 183: // control_socket: "control-socket" $@43 ":" "{" control_socket_params "}"
#line 775 "d2_parser.yy"
                                                            {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1722 "d2_parser.cc"
    break;

  case 184: // $@44: %empty
#line 780 "d2_parser.yy"
                                 {
    ctx.unique("control-sockets", ctx.loc2pos(yystack_[0].location));
    ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("control-sockets", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.CONTROL_SOCKET);
}
#line 1735 "d2_parser.cc"
    break;

  case 185: // control_sockets: "control-sockets" $@44 ":" "[" control_socket_list "]"
#line 787 "d2_parser.yy"
                                                            {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1744 "d2_parser.cc"
    break;

  case 190: // not_empty_control_socket_list: not_empty_control_socket_list ","
#line 798 "d2_parser.yy"
                                                                   {
                                 ctx.warnAboutExtraCommas(yystack_[0].location);
                                 }
#line 1752 "d2_parser.cc"
    break;

  case 191: // $@45: %empty
#line 803 "d2_parser.yy"
                                     {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 1762 "d2_parser.cc"
    break;

  case 192: // control_socket_entry: "{" $@45 control_socket_params "}"
#line 807 "d2_parser.yy"
                                       {
    ctx.stack_.pop_back();
}
#line 1770 "d2_parser.cc"
    break;

  case 195: // control_socket_params: control_socket_params ","
#line 813 "d2_parser.yy"
                                                   {
                         ctx.warnAboutExtraCommas(yystack_[0].location);
                         }
#line 1778 "d2_parser.cc"
    break;

  case 208: // $@46: %empty
#line 832 "d2_parser.yy"
                                 {
    ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.CONTROL_SOCKET_TYPE);
}
#line 1787 "d2_parser.cc"
    break;

  case 209: // control_socket_type: "socket-type" $@46 ":" control_socket_type_value
#line 835 "d2_parser.yy"
                                  {
    ctx.stack_.back()->set("socket-type", yystack_[0].value.as < ElementPtr > ());
    ctx.leave();
}
#line 1796 "d2_parser.cc"
    break;

  case 210: // control_socket_type_value: "unix"
#line 841 "d2_parser.yy"
         { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("unix", ctx.loc2pos(yystack_[0].location))); }
#line 1802 "d2_parser.cc"
    break;

  case 211: // control_socket_type_value: "http"
#line 842 "d2_parser.yy"
         { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("http", ctx.loc2pos(yystack_[0].location))); }
#line 1808 "d2_parser.cc"
    break;

  case 212: // control_socket_type_value: "https"
#line 843 "d2_parser.yy"
          { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("https", ctx.loc2pos(yystack_[0].location))); }
#line 1814 "d2_parser.cc"
    break;

  case 213: // $@47: %empty
#line 846 "d2_parser.yy"
                                 {
    ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location));
    ctx.unique("socket-address", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1824 "d2_parser.cc"
    break;

  case 214: // control_socket_name: "socket-name" $@47 ":" "constant string"
#line 850 "d2_parser.yy"
               {
    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("socket-name", name);
    ctx.leave();
}
#line 1834 "d2_parser.cc"
    break;

  case 215: // $@48: %empty
#line 856 "d2_parser.yy"
                                       {
    ctx.unique("socket-address", ctx.loc2pos(yystack_[0].location));
    ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1844 "d2_parser.cc"
    break;

  case 216: // control_socket_address: "socket-address" $@48 ":" "constant string"
#line 860 "d2_parser.yy"
               {
    ElementPtr address(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("socket-address", address);
    ctx.leave();
}
#line 1854 "d2_parser.cc"
    break;

  case 217: // control_socket_port: "socket-port" ":" "integer"
#line 866 "d2_parser.yy"
                                               {
    ctx.unique("socket-port", ctx.loc2pos(yystack_[2].location));
    ElementPtr port(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("socket-port", port);
}
#line 1864 "d2_parser.cc"
    break;

  case 218: // $@49: %empty
#line 872 "d2_parser.yy"
                           {
    ctx.unique("trust-anchor", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1873 "d2_parser.cc"
    break;

  case 219: // trust_anchor: "trust-anchor" $@49 ":" "constant string"
#line 875 "d2_parser.yy"
               {
    ElementPtr ca(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("trust-anchor", ca);
    ctx.leave();
}
#line 1883 "d2_parser.cc"
    break;

  case 220: // $@50: %empty
#line 881 "d2_parser.yy"
                     {
    ctx.unique("cert-file", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1892 "d2_parser.cc"
    break;

  case 221: // cert_file: "cert-file" $@50 ":" "constant string"
#line 884 "d2_parser.yy"
               {
    ElementPtr cert(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("cert-file", cert);
    ctx.leave();
}
#line 1902 "d2_parser.cc"
    break;

  case 222: // $@51: %empty
#line 890 "d2_parser.yy"
                   {
    ctx.unique("key-file", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1911 "d2_parser.cc"
    break;

  case 223: // key_file: "key-file" $@51 ":" "constant string"
#line 893 "d2_parser.yy"
               {
    ElementPtr key(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("key-file", key);
    ctx.leave();
}
#line 1921 "d2_parser.cc"
    break;

  case 224: // cert_required: "cert-required" ":" "boolean"
#line 899 "d2_parser.yy"
                                           {
    ctx.unique("cert-required", ctx.loc2pos(yystack_[2].location));
    ElementPtr req(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("cert-required", req);
}
#line 1931 "d2_parser.cc"
    break;

  case 225: // $@52: %empty
#line 907 "d2_parser.yy"
                               {
    ctx.unique("authentication", ctx.loc2pos(yystack_[0].location));
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("authentication", m);
    ctx.stack_.push_back(m);
    ctx.enter(ctx.AUTHENTICATION);
}
#line 1943 "d2_parser.cc"
    break;

  case 226: // authentication: "authentication" $@52 ":" "{" auth_params "}"
#line 913 "d2_parser.yy"
                                                  {
    // The type parameter is required
    ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 1954 "d2_parser.cc"
    break;

  case 229: // auth_params: auth_params ","
#line 922 "d2_parser.yy"
                               {
               ctx.warnAboutExtraCommas(yystack_[0].location);
               }
#line 1962 "d2_parser.cc"
    break;

  case 237: // $@53: %empty
#line 936 "d2_parser.yy"
                {
    ctx.unique("type", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.AUTH_TYPE);
}
#line 1971 "d2_parser.cc"
    break;

  case 238: // auth_type: "type" $@53 ":" auth_type_value
#line 939 "d2_parser.yy"
                        {
    ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ());
    ctx.leave();
}
#line 1980 "d2_parser.cc"
    break;

  case 239: // auth_type_value: "basic"
#line 944 "d2_parser.yy"
                       { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("basic", ctx.loc2pos(yystack_[0].location))); }
#line 1986 "d2_parser.cc"
    break;

  case 240: // $@54: %empty
#line 947 "d2_parser.yy"
             {
    ctx.unique("realm", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 1995 "d2_parser.cc"
    break;

  case 241: // realm: "realm" $@54 ":" "constant string"
#line 950 "d2_parser.yy"
               {
    ElementPtr realm(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("realm", realm);
    ctx.leave();
}
#line 2005 "d2_parser.cc"
    break;

  case 242: // $@55: %empty
#line 956 "d2_parser.yy"
                     {
    ctx.unique("directory", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2014 "d2_parser.cc"
    break;

  case 243: // directory: "directory" $@55 ":" "constant string"
#line 959 "d2_parser.yy"
               {
    ElementPtr directory(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("directory", directory);
    ctx.leave();
}
#line 2024 "d2_parser.cc"
    break;

  case 244: // $@56: %empty
#line 965 "d2_parser.yy"
                 {
    ctx.unique("clients", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("clients", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.CLIENTS);
}
#line 2036 "d2_parser.cc"
    break;

  case 245: // clients: "clients" $@56 ":" "[" clients_list "]"
#line 971 "d2_parser.yy"
                                                     {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 2045 "d2_parser.cc"
    break;

  case 250: // not_empty_clients_list: not_empty_clients_list ","
#line 982 "d2_parser.yy"
                                                     {
                          ctx.warnAboutExtraCommas(yystack_[0].location);
                          }
#line 2053 "d2_parser.cc"
    break;

  case 251: // $@57: %empty
#line 987 "d2_parser.yy"
                           {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 2063 "d2_parser.cc"
    break;

  case 252: // basic_auth: "{" $@57 clients_params "}"
#line 991 "d2_parser.yy"
                                {
    ctx.stack_.pop_back();
}
#line 2071 "d2_parser.cc"
    break;

  case 255: // clients_params: clients_params ","
#line 997 "d2_parser.yy"
                                     {
                  ctx.warnAboutExtraCommas(yystack_[0].location);
                  }
#line 2079 "d2_parser.cc"
    break;

  case 263: // $@58: %empty
#line 1011 "d2_parser.yy"
           {
    ctx.unique("user", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2088 "d2_parser.cc"
    break;

  case 264: // user: "user" $@58 ":" "constant string"
#line 1014 "d2_parser.yy"
               {
    ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("user", user);
    ctx.leave();
}
#line 2098 "d2_parser.cc"
    break;

  case 265: // $@59: %empty
#line 1020 "d2_parser.yy"
                     {
    ctx.unique("user-file", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2107 "d2_parser.cc"
    break;

  case 266: // user_file: "user-file" $@59 ":" "constant string"
#line 1023 "d2_parser.yy"
               {
    ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("user-file", user);
    ctx.leave();
}
#line 2117 "d2_parser.cc"
    break;

  case 267: // $@60: %empty
#line 1029 "d2_parser.yy"
                   {
    ctx.unique("password", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2126 "d2_parser.cc"
    break;

  case 268: // password: "password" $@60 ":" "constant string"
#line 1032 "d2_parser.yy"
               {
    ElementPtr pwd(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("password", pwd);
    ctx.leave();
}
#line 2136 "d2_parser.cc"
    break;

  case 269: // $@61: %empty
#line 1038 "d2_parser.yy"
                             {
    ctx.unique("password-file", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2145 "d2_parser.cc"
    break;

  case 270: // password_file: "password-file" $@61 ":" "constant string"
#line 1041 "d2_parser.yy"
               {
    ElementPtr password(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("password-file", password);
    ctx.leave();
}
#line 2155 "d2_parser.cc"
    break;

  case 271: // $@62: %empty
#line 1049 "d2_parser.yy"
                                 {
    ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("hooks-libraries", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.HOOKS_LIBRARIES);
}
#line 2167 "d2_parser.cc"
    break;

  case 272: // hooks_libraries: "hooks-libraries" $@62 ":" "[" hooks_libraries_list "]"
#line 1055 "d2_parser.yy"
                                                             {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 2176 "d2_parser.cc"
    break;

  case 277: // not_empty_hooks_libraries_list: not_empty_hooks_libraries_list ","
#line 1066 "d2_parser.yy"
                                           {
        ctx.warnAboutExtraCommas(yystack_[0].location);
        }
#line 2184 "d2_parser.cc"
    break;

  case 278: // $@63: %empty
#line 1071 "d2_parser.yy"
                              {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 2194 "d2_parser.cc"
    break;

  case 279: // hooks_library: "{" $@63 hooks_params "}"
#line 1075 "d2_parser.yy"
                              {
    // The library hooks parameter is required
    ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
    ctx.stack_.pop_back();
}
#line 2204 "d2_parser.cc"
    break;

  case 280: // $@64: %empty
#line 1081 "d2_parser.yy"
                                  {
    // Parse the hooks-libraries list entry map
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.push_back(m);
}
#line 2214 "d2_parser.cc"
    break;

  case 281: // sub_hooks_library: "{" $@64 hooks_params "}"
#line 1085 "d2_parser.yy"
                              {
    // The library hooks parameter is required
    ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
    // parsing completed
}
#line 2224 "d2_parser.cc"
    break;

  case 284: // hooks_params: hooks_params ","
#line 1093 "d2_parser.yy"
                                 {
                ctx.warnAboutExtraCommas(yystack_[0].location);
                }
#line 2232 "d2_parser.cc"
    break;

  case 288: // $@65: %empty
#line 1103 "d2_parser.yy"
                 {
    ctx.unique("library", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2241 "d2_parser.cc"
    break;

  case 289: // library: "library" $@65 ":" "constant string"
#line 1106 "d2_parser.yy"
               {
    ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("library", lib);
    ctx.leave();
}
#line 2251 "d2_parser.cc"
    break;

  case 290: // $@66: %empty
#line 1112 "d2_parser.yy"
                       {
    ctx.unique("parameters", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2260 "d2_parser.cc"
    break;

  case 291: // parameters: "parameters" $@66 ":" map_value
#line 1115 "d2_parser.yy"
                  {
    ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ());
    ctx.leave();
}
#line 2269 "d2_parser.cc"
    break;

  case 292: // $@67: %empty
#line 1122 "d2_parser.yy"
                 {
    ctx.unique("loggers", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("loggers", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.LOGGERS);
}
#line 2281 "d2_parser.cc"
    break;

  case 293: // loggers: "loggers" $@67 ":" "[" loggers_entries "]"
#line 1128 "d2_parser.yy"
                                                         {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 2290 "d2_parser.cc"
    break;

  case 296: // loggers_entries: loggers_entries ","
#line 1137 "d2_parser.yy"
                                       {
                   ctx.warnAboutExtraCommas(yystack_[0].location);
                   }
#line 2298 "d2_parser.cc"
    break;

  case 297: // $@68: %empty
#line 1143 "d2_parser.yy"
                             {
    ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(l);
    ctx.stack_.push_back(l);
}
#line 2308 "d2_parser.cc"
    break;

  case 298: // logger_entry: "{" $@68 logger_params "}"
#line 1147 "d2_parser.yy"
                               {
    ctx.stack_.pop_back();
}
#line 2316 "d2_parser.cc"
    break;

  case 301: // logger_params: logger_params ","
#line 1153 "d2_parser.yy"
                                   {
                 ctx.warnAboutExtraCommas(yystack_[0].location);
                 }
#line 2324 "d2_parser.cc"
    break;

  case 309: // $@69: %empty
#line 1167 "d2_parser.yy"
           {
    ctx.unique("name", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2333 "d2_parser.cc"
    break;

  case 310: // name: "name" $@69 ":" "constant string"
#line 1170 "d2_parser.yy"
               {
    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("name", name);
    ctx.leave();
}
#line 2343 "d2_parser.cc"
    break;

  case 311: // debuglevel: "debuglevel" ":" "integer"
#line 1176 "d2_parser.yy"
                                     {
    ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location));
    ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("debuglevel", dl);
}
#line 2353 "d2_parser.cc"
    break;

  case 312: // $@70: %empty
#line 1182 "d2_parser.yy"
                   {
    ctx.unique("severity", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2362 "d2_parser.cc"
    break;

  case 313: // severity: "severity" $@70 ":" "constant string"
#line 1185 "d2_parser.yy"
               {
    ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("severity", sev);
    ctx.leave();
}
#line 2372 "d2_parser.cc"
    break;

  case 314: // $@71: %empty
#line 1191 "d2_parser.yy"
                                    {
    ctx.unique("output-options", ctx.loc2pos(yystack_[0].location));
    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("output-options", l);
    ctx.stack_.push_back(l);
    ctx.enter(ctx.OUTPUT_OPTIONS);
}
#line 2384 "d2_parser.cc"
    break;

  case 315: // output_options_list: "output-options" $@71 ":" "[" output_options_list_content "]"
#line 1197 "d2_parser.yy"
                                                                    {
    ctx.stack_.pop_back();
    ctx.leave();
}
#line 2393 "d2_parser.cc"
    break;

  case 318: // output_options_list_content: output_options_list_content ","
#line 1204 "d2_parser.yy"
                                                               {
                               ctx.warnAboutExtraCommas(yystack_[0].location);
                               }
#line 2401 "d2_parser.cc"
    break;

  case 319: // $@72: %empty
#line 1209 "d2_parser.yy"
                             {
    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->add(m);
    ctx.stack_.push_back(m);
}
#line 2411 "d2_parser.cc"
    break;

  case 320: // output_entry: "{" $@72 output_params_list "}"
#line 1213 "d2_parser.yy"
                                    {
    ctx.stack_.pop_back();
}
#line 2419 "d2_parser.cc"
    break;

  case 323: // output_params_list: output_params_list ","
#line 1219 "d2_parser.yy"
                                        {
                 ctx.warnAboutExtraCommas(yystack_[0].location);
                 }
#line 2427 "d2_parser.cc"
    break;

  case 329: // $@73: %empty
#line 1231 "d2_parser.yy"
               {
    ctx.unique("output", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2436 "d2_parser.cc"
    break;

  case 330: // output: "output" $@73 ":" "constant string"
#line 1234 "d2_parser.yy"
               {
    ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("output", sev);
    ctx.leave();
}
#line 2446 "d2_parser.cc"
    break;

  case 331: // flush: "flush" ":" "boolean"
#line 1240 "d2_parser.yy"
                           {
    ctx.unique("flush", ctx.loc2pos(yystack_[2].location));
    ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("flush", flush);
}
#line 2456 "d2_parser.cc"
    break;

  case 332: // maxsize: "maxsize" ":" "integer"
#line 1246 "d2_parser.yy"
                               {
    ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location));
    ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("maxsize", maxsize);
}
#line 2466 "d2_parser.cc"
    break;

  case 333: // maxver: "maxver" ":" "integer"
#line 1252 "d2_parser.yy"
                             {
    ctx.unique("maxver", ctx.loc2pos(yystack_[2].location));
    ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("maxver", maxver);
}
#line 2476 "d2_parser.cc"
    break;

  case 334: // $@74: %empty
#line 1258 "d2_parser.yy"
                 {
    ctx.unique("pattern", ctx.loc2pos(yystack_[0].location));
    ctx.enter(ctx.NO_KEYWORD);
}
#line 2485 "d2_parser.cc"
    break;

  case 335: // pattern: "pattern" $@74 ":" "constant string"
#line 1261 "d2_parser.yy"
               {
    ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
    ctx.stack_.back()->set("pattern", sev);
    ctx.leave();
}
#line 2495 "d2_parser.cc"
    break;


#line 2499 "d2_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
  D2Parser::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
  D2Parser::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
  D2Parser::symbol_name (symbol_kind_type yysymbol)
  {
    return yytnamerr_ (yytname_[yysymbol]);
  }



  // D2Parser::context.
  D2Parser::context::context (const D2Parser& yyparser, const symbol_type& yyla)
    : yyparser_ (yyparser)
    , yyla_ (yyla)
  {}

  int
  D2Parser::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
  D2Parser::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
  D2Parser::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 D2Parser::yypact_ninf_ = -215;

  const signed char D2Parser::yytable_ninf_ = -1;

  const short
  D2Parser::yypact_[] =
  {
      99,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,    33,     8,     0,    38,    42,    55,    73,   105,    96,
     107,   125,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,     8,    44,   129,     7,    47,   133,   141,   140,
      24,   142,   -25,  -215,   153,   160,   197,   194,   200,  -215,
      22,  -215,  -215,   201,   202,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,   203,  -215,    39,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,   204,  -215,  -215,  -215,  -215,
    -215,  -215,    43,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
     198,   206,  -215,  -215,  -215,  -215,  -215,  -215,  -215,    65,
    -215,  -215,  -215,  -215,  -215,   207,   214,  -215,  -215,   216,
    -215,  -215,  -215,  -215,  -215,    71,  -215,  -215,  -215,  -215,
    -215,    58,  -215,  -215,  -215,  -215,   115,  -215,  -215,  -215,
    -215,     8,     8,  -215,   132,   217,  -215,  -215,   218,   139,
     144,   220,   221,   223,   224,   225,   226,   227,   228,   229,
     230,   231,  -215,     7,  -215,   232,   158,   234,   235,   236,
      47,  -215,    47,  -215,   133,   237,   238,   239,   141,  -215,
     141,  -215,   140,   240,   166,   242,    24,  -215,    24,   142,
    -215,   243,   244,   -34,  -215,  -215,  -215,   245,   246,   172,
    -215,  -215,    76,   233,   247,   179,   248,   249,   253,   252,
     255,   256,   257,  -215,   189,  -215,   190,   191,   192,  -215,
     116,  -215,   193,   258,   195,  -215,   123,  -215,   196,  -215,
     199,  -215,   130,  -215,   205,   247,  -215,     8,     7,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,   -15,   -15,   133,
      18,   259,   265,   268,  -215,  -215,  -215,  -215,  -215,  -215,
     142,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,   174,
    -215,  -215,   175,  -215,  -215,  -215,   176,   270,  -215,  -215,
    -215,   260,  -215,  -215,  -215,  -215,   261,  -215,  -215,  -215,
     177,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,   272,   277,  -215,  -215,   275,   279,  -215,  -215,
      78,  -215,    87,  -215,   280,   -15,  -215,  -215,  -215,   281,
     282,   283,   173,   284,   285,   286,   287,   215,    18,  -215,
      18,  -215,   259,   -25,  -215,   265,    35,   268,  -215,  -215,
     293,  -215,   162,   241,   250,  -215,   292,   251,   254,   262,
    -215,  -215,   178,  -215,   184,  -215,  -215,  -215,   298,  -215,
    -215,  -215,  -215,   185,  -215,  -215,  -215,  -215,  -215,  -215,
     140,  -215,  -215,  -215,  -215,  -215,  -215,    63,  -215,  -215,
    -215,  -215,  -215,   299,   301,   264,   303,    35,  -215,   302,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,   186,  -215,  -215,
    -215,  -215,  -215,   266,   304,  -215,   267,  -215,  -215,   306,
     307,   309,   310,    63,  -215,  -215,   308,  -215,   273,   269,
     271,   312,  -215,  -215,    98,  -215,  -215,  -215,  -215,  -215,
     311,    50,   308,  -215,  -215,   314,   318,  -215,  -215,   319,
     320,   321,  -215,   187,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,    80,  -215,   311,   322,   274,   278,   288,   323,    50,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,   188,  -215,
    -215,  -215,  -215,  -215,  -215,   276,  -215,  -215,  -215,   290,
    -215,   326,   327,   329,   330,    80,  -215,  -215,  -215,   291,
     294,   295,   296,  -215,  -215,  -215,  -215,  -215
  };

  const short
  D2Parser::yydefact_[] =
  {
       0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
      20,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     1,    38,    30,    26,    25,    22,    23,    24,
      29,     3,    27,    28,    46,     5,    52,     7,   160,     9,
     151,    11,   108,    13,    99,    15,   132,    17,   125,    19,
     280,    21,    40,    33,     0,     0,     0,   153,     0,   101,
       0,     0,     0,    42,     0,    41,     0,     0,    34,    48,
       0,    50,    72,     0,     0,    76,    80,    82,    84,    86,
      88,   149,   182,   184,   271,   292,     0,    71,     0,    54,
      57,    58,    59,    60,    61,    69,    70,    62,    63,    64,
      65,    66,    67,    68,   175,     0,   178,   180,   173,   172,
     170,   171,     0,   162,   165,   166,   167,   168,   169,   158,
       0,   154,   155,   121,   123,   119,   118,   116,   117,     0,
     110,   113,   114,   115,   106,     0,   102,   103,   146,     0,
     144,   143,   141,   142,   140,     0,   134,   137,   138,   139,
     130,     0,   127,   288,   290,   285,     0,   282,   286,   287,
      39,    44,     0,    31,    37,     0,    51,    47,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,    45,    56,    53,     0,     0,     0,     0,     0,
     164,   161,     0,   152,   157,     0,     0,     0,   112,   109,
       0,   100,   105,     0,     0,     0,   136,   133,     0,   129,
     126,     0,     0,   284,   281,    43,    35,     0,     0,     0,
      74,    75,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    55,     0,   177,     0,     0,     0,   163,
       0,   156,     0,     0,     0,   111,     0,   104,     0,   148,
       0,   135,     0,   128,     0,     0,   283,     0,     0,    73,
      78,    79,    77,    81,    32,    83,    85,    90,    90,   153,
       0,   186,   273,     0,   176,   179,   181,   174,   159,   122,
       0,   120,   107,   147,   145,   131,   289,   291,    36,     0,
      97,    96,     0,    91,    92,    95,     0,     0,   208,   213,
     215,     0,   225,   218,   220,   222,     0,   207,   205,   206,
       0,   193,   196,   197,   198,   199,   201,   202,   203,   204,
     200,   191,     0,   187,   188,   278,     0,   274,   275,   297,
       0,   294,     0,    49,     0,    94,    87,    89,   150,     0,
       0,     0,     0,     0,     0,     0,     0,     0,   195,   183,
       0,   185,   190,     0,   272,   277,     0,   296,   293,   124,
       0,    93,     0,     0,     0,   217,     0,     0,     0,     0,
     224,   194,     0,   189,     0,   276,   309,   314,     0,   312,
     308,   306,   307,     0,   299,   302,   304,   305,   303,   295,
     101,   210,   211,   212,   209,   214,   216,     0,   219,   221,
     223,   192,   279,     0,     0,     0,     0,   301,   298,     0,
     237,   240,   242,   244,   236,   235,   234,     0,   227,   230,
     231,   232,   233,     0,     0,   311,     0,   300,    98,     0,
       0,     0,     0,   229,   226,   310,     0,   313,     0,     0,
       0,     0,   228,   319,     0,   316,   239,   238,   241,   243,
     246,     0,   318,   315,   251,     0,   247,   248,   329,     0,
       0,     0,   334,     0,   321,   324,   325,   326,   327,   328,
     317,     0,   245,   250,     0,     0,     0,     0,     0,   323,
     320,   263,   265,   267,   269,   262,   260,   261,     0,   253,
     256,   257,   258,   259,   249,     0,   331,   332,   333,     0,
     322,     0,     0,     0,     0,   255,   252,   330,   335,     0,
       0,     0,     0,   254,   264,   266,   268,   270
  };

  const short
  D2Parser::yypgoto_[] =
  {
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,   -41,  -215,  -214,  -215,    67,  -215,  -215,  -215,
    -215,  -215,  -215,   -56,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,    77,   154,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,   -55,  -215,   -44,  -215,  -215,  -215,  -215,  -215,
      68,  -215,     3,  -215,  -215,  -215,  -215,   -42,  -215,   137,
    -215,  -215,  -215,   146,   152,  -215,  -215,   -51,  -215,  -215,
    -215,  -215,  -215,    79,   147,  -215,  -215,  -215,   150,   155,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,    91,
    -215,   168,  -215,  -215,  -215,   183,   180,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,    12,  -215,    15,    23,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,   -67,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,   -97,  -215,  -215,  -126,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,  -215,
    -215,  -215,    25,  -215,  -215,  -215,    28,   169,  -215,  -215,
    -215,  -215,  -215,  -215,  -215,    26,  -215,  -215,   -23,  -215,
    -215,  -215,  -215,  -215,  -215,  -215,  -215,   -66,  -215,  -215,
     -94,  -215,  -215,  -215,  -215,  -215,  -215,  -215
  };

  const short
  D2Parser::yydefgoto_[] =
  {
       0,    11,    12,    13,    14,    15,    16,    17,    18,    19,
      20,    21,    30,    31,    32,    53,   265,    67,    68,    33,
      52,    64,    65,    87,    35,    54,    70,   165,    71,    37,
      55,    88,    89,    90,   168,    91,    92,    93,   171,   262,
      94,   172,    95,   173,    96,   174,    97,   175,    98,   176,
     292,   293,   294,   295,   334,    45,    59,   135,   136,   137,
     200,    43,    58,   129,   130,   131,   197,   132,   195,   133,
     196,    49,    61,   151,   152,   208,    47,    60,   145,   146,
     147,   205,   148,   203,   149,    99,   177,    41,    57,   120,
     121,   122,   192,    39,    56,   112,   113,   114,   189,   115,
     185,   116,   117,   187,   118,   188,   100,   178,   101,   179,
     322,   323,   324,   350,   310,   311,   312,   339,   394,   313,
     340,   314,   341,   315,   316,   344,   317,   345,   318,   346,
     319,   320,   343,   417,   418,   419,   429,   447,   420,   430,
     421,   431,   422,   432,   455,   456,   457,   471,   488,   489,
     490,   501,   491,   502,   492,   503,   493,   504,   102,   180,
     326,   327,   328,   353,    51,    62,   156,   157,   158,   211,
     159,   212,   103,   181,   330,   331,   356,   383,   384,   385,
     403,   386,   387,   406,   388,   404,   444,   445,   451,   463,
     464,   465,   474,   466,   467,   468,   469,   478
  };

  const short
  D2Parser::yytable_[] =
  {
     109,   110,   126,   127,   141,   142,   155,    34,   290,   144,
     264,    63,   111,    23,   128,    24,   143,    25,    72,    73,
      74,    75,   153,   154,    76,   166,    77,    78,    79,    80,
     167,   153,   154,    22,    81,   138,   139,    77,    78,    82,
      83,   264,   183,    77,    78,    36,   190,   184,   123,    38,
     140,   191,   298,    86,    77,    78,   299,   300,   301,   302,
      40,   209,    84,    86,   210,    85,    77,    78,   198,   303,
     304,   305,   306,   199,   206,   104,   105,   106,   107,   207,
      42,   357,    77,    78,   358,    86,    26,    27,    28,    29,
     209,   260,   261,   359,   376,   377,    86,   378,   379,    77,
      78,   452,    86,    46,   453,   410,   108,   411,   412,   413,
      44,   458,    48,    86,   459,   460,   461,   462,   213,   190,
     215,   216,    66,   214,   278,    86,   198,   481,   482,   483,
     484,   282,    50,   206,   109,   110,   109,   110,   285,    69,
     119,    86,   126,   127,   126,   127,   111,   134,   111,   150,
     141,   142,   141,   142,   128,   144,   128,   144,    86,   160,
      77,    78,   143,   161,   143,   123,   124,     1,     2,     3,
       4,     5,     6,     7,     8,     9,    10,   183,   335,   335,
     348,   348,   333,   336,   337,   349,   401,   213,   407,   433,
     479,   505,   402,   408,   434,   480,   506,   391,   392,   393,
     125,   162,   163,   164,   193,   169,   170,   182,   186,   194,
     217,   291,   291,   201,   307,   308,   288,   202,   220,    86,
     204,   218,   219,   221,   222,   223,   309,   224,   225,   226,
     227,   228,   229,   230,   231,   232,   234,   235,   236,   237,
     238,   242,   243,   244,   248,   249,   250,   254,   255,   257,
     259,   263,   365,   258,    24,   267,   268,   266,   269,   270,
     271,   272,   273,   280,   342,   347,   321,   274,   275,   276,
     277,   279,   325,   281,   283,   329,   338,   284,   351,   291,
     352,   354,   355,   286,   360,   362,   363,   364,   366,   367,
     368,   369,   307,   308,   307,   308,   370,   155,   390,   397,
     380,   381,   405,   423,   309,   424,   309,   426,   428,   436,
     438,   439,   382,   440,   441,   443,   446,   450,   454,   395,
     472,   473,   287,   475,   476,   477,   495,   499,   396,   398,
     509,   510,   399,   511,   512,   289,   296,   233,   361,   247,
     400,   414,   415,   425,   435,   437,   246,   448,   409,   449,
     245,   380,   381,   416,   507,   496,   253,   497,   252,   332,
     297,   251,   241,   382,   373,   372,   442,   498,   508,   514,
     239,   371,   515,   516,   517,   240,   494,   414,   415,   513,
     375,   374,   256,   389,   427,   500,   470,     0,     0,   416,
       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,   485,   486,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,   487,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,   485,
     486,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,   487
  };

  const short
  D2Parser::yycheck_[] =
  {
      56,    56,    58,    58,    60,    60,    62,     7,    23,    60,
     224,    52,    56,     5,    58,     7,    60,     9,    11,    12,
      13,    14,    56,    57,    17,     3,    19,    20,    21,    22,
       8,    56,    57,     0,    27,    11,    12,    19,    20,    32,
      33,   255,     3,    19,    20,     7,     3,     8,    24,     7,
      26,     8,    34,    78,    19,    20,    38,    39,    40,    41,
       5,     3,    55,    78,     6,    58,    19,    20,     3,    51,
      52,    53,    54,     8,     3,    28,    29,    30,    31,     8,
       7,     3,    19,    20,     6,    78,    78,    79,    80,    81,
       3,    15,    16,     6,    59,    60,    78,    62,    63,    19,
      20,     3,    78,     7,     6,    42,    59,    44,    45,    46,
       5,    61,     5,    78,    64,    65,    66,    67,     3,     3,
     161,   162,    78,     8,     8,    78,     3,    47,    48,    49,
      50,     8,     7,     3,   190,   190,   192,   192,     8,    10,
       7,    78,   198,   198,   200,   200,   190,     7,   192,     7,
     206,   206,   208,   208,   198,   206,   200,   208,    78,     6,
      19,    20,   206,     3,   208,    24,    25,    68,    69,    70,
      71,    72,    73,    74,    75,    76,    77,     3,     3,     3,
       3,     3,     8,     8,     8,     8,     8,     3,     3,     3,
       3,     3,     8,     8,     8,     8,     8,    35,    36,    37,
      59,     4,     8,     3,     6,     4,     4,     4,     4,     3,
      78,   267,   268,     6,   270,   270,   257,     3,    79,    78,
       4,     4,     4,    79,     4,     4,   270,     4,     4,     4,
       4,     4,     4,     4,     4,     4,     4,    79,     4,     4,
       4,     4,     4,     4,     4,    79,     4,     4,     4,     4,
      78,    18,    79,     7,     7,     7,     7,    78,     5,     7,
       5,     5,     5,     5,     4,     4,     7,    78,    78,    78,
      78,    78,     7,    78,    78,     7,     6,    78,     6,   335,
       3,     6,     3,    78,     4,     4,     4,     4,     4,     4,
       4,     4,   348,   348,   350,   350,    81,   353,     5,     7,
     356,   356,     4,     4,   348,     4,   350,     4,     6,     5,
       4,     4,   356,     4,     4,     7,    43,     5,     7,    78,
       6,     3,   255,     4,     4,     4,     4,     4,    78,    78,
       4,     4,    78,     4,     4,   258,   268,   183,   335,   202,
      78,   397,   397,    79,    78,    78,   200,    78,   390,    78,
     198,   407,   407,   397,    78,    81,   209,    79,   208,   280,
     269,   206,   194,   407,   352,   350,   433,    79,    78,    78,
     190,   348,    78,    78,    78,   192,   473,   433,   433,   505,
     355,   353,   213,   357,   407,   479,   452,    -1,    -1,   433,
      -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,   471,   471,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,   471,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   505,
     505,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      -1,   505
  };

  const short
  D2Parser::yystos_[] =
  {
       0,    68,    69,    70,    71,    72,    73,    74,    75,    76,
      77,    83,    84,    85,    86,    87,    88,    89,    90,    91,
      92,    93,     0,     5,     7,     9,    78,    79,    80,    81,
      94,    95,    96,   101,     7,   106,     7,   111,     7,   175,
       5,   169,     7,   143,     5,   137,     7,   158,     5,   153,
       7,   246,   102,    97,   107,   112,   176,   170,   144,   138,
     159,   154,   247,    94,   103,   104,    78,    99,   100,    10,
     108,   110,    11,    12,    13,    14,    17,    19,    20,    21,
      22,    27,    32,    33,    55,    58,    78,   105,   113,   114,
     115,   117,   118,   119,   122,   124,   126,   128,   130,   167,
     188,   190,   240,   254,    28,    29,    30,    31,    59,   105,
     124,   126,   177,   178,   179,   181,   183,   184,   186,     7,
     171,   172,   173,    24,    25,    59,   105,   124,   126,   145,
     146,   147,   149,   151,     7,   139,   140,   141,    11,    12,
      26,   105,   124,   126,   149,   160,   161,   162,   164,   166,
       7,   155,   156,    56,    57,   105,   248,   249,   250,   252,
       6,     3,     4,     8,     3,   109,     3,     8,   116,     4,
       4,   120,   123,   125,   127,   129,   131,   168,   189,   191,
     241,   255,     4,     3,     8,   182,     4,   185,   187,   180,
       3,     8,   174,     6,     3,   150,   152,   148,     3,     8,
     142,     6,     3,   165,     4,   163,     3,     8,   157,     3,
       6,   251,   253,     3,     8,    94,    94,    78,     4,     4,
      79,    79,     4,     4,     4,     4,     4,     4,     4,     4,
       4,     4,     4,   114,     4,    79,     4,     4,     4,   178,
     177,   173,     4,     4,     4,   146,   145,   141,     4,    79,
       4,   161,   160,   156,     4,     4,   249,     4,     7,    78,
      15,    16,   121,    18,    96,    98,    78,     7,     7,     5,
       7,     5,     5,     5,    78,    78,    78,    78,     8,    78,
       5,    78,     8,    78,    78,     8,    78,    98,    94,   113,
      23,   105,   132,   133,   134,   135,   132,   171,    34,    38,
      39,    40,    41,    51,    52,    53,    54,   105,   124,   126,
     196,   197,   198,   201,   203,   205,   206,   208,   210,   212,
     213,     7,   192,   193,   194,     7,   242,   243,   244,     7,
     256,   257,   155,     8,   136,     3,     8,     8,     6,   199,
     202,   204,     4,   214,   207,   209,   211,     4,     3,     8,
     195,     6,     3,   245,     6,     3,   258,     3,     6,     6,
       4,   134,     4,     4,     4,    79,     4,     4,     4,     4,
      81,   197,   196,   194,   248,   244,    59,    60,    62,    63,
     105,   124,   126,   259,   260,   261,   263,   264,   266,   257,
       5,    35,    36,    37,   200,    78,    78,     7,    78,    78,
      78,     8,     8,   262,   267,     4,   265,     3,     8,   139,
      42,    44,    45,    46,   105,   124,   126,   215,   216,   217,
     220,   222,   224,     4,     4,    79,     4,   260,     6,   218,
     221,   223,   225,     3,     8,    78,     5,    78,     4,     4,
       4,     4,   216,     7,   268,   269,    43,   219,    78,    78,
       5,   270,     3,     6,     7,   226,   227,   228,    61,    64,
      65,    66,    67,   271,   272,   273,   275,   276,   277,   278,
     269,   229,     6,     3,   274,     4,     4,     4,   279,     3,
       8,    47,    48,    49,    50,   105,   124,   126,   230,   231,
     232,   234,   236,   238,   228,     4,    81,    79,    79,     4,
     272,   233,   235,   237,   239,     3,     8,    78,    78,     4,
       4,     4,     4,   231,    78,    78,    78,    78
  };

  const short
  D2Parser::yyr1_[] =
  {
       0,    82,    84,    83,    85,    83,    86,    83,    87,    83,
      88,    83,    89,    83,    90,    83,    91,    83,    92,    83,
      93,    83,    94,    94,    94,    94,    94,    94,    94,    95,
      97,    96,    98,    99,    99,   100,   100,   100,   102,   101,
     103,   103,   104,   104,   104,   105,   107,   106,   109,   108,
     108,   110,   112,   111,   113,   113,   113,   114,   114,   114,
     114,   114,   114,   114,   114,   114,   114,   114,   114,   114,
     114,   114,   116,   115,   117,   118,   120,   119,   121,   121,
     123,   122,   125,   124,   127,   126,   129,   128,   131,   130,
     132,   132,   133,   133,   133,   134,   134,   136,   135,   138,
     137,   139,   139,   140,   140,   140,   142,   141,   144,   143,
     145,   145,   145,   146,   146,   146,   146,   146,   146,   148,
     147,   150,   149,   152,   151,   154,   153,   155,   155,   155,
     157,   156,   159,   158,   160,   160,   160,   161,   161,   161,
     161,   161,   161,   161,   163,   162,   165,   164,   166,   168,
     167,   170,   169,   171,   171,   172,   172,   172,   174,   173,
     176,   175,   177,   177,   177,   178,   178,   178,   178,   178,
     178,   178,   178,   180,   179,   182,   181,   183,   185,   184,
     187,   186,   189,   188,   191,   190,   192,   192,   193,   193,
     193,   195,   194,   196,   196,   196,   197,   197,   197,   197,
     197,   197,   197,   197,   197,   197,   197,   197,   199,   198,
     200,   200,   200,   202,   201,   204,   203,   205,   207,   206,
     209,   208,   211,   210,   212,   214,   213,   215,   215,   215,
     216,   216,   216,   216,   216,   216,   216,   218,   217,   219,
     221,   220,   223,   222,   225,   224,   226,   226,   227,   227,
     227,   229,   228,   230,   230,   230,   231,   231,   231,   231,
     231,   231,   231,   233,   232,   235,   234,   237,   236,   239,
     238,   241,   240,   242,   242,   243,   243,   243,   245,   244,
     247,   246,   248,   248,   248,   248,   249,   249,   251,   250,
     253,   252,   255,   254,   256,   256,   256,   258,   257,   259,
     259,   259,   260,   260,   260,   260,   260,   260,   260,   262,
     261,   263,   265,   264,   267,   266,   268,   268,   268,   270,
     269,   271,   271,   271,   272,   272,   272,   272,   272,   274,
     273,   275,   276,   277,   279,   278
  };

  const signed char
  D2Parser::yyr2_[] =
  {
       0,     2,     0,     3,     0,     3,     0,     3,     0,     3,
       0,     3,     0,     3,     0,     3,     0,     3,     0,     3,
       0,     3,     1,     1,     1,     1,     1,     1,     1,     1,
       0,     4,     1,     0,     1,     3,     5,     2,     0,     4,
       0,     1,     1,     3,     2,     2,     0,     4,     0,     6,
       1,     2,     0,     4,     1,     3,     2,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     0,     4,     3,     3,     0,     4,     1,     1,
       0,     4,     0,     4,     0,     4,     0,     6,     0,     6,
       0,     1,     1,     3,     2,     1,     1,     0,     6,     0,
       4,     0,     1,     1,     3,     2,     0,     4,     0,     4,
       1,     3,     2,     1,     1,     1,     1,     1,     1,     0,
       4,     0,     4,     0,     6,     0,     4,     1,     3,     2,
       0,     4,     0,     4,     1,     3,     2,     1,     1,     1,
       1,     1,     1,     1,     0,     4,     0,     4,     3,     0,
       6,     0,     4,     0,     1,     1,     3,     2,     0,     4,
       0,     4,     1,     3,     2,     1,     1,     1,     1,     1,
       1,     1,     1,     0,     4,     0,     4,     3,     0,     4,
       0,     4,     0,     6,     0,     6,     0,     1,     1,     3,
       2,     0,     4,     1,     3,     2,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
       1,     1,     1,     0,     4,     0,     4,     3,     0,     4,
       0,     4,     0,     4,     3,     0,     6,     1,     3,     2,
       1,     1,     1,     1,     1,     1,     1,     0,     4,     1,
       0,     4,     0,     4,     0,     6,     0,     1,     1,     3,
       2,     0,     4,     1,     3,     2,     1,     1,     1,     1,
       1,     1,     1,     0,     4,     0,     4,     0,     4,     0,
       4,     0,     6,     0,     1,     1,     3,     2,     0,     4,
       0,     4,     1,     3,     2,     1,     1,     1,     0,     4,
       0,     4,     0,     6,     1,     3,     2,     0,     4,     1,
       3,     2,     1,     1,     1,     1,     1,     1,     1,     0,
       4,     3,     0,     4,     0,     6,     1,     3,     2,     0,
       4,     1,     3,     2,     1,     1,     1,     1,     1,     0,
       4,     3,     3,     3,     0,     4
  };


#if D2_PARSER_DEBUG || 1
  // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
  // First, the terminals, then, starting at \a YYNTOKENS, nonterminals.
  const char*
  const D2Parser::yytname_[] =
  {
  "\"end of file\"", "error", "\"invalid token\"", "\",\"", "\":\"",
  "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"DhcpDdns\"",
  "\"ip-address\"", "\"port\"", "\"dns-server-timeout\"",
  "\"ncr-protocol\"", "\"UDP\"", "\"TCP\"", "\"ncr-format\"", "\"JSON\"",
  "\"user-context\"", "\"comment\"", "\"forward-ddns\"",
  "\"reverse-ddns\"", "\"ddns-domains\"", "\"key-name\"",
  "\"dns-servers\"", "\"hostname\"", "\"tsig-keys\"", "\"algorithm\"",
  "\"digest-bits\"", "\"secret\"", "\"secret-file\"", "\"control-socket\"",
  "\"control-sockets\"", "\"socket-type\"", "\"unix\"", "\"http\"",
  "\"https\"", "\"socket-name\"", "\"socket-address\"", "\"socket-port\"",
  "\"authentication\"", "\"type\"", "\"basic\"", "\"realm\"",
  "\"directory\"", "\"clients\"", "\"user\"", "\"user-file\"",
  "\"password\"", "\"password-file\"", "\"trust-anchor\"", "\"cert-file\"",
  "\"key-file\"", "\"cert-required\"", "\"hooks-libraries\"",
  "\"library\"", "\"parameters\"", "\"loggers\"", "\"name\"",
  "\"output-options\"", "\"output\"", "\"debuglevel\"", "\"severity\"",
  "\"flush\"", "\"maxsize\"", "\"maxver\"", "\"pattern\"", "TOPLEVEL_JSON",
  "TOPLEVEL_DHCPDDNS", "SUB_DHCPDDNS", "SUB_TSIG_KEY", "SUB_TSIG_KEYS",
  "SUB_DDNS_DOMAIN", "SUB_DDNS_DOMAINS", "SUB_DNS_SERVER",
  "SUB_DNS_SERVERS", "SUB_HOOKS_LIBRARY", "\"constant string\"",
  "\"integer\"", "\"floating point\"", "\"boolean\"", "$accept", "start",
  "$@1", "$@2", "$@3", "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10",
  "value", "sub_json", "map2", "$@11", "map_value", "map_content",
  "not_empty_map", "list_generic", "$@12", "list_content",
  "not_empty_list", "unknown_map_entry", "syntax_map", "$@13",
  "global_object", "$@14", "global_object_comma", "sub_dhcpddns", "$@15",
  "dhcpddns_params", "dhcpddns_param", "ip_address", "$@16", "port",
  "dns_server_timeout", "ncr_protocol", "$@17", "ncr_protocol_value",
  "ncr_format", "$@18", "user_context", "$@19", "comment", "$@20",
  "forward_ddns", "$@21", "reverse_ddns", "$@22", "ddns_mgr_params",
  "not_empty_ddns_mgr_params", "ddns_mgr_param", "ddns_domains", "$@23",
  "sub_ddns_domains", "$@24", "ddns_domain_list",
  "not_empty_ddns_domain_list", "ddns_domain", "$@25", "sub_ddns_domain",
  "$@26", "ddns_domain_params", "ddns_domain_param", "ddns_domain_name",
  "$@27", "ddns_key_name", "$@28", "dns_servers", "$@29",
  "sub_dns_servers", "$@30", "dns_server_list", "dns_server", "$@31",
  "sub_dns_server", "$@32", "dns_server_params", "dns_server_param",
  "dns_server_hostname", "$@33", "dns_server_ip_address", "$@34",
  "dns_server_port", "tsig_keys", "$@35", "sub_tsig_keys", "$@36",
  "tsig_keys_list", "not_empty_tsig_keys_list", "tsig_key", "$@37",
  "sub_tsig_key", "$@38", "tsig_key_params", "tsig_key_param",
  "tsig_key_name", "$@39", "tsig_key_algorithm", "$@40",
  "tsig_key_digest_bits", "tsig_key_secret", "$@41",
  "tsig_key_secret_file", "$@42", "control_socket", "$@43",
  "control_sockets", "$@44", "control_socket_list",
  "not_empty_control_socket_list", "control_socket_entry", "$@45",
  "control_socket_params", "control_socket_param", "control_socket_type",
  "$@46", "control_socket_type_value", "control_socket_name", "$@47",
  "control_socket_address", "$@48", "control_socket_port", "trust_anchor",
  "$@49", "cert_file", "$@50", "key_file", "$@51", "cert_required",
  "authentication", "$@52", "auth_params", "auth_param", "auth_type",
  "$@53", "auth_type_value", "realm", "$@54", "directory", "$@55",
  "clients", "$@56", "clients_list", "not_empty_clients_list",
  "basic_auth", "$@57", "clients_params", "clients_param", "user", "$@58",
  "user_file", "$@59", "password", "$@60", "password_file", "$@61",
  "hooks_libraries", "$@62", "hooks_libraries_list",
  "not_empty_hooks_libraries_list", "hooks_library", "$@63",
  "sub_hooks_library", "$@64", "hooks_params", "hooks_param", "library",
  "$@65", "parameters", "$@66", "loggers", "$@67", "loggers_entries",
  "logger_entry", "$@68", "logger_params", "logger_param", "name", "$@69",
  "debuglevel", "severity", "$@70", "output_options_list", "$@71",
  "output_options_list_content", "output_entry", "$@72",
  "output_params_list", "output_params", "output", "$@73", "flush",
  "maxsize", "maxver", "pattern", "$@74", YY_NULLPTR
  };
#endif


#if D2_PARSER_DEBUG
  const short
  D2Parser::yyrline_[] =
  {
       0,   154,   154,   154,   155,   155,   156,   156,   157,   157,
     158,   158,   159,   159,   160,   160,   161,   161,   162,   162,
     163,   163,   171,   172,   173,   174,   175,   176,   177,   180,
     185,   185,   196,   199,   200,   203,   208,   214,   219,   219,
     226,   227,   230,   234,   238,   248,   257,   257,   270,   270,
     280,   283,   287,   287,   295,   296,   297,   303,   304,   305,
     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
     316,   317,   320,   320,   329,   338,   348,   348,   357,   358,
     361,   361,   370,   370,   395,   395,   422,   422,   433,   433,
     444,   445,   448,   449,   450,   455,   456,   461,   461,   472,
     472,   479,   480,   483,   484,   485,   490,   490,   498,   498,
     505,   506,   507,   512,   513,   514,   515,   516,   517,   521,
     521,   534,   534,   547,   547,   558,   558,   565,   566,   567,
     572,   572,   580,   580,   587,   588,   589,   594,   595,   596,
     597,   598,   599,   600,   603,   603,   616,   616,   625,   640,
     640,   651,   651,   658,   659,   662,   663,   664,   669,   669,
     677,   677,   686,   687,   688,   693,   694,   695,   696,   697,
     698,   699,   700,   703,   703,   716,   716,   728,   737,   737,
     750,   750,   768,   768,   780,   780,   792,   793,   796,   797,
     798,   803,   803,   811,   812,   813,   818,   819,   820,   821,
     822,   823,   824,   825,   826,   827,   828,   829,   832,   832,
     841,   842,   843,   846,   846,   856,   856,   866,   872,   872,
     881,   881,   890,   890,   899,   907,   907,   920,   921,   922,
     927,   928,   929,   930,   931,   932,   933,   936,   936,   944,
     947,   947,   956,   956,   965,   965,   976,   977,   980,   981,
     982,   987,   987,   995,   996,   997,  1002,  1003,  1004,  1005,
    1006,  1007,  1008,  1011,  1011,  1020,  1020,  1029,  1029,  1038,
    1038,  1049,  1049,  1060,  1061,  1064,  1065,  1066,  1071,  1071,
    1081,  1081,  1091,  1092,  1093,  1096,  1099,  1100,  1103,  1103,
    1112,  1112,  1122,  1122,  1135,  1136,  1137,  1143,  1143,  1151,
    1152,  1153,  1158,  1159,  1160,  1161,  1162,  1163,  1164,  1167,
    1167,  1176,  1182,  1182,  1191,  1191,  1202,  1203,  1204,  1209,
    1209,  1217,  1218,  1219,  1224,  1225,  1226,  1227,  1228,  1231,
    1231,  1240,  1246,  1252,  1258,  1258
  };

  void
  D2Parser::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
  D2Parser::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 // D2_PARSER_DEBUG


#line 14 "d2_parser.yy"
} } // isc::d2
#line 3403 "d2_parser.cc"

#line 1267 "d2_parser.yy"


void
isc::d2::D2Parser::error(const location_type& loc,
                              const std::string& what)
{
    ctx.error(loc, what);
}
