{

public:

/// Type of *this.

typedef value_type self_type;

/// Empty construction.

value_type () YY_NOEXCEPT

: yyraw_ ()

{}

/// Construct and fill.

template <typename T>

value_type (YY_RVREF (T) t)

{

new (yyas_<T> ()) T (YY_MOVE (t));

}

#if 201103L <= YY_CPLUSPLUS

/// Non copyable.

value_type (const self_type&) = delete;

/// Non copyable.

self_type& operator= (const self_type&) = delete;

#endif

/// Destruction, allowed only if empty.

~value_type () YY_NOEXCEPT

{}

# if 201103L <= YY_CPLUSPLUS

/// Instantiate a \a T in here from \a t.

template <typename T, typename... U>

T&

emplace (U&&... u)

{

return *new (yyas_<T> ()) T (std::forward <U>(u)...);

}

# else

/// Instantiate an empty \a T in here.

template <typename T>

T&

emplace ()

{

return *new (yyas_<T> ()) T ();

}

/// Instantiate a \a T in here from \a t.

template <typename T>

T&

emplace (const T& t)

{

return *new (yyas_<T> ()) T (t);

}

# endif

/// Instantiate an empty \a T in here.

/// Obsolete, use emplace.

template <typename T>

T&

build ()

{

return emplace<T> ();

}

/// Instantiate a \a T in here from \a t.

/// Obsolete, use emplace.

template <typename T>

T&

build (const T& t)

{

return emplace<T> (t);

}

/// Accessor to a built \a T.

template <typename T>

T&

as () YY_NOEXCEPT

{

return *yyas_<T> ();

}

/// Const accessor to a built \a T (for %printer).

template <typename T>

const T&

as () const YY_NOEXCEPT

{

return *yyas_<T> ();

}

/// Swap the content with \a that, of same type.

///

/// Both variants must be built beforehand, because swapping the actual

/// data requires reading it (with as()), and this is not possible on

/// unconstructed variants: it would require some dynamic testing, which

/// should not be the variant's responsibility.

/// Swapping between built and (possibly) non-built is done with

/// self_type::move ().

template <typename T>

void

swap (self_type& that) YY_NOEXCEPT

{

std::swap (as<T> (), that.as<T> ());

}

/// Move the content of \a that to this.

///

/// Destroys \a that.

template <typename T>

void

move (self_type& that)

{

# if 201103L <= YY_CPLUSPLUS

emplace<T> (std::move (that.as<T> ()));

# else

emplace<T> ();

swap<T> (that);

# endif

that.destroy<T> ();

}

# if 201103L <= YY_CPLUSPLUS

/// Move the content of \a that to this.

template <typename T>

void

move (self_type&& that)

{

emplace<T> (std::move (that.as<T> ()));

that.destroy<T> ();

}

#endif

/// Copy the content of \a that to this.

template <typename T>

void

copy (const self_type& that)

{

emplace<T> (that.as<T> ());

}

/// Destroy the stored \a T.

template <typename T>

void

destroy ()

{

as<T> ().~T ();

}

private:

#if YY_CPLUSPLUS < 201103L

/// Non copyable.

value_type (const self_type&);

/// Non copyable.

self_type& operator= (const self_type&);

#endif

/// Accessor to raw memory as \a T.

template <typename T>

T*

yyas_ () YY_NOEXCEPT

{

void *yyp = yyraw_;

return static_cast<T*> (yyp);

}

/// Const accessor to raw memory as \a T.

template <typename T>

const T*

yyas_ () const YY_NOEXCEPT

{

const void *yyp = yyraw_;

return static_cast<const T*> (yyp);

}

/// An auxiliary type to compute the largest semantic type.

union union_type

{

// piecewise_list

char dummy1[sizeof (SymEngine::PiecewiseVec)];

// st_expr

// expr

// leaf

// func

// pwise

char dummy2[sizeof (SymEngine::RCP<const SymEngine::Basic>)];

// expr_list

char dummy3[sizeof (SymEngine::vec_basic)];

// epair

char dummy4[sizeof (std::pair<SymEngine::RCP<const SymEngine::Basic>, SymEngine::RCP<const SymEngine::Boolean>>)];

// PIECEWISE

// IDENTIFIER

// NUMERIC

// IMPLICIT_MUL

char dummy5[sizeof (std::string)];

};

/// The size of the largest semantic type.

enum { size = sizeof (union_type) };

/// A buffer to store semantic values.

union

{

/// Strongest alignment constraints.

long double yyalign_me_;

/// A buffer large enough to store any of the semantic values.

char yyraw_[size];

};

{

syntax_error (const std::string& m)

: std::runtime_error (m)

{}

syntax_error (const syntax_error& s)

: std::runtime_error (s.what ())

{}

~syntax_error () YY_NOEXCEPT YY_NOTHROW;

{

enum token_kind_type

{

YYEMPTY = -2,

END_OF_FILE = 0, // END_OF_FILE

YYerror = 256, // error

YYUNDEF = 257, // "invalid token"

PIECEWISE = 258, // PIECEWISE

IDENTIFIER = 259, // IDENTIFIER

NUMERIC = 260, // NUMERIC

IMPLICIT_MUL = 261, // IMPLICIT_MUL

EQ = 262, // EQ

NE = 263, // NE

LE = 264, // LE

GE = 265, // GE

UMINUS = 266, // UMINUS

UPLUS = 267, // UPLUS

POW = 268, // POW

NOT = 269 // NOT

};

/// Backward compatibility alias (Bison 3.6).

typedef token_kind_type yytokentype;

{

enum symbol_kind_type

{

YYNTOKENS = 28, ///< Number of tokens.

S_YYEMPTY = -2,

S_YYEOF = 0, // END_OF_FILE

S_YYerror = 1, // error

S_YYUNDEF = 2, // "invalid token"

S_PIECEWISE = 3, // PIECEWISE

S_IDENTIFIER = 4, // IDENTIFIER

S_NUMERIC = 5, // NUMERIC

S_IMPLICIT_MUL = 6, // IMPLICIT_MUL

S_7_ = 7, // '|'

S_8_ = 8, // '^'

S_9_ = 9, // '&'

S_EQ = 10, // EQ

S_11_ = 11, // '>'

S_12_ = 12, // '<'

S_NE = 13, // NE

S_LE = 14, // LE

S_GE = 15, // GE

S_16_ = 16, // '-'

S_17_ = 17, // '+'

S_18_ = 18, // '*'

S_19_ = 19, // '/'

S_UMINUS = 20, // UMINUS

S_UPLUS = 21, // UPLUS

S_POW = 22, // POW

S_NOT = 23, // NOT

S_24_ = 24, // '('

S_25_ = 25, // ')'

S_26_ = 26, // '~'

S_27_ = 27, // ','

S_YYACCEPT = 28, // $accept

S_st_expr = 29, // st_expr

S_expr = 30, // expr

S_leaf = 31, // leaf

S_func = 32, // func

S_epair = 33, // epair

S_piecewise_list = 34, // piecewise_list

S_pwise = 35, // pwise

S_expr_list = 36 // expr_list

};

{

/// Alias to Base.

typedef Base super_type;

/// Default constructor.

basic_symbol () YY_NOEXCEPT

: value ()

{}

#if 201103L <= YY_CPLUSPLUS

/// Move constructor.

basic_symbol (basic_symbol&& that)

: Base (std::move (that))

, value ()

{

switch (this->kind ())

{

case symbol_kind::S_piecewise_list: // piecewise_list

value.move< SymEngine::PiecewiseVec > (std::move (that.value));

break;

case symbol_kind::S_st_expr: // st_expr

case symbol_kind::S_expr: // expr

case symbol_kind::S_leaf: // leaf

case symbol_kind::S_func: // func

case symbol_kind::S_pwise: // pwise

value.move< SymEngine::RCP<const SymEngine::Basic> > (std::move (that.value));

break;

case symbol_kind::S_expr_list: // expr_list

value.move< SymEngine::vec_basic > (std::move (that.value));

break;

case symbol_kind::S_epair: // epair

value.move< std::pair<SymEngine::RCP<const SymEngine::Basic>, SymEngine::RCP<const SymEngine::Boolean>> > (std::move (that.value));

break;

case symbol_kind::S_PIECEWISE: // PIECEWISE

case symbol_kind::S_IDENTIFIER: // IDENTIFIER

case symbol_kind::S_NUMERIC: // NUMERIC

case symbol_kind::S_IMPLICIT_MUL: // IMPLICIT_MUL

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

break;

default:

break;

}

}

#endif

/// Copy constructor.

basic_symbol (const basic_symbol& that);

/// Constructors for typed symbols.

#if 201103L <= YY_CPLUSPLUS

basic_symbol (typename Base::kind_type t)

: Base (t)

{}

#else

basic_symbol (typename Base::kind_type t)

: Base (t)

{}

#endif

#if 201103L <= YY_CPLUSPLUS

basic_symbol (typename Base::kind_type t, SymEngine::PiecewiseVec&& v)

: Base (t)

, value (std::move (v))

{}

#else

basic_symbol (typename Base::kind_type t, const SymEngine::PiecewiseVec& v)

: Base (t)

, value (v)

{}

#endif

#if 201103L <= YY_CPLUSPLUS

basic_symbol (typename Base::kind_type t, SymEngine::RCP<const SymEngine::Basic>&& v)

: Base (t)

, value (std::move (v))

{}

#else

basic_symbol (typename Base::kind_type t, const SymEngine::RCP<const SymEngine::Basic>& v)

: Base (t)

, value (v)

{}

#endif

#if 201103L <= YY_CPLUSPLUS

basic_symbol (typename Base::kind_type t, SymEngine::vec_basic&& v)

: Base (t)

, value (std::move (v))

{}

#else

basic_symbol (typename Base::kind_type t, const SymEngine::vec_basic& v)

: Base (t)

, value (v)

{}

#endif

#if 201103L <= YY_CPLUSPLUS

basic_symbol (typename Base::kind_type t, std::pair<SymEngine::RCP<const SymEngine::Basic>, SymEngine::RCP<const SymEngine::Boolean>>&& v)

: Base (t)

, value (std::move (v))

{}

#else

basic_symbol (typename Base::kind_type t, const std::pair<SymEngine::RCP<const SymEngine::Basic>, SymEngine::RCP<const SymEngine::Boolean>>& v)

: Base (t)

, value (v)

{}

#endif

#if 201103L <= YY_CPLUSPLUS

basic_symbol (typename Base::kind_type t, std::string&& v)

: Base (t)

, value (std::move (v))

{}

#else

basic_symbol (typename Base::kind_type t, const std::string& v)

: Base (t)

, value (v)

{}

#endif

/// Destroy the symbol.

~basic_symbol ()

{

clear ();

}

/// Destroy contents, and record that is empty.

void clear () YY_NOEXCEPT

{

// User destructor.

symbol_kind_type yykind = this->kind ();

basic_symbol<Base>& yysym = *this;

(void) yysym;

switch (yykind)

{

default:

break;

}

// Value type destructor.

switch (yykind)

{

case symbol_kind::S_piecewise_list: // piecewise_list

value.template destroy< SymEngine::PiecewiseVec > ();

break;

case symbol_kind::S_st_expr: // st_expr

case symbol_kind::S_expr: // expr

case symbol_kind::S_leaf: // leaf

case symbol_kind::S_func: // func

case symbol_kind::S_pwise: // pwise

value.template destroy< SymEngine::RCP<const SymEngine::Basic> > ();

break;

case symbol_kind::S_expr_list: // expr_list

value.template destroy< SymEngine::vec_basic > ();

break;

case symbol_kind::S_epair: // epair

value.template destroy< std::pair<SymEngine::RCP<const SymEngine::Basic>, SymEngine::RCP<const SymEngine::Boolean>> > ();

break;

case symbol_kind::S_PIECEWISE: // PIECEWISE

case symbol_kind::S_IDENTIFIER: // IDENTIFIER

case symbol_kind::S_NUMERIC: // NUMERIC

case symbol_kind::S_IMPLICIT_MUL: // IMPLICIT_MUL

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

break;

default:

break;

}

Base::clear ();

}

#if YYDEBUG || 0

/// The user-facing name of this symbol.

const char *name () const YY_NOEXCEPT

{

return parser::symbol_name (this->kind ());

}

#endif // #if YYDEBUG || 0

/// Backward compatibility (Bison 3.6).

symbol_kind_type type_get () const YY_NOEXCEPT;

/// Whether empty.

bool empty () const YY_NOEXCEPT;

/// Destructive move, \a s is emptied into this.

void move (basic_symbol& s);

/// The semantic value.

value_type value;

private:

#if YY_CPLUSPLUS < 201103L

/// Assignment operator.

basic_symbol& operator= (const basic_symbol& that);

#endif

{

/// The symbol kind as needed by the constructor.

typedef token_kind_type kind_type;

/// Default constructor.

by_kind () YY_NOEXCEPT;

#if 201103L <= YY_CPLUSPLUS

/// Move constructor.

by_kind (by_kind&& that) YY_NOEXCEPT;

#endif

/// Copy constructor.

by_kind (const by_kind& that) YY_NOEXCEPT;

/// Constructor from (external) token numbers.

by_kind (kind_type t) YY_NOEXCEPT;

/// Record that this symbol is empty.

void clear () YY_NOEXCEPT;

/// Steal the symbol kind from \a that.

void move (by_kind& that);

/// The (internal) type number (corresponding to \a type).

/// \a empty when empty.

symbol_kind_type kind () const YY_NOEXCEPT;

/// Backward compatibility (Bison 3.6).

symbol_kind_type type_get () const YY_NOEXCEPT;

/// The symbol kind.

/// \a S_YYEMPTY when empty.

symbol_kind_type kind_;