ceph/src/boost/libs/log/src/code_conversion.cpp

   1 /*
   2  *          Copyright Andrey Semashev 2007 - 2015.
   3  * Distributed under the Boost Software License, Version 1.0.
   4  *    (See accompanying file LICENSE_1_0.txt or copy at
   5  *          http://www.boost.org/LICENSE_1_0.txt)
   6  */
   7 /*!
   8  * \file   code_conversion.cpp
   9  * \author Andrey Semashev
  10  * \date   08.11.2008
  11  *
  12  * \brief  This header is the Boost.Log library implementation, see the library documentation
  13  *         at http://www.boost.org/doc/libs/release/libs/log/doc/html/index.html.
  14  */
  15
  16 #include <boost/log/detail/config.hpp>
  17 #include <cstddef>
  18 #include <locale>
  19 #include <string>
  20 #include <stdexcept>
  21 #include <algorithm>
  22 #include <boost/log/exceptions.hpp>
  23 #include <boost/log/detail/code_conversion.hpp>
  24 #if defined(BOOST_WINDOWS)
  25 #include <cstring>
  26 #include <limits>
  27 #include <boost/winapi/get_last_error.hpp>
  28 #include <boost/winapi/character_code_conversion.hpp>
  29 #endif
  30 #include <boost/log/detail/header.hpp>
  31
  32 namespace boost {
  33
  34 BOOST_LOG_OPEN_NAMESPACE
  35
  36 namespace aux {
  37
  38 BOOST_LOG_ANONYMOUS_NAMESPACE {
  39
  40 //! The function performs character conversion with the specified facet
  41 template< typename LocalCharT >
  42 inline std::codecvt_base::result convert(
  43     std::codecvt< LocalCharT, char, std::mbstate_t > const& fac,
  44     std::mbstate_t& state,
  45     const char*& pSrcBegin,
  46     const char* pSrcEnd,
  47     LocalCharT*& pDstBegin,
  48     LocalCharT* pDstEnd)
  49 {
  50     return fac.in(state, pSrcBegin, pSrcEnd, pSrcBegin, pDstBegin, pDstEnd, pDstBegin);
  51 }
  52
  53 //! The function performs character conversion with the specified facet
  54 template< typename LocalCharT >
  55 inline std::codecvt_base::result convert(
  56     std::codecvt< LocalCharT, char, std::mbstate_t > const& fac,
  57     std::mbstate_t& state,
  58     const LocalCharT*& pSrcBegin,
  59     const LocalCharT* pSrcEnd,
  60     char*& pDstBegin,
  61     char* pDstEnd)
  62 {
  63     return fac.out(state, pSrcBegin, pSrcEnd, pSrcBegin, pDstBegin, pDstEnd, pDstBegin);
  64 }
  65
  66 } // namespace
  67
  68 #if defined(BOOST_MSVC)
  69 #pragma warning(push)
  70 // conversion from 'X' to 'Y', possible loss of data
  71 // This warning is triggered for the noconv case below, where we convert wchar_t to char if the locale facet
  72 // reports that no code conversion is needed. In such a case, no data loss will happen.
  73 #pragma warning(disable: 4244)
  74 #endif
  75
  76 template< typename SourceCharT, typename TargetCharT, typename FacetT >
  77 inline std::size_t code_convert(const SourceCharT* begin, const SourceCharT* end, std::basic_string< TargetCharT >& converted, std::size_t max_size, FacetT const& fac)
  78 {
  79     typedef typename FacetT::state_type state_type;
  80     TargetCharT converted_buffer[256];
  81
  82     const SourceCharT* const original_begin = begin;
  83     state_type state = state_type();
  84     std::size_t buf_size = (std::min)(max_size, sizeof(converted_buffer) / sizeof(*converted_buffer));
  85     while (begin != end && buf_size > 0u)
  86     {
  87         TargetCharT* dest = converted_buffer;
  88         std::codecvt_base::result res = convert(
  89             fac,
  90             state,
  91             begin,
  92             end,
  93             dest,
  94             dest + buf_size);
  95
  96         switch (res)
  97         {
  98         case std::codecvt_base::ok:
  99             // All characters were successfully converted
 100             // NOTE: MSVC 11 also returns ok when the source buffer was only partially consumed, so we also check that the begin pointer has reached the end.
 101             converted.append(converted_buffer, dest);
 102             max_size -= dest - converted_buffer;
 103             break;
 104
 105         case std::codecvt_base::noconv:
 106             {
 107                 // Not possible, unless both character types are actually equivalent
 108                 const std::size_t size = (std::min)(max_size, static_cast< std::size_t >(end - begin));
 109                 converted.append(begin, begin + size);
 110                 begin += size;
 111                 max_size -= size;
 112             }
 113             goto done;
 114
 115         case std::codecvt_base::partial:
 116             // Some characters were converted, some were not
 117             if (dest != converted_buffer)
 118             {
 119                 // Some conversion took place, so it seems like
 120                 // the destination buffer might not have been long enough
 121                 converted.append(converted_buffer, dest);
 122                 max_size -= dest - converted_buffer;
 123
 124                 // ...and go on for the next part
 125                 break;
 126             }
 127             else
 128             {
 129                 // Nothing was converted
 130                 if (begin == end)
 131                     goto done;
 132
 133                 // Looks like the tail of the source buffer contains only part of the last character.
 134                 // In this case we intentionally fall through to throw an exception.
 135             }
 136             BOOST_FALLTHROUGH;
 137
 138         default: // std::codecvt_base::error
 139             BOOST_LOG_THROW_DESCR(conversion_error, "Could not convert character encoding");
 140         }
 141
 142         buf_size = (std::min)(max_size, sizeof(converted_buffer) / sizeof(*converted_buffer));
 143     }
 144
 145 done:
 146     return static_cast< std::size_t >(begin - original_begin);
 147 }
 148
 149 #if defined(BOOST_MSVC)
 150 #pragma warning(pop)
 151 #endif
 152
 153 //! The function converts one string to the character type of another
 154 BOOST_LOG_API bool code_convert_impl(const wchar_t* str1, std::size_t len, std::string& str2, std::size_t max_size, std::locale const& loc)
 155 {
 156     return code_convert(str1, str1 + len, str2, max_size, std::use_facet< std::codecvt< wchar_t, char, std::mbstate_t > >(loc)) == len;
 157 }
 158
 159 //! The function converts one string to the character type of another
 160 BOOST_LOG_API bool code_convert_impl(const char* str1, std::size_t len, std::wstring& str2, std::size_t max_size, std::locale const& loc)
 161 {
 162     return code_convert(str1, str1 + len, str2, max_size, std::use_facet< std::codecvt< wchar_t, char, std::mbstate_t > >(loc)) == len;
 163 }
 164
 165 #if !defined(BOOST_LOG_NO_CXX11_CODECVT_FACETS)
 166
 167 #if !defined(BOOST_NO_CXX11_CHAR16_T)
 168
 169 //! The function converts one string to the character type of another
 170 BOOST_LOG_API bool code_convert_impl(const char16_t* str1, std::size_t len, std::string& str2, std::size_t max_size, std::locale const& loc)
 171 {
 172     return code_convert(str1, str1 + len, str2, max_size, std::use_facet< std::codecvt< char16_t, char, std::mbstate_t > >(loc)) == len;
 173 }
 174
 175 //! The function converts one string to the character type of another
 176 BOOST_LOG_API bool code_convert_impl(const char* str1, std::size_t len, std::u16string& str2, std::size_t max_size, std::locale const& loc)
 177 {
 178     return code_convert(str1, str1 + len, str2, max_size, std::use_facet< std::codecvt< char16_t, char, std::mbstate_t > >(loc)) == len;
 179 }
 180
 181 //! The function converts one string to the character type of another
 182 BOOST_LOG_API bool code_convert_impl(const char16_t* str1, std::size_t len, std::wstring& str2, std::size_t max_size, std::locale const& loc)
 183 {
 184     std::string temp_str;
 185     code_convert(str1, str1 + len, temp_str, temp_str.max_size(), std::use_facet< std::codecvt< char16_t, char, std::mbstate_t > >(loc));
 186     const std::size_t temp_size = temp_str.size();
 187     return code_convert(temp_str.c_str(), temp_str.c_str() + temp_size, str2, max_size, std::use_facet< std::codecvt< wchar_t, char, std::mbstate_t > >(loc)) == temp_size;
 188 }
 189
 190 #endif
 191
 192 #if !defined(BOOST_NO_CXX11_CHAR32_T)
 193
 194 //! The function converts one string to the character type of another
 195 BOOST_LOG_API bool code_convert_impl(const char32_t* str1, std::size_t len, std::string& str2, std::size_t max_size, std::locale const& loc)
 196 {
 197     return code_convert(str1, str1 + len, str2, max_size, std::use_facet< std::codecvt< char32_t, char, std::mbstate_t > >(loc)) == len;
 198 }
 199
 200 //! The function converts one string to the character type of another
 201 BOOST_LOG_API bool code_convert_impl(const char* str1, std::size_t len, std::u32string& str2, std::size_t max_size, std::locale const& loc)
 202 {
 203     return code_convert(str1, str1 + len, str2, max_size, std::use_facet< std::codecvt< char32_t, char, std::mbstate_t > >(loc)) == len;
 204 }
 205
 206 //! The function converts one string to the character type of another
 207 BOOST_LOG_API bool code_convert_impl(const char32_t* str1, std::size_t len, std::wstring& str2, std::size_t max_size, std::locale const& loc)
 208 {
 209     std::string temp_str;
 210     code_convert(str1, str1 + len, temp_str, temp_str.max_size(), std::use_facet< std::codecvt< char32_t, char, std::mbstate_t > >(loc));
 211     const std::size_t temp_size = temp_str.size();
 212     return code_convert(temp_str.c_str(), temp_str.c_str() + temp_size, str2, max_size, std::use_facet< std::codecvt< wchar_t, char, std::mbstate_t > >(loc)) == temp_size;
 213 }
 214
 215 #endif
 216
 217 #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_CHAR32_T)
 218
 219 //! The function converts one string to the character type of another
 220 BOOST_LOG_API bool code_convert_impl(const char16_t* str1, std::size_t len, std::u32string& str2, std::size_t max_size, std::locale const& loc)
 221 {
 222     std::string temp_str;
 223     code_convert(str1, str1 + len, temp_str, temp_str.max_size(), std::use_facet< std::codecvt< char16_t, char, std::mbstate_t > >(loc));
 224     const std::size_t temp_size = temp_str.size();
 225     return code_convert(temp_str.c_str(), temp_str.c_str() + temp_size, str2, max_size, std::use_facet< std::codecvt< char32_t, char, std::mbstate_t > >(loc)) == temp_size;
 226 }
 227
 228 //! The function converts one string to the character type of another
 229 BOOST_LOG_API bool code_convert_impl(const char32_t* str1, std::size_t len, std::u16string& str2, std::size_t max_size, std::locale const& loc)
 230 {
 231     std::string temp_str;
 232     code_convert(str1, str1 + len, temp_str, temp_str.max_size(), std::use_facet< std::codecvt< char32_t, char, std::mbstate_t > >(loc));
 233     const std::size_t temp_size = temp_str.size();
 234     return code_convert(temp_str.c_str(), temp_str.c_str() + temp_size, str2, max_size, std::use_facet< std::codecvt< char16_t, char, std::mbstate_t > >(loc)) == temp_size;
 235 }
 236
 237 #endif
 238
 239 #endif // !defined(BOOST_LOG_NO_CXX11_CODECVT_FACETS)
 240
 241 #if defined(BOOST_WINDOWS)
 242
 243 //! Converts UTF-8 to UTF-16
 244 std::wstring utf8_to_utf16(const char* str)
 245 {
 246     std::size_t utf8_len = std::strlen(str);
 247     if (utf8_len == 0)
 248         return std::wstring();
 249     else if (BOOST_UNLIKELY(utf8_len > static_cast< std::size_t >((std::numeric_limits< int >::max)())))
 250         BOOST_LOG_THROW_DESCR(bad_alloc, "UTF-8 string too long");
 251
 252     int len = boost::winapi::MultiByteToWideChar(boost::winapi::CP_UTF8_, boost::winapi::MB_ERR_INVALID_CHARS_, str, static_cast< int >(utf8_len), NULL, 0);
 253     if (BOOST_LIKELY(len > 0))
 254     {
 255         std::wstring wstr;
 256         wstr.resize(len);
 257
 258         len = boost::winapi::MultiByteToWideChar(boost::winapi::CP_UTF8_, boost::winapi::MB_ERR_INVALID_CHARS_, str, static_cast< int >(utf8_len), &wstr[0], len);
 259         if (BOOST_LIKELY(len > 0))
 260         {
 261             return wstr;
 262         }
 263     }
 264
 265     const boost::winapi::DWORD_ err = boost::winapi::GetLastError();
 266     BOOST_LOG_THROW_DESCR_PARAMS(system_error, "Failed to convert UTF-8 to UTF-16", (err));
 267     BOOST_LOG_UNREACHABLE_RETURN(std::wstring());
 268 }
 269
 270 //! Converts UTF-16 to UTF-8
 271 std::string utf16_to_utf8(const wchar_t* wstr)
 272 {
 273     std::size_t utf16_len = std::wcslen(wstr);
 274     if (utf16_len == 0)
 275         return std::string();
 276     else if (BOOST_UNLIKELY(utf16_len > static_cast< std::size_t >((std::numeric_limits< int >::max)())))
 277         BOOST_LOG_THROW_DESCR(bad_alloc, "UTF-16 string too long");
 278
 279     const boost::winapi::DWORD_ flags =
 280 #if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
 281         boost::winapi::WC_ERR_INVALID_CHARS_;
 282 #else
 283         0u;
 284 #endif
 285     int len = boost::winapi::WideCharToMultiByte(boost::winapi::CP_UTF8_, flags, wstr, static_cast< int >(utf16_len), NULL, 0, NULL, NULL);
 286     if (BOOST_LIKELY(len > 0))
 287     {
 288         std::string str;
 289         str.resize(len);
 290
 291         len = boost::winapi::WideCharToMultiByte(boost::winapi::CP_UTF8_, flags, wstr, static_cast< int >(utf16_len), &str[0], len, NULL, NULL);
 292         if (BOOST_LIKELY(len > 0))
 293         {
 294             return str;
 295         }
 296     }
 297
 298     const boost::winapi::DWORD_ err = boost::winapi::GetLastError();
 299     BOOST_LOG_THROW_DESCR_PARAMS(system_error, "Failed to convert UTF-16 to UTF-8", (err));
 300     BOOST_LOG_UNREACHABLE_RETURN(std::string());
 301 }
 302
 303 #endif // defined(BOOST_WINDOWS)
 304
 305 } // namespace aux
 306
 307 BOOST_LOG_CLOSE_NAMESPACE // namespace log
 308
 309 } // namespace boost
 310
 311 #include <boost/log/detail/footer.hpp>