// A Bison parser, made by GNU Bison 3.0.4.

// Skeleton implementation for Bison LALR(1) parsers in C++

// Copyright (C) 2002-2015 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 <http://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.

// First part of user declarations.

#line 37 "d4_function_parser.tab.cc" // lalr1.cc:404

# ifndef YY_NULLPTR

#  if defined __cplusplus && 201103L <= __cplusplus

#   define YY_NULLPTR nullptr

#  else

#   define YY_NULLPTR 0

#  endif

# endif

#include "d4_function_parser.tab.hh"

// User implementation prologue.

#line 51 "d4_function_parser.tab.cc" // lalr1.cc:412

// Unqualified %code blocks.

#line 77 "d4_function_parser.yy" // lalr1.cc:413

    #include "BaseType.h"

    #include "DMR.h"

    #include "D4RValue.h"

    #include "ServerFunctionsList.h"

    #include "parser-util.h"

    /* include for all driver functions */

    #include "D4FunctionEvaluator.h"

    using namespace libdap ;

    /* this is silly, but I can't figure out a way around it */

    static int yylex(libdap::D4FunctionParser::semantic_type *yylval,

                     libdap::location *loc,

                     libdap::D4FunctionScanner  &scanner,

                     libdap::D4FunctionEvaluator   &evaluator);

#line 73 "d4_function_parser.tab.cc" // lalr1.cc:413

#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

#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 (/*CONSTCOND*/ false)

# endif

// Suppress unused-variable warnings by "using" E.

#define YYUSE(E) ((void) (E))

// Enable debugging if requested.

#if YYDEBUG

// 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_ << std::endl;                  \

    }                                           \

  } while (false)

# define YY_REDUCE_PRINT(Rule)          \

  do {                                  \

    if (yydebug_)                       \

      yy_reduce_print_ (Rule);          \

  } while (false)

# define YY_STACK_PRINT()               \

  do {                                  \

    if (yydebug_)                       \

      yystack_print_ ();                \

  } while (false)

#else // !YYDEBUG

# define YYCDEBUG if (false) std::cerr

# define YY_SYMBOL_PRINT(Title, Symbol)  YYUSE(Symbol)

# define YY_REDUCE_PRINT(Rule)           static_cast<void>(0)

# define YY_STACK_PRINT()                static_cast<void>(0)

#endif // !YYDEBUG

#define yyerrok         (yyerrstatus_ = 0)

#define yyclearin       (yyla.clear ())

#define YYACCEPT        goto yyacceptlab

#define YYABORT         goto yyabortlab

#define YYERROR         goto yyerrorlab

#define YYRECOVERING()  (!!yyerrstatus_)

#line 34 "d4_function_parser.yy" // lalr1.cc:479

namespace libdap {

#line 159 "d4_function_parser.tab.cc" // lalr1.cc:479

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

  D4FunctionParser::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;

              // Fall through.

            default:

              yyr += *yyp;

              break;

            case '"':

              return yyr;

            }

      do_not_strip_quotes: ;

      }

    return yystr;

  }

  /// Build a parser object.

  D4FunctionParser::D4FunctionParser (D4FunctionScanner  &scanner_yyarg, D4FunctionEvaluator  &evaluator_yyarg)

    :

#if YYDEBUG

      yydebug_ (false),

      yycdebug_ (&std::cerr),

#endif

      scanner (scanner_yyarg),

      evaluator (evaluator_yyarg)

  {}

  D4FunctionParser::~D4FunctionParser ()

  {}

  /*---------------.

  | Symbol types.  |

  `---------------*/

  inline

  D4FunctionParser::syntax_error::syntax_error (const location_type& l, const std::string& m)

    : std::runtime_error (m)

    , location (l)

  {}

  // basic_symbol.

  template <typename Base>

  inline

  D4FunctionParser::basic_symbol<Base>::basic_symbol ()

    : value ()

  {}

  template <typename Base>

  inline

  D4FunctionParser::basic_symbol<Base>::basic_symbol (const basic_symbol& other)

    : Base (other)

    , value ()

    , location (other.location)

  {

      switch (other.type_get ())

    {

      case 7: // "function name"

      case 44: // fname

        value.copy< D4Function > (other.value);

        break;

      case 5: // "argument"

      case 6: // "function"

      case 8: // "variable or constant"

      case 9: // "array constant"

      case 43: // function

      case 46: // arg

      case 47: // variable_or_constant

      case 48: // array_constant

        value.copy< D4RValue* > (other.value);

        break;

      case 3: // "functions"

      case 4: // "arguments"

      case 42: // functions

      case 45: // args

        value.copy< D4RValueList* > (other.value);

        break;

      case 20: // "word"

      case 21: // "string"

      case 60: // id

      case 61: // group

      case 62: // path

      case 63: // name

        value.copy< std::string > (other.value);

        break;

      case 10: // "fast byte arg list"

      case 50: // fast_byte_arg_list

        value.copy< std::vector<dods_byte>* > (other.value);

        break;

      case 18: // "fast float32 arg list"

      case 58: // fast_float32_arg_list

        value.copy< std::vector<dods_float32>* > (other.value);

        break;

      case 19: // "fast float64 arg list"

      case 59: // fast_float64_arg_list

        value.copy< std::vector<dods_float64>* > (other.value);

        break;

      case 13: // "fast int16 arg list"

      case 53: // fast_int16_arg_list

        value.copy< std::vector<dods_int16>* > (other.value);

        break;

      case 15: // "fast int32 arg list"

      case 55: // fast_int32_arg_list

        value.copy< std::vector<dods_int32>* > (other.value);

        break;

      case 17: // "fast int64 arg list"

      case 57: // fast_int64_arg_list

        value.copy< std::vector<dods_int64>* > (other.value);

        break;

      case 11: // "fast int8 arg list"

      case 51: // fast_int8_arg_list

        value.copy< std::vector<dods_int8>* > (other.value);

        break;

      case 12: // "fast uint16 arg list"

      case 52: // fast_uint16_arg_list

        value.copy< std::vector<dods_uint16>* > (other.value);

        break;

      case 14: // "fast uint32 arg list"

      case 54: // fast_uint32_arg_list

        value.copy< std::vector<dods_uint32>* > (other.value);

        break;

      case 16: // "fast uint64 arg list"

      case 56: // fast_uint64_arg_list

        value.copy< std::vector<dods_uint64>* > (other.value);

        break;

      default:

        break;

    }

  }

  template <typename Base>

  inline

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const semantic_type& v, const location_type& l)

    : Base (t)

    , value ()

    , location (l)

  {

    (void) v;

      switch (this->type_get ())

    {

      case 7: // "function name"

      case 44: // fname

        value.copy< D4Function > (v);

        break;

      case 5: // "argument"

      case 6: // "function"

      case 8: // "variable or constant"

      case 9: // "array constant"

      case 43: // function

      case 46: // arg

      case 47: // variable_or_constant

      case 48: // array_constant

        value.copy< D4RValue* > (v);

        break;

      case 3: // "functions"

      case 4: // "arguments"

      case 42: // functions

      case 45: // args

        value.copy< D4RValueList* > (v);

        break;

      case 20: // "word"

      case 21: // "string"

      case 60: // id

      case 61: // group

      case 62: // path

      case 63: // name

        value.copy< std::string > (v);

        break;

      case 10: // "fast byte arg list"

      case 50: // fast_byte_arg_list

        value.copy< std::vector<dods_byte>* > (v);

        break;

      case 18: // "fast float32 arg list"

      case 58: // fast_float32_arg_list

        value.copy< std::vector<dods_float32>* > (v);

        break;

      case 19: // "fast float64 arg list"

      case 59: // fast_float64_arg_list

        value.copy< std::vector<dods_float64>* > (v);

        break;

      case 13: // "fast int16 arg list"

      case 53: // fast_int16_arg_list

        value.copy< std::vector<dods_int16>* > (v);

        break;

      case 15: // "fast int32 arg list"

      case 55: // fast_int32_arg_list

        value.copy< std::vector<dods_int32>* > (v);

        break;

      case 17: // "fast int64 arg list"

      case 57: // fast_int64_arg_list

        value.copy< std::vector<dods_int64>* > (v);

        break;

      case 11: // "fast int8 arg list"

      case 51: // fast_int8_arg_list

        value.copy< std::vector<dods_int8>* > (v);

        break;

      case 12: // "fast uint16 arg list"

      case 52: // fast_uint16_arg_list

        value.copy< std::vector<dods_uint16>* > (v);

        break;

      case 14: // "fast uint32 arg list"

      case 54: // fast_uint32_arg_list

        value.copy< std::vector<dods_uint32>* > (v);

        break;

      case 16: // "fast uint64 arg list"

      case 56: // fast_uint64_arg_list

        value.copy< std::vector<dods_uint64>* > (v);

        break;

      default:

        break;

    }

}

  // Implementation of basic_symbol constructor for each type.

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const location_type& l)

    : Base (t)

    , value ()

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const D4Function v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const D4RValue* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const D4RValueList* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::string v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_byte>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_float32>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_float64>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_int16>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_int32>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_int64>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_int8>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_uint16>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_uint32>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  D4FunctionParser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, const std::vector<dods_uint64>* v, const location_type& l)

    : Base (t)

    , value (v)

    , location (l)

  {}

  template <typename Base>

  inline

  D4FunctionParser::basic_symbol<Base>::~basic_symbol ()

  {

    clear ();

  }

  template <typename Base>

  inline

  void

  D4FunctionParser::basic_symbol<Base>::clear ()

  {

    // User destructor.

    symbol_number_type yytype = this->type_get ();

    basic_symbol<Base>& yysym = *this;

    (void) yysym;

    switch (yytype)

    {

   default:

      break;

    }

    // Type destructor.

    switch (yytype)

    {

      case 7: // "function name"

      case 44: // fname

        value.template destroy< D4Function > ();

        break;

      case 5: // "argument"

      case 6: // "function"

      case 8: // "variable or constant"

      case 9: // "array constant"

      case 43: // function

      case 46: // arg

      case 47: // variable_or_constant

      case 48: // array_constant

        value.template destroy< D4RValue* > ();

        break;

      case 3: // "functions"

      case 4: // "arguments"

      case 42: // functions

      case 45: // args

        value.template destroy< D4RValueList* > ();

        break;

      case 20: // "word"

      case 21: // "string"

      case 60: // id

      case 61: // group

      case 62: // path

      case 63: // name

        value.template destroy< std::string > ();

        break;

      case 10: // "fast byte arg list"

      case 50: // fast_byte_arg_list

        value.template destroy< std::vector<dods_byte>* > ();

        break;

      case 18: // "fast float32 arg list"

      case 58: // fast_float32_arg_list

        value.template destroy< std::vector<dods_float32>* > ();

        break;

      case 19: // "fast float64 arg list"

      case 59: // fast_float64_arg_list

        value.template destroy< std::vector<dods_float64>* > ();

        break;

      case 13: // "fast int16 arg list"

      case 53: // fast_int16_arg_list

        value.template destroy< std::vector<dods_int16>* > ();

        break;

      case 15: // "fast int32 arg list"

      case 55: // fast_int32_arg_list

        value.template destroy< std::vector<dods_int32>* > ();

        break;

      case 17: // "fast int64 arg list"

      case 57: // fast_int64_arg_list

        value.template destroy< std::vector<dods_int64>* > ();

        break;

      case 11: // "fast int8 arg list"

      case 51: // fast_int8_arg_list

        value.template destroy< std::vector<dods_int8>* > ();

        break;

      case 12: // "fast uint16 arg list"

      case 52: // fast_uint16_arg_list

        value.template destroy< std::vector<dods_uint16>* > ();

        break;

      case 14: // "fast uint32 arg list"

      case 54: // fast_uint32_arg_list

        value.template destroy< std::vector<dods_uint32>* > ();

        break;

      case 16: // "fast uint64 arg list"

      case 56: // fast_uint64_arg_list

        value.template destroy< std::vector<dods_uint64>* > ();

        break;

      default:

        break;

    }

    Base::clear ();

  }

  template <typename Base>

  inline

  bool

  D4FunctionParser::basic_symbol<Base>::empty () const

  {

    return Base::type_get () == empty_symbol;

  }

  template <typename Base>

  inline

  void

  D4FunctionParser::basic_symbol<Base>::move (basic_symbol& s)

  {

    super_type::move(s);

      switch (this->type_get ())

    {

      case 7: // "function name"

      case 44: // fname

        value.move< D4Function > (s.value);

        break;

      case 5: // "argument"

      case 6: // "function"

      case 8: // "variable or constant"

      case 9: // "array constant"

      case 43: // function

      case 46: // arg

      case 47: // variable_or_constant

      case 48: // array_constant

        value.move< D4RValue* > (s.value);

        break;

      case 3: // "functions"

      case 4: // "arguments"

      case 42: // functions

      case 45: // args

        value.move< D4RValueList* > (s.value);

        break;

      case 20: // "word"

      case 21: // "string"

      case 60: // id

      case 61: // group

      case 62: // path

      case 63: // name

        value.move< std::string > (s.value);

        break;

      case 10: // "fast byte arg list"

      case 50: // fast_byte_arg_list

        value.move< std::vector<dods_byte>* > (s.value);

        break;

      case 18: // "fast float32 arg list"

      case 58: // fast_float32_arg_list

        value.move< std::vector<dods_float32>* > (s.value);

        break;

      case 19: // "fast float64 arg list"

      case 59: // fast_float64_arg_list

        value.move< std::vector<dods_float64>* > (s.value);

        break;

      case 13: // "fast int16 arg list"

      case 53: // fast_int16_arg_list

        value.move< std::vector<dods_int16>* > (s.value);

        break;

      case 15: // "fast int32 arg list"

      case 55: // fast_int32_arg_list

        value.move< std::vector<dods_int32>* > (s.value);

        break;

      case 17: // "fast int64 arg list"

      case 57: // fast_int64_arg_list

        value.move< std::vector<dods_int64>* > (s.value);

        break;

      case 11: // "fast int8 arg list"

      case 51: // fast_int8_arg_list

        value.move< std::vector<dods_int8>* > (s.value);

        break;

      case 12: // "fast uint16 arg list"

      case 52: // fast_uint16_arg_list

        value.move< std::vector<dods_uint16>* > (s.value);

        break;

      case 14: // "fast uint32 arg list"

      case 54: // fast_uint32_arg_list

        value.move< std::vector<dods_uint32>* > (s.value);

        break;

      case 16: // "fast uint64 arg list"

      case 56: // fast_uint64_arg_list

        value.move< std::vector<dods_uint64>* > (s.value);

        break;

      default:

        break;

    }

    location = s.location;

  }

  // by_type.

  inline

  D4FunctionParser::by_type::by_type ()

    : type (empty_symbol)

  {}

  inline

  D4FunctionParser::by_type::by_type (const by_type& other)

    : type (other.type)

  {}

  inline

  D4FunctionParser::by_type::by_type (token_type t)

    : type (yytranslate_ (t))

  {}

  inline

  void

  D4FunctionParser::by_type::clear ()

  {

    type = empty_symbol;

  }

  inline

  void

  D4FunctionParser::by_type::move (by_type& that)

  {

    type = that.type;

    that.clear ();

  }

  inline

  int

  D4FunctionParser::by_type::type_get () const

  {

    return type;

  }

  // Implementation of make_symbol for each symbol type.

  D4FunctionParser::symbol_type

  D4FunctionParser::make_END (const location_type& l)

  {

    return symbol_type (token::END, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_WORD (const std::string& v, const location_type& l)

  {

    return symbol_type (token::WORD, v, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_STRING (const std::string& v, const location_type& l)

  {

    return symbol_type (token::STRING, v, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_SEMICOLON (const location_type& l)

  {

    return symbol_type (token::SEMICOLON, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_COLON (const location_type& l)

  {

    return symbol_type (token::COLON, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_LPAREN (const location_type& l)

  {

    return symbol_type (token::LPAREN, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_RPAREN (const location_type& l)

  {

    return symbol_type (token::RPAREN, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_COMMA (const location_type& l)

  {

    return symbol_type (token::COMMA, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_GROUP_SEP (const location_type& l)

  {

    return symbol_type (token::GROUP_SEP, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_PATH_SEP (const location_type& l)

  {

    return symbol_type (token::PATH_SEP, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_DOLLAR_BYTE (const location_type& l)

  {

    return symbol_type (token::DOLLAR_BYTE, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_DOLLAR_UINT8 (const location_type& l)

  {

    return symbol_type (token::DOLLAR_UINT8, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_DOLLAR_INT8 (const location_type& l)

  {

    return symbol_type (token::DOLLAR_INT8, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_DOLLAR_UINT16 (const location_type& l)

  {

    return symbol_type (token::DOLLAR_UINT16, l);

  }

  D4FunctionParser::symbol_type

  D4FunctionParser::make_DOLLAR_INT16 (const location_type& l)

  {

    return symbol_type (token::DOLLAR_INT16, l);

  }