Ticket #7701: locale.diff

libs/locale/src/std/codecvt.cpp

@@ -18 +18 @@
     std::locale codecvt_bychar( std::locale const &in,
                                 std::string const &locale_name)
     {
-        return std::locale(in,new std::codecvt_byname<CharType,char,mbstate_t>(locale_name.c_str()));
+        return std::locale(in,new std::codecvt_byname<CharType,char,std::mbstate_t>(locale_name.c_str()));
     }
     
 

libs/locale/src/util/codecvt_converter.cpp

@@ -70 +70 @@
             if(!utf::is_valid_codepoint(u))
                 return illegal;
             int width = utf::utf_traits<char>::width(u);
-            ptrdiff_t d=end-begin;
+            std::ptrdiff_t d=end-begin;
             if(d < width)
                 return incomplete;
             utf::utf_traits<char>::encode(u,begin);
@@ -229 +229 @@
     // Real codecvt
 
     template<typename CharType>
-    class code_converter : public std::codecvt<CharType,char,mbstate_t> 
+    class code_converter : public std::codecvt<CharType,char,std::mbstate_t> 
     {
     public:
         code_converter(std::auto_ptr<base_converter> cvt,size_t refs = 0) :
-            std::codecvt<CharType,char,mbstate_t>(refs),
+          std::codecvt<CharType,char,std::mbstate_t>(refs),
             cvt_(cvt)
         {
             max_len_ = cvt_->max_len(); 
@@ -627 +627 @@
 
     };
 
-    static const char ensure_mbstate_size_is_at_least_2[sizeof(mbstate_t) >= 2 ? 1 : -1] = {0};
+    static const char ensure_mbstate_size_is_at_least_2[sizeof(std::mbstate_t) >= 2 ? 1 : -1] = {0};
     
     template<>
-    class code_converter<char> : public std::codecvt<char,char,mbstate_t>
+    class code_converter<char> : public std::codecvt<char,char,std::mbstate_t>
     {
     public:
         code_converter(std::auto_ptr<base_converter> /*cvt*/,size_t refs = 0) : 
-            std::codecvt<char,char,mbstate_t>(refs)  
+          std::codecvt<char,char,std::mbstate_t>(refs)  
         {
         }
     };

libs/locale/src/util/gregorian.cpp

@@ -70 +70 @@
             return days[is_leap(year)][month-1] + day - 1;
         }
         
-        time_t internal_timegm(std::tm const *t)
+        std::time_t internal_timegm(std::tm const *t)
         {
             int year = t->tm_year + 1900;
             int month = t->tm_mon;
@@ -88 +88 @@
             int day_of_year = days_from_1jan(year,month,day);
             int days_since_epoch = days_from_1970(year) + day_of_year;
             
-            time_t seconds_in_day = 3600 * 24;
-            time_t result =  seconds_in_day * days_since_epoch + 3600 * t->tm_hour + 60 * t->tm_min + t->tm_sec;
+            std::time_t seconds_in_day = 3600 * 24;
+            std::time_t result =  seconds_in_day * days_since_epoch + 3600 * t->tm_hour + 60 * t->tm_min + t->tm_sec;
             
             return result;
         }
@@ -235 +235 @@
                     std::tm val = tm_updated_;
                     val.tm_isdst = -1;
                     val.tm_wday = -1; // indecator of error
-                    time_t point = -1;
+                    std::time_t point = -1;
                     if(is_local_) {
                         point = mktime(&val);
-                        if(point == static_cast<time_t>(-1)){
+                        if(point == static_cast<std::time_t>(-1)){
                             #ifndef BOOST_WINDOWS
                             // windows does not handle negative time_t, under other plaforms
                             // it may be actually valid value in  1969-12-31 23:59:59
@@ -318 +318 @@
                         #ifdef BOOST_WINDOWS
                         return 1970; // Unix epoch windows can't handle negative time_t
                         #else
-                        if(sizeof(time_t) == 4)
+                        if(sizeof(std::time_t) == 4)
                             return 1901; // minimal year with 32 bit time_t
                         else
                             return 1; 
@@ -326 +326 @@
                     case absolute_maximum:
                     case least_maximum:
                     case actual_maximum:
-                        if(sizeof(time_t) == 4)
+                        if(sizeof(std::time_t) == 4)
                             return 2038; // Y2K38 - maximal with 32 bit time_t
                         else
                             return std::numeric_limits<int>::max();
@@ -565 +565 @@
             ///
             virtual void set_time(posix_time const &p)
             {
-                from_time(static_cast<time_t>(p.seconds));
+                from_time(static_cast<std::time_t>(p.seconds));
             }
             virtual posix_time get_time() const  
             {
@@ -791 +791 @@
 
     private:
 
-        void from_time(time_t point)
+        void from_time(std::time_t point)
         {
-            time_t real_point = point + tzoff_;
+            std::time_t real_point = point + tzoff_;
             std::tm *t = 0;
             #ifdef BOOST_WINDOWS
             // Windows uses TLS, thread safe
@@ -811 +811 @@
             time_ = point;
         }
         int first_day_of_week_;
-        time_t time_;
+        std::time_t time_;
         std::tm tm_;
         std::tm tm_updated_;
         bool normalized_;

libs/locale/src/util/numeric.hpp

@@ -14 +14 @@
 #include <boost/locale/info.hpp>
 #include <sstream>
 #include <vector>
+#include <ctime>
 #include <stdlib.h>
 
 #include "timezone.hpp"
@@ -177 +178 @@
         return out;
     }
 
-    iter_type format_time(iter_type out,std::ios_base &ios,char_type fill,time_t time,char c) const
+    iter_type format_time(iter_type out,std::ios_base &ios,char_type fill,std::time_t time,char c) const
     {
         string_type fmt;
         fmt+=char_type('%');
@@ -185 +186 @@
         return format_time(out,ios,fill,time,fmt);
     }
 
-    iter_type format_time(iter_type out,std::ios_base &ios,char_type fill,time_t time,string_type const &format) const
+    iter_type format_time(iter_type out,std::ios_base &ios,char_type fill,std::time_t time,string_type const &format) const
     {
         std::string tz = ios_info::get(ios).time_zone();
         std::tm tm;