You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
341 lines
11 KiB
341 lines
11 KiB
/*============================================================================= |
|
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
|
|
|