/*============================================================================= | |
Phoenix V1.2.1 | |
Copyright (c) 2001-2002 Joel de Guzman | |
Distributed under the Boost Software License, Version 1.0. (See accompanying | |
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
==============================================================================*/ | |
#ifndef PHOENIX_SPECIAL_OPS_HPP | |
#define PHOENIX_SPECIAL_OPS_HPP | |
#include <boost/config.hpp> | |
#ifdef BOOST_NO_STRINGSTREAM | |
#include <strstream> | |
#define PHOENIX_SSTREAM strstream | |
#else | |
#include <sstream> | |
#define PHOENIX_SSTREAM stringstream | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
#include <boost/spirit/home/classic/phoenix/operators.hpp> | |
#include <iosfwd> | |
/////////////////////////////////////////////////////////////////////////////// | |
#if defined(_STLPORT_VERSION) && defined(__STL_USE_OWN_NAMESPACE) | |
#define PHOENIX_STD _STLP_STD | |
#define PHOENIX_NO_STD_NAMESPACE | |
#else | |
#define PHOENIX_STD std | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
//#if !defined(PHOENIX_NO_STD_NAMESPACE) | |
namespace PHOENIX_STD | |
{ | |
//#endif | |
template<typename T> class complex; | |
//#if !defined(PHOENIX_NO_STD_NAMESPACE) | |
} | |
//#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace phoenix | |
{ | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// The following specializations take into account the C++ standard | |
// library components. There are a couple of issues that have to be | |
// dealt with to enable lazy operator overloads for the standard | |
// library classes. | |
// | |
// *iostream (e.g. cout, cin, strstream/ stringstream) uses non- | |
// canonical shift operator overloads where the lhs is taken in | |
// by reference. | |
// | |
// *I/O manipulators overloads for the RHS of the << and >> | |
// operators. | |
// | |
// *STL iterators can be objects that conform to pointer semantics. | |
// Some operators need to be specialized for these. | |
// | |
// *std::complex is given a rank (see rank class in operators.hpp) | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// specialization for rank<std::complex> | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
template <typename T> struct rank<PHOENIX_STD::complex<T> > | |
{ static int const value = 170 + rank<T>::value; }; | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// specializations for std::istream | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
#if defined(__GNUC__) && (__GNUC__ < 3) | |
#if defined(_STLPORT_VERSION) | |
#define PHOENIX_ISTREAM _IO_istream_withassign | |
#else | |
#define PHOENIX_ISTREAM PHOENIX_STD::_IO_istream_withassign | |
#endif | |
#else | |
// #if (defined(__ICL) && defined(_STLPORT_VERSION)) | |
// #define PHOENIX_ISTREAM istream_withassign | |
// #else | |
#define PHOENIX_ISTREAM PHOENIX_STD::istream | |
// #endif | |
#endif | |
////////////////////////////////// | |
#if defined(__GNUC__) && (__GNUC__ < 3) | |
// || (defined(__ICL) && defined(_STLPORT_VERSION)) | |
template <typename T1> | |
struct binary_operator<shift_r_op, PHOENIX_ISTREAM, T1> | |
{ | |
typedef PHOENIX_STD::istream& result_type; | |
static result_type eval(PHOENIX_STD::istream& out, T1& rhs) | |
{ return out >> rhs; } | |
}; | |
#endif | |
////////////////////////////////// | |
template <typename T1> | |
struct binary_operator<shift_r_op, PHOENIX_STD::istream, T1> | |
{ | |
typedef PHOENIX_STD::istream& result_type; | |
static result_type eval(PHOENIX_STD::istream& out, T1& rhs) | |
{ return out >> rhs; } | |
}; | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary3 | |
<shift_r_op, variable<PHOENIX_ISTREAM>, BaseT>::type | |
operator>>(PHOENIX_ISTREAM& _0, actor<BaseT> const& _1) | |
{ | |
return impl::make_binary3 | |
<shift_r_op, variable<PHOENIX_ISTREAM>, BaseT> | |
::construct(var(_0), _1); | |
} | |
#undef PHOENIX_ISTREAM | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// specializations for std::ostream | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
#if defined(__GNUC__) && (__GNUC__ < 3) | |
#if defined(_STLPORT_VERSION) | |
#define PHOENIX_OSTREAM _IO_ostream_withassign | |
#else | |
#define PHOENIX_OSTREAM PHOENIX_STD::_IO_ostream_withassign | |
#endif | |
#else | |
// #if (defined(__ICL) && defined(_STLPORT_VERSION)) | |
// #define PHOENIX_OSTREAM ostream_withassign | |
// #else | |
#define PHOENIX_OSTREAM PHOENIX_STD::ostream | |
// #endif | |
#endif | |
////////////////////////////////// | |
#if defined(__GNUC__) && (__GNUC__ < 3) | |
// || (defined(__ICL) && defined(_STLPORT_VERSION)) | |
template <typename T1> | |
struct binary_operator<shift_l_op, PHOENIX_OSTREAM, T1> | |
{ | |
typedef PHOENIX_STD::ostream& result_type; | |
static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs) | |
{ return out << rhs; } | |
}; | |
#endif | |
////////////////////////////////// | |
template <typename T1> | |
struct binary_operator<shift_l_op, PHOENIX_STD::ostream, T1> | |
{ | |
typedef PHOENIX_STD::ostream& result_type; | |
static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs) | |
{ return out << rhs; } | |
}; | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary3 | |
<shift_l_op, variable<PHOENIX_OSTREAM>, BaseT>::type | |
operator<<(PHOENIX_OSTREAM& _0, actor<BaseT> const& _1) | |
{ | |
return impl::make_binary3 | |
<shift_l_op, variable<PHOENIX_OSTREAM>, BaseT> | |
::construct(var(_0), _1); | |
} | |
#undef PHOENIX_OSTREAM | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// specializations for std::strstream / stringstream | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
template <typename T1> | |
struct binary_operator<shift_r_op, PHOENIX_STD::PHOENIX_SSTREAM, T1> | |
{ | |
typedef PHOENIX_STD::istream& result_type; | |
static result_type eval(PHOENIX_STD::istream& out, T1& rhs) | |
{ return out >> rhs; } | |
}; | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary3 | |
<shift_r_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>::type | |
operator>>(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor<BaseT> const& _1) | |
{ | |
return impl::make_binary3 | |
<shift_r_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT> | |
::construct(var(_0), _1); | |
} | |
////////////////////////////////// | |
template <typename T1> | |
struct binary_operator<shift_l_op, PHOENIX_STD::PHOENIX_SSTREAM, T1> | |
{ | |
typedef PHOENIX_STD::ostream& result_type; | |
static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs) | |
{ return out << rhs; } | |
}; | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary3 | |
<shift_l_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>::type | |
operator<<(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor<BaseT> const& _1) | |
{ | |
return impl::make_binary3 | |
<shift_l_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT> | |
::construct(var(_0), _1); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// I/O manipulator specializations | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
#if (!defined(__GNUC__) || (__GNUC__ > 2)) | |
// && !(defined(__ICL) && defined(_STLPORT_VERSION)) | |
typedef PHOENIX_STD::ios_base& (*iomanip_t)(PHOENIX_STD::ios_base&); | |
typedef PHOENIX_STD::istream& (*imanip_t)(PHOENIX_STD::istream&); | |
typedef PHOENIX_STD::ostream& (*omanip_t)(PHOENIX_STD::ostream&); | |
#if defined(__BORLANDC__) | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// Borland does not like i/o manipulators functions such as endl to | |
// be the rhs of a lazy << operator (Borland incorrectly reports | |
// ambiguity). To get around the problem, we provide function | |
// pointer versions of the same name with a single trailing | |
// underscore. | |
// | |
// You can use the same trick for other i/o manipulators. | |
// Alternatively, you can prefix the manipulator with a '&' | |
// operator. Example: | |
// | |
// cout << arg1 << &endl | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
imanip_t ws_ = &PHOENIX_STD::ws; | |
iomanip_t dec_ = &PHOENIX_STD::dec; | |
iomanip_t hex_ = &PHOENIX_STD::hex; | |
iomanip_t oct_ = &PHOENIX_STD::oct; | |
omanip_t endl_ = &PHOENIX_STD::endl; | |
omanip_t ends_ = &PHOENIX_STD::ends; | |
omanip_t flush_ = &PHOENIX_STD::flush; | |
#else // __BORLANDC__ | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// The following are overloads for I/O manipulators. | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary1<shift_l_op, BaseT, imanip_t>::type | |
operator>>(actor<BaseT> const& _0, imanip_t _1) | |
{ | |
return impl::make_binary1<shift_l_op, BaseT, imanip_t>::construct(_0, _1); | |
} | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type | |
operator>>(actor<BaseT> const& _0, iomanip_t _1) | |
{ | |
return impl::make_binary1<shift_l_op, BaseT, iomanip_t>::construct(_0, _1); | |
} | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary1<shift_l_op, BaseT, omanip_t>::type | |
operator<<(actor<BaseT> const& _0, omanip_t _1) | |
{ | |
return impl::make_binary1<shift_l_op, BaseT, omanip_t>::construct(_0, _1); | |
} | |
////////////////////////////////// | |
template <typename BaseT> | |
inline typename impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type | |
operator<<(actor<BaseT> const& _0, iomanip_t _1) | |
{ | |
return impl::make_binary1<shift_l_op, BaseT, iomanip_t>::construct(_0, _1); | |
} | |
#endif // __BORLANDC__ | |
#endif // !defined(__GNUC__) || (__GNUC__ > 2) | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// specializations for stl iterators and containers | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
template <typename T> | |
struct unary_operator<dereference_op, T> | |
{ | |
typedef typename T::reference result_type; | |
static result_type eval(T const& iter) | |
{ return *iter; } | |
}; | |
////////////////////////////////// | |
template <typename T0, typename T1> | |
struct binary_operator<index_op, T0, T1> | |
{ | |
typedef typename T0::reference result_type; | |
static result_type eval(T0& container, T1 const& index) | |
{ return container[index]; } | |
}; | |
////////////////////////////////// | |
template <typename T0, typename T1> | |
struct binary_operator<index_op, T0 const, T1> | |
{ | |
typedef typename T0::const_reference result_type; | |
static result_type eval(T0 const& container, T1 const& index) | |
{ return container[index]; } | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
} // namespace phoenix | |
#undef PHOENIX_SSTREAM | |
#undef PHOENIX_STD | |
#endif |