diff DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/special_ops.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/special_ops.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,341 @@
+/*=============================================================================
+    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