Ticket #5024: cuda.patch

File cuda.patch, 12.2 KB (added by anonymous, 12 years ago)

  • boost/lexical_cast.hpp

     
    342342#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
    343343            BOOST_STATIC_CONSTANT(std::size_t, value =
    344344                  std::numeric_limits<Source>::is_signed +
    345                   std::numeric_limits<Source>::is_specialized + // == 1
     345                  std::numeric_limits<Source>::is_specialized +
    346346                  std::numeric_limits<Source>::digits10 * 2
    347347              );
    348348#else

  • boost/mpl/assert.hpp

     
    146146template< typename P > struct assert_arg_pred_not
    147147{
    148148    typedef typename P::type p_type;
     149#ifdef __CUDACC__
     150    enum { p = !p_type::value };
     151#else
    149152    BOOST_MPL_AUX_ASSERT_CONSTANT( bool, p = !p_type::value );
     153#endif
    150154    typedef typename assert_arg_pred_impl<p>::type type;
    151155};
    152156

  • boost/mpl/size_t_fwd.hpp

     
    2020
    2121BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
    2222
     23#if defined(__CUDACC__)
     24typedef std::size_t std_size_t;
     25template< std_size_t N > struct size_t;
     26#else
    2327template< std::size_t N > struct size_t;
     28#endif
    2429
    2530BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
    2631BOOST_MPL_AUX_ADL_BARRIER_DECL(size_t)

  • boost/mpl/aux_/config/gcc.hpp

     
    1414// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
    1515// $Revision: 49267 $
    1616
    17 #if defined(__GNUC__) && !defined(__EDG_VERSION__)
     17#if defined(__GNUC__) && !(defined(__EDG_VERSION__) || defined(__CUDACC__))
    1818#   define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
    1919#else
    2020#   define BOOST_MPL_CFG_GCC 0

  • boost/mpl/aux_/integral_wrapper.hpp

     
    5656// have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC),
    5757// while some other don't like 'value + 1' (Borland), and some don't like
    5858// either
    59 #if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
     59#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)  || defined(__CUDACC__)
    6060 private:
    6161    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));
    6262    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)));

  • boost/mpl/size_t.hpp

     
    1616
    1717#include <boost/mpl/size_t_fwd.hpp>
    1818
     19
     20#if defined(__CUDACC__)
     21
     22//typedef std::size_t std_size_t;
     23#define AUX_WRAPPER_VALUE_TYPE std_size_t
     24#define AUX_WRAPPER_NAME size_t
     25#define AUX_WRAPPER_PARAMS(N) std_size_t N
     26
     27#else
     28
    1929#define AUX_WRAPPER_VALUE_TYPE std::size_t
    2030#define AUX_WRAPPER_NAME size_t
    2131#define AUX_WRAPPER_PARAMS(N) std::size_t N
    2232
     33#endif
     34
    2335#include <boost/mpl/aux_/integral_wrapper.hpp>
    2436
    2537#endif // BOOST_MPL_SIZE_T_HPP_INCLUDED

  • boost/iterator/iterator_concepts.hpp

     
    133133    , boost::EqualityComparable<Iterator>
    134134
    135135  {
     136  private:
     137      template<class C>
     138          struct trait {
     139          typedef typename C::traversal_category traversal_category;
     140      };
     141  public:
    136142      BOOST_CONCEPT_ASSERT((
    137143          boost::Convertible<
    138              BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
     144             typename trait<SinglePassIterator>::traversal_category
    139145           , boost::single_pass_traversal_tag
    140146          > ));
    141147  };
    … …  
    148154     
    149155      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
    150156      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
    151 
     157  private:
     158      template<class C>
     159          struct trait {
     160          typedef typename C::traversal_category traversal_category;
     161      };
     162  public:
    152163      BOOST_CONCEPT_ASSERT((
    153164          boost::Convertible<
    154              BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
     165             typename trait<ForwardTraversal>::traversal_category
    155166           , boost::forward_traversal_tag
    156167          > ));
    157168  };
    … …  
    159170  BOOST_concept(BidirectionalTraversal,(Iterator))
    160171    : ForwardTraversal<Iterator>
    161172  {
     173  private:
     174      template<class C>
     175          struct trait {
     176          typedef typename C::traversal_category traversal_category;
     177      };
     178  public:
    162179      BOOST_CONCEPT_ASSERT((
    163180          boost::Convertible<
    164              BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
     181             typename trait<BidirectionalTraversal>::traversal_category
    165182           , boost::bidirectional_traversal_tag
    166183          > ));
    167184
    … …  
    177194  BOOST_concept(RandomAccessTraversal,(Iterator))
    178195    : BidirectionalTraversal<Iterator>
    179196  {
     197  private:
     198      template<class C>
     199          struct trait {
     200          typedef typename C::traversal_category traversal_category;
     201      };
     202  public:
    180203      BOOST_CONCEPT_ASSERT((
    181204          boost::Convertible<
    182              BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
     205             typename trait<RandomAccessTraversal>::traversal_category
    183206           , boost::random_access_traversal_tag
    184207          > ));
    185208

  • boost/config/compiler/nvcc.hpp

     
    1515// BOOST_GPU_ENABLED : Flag a function or a method as being enabled on the host and device
    1616#define BOOST_GPU_ENABLED __host__ __device__
    1717
     18// #ifndef __CUDA_ARCH__
     19// #define BOOST_NO_DEDUCED_TYPENAME
     20// #warning BOOST_NO_DEDUCED_TYPENAME
     21// #else
     22// #warning !BOOST_NO_DEDUCED_TYPENAME
     23// #endif
     24
    1825// Boost support macro for NVCC
    1926// NVCC Basically behaves like some flavor of MSVC6 + some specific quirks
    20 #define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
    21 #define BOOST_MSVC6_MEMBER_TEMPLATES
     27//#define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
     28//#define BOOST_MSVC6_MEMBER_TEMPLATES
    2229#define BOOST_HAS_UNISTD_H
    2330#define BOOST_HAS_STDINT_H
    2431#define BOOST_HAS_SIGACTION

  • boost/concept_check.hpp

     
    506506      BOOST_CONCEPT_USAGE(ForwardIterator)
    507507      {
    508508          BOOST_CONCEPT_ASSERT((Convertible<
    509               BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
     509              typename InputIterator<TT>::iterator_category
    510510            , std::forward_iterator_tag
    511511          >));
    512512         
    … …  
    534534      BOOST_CONCEPT_USAGE(BidirectionalIterator)
    535535      {
    536536          BOOST_CONCEPT_ASSERT((Convertible<
    537               BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
     537              typename ForwardIterator<TT>::iterator_category
    538538            , std::bidirectional_iterator_tag
    539539          >));
    540540
    … …  
    638638      BOOST_CONCEPT_USAGE(Mutable_Container)
    639639      {
    640640          BOOST_CONCEPT_ASSERT((
    641                Assignable<typename Mutable_Container::value_type>));
     641               Assignable<typename Container<C>::value_type>));
    642642         
    643643          BOOST_CONCEPT_ASSERT((InputIterator<iterator>));
    644644         
    … …  
    659659      {
    660660          BOOST_CONCEPT_ASSERT((
    661661               ForwardIterator<
    662                     typename ForwardContainer::const_iterator
     662                 typename Container<C>::const_iterator
    663663               >));
    664664      }
    665665  }; 
    … …  
    668668    : ForwardContainer<C>
    669669    , Mutable_Container<C>
    670670  {
     671   private:
     672      template<class C_>
     673      struct traits {
     674          typedef typename C_::iterator iterator;
     675      };
     676      typedef traits<Mutable_ForwardContainer> self;
     677  public:
    671678      BOOST_CONCEPT_USAGE(Mutable_ForwardContainer)
    672679      {
    673680          BOOST_CONCEPT_ASSERT((
    674681               Mutable_ForwardIterator<
    675                    typename Mutable_ForwardContainer::iterator
     682                   typename self::iterator
    676683               >));
    677684      }
    678685  }; 
    … …  
    688695      {
    689696          BOOST_CONCEPT_ASSERT((
    690697              BidirectionalIterator<
    691                   typename ReversibleContainer::const_iterator>));
     698                  typename ForwardContainer<C>::const_iterator>));
    692699         
    693700          BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>));
    694701         
    … …  
    732739      {
    733740          BOOST_CONCEPT_ASSERT((
    734741              RandomAccessIterator<
    735                   typename RandomAccessContainer::const_iterator
     742                  typename ReversibleContainer<C>::const_iterator
    736743              >));
    737744         
    738745          const_constraints(c);
    … …  
    753760    , RandomAccessContainer<C>
    754761  {
    755762   private:
    756       typedef Mutable_RandomAccessContainer self;
     763      template<class C_>
     764      struct traits {
     765          typedef typename C_::iterator iterator;
     766          typedef typename C_::reverse_iterator reverse_iterator;
     767          typedef typename C_::reference reference;
     768      };
     769      typedef traits<Mutable_RandomAccessContainer> self;
    757770   public:
    758771      BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer)
    759772      {
    … …  
    777790      // ... so why aren't we following the standard?  --DWA
    778791    , DefaultConstructible<S>
    779792  {
     793   private:
     794      template<class S_>
     795      struct traits {
     796          typedef typename S_::reference reference;
     797          typedef typename S_::const_reference const_reference;
     798      };
     799      typedef traits<Sequence> self;
     800  public:
    780801      BOOST_CONCEPT_USAGE(Sequence)
    781802      {
    782803          S
    … …  
    791812          c.erase(p);
    792813          c.erase(p, q);
    793814
    794           typename Sequence::reference r = c.front();
     815          typename self::reference r = c.front();
    795816
    796817          ignore_unused_variable_warning(c);
    797818          ignore_unused_variable_warning(c2);
    … …  
    801822      }
    802823   private:
    803824      void const_constraints(const S& c) {
    804           typename Sequence::const_reference r = c.front();
     825          typename self::const_reference r = c.front();
    805826          ignore_unused_variable_warning(r);
    806827      }
    807828   
    … …  
    827848  BOOST_concept(BackInsertionSequence,(S))
    828849    : Sequence<S>
    829850  {
     851  private:
     852      template<class S_>
     853      struct traits {
     854          typedef typename S_::reference reference;
     855          typedef typename S_::const_reference const_reference;
     856      };
     857      typedef traits<BackInsertionSequence> self;
     858  public:
    830859      BOOST_CONCEPT_USAGE(BackInsertionSequence)
    831860      {
    832861          c.push_back(t);
    833862          c.pop_back();
    834           typename BackInsertionSequence::reference r = c.back();
     863          typename self::reference r = c.back();
    835864          ignore_unused_variable_warning(r);
    836865          const_constraints(c);
    837866      }
    838867   private:
    839868      void const_constraints(const S& cc) {
    840           typename BackInsertionSequence::const_reference
     869          typename self::const_reference
    841870              r = cc.back();
    842871          ignore_unused_variable_warning(r);
    843872      };
    … …  
    849878    : ForwardContainer<C>
    850879    , DefaultConstructible<C>
    851880  {
     881  private:
     882      template<class S_>
     883      struct traits {
     884          typedef typename S_::value_type value_type;
     885      };
     886      typedef traits<AssociativeContainer> self;
     887  public:
    852888      typedef typename C::key_type key_type;
    853889      typedef typename C::key_compare key_compare;
    854890      typedef typename C::value_compare value_compare;
    … …  
    864900          const_constraints(c);
    865901          BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>));
    866902         
    867           typedef typename AssociativeContainer::value_type value_type_;
     903          typedef typename self::value_type value_type_;
    868904          BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>));
    869905      }
    870906