passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/core/scoped_enum.hpp

@@ -43,7 +43,8 @@ namespace boost
    * @throws No-throws.
    */
   template <typename UnderlyingType, typename EnumType>
-  UnderlyingType underlying_cast(EnumType v)
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
   {
     return v.get_underlying_value_();
   }
@@ -61,7 +62,7 @@ namespace boost
    */
   template <typename EnumType>
   inline
-  typename EnumType::enum_type native_value(EnumType e)
+  BOOST_CONSTEXPR typename EnumType::enum_type native_value(EnumType e) BOOST_NOEXCEPT
   {
     return e.get_native_value_();
   }
@@ -75,14 +76,15 @@ namespace boost
   };
 
   template <typename UnderlyingType, typename EnumType>
-  UnderlyingType underlying_cast(EnumType v)
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
   {
     return static_cast<UnderlyingType>(v);
   }
 
   template <typename EnumType>
   inline
-  EnumType native_value(EnumType e)
+  BOOST_CONSTEXPR EnumType native_value(EnumType e) BOOST_NOEXCEPT
   {
     return e;
   }
@@ -96,7 +98,7 @@ namespace boost
 #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
 
 #define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
-     explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
+     explicit BOOST_CONSTEXPR operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
 
 #else
 
@@ -115,8 +117,8 @@ namespace boost
         typedef void is_boost_scoped_enum_tag;                          \
         typedef UnderlyingType underlying_type;                         \
         EnumType() BOOST_NOEXCEPT {}                                    \
-        explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
-        underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
+        explicit BOOST_CONSTEXPR EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+        BOOST_CONSTEXPR underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
         BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
     private:                                                            \
         underlying_type v_;                                             \
@@ -125,30 +127,30 @@ namespace boost
         enum enum_type
 
 #define BOOST_SCOPED_ENUM_DECLARE_END2() \
-        enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
-        friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
-        friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
-        friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
-        friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
-        friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
-        friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
-        friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
-        friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
-        friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
-        friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
-        friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
-        friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
-        friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
-        friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
-        friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
-        friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
-        friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
-        friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
+        BOOST_CONSTEXPR enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
+        friend BOOST_CONSTEXPR bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
+        friend BOOST_CONSTEXPR bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
+        friend BOOST_CONSTEXPR bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
+        friend BOOST_CONSTEXPR bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
+        friend BOOST_CONSTEXPR bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
+        friend BOOST_CONSTEXPR bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
     };
 
 #define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
     ; \
-    EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+    BOOST_CONSTEXPR EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
     BOOST_SCOPED_ENUM_DECLARE_END2()
 
 /**

data/src/cxx_supportlib/vendor-modified/boost/current_function.hpp

@@ -28,7 +28,11 @@ namespace detail
 inline void current_function_helper()
 {
 
-#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
+#if defined( BOOST_DISABLE_CURRENT_FUNCTION )
+
+# define BOOST_CURRENT_FUNCTION "(unknown)"
+
+#elif defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
 
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 

data/src/cxx_supportlib/vendor-modified/boost/date_time/c_time.hpp

@@ -57,15 +57,15 @@ namespace date_time {
       static std::tm* localtime(const std::time_t* t, std::tm* result)
       {
         // localtime_r() not in namespace std???
- 	#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
- 	std::tm tmp;
- 	if(!localtime_r(t,&tmp))
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
+        std::tm tmp;
+        if(!localtime_r(t,&tmp))
             result = 0;
-	else
-            *result = tmp;	
- 	#else
+        else
+            *result = tmp;
+#else
         result = localtime_r(t, result);
-	#endif
+#endif
         if (!result)
           boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
         return result;
@@ -75,15 +75,15 @@ namespace date_time {
       static std::tm* gmtime(const std::time_t* t, std::tm* result)
       {
         // gmtime_r() not in namespace std???
- 	#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
- 	std::tm tmp;
- 	if(!gmtime_r(t,&tmp))
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
+        std::tm tmp;
+        if(!gmtime_r(t,&tmp))
           result = 0;
         else
-          *result = tmp;	
-	#else
+          *result = tmp;
+#else
         result = gmtime_r(t, result);
-	#endif
+#endif
         if (!result)
           boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
         return result;

data/src/cxx_supportlib/vendor-modified/boost/date_time/constrained_value.hpp

@@ -39,7 +39,7 @@ namespace CV {
    *
    */
   template<class value_policies>
-  class constrained_value {
+  class BOOST_SYMBOL_VISIBLE constrained_value {
   public:
     typedef typename value_policies::value_type value_type;
     //    typedef except_type exception_type;
@@ -80,9 +80,9 @@ namespace CV {
   //! Template to shortcut the constrained_value policy creation process
   template<typename rep_type, rep_type min_value, 
            rep_type max_value, class exception_type>
-  class simple_exception_policy
+  class BOOST_SYMBOL_VISIBLE simple_exception_policy
   {
-    struct exception_wrapper : public exception_type
+    struct BOOST_SYMBOL_VISIBLE exception_wrapper : public exception_type
     {
       // In order to support throw_exception mechanism in the BOOST_NO_EXCEPTIONS mode,
       // we'll have to provide a way to acquire std::exception from the exception being thrown.

data/src/cxx_supportlib/vendor-modified/boost/date_time/date.hpp

@@ -10,6 +10,7 @@
  */
 
 #include <boost/operators.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/year_month_day.hpp>
 #include <boost/date_time/special_defs.hpp>
 
@@ -50,7 +51,7 @@ namespace date_time {
 
 
   template<class T, class calendar, class duration_type_>
-  class date : private
+  class BOOST_SYMBOL_VISIBLE date : private
        boost::less_than_comparable<T
      , boost::equality_comparable<T
     > >

data/src/cxx_supportlib/vendor-modified/boost/date_time/date_duration.hpp

@@ -12,6 +12,7 @@
 
 #include <boost/operators.hpp>
 #include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace date_time {
@@ -19,7 +20,7 @@ namespace date_time {
 
   //! Duration type with date level resolution
   template<class duration_rep_traits>
-  class date_duration : private
+  class BOOST_SYMBOL_VISIBLE date_duration : private
               boost::less_than_comparable1< date_duration< duration_rep_traits >
             , boost::equality_comparable1< date_duration< duration_rep_traits >
             , boost::addable1< date_duration< duration_rep_traits >
@@ -121,7 +122,7 @@ namespace date_time {
   /*! Struct for instantiating date_duration with <b>NO</b> special values
    * functionality. Allows for transparent implementation of either
    * date_duration<long> or date_duration<int_adapter<long> > */
-  struct duration_traits_long
+  struct BOOST_SYMBOL_VISIBLE duration_traits_long
   {
     typedef long int_type;
     typedef long impl_type;
@@ -131,7 +132,7 @@ namespace date_time {
   /*! Struct for instantiating date_duration <b>WITH</b> special values
    * functionality. Allows for transparent implementation of either
    * date_duration<long> or date_duration<int_adapter<long> > */
-  struct duration_traits_adapted
+  struct BOOST_SYMBOL_VISIBLE duration_traits_adapted
   {
     typedef long int_type;
     typedef boost::date_time::int_adapter<long> impl_type;

data/src/cxx_supportlib/vendor-modified/boost/date_time/date_duration_types.hpp

@@ -8,7 +8,8 @@
  * Author: Jeff Garland, Bart Garst
  * $Date$
  */
-                                                                                
+
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/int_adapter.hpp>
 #include <boost/date_time/special_defs.hpp>
 #include <boost/date_time/date_duration.hpp>
@@ -19,7 +20,7 @@ namespace date_time {
 
   //! Additional duration type that represents a number of n*7 days
   template <class duration_config>
-  class weeks_duration : public date_duration<duration_config> {
+  class BOOST_SYMBOL_VISIBLE weeks_duration : public date_duration<duration_config> {
   public:
     weeks_duration(typename duration_config::impl_type w) 
       : date_duration<duration_config>(w * 7) {}
@@ -29,7 +30,7 @@ namespace date_time {
 
   // predeclare
   template<class t>
-  class years_duration;
+  class BOOST_SYMBOL_VISIBLE years_duration;
 
   //! additional duration type that represents a logical month
   /*! A logical month enables things like: "date(2002,Mar,2) + months(2) -> 
@@ -37,7 +38,7 @@ namespace date_time {
    * also be a last-day-of-the-month.
    */
   template<class base_config>
-  class months_duration 
+  class BOOST_SYMBOL_VISIBLE months_duration
   {
     private:
       typedef typename base_config::int_rep int_rep;
@@ -159,7 +160,7 @@ namespace date_time {
    * 2004-Feb-29).
    */
   template<class base_config>
-  class years_duration 
+  class BOOST_SYMBOL_VISIBLE years_duration
   {
     private:
       typedef typename base_config::int_rep int_rep;

data/src/cxx_supportlib/vendor-modified/boost/date_time/date_facet.hpp

@@ -46,7 +46,7 @@ namespace boost { namespace date_time {
   template <class date_type,
             class CharT,
             class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class date_facet : public std::locale::facet {
+  class BOOST_SYMBOL_VISIBLE date_facet : public std::locale::facet {
   public:
     typedef typename date_type::duration_type duration_type;
     // greg_weekday is gregorian_calendar::day_of_week_type
@@ -408,7 +408,7 @@ namespace boost { namespace date_time {
   template <class date_type,
             class CharT,
             class InItrT = std::istreambuf_iterator<CharT, std::char_traits<CharT> > >
-  class date_input_facet : public std::locale::facet {
+  class BOOST_SYMBOL_VISIBLE date_input_facet : public std::locale::facet {
   public:
     typedef typename date_type::duration_type duration_type;
     // greg_weekday is gregorian_calendar::day_of_week_type

data/src/cxx_supportlib/vendor-modified/boost/date_time/date_names_put.hpp

@@ -10,14 +10,15 @@
  */
 
 
-#include "boost/date_time/locale_config.hpp" // set BOOST_DATE_TIME_NO_LOCALE
+#include <boost/date_time/locale_config.hpp> // set BOOST_DATE_TIME_NO_LOCALE
 
 #ifndef BOOST_DATE_TIME_NO_LOCALE
 
-#include "boost/date_time/special_defs.hpp"
-#include "boost/date_time/date_defs.hpp"
-#include "boost/date_time/parse_format_base.hpp"
-#include "boost/lexical_cast.hpp"
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/date_defs.hpp>
+#include <boost/date_time/parse_format_base.hpp>
+#include <boost/lexical_cast.hpp>
 #include <locale>
 
 
@@ -39,7 +40,7 @@ namespace date_time {
     template<class Config,
              class charT = char,
              class OutputIterator = std::ostreambuf_iterator<charT> >
-    class date_names_put : public std::locale::facet
+    class BOOST_SYMBOL_VISIBLE date_names_put : public std::locale::facet
     {
     public:
       date_names_put() {}
@@ -208,7 +209,7 @@ namespace date_time {
     template<class Config,
              class charT = char,
              class OutputIterator = std::ostreambuf_iterator<charT> >
-    class all_date_names_put : public date_names_put<Config, charT, OutputIterator>
+    class BOOST_SYMBOL_VISIBLE all_date_names_put : public date_names_put<Config, charT, OutputIterator>
     {
     public:
       all_date_names_put(const charT* const month_short_names[],

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_calendar.hpp

@@ -10,6 +10,7 @@
  */
 
 #include <boost/cstdint.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/gregorian/greg_weekday.hpp>
 #include <boost/date_time/gregorian/greg_day_of_year.hpp>
 #include <boost/date_time/gregorian_calendar.hpp>
@@ -23,7 +24,7 @@ namespace gregorian {
   typedef date_time::int_adapter<uint32_t> fancy_date_rep;
 
   //! Gregorian calendar for this implementation, hard work in the base
-  class gregorian_calendar :
+  class BOOST_SYMBOL_VISIBLE gregorian_calendar :
     public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
   public:
     //! Type to hold a weekday (eg: Sunday, Monday,...)

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_date.hpp

@@ -10,6 +10,7 @@
  */
 
 #include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/date.hpp>
 #include <boost/date_time/special_defs.hpp>
 #include <boost/date_time/gregorian/greg_calendar.hpp>
@@ -34,7 +35,7 @@ namespace gregorian {
       supported.
       \ingroup date_basics
   */
-  class date : public date_time::date<date, gregorian_calendar, date_duration>
+  class BOOST_SYMBOL_VISIBLE date : public date_time::date<date, gregorian_calendar, date_duration>
   {
    public:
     typedef gregorian_calendar::year_type year_type;

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_day.hpp

@@ -9,7 +9,8 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
+#include <boost/date_time/constrained_value.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <stdexcept>
 #include <string>
 
@@ -17,7 +18,7 @@ namespace boost {
 namespace gregorian {
 
   //! Exception type for gregorian day of month (1..31)
-  struct bad_day_of_month : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_day_of_month : public std::out_of_range
   {
     bad_day_of_month() : 
       std::out_of_range(std::string("Day of month value is out of range 1..31")) 
@@ -39,7 +40,7 @@ namespace gregorian {
       is automatically range checked so values outside of the range 1-31
       will cause a bad_day_of_month exception
   */
-  class greg_day : public greg_day_rep {
+  class BOOST_SYMBOL_VISIBLE greg_day : public greg_day_rep {
   public:
     greg_day(unsigned short day_of_month) : greg_day_rep(day_of_month) {}
     unsigned short as_number() const {return value_;}

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_day_of_year.hpp

@@ -9,7 +9,8 @@
  * $Date$
  */
 
-#include "boost/date_time/constrained_value.hpp"
+#include <boost/date_time/constrained_value.hpp>
+#include <boost/date_time/compiler_config.hpp>
 #include <stdexcept>
 #include <string>
 
@@ -17,7 +18,7 @@ namespace boost {
 namespace gregorian {
 
   //! Exception type for day of year (1..366)
-  struct bad_day_of_year : public std::out_of_range
+  struct BOOST_SYMBOL_VISIBLE bad_day_of_year : public std::out_of_range
   {
     bad_day_of_year() : 
       std::out_of_range(std::string("Day of year value is out of range 1..366")) 

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_duration.hpp

@@ -9,6 +9,7 @@
  * $Date$
  */
 
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/date_duration.hpp>
 #include <boost/date_time/int_adapter.hpp>
 #include <boost/date_time/special_defs.hpp>
@@ -22,7 +23,7 @@ namespace gregorian {
   //! Durations in days for gregorian system
   /*! \ingroup date_basics
    */
-  class date_duration :
+  class BOOST_SYMBOL_VISIBLE date_duration :
     public boost::date_time::date_duration< date_duration_rep >
   {
     typedef boost::date_time::date_duration< date_duration_rep > base_type;

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_duration_types.hpp

@@ -1,6 +1,6 @@
 #ifndef GREG_DURATION_TYPES_HPP___
 #define GREG_DURATION_TYPES_HPP___
-                                                                                
+
 /* Copyright (c) 2004 CrystalClear Software, Inc.
  * Subject to Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
@@ -9,6 +9,7 @@
  */
 
 
+#include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/gregorian/greg_date.hpp>
 #include <boost/date_time/int_adapter.hpp>
 #include <boost/date_time/adjust_functors.hpp>
@@ -19,7 +20,7 @@ namespace boost {
 namespace gregorian {
 
   //! config struct for additional duration types (ie months_duration<> & years_duration<>)
-  struct greg_durations_config {
+  struct BOOST_SYMBOL_VISIBLE greg_durations_config {
     typedef date date_type;
     typedef date_time::int_adapter<int> int_rep;
     typedef date_time::month_functor<date_type> month_adjustor_type; 
@@ -28,7 +29,7 @@ namespace gregorian {
   typedef date_time::months_duration<greg_durations_config> months;
   typedef date_time::years_duration<greg_durations_config> years;
 
-  class weeks_duration : public date_duration {
+  class BOOST_SYMBOL_VISIBLE weeks_duration : public date_duration {
   public:
     weeks_duration(duration_rep w) 
       : date_duration(w * 7) {}