bison_parser.h

Go to the documentation of this file.

// A Bison parser, made by GNU Bison 3.8.2.
 
// Skeleton interface 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.
 
// C++ LALR(1) parser skeleton written by Akim Demaille.
 
// 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.
 
#ifndef YY_SLAMPARSER_BISON_PARSER_H_INCLUDED
#define YY_SLAMPARSER_BISON_PARSER_H_INCLUDED
 
#include <cstdlib>  // std::abort
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
 
#if defined __cplusplus
#define YY_CPLUSPLUS __cplusplus
#else
#define YY_CPLUSPLUS 199711L
#endif
 
// Support move semantics when possible.
#if 201103L <= YY_CPLUSPLUS
#define YY_MOVE std::move
#define YY_MOVE_OR_COPY move
#define YY_MOVE_REF(Type) Type&&
#define YY_RVREF(Type) Type&&
#define YY_COPY(Type) Type
#else
#define YY_MOVE
#define YY_MOVE_OR_COPY copy
#define YY_MOVE_REF(Type) Type&
#define YY_RVREF(Type) const Type&
#define YY_COPY(Type) const Type&
#endif
 
// Support noexcept when possible.
#if 201103L <= YY_CPLUSPLUS
#define YY_NOEXCEPT noexcept
#define YY_NOTHROW
#else
#define YY_NOEXCEPT
#define YY_NOTHROW throw()
#endif
 
// Support constexpr when possible.
#if 201703 <= YY_CPLUSPLUS
#define YY_CONSTEXPR constexpr
#else
#define YY_CONSTEXPR
#endif
#include "location.hh"
 
#ifndef YY_ATTRIBUTE_PURE
#if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#define YY_ATTRIBUTE_PURE __attribute__((__pure__))
#else
#define YY_ATTRIBUTE_PURE
#endif
#endif
 
#ifndef YY_ATTRIBUTE_UNUSED
#if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#define YY_ATTRIBUTE_UNUSED __attribute__((__unused__))
#else
#define YY_ATTRIBUTE_UNUSED
#endif
#endif
 
/* Suppress unused-variable warnings by "using" E.  */
#if !defined lint || defined __GNUC__
#define YY_USE(E) ((void)(E))
#else
#define YY_USE(E) /* empty */
#endif
 
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
#if defined __GNUC__ && !defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
#if __GNUC__ * 100 + __GNUC_MINOR__ < 407
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
  _Pragma("GCC diagnostic push")            \
      _Pragma("GCC diagnostic ignored \"-Wuninitialized\"")
#else
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                 \
  _Pragma("GCC diagnostic push")                            \
      _Pragma("GCC diagnostic ignored \"-Wuninitialized\"") \
          _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
#endif
#define YY_IGNORE_MAYBE_UNINITIALIZED_END _Pragma("GCC diagnostic pop")
#else
#define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
#define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
 
#if defined __cplusplus && defined __GNUC__ && !defined __ICC && 6 <= __GNUC__
#define YY_IGNORE_USELESS_CAST_BEGIN \
  _Pragma("GCC diagnostic push")     \
      _Pragma("GCC diagnostic ignored \"-Wuseless-cast\"")
#define YY_IGNORE_USELESS_CAST_END _Pragma("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_END
#endif
 
#ifndef YY_CAST
#ifdef __cplusplus
#define YY_CAST(Type, Val) static_cast<Type>(Val)
#define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type>(Val)
#else
#define YY_CAST(Type, Val) ((Type)(Val))
#define YY_REINTERPRET_CAST(Type, Val) ((Type)(Val))
#endif
#endif
#ifndef YY_NULLPTR
#if defined __cplusplus
#if 201103L <= __cplusplus
#define YY_NULLPTR nullptr
#else
#define YY_NULLPTR 0
#endif
#else
#define YY_NULLPTR ((void*)0)
#endif
#endif
 
/* Debug traces.  */
#ifndef SLAMPARSERDEBUG
#if defined YYDEBUG
#if YYDEBUG
#define SLAMPARSERDEBUG 1
#else
#define SLAMPARSERDEBUG 0
#endif
#else /* ! defined YYDEBUG */
#define SLAMPARSERDEBUG 0
#endif /* ! defined YYDEBUG */
#endif /* ! defined SLAMPARSERDEBUG */
 
namespace SlamParser {
#line 190 "bison_parser.h"
 
class Parser {
 public:
#ifdef SLAMPARSERSTYPE
#ifdef __GNUC__
#pragma GCC message \
    "bison: do not #define SLAMPARSERSTYPE in C++, use %define api.value.type"
#endif
  typedef SLAMPARSERSTYPE value_type;
#else
  union value_type {
#line 53 "parser.yy"
 
    int integerVal;
    double doubleVal;
    std::string* stringVal;
    class CommandNode* commandNode;
    std::vector<int>* intList;
 
#line 216 "bison_parser.h"
  };
#endif
  typedef value_type semantic_type;
 
  typedef location location_type;
 
  struct syntax_error : std::runtime_error {
    syntax_error(const location_type& l, const std::string& m)
        : std::runtime_error(m), location(l) {}
 
    syntax_error(const syntax_error& s)
        : std::runtime_error(s.what()), location(s.location) {}
 
    ~syntax_error() YY_NOEXCEPT YY_NOTHROW;
 
    location_type location;
  };
 
  struct token {
    enum token_kind_type {
      SLAMPARSEREMPTY = -2,
      END = 0,                // "end of file"
      SLAMPARSERerror = 256,  // error
      SLAMPARSERUNDEF = 257,  // "invalid token"
      EOL = 258,              // "end of line"
      INTEGER = 259,          // "integer"
      DOUBLE = 260,           // "double"
      STRING = 261,           // "string"
      ADD = 262,              // "ADD"
      V_SE2 = 263,            // "Vertex SE2"
      V_SE3 = 264,            // "Vertex SE3"
      E_SE2 = 265,            // "Edge SE2"
      E_SE3 = 266,            // "Edge SE3"
      FIX = 267,              // "Fix"
      SOLVE_STATE = 268,      // "Solve State"
      QUERY_STATE = 269       // "Query State"
    };
    typedef token_kind_type yytokentype;
  };
 
  typedef token::token_kind_type token_kind_type;
 
  typedef token_kind_type token_type;
 
  struct symbol_kind {
    enum symbol_kind_type {
      YYNTOKENS = 16,  
      S_YYEMPTY = -2,
      S_YYEOF = 0,         // "end of file"
      S_YYerror = 1,       // error
      S_YYUNDEF = 2,       // "invalid token"
      S_EOL = 3,           // "end of line"
      S_INTEGER = 4,       // "integer"
      S_DOUBLE = 5,        // "double"
      S_STRING = 6,        // "string"
      S_ADD = 7,           // "ADD"
      S_V_SE2 = 8,         // "Vertex SE2"
      S_V_SE3 = 9,         // "Vertex SE3"
      S_E_SE2 = 10,        // "Edge SE2"
      S_E_SE3 = 11,        // "Edge SE3"
      S_FIX = 12,          // "Fix"
      S_SOLVE_STATE = 13,  // "Solve State"
      S_QUERY_STATE = 14,  // "Query State"
      S_15_ = 15,          // ';'
      S_YYACCEPT = 16,     // $accept
      S_int_list = 17,     // int_list
      S_NUMBER = 18,       // NUMBER
      S_add_se2 = 19,      // add_se2
      S_add_se3 = 20,      // add_se3
      S_fix_node = 21,     // fix_node
      S_solve_state = 22,  // solve_state
      S_query_state = 23,  // query_state
      S_command = 24,      // command
      S_start = 25         // start
    };
  };
 
  typedef symbol_kind::symbol_kind_type symbol_kind_type;
 
  static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS;
 
  template <typename Base>
  struct basic_symbol : Base {
    typedef Base super_type;
 
    basic_symbol() YY_NOEXCEPT : value(), location() {}
 
#if 201103L <= YY_CPLUSPLUS
    basic_symbol(basic_symbol&& that)
        : Base(std::move(that)),
          value(std::move(that.value)),
          location(std::move(that.location)) {}
#endif
 
    basic_symbol(const basic_symbol& that);
    basic_symbol(typename Base::kind_type t, YY_MOVE_REF(location_type) l);
 
    basic_symbol(typename Base::kind_type t, YY_RVREF(value_type) v,
                 YY_RVREF(location_type) l);
 
    ~basic_symbol() { clear(); }
 
    void clear() YY_NOEXCEPT { Base::clear(); }
 
    std::string name() const YY_NOEXCEPT {
      return Parser::symbol_name(this->kind());
    }
 
    symbol_kind_type type_get() const YY_NOEXCEPT;
 
    bool empty() const YY_NOEXCEPT;
 
    void move(basic_symbol& s);
 
    value_type value;
 
    location_type location;
 
   private:
#if YY_CPLUSPLUS < 201103L
    basic_symbol& operator=(const basic_symbol& that);
#endif
  };
 
  struct by_kind {
    typedef token_kind_type kind_type;
 
    by_kind() YY_NOEXCEPT;
 
#if 201103L <= YY_CPLUSPLUS
    by_kind(by_kind&& that) YY_NOEXCEPT;
#endif
 
    by_kind(const by_kind& that) YY_NOEXCEPT;
 
    by_kind(kind_type t) YY_NOEXCEPT;
 
    void clear() YY_NOEXCEPT;
 
    void move(by_kind& that);
 
    symbol_kind_type kind() const YY_NOEXCEPT;
 
    symbol_kind_type type_get() const YY_NOEXCEPT;
 
    symbol_kind_type kind_;
  };
 
  typedef by_kind by_type;
 
  struct symbol_type : basic_symbol<by_kind> {};
 
  Parser(class Driver& driver_yyarg);
  virtual ~Parser();
 
#if 201103L <= YY_CPLUSPLUS
  Parser(const Parser&) = delete;
  Parser& operator=(const Parser&) = delete;
#endif
 
  int operator()();
 
  virtual int parse();
 
#if SLAMPARSERDEBUG
  std::ostream& debug_stream() const YY_ATTRIBUTE_PURE;
  void set_debug_stream(std::ostream&);
 
  typedef int debug_level_type;
  debug_level_type debug_level() const YY_ATTRIBUTE_PURE;
  void set_debug_level(debug_level_type l);
#endif
 
  virtual void error(const location_type& loc, const std::string& msg);
 
  void error(const syntax_error& err);
 
  static std::string symbol_name(symbol_kind_type yysymbol);
 
  class context {
   public:
    context(const Parser& yyparser, const symbol_type& yyla);
    const symbol_type& lookahead() const YY_NOEXCEPT { return yyla_; }
    symbol_kind_type token() const YY_NOEXCEPT { return yyla_.kind(); }
    const location_type& location() const YY_NOEXCEPT { return yyla_.location; }
 
    int expected_tokens(symbol_kind_type yyarg[], int yyargn) const;
 
   private:
    const Parser& yyparser_;
    const symbol_type& yyla_;
  };
 
 private:
#if YY_CPLUSPLUS < 201103L
  Parser(const Parser&);
  Parser& operator=(const Parser&);
#endif
 
  typedef signed char state_type;
 
  int yy_syntax_error_arguments_(const context& yyctx, symbol_kind_type yyarg[],
                                 int yyargn) const;
 
  virtual std::string yysyntax_error_(const context& yyctx) const;
  static state_type yy_lr_goto_state_(state_type yystate, int yysym);
 
  static bool yy_pact_value_is_default_(int yyvalue) YY_NOEXCEPT;
 
  static bool yy_table_value_is_error_(int yyvalue) YY_NOEXCEPT;
 
  static const signed char yypact_ninf_;
  static const signed char yytable_ninf_;
 
  static symbol_kind_type yytranslate_(int t) YY_NOEXCEPT;
 
  static std::string yytnamerr_(const char* yystr);
 
  static const char* const yytname_[];
 
  // Tables.
  // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
  // STATE-NUM.
  static const signed char yypact_[];
 
  // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
  // Performed when YYTABLE does not specify something else to do.  Zero
  // means the default is an error.
  static const signed char yydefact_[];
 
  // YYPGOTO[NTERM-NUM].
  static const signed char yypgoto_[];
 
  // YYDEFGOTO[NTERM-NUM].
  static const signed char yydefgoto_[];
 
  // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
  // positive, shift that token.  If negative, reduce the rule whose
  // number is the opposite.  If YYTABLE_NINF, syntax error.
  static const signed char yytable_[];
 
  static const signed char yycheck_[];
 
  // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
  // state STATE-NUM.
  static const signed char yystos_[];
 
  // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.
  static const signed char yyr1_[];
 
  // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule
  // RULE-NUM.
  static const signed char yyr2_[];
 
#if SLAMPARSERDEBUG
  // YYRLINE[YYN] -- Source line where rule number YYN was defined.
  static const unsigned char yyrline_[];
  virtual void yy_reduce_print_(int r) const;
  virtual void yy_stack_print_() const;
 
  int yydebug_;
  std::ostream* yycdebug_;
 
  template <typename Base>
  void yy_print_(std::ostream& yyo, const basic_symbol<Base>& yysym) const;
#endif
 
  template <typename Base>
  void yy_destroy_(const char* yymsg, basic_symbol<Base>& yysym) const;
 
 private:
  struct by_state {
    by_state() YY_NOEXCEPT;
 
    typedef state_type kind_type;
 
    by_state(kind_type s) YY_NOEXCEPT;
 
    by_state(const by_state& that) YY_NOEXCEPT;
 
    void clear() YY_NOEXCEPT;
 
    void move(by_state& that);
 
    symbol_kind_type kind() const YY_NOEXCEPT;
 
    enum { empty_state = 0 };
 
    state_type state;
  };
 
  struct stack_symbol_type : basic_symbol<by_state> {
    typedef basic_symbol<by_state> super_type;
    stack_symbol_type();
    stack_symbol_type(YY_RVREF(stack_symbol_type) that);
    stack_symbol_type(state_type s, YY_MOVE_REF(symbol_type) sym);
#if YY_CPLUSPLUS < 201103L
    stack_symbol_type& operator=(stack_symbol_type& that);
 
    stack_symbol_type& operator=(const stack_symbol_type& that);
#endif
  };
 
  template <typename T, typename S = std::vector<T> >
  class stack {
   public:
    // Hide our reversed order.
    typedef typename S::iterator iterator;
    typedef typename S::const_iterator const_iterator;
    typedef typename S::size_type size_type;
    typedef typename std::ptrdiff_t index_type;
 
    stack(size_type n = 200) YY_NOEXCEPT : seq_(n) {}
 
#if 201103L <= YY_CPLUSPLUS
    stack(const stack&) = delete;
    stack& operator=(const stack&) = delete;
#endif
 
    const T& operator[](index_type i) const {
      return seq_[size_type(size() - 1 - i)];
    }
 
    T& operator[](index_type i) { return seq_[size_type(size() - 1 - i)]; }
 
    void push(YY_MOVE_REF(T) t) {
      seq_.push_back(T());
      operator[](0).move(t);
    }
 
    void pop(std::ptrdiff_t n = 1) YY_NOEXCEPT {
      for (; 0 < n; --n) seq_.pop_back();
    }
 
    void clear() YY_NOEXCEPT { seq_.clear(); }
 
    index_type size() const YY_NOEXCEPT { return index_type(seq_.size()); }
 
    const_iterator begin() const YY_NOEXCEPT { return seq_.begin(); }
 
    const_iterator end() const YY_NOEXCEPT { return seq_.end(); }
 
    class slice {
     public:
      slice(const stack& stack, index_type range) YY_NOEXCEPT : stack_(stack),
                                                                range_(range) {}
 
      const T& operator[](index_type i) const { return stack_[range_ - i]; }
 
     private:
      const stack& stack_;
      index_type range_;
    };
 
   private:
#if YY_CPLUSPLUS < 201103L
    stack(const stack&);
    stack& operator=(const stack&);
#endif
    S seq_;
  };
 
  typedef stack<stack_symbol_type> stack_type;
 
  stack_type yystack_;
 
  void yypush_(const char* m, YY_MOVE_REF(stack_symbol_type) sym);
 
  void yypush_(const char* m, state_type s, YY_MOVE_REF(symbol_type) sym);
 
  void yypop_(int n = 1) YY_NOEXCEPT;
 
  enum {
    yylast_ = 68,  
    yynnts_ = 10,  
    yyfinal_ = 2   
  };
 
  // User arguments.
  class Driver& driver;
};
 
}  // namespace SlamParser
#line 833 "bison_parser.h"
 
#endif  // !YY_SLAMPARSER_BISON_PARSER_H_INCLUDED