Add Android locale support and default locale fallback

[niravd]

Summary

This is based on the Bionic <ctype.h> declarations. Note that
unfortunately, the _ctype_ table exposed by this header has a bug
so a fixed copy is included here instead.

See src/support/android/locale_android.cpp for details.

Fallback to locale("C") - Android's newlocale() return null for anything
other than "", "C", and "POSIX", fallback to "C" to allow more tests to
run and uncover other issues.

[danalbert]

Android is using the builtin rune table: https://github.com/llvm-mirror/libcxx/blob/master/include/__config#L814. We can't use the builtin ctype table on Android because it uses a mask that is not wide enough to implement some parts of the C++ standard properly.

Fallback to locale("C") - Android's newlocale() return null for anything
other than "", "C", and "POSIX", fallback to "C" to allow more tests to
run and uncover other issues.

That's just a bad idea. If we can't fulfill the locale that was requested then the call needs to fail.

include/__locale

#elif defined(_NEWLIB_VERSION)
     static const mask alpha  = _U | _L;
     static const mask digit  = _N;
     static const mask punct  = _P;
     static const mask xdigit = _X | _N;
     static const mask blank  = _B;
 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
+#elif defined(__ANDROID__)
+    # if !defined(_U)
+    #   if !defined(_CTYPE_U)
+    #    error Bionic header ctype.h does not define either _U nor _CTYPE_U
+    #   endif
+    #   define _U _CTYPE_U
+    #   define _L _CTYPE_L
+    #   define _N _CTYPE_N
+    #   define _S _CTYPE_S
+    #   define _P _CTYPE_P
+    #   define _C _CTYPE_C
+    #   define _X _CTYPE_X
+    #   define _B _CTYPE_B
+    # endif
+typedef unsigned short mask;
+    static const mask space  = _S;
+    static const mask print  = _P | _U | _L | _N | _B;
+    static const mask cntrl  = _C;
+    static const mask upper  = _U;
+    static const mask lower  = _L;
+    static const mask alpha  = _U | _L;
+    static const mask digit  = _N;
+    static const mask punct  = _P;
+    static const mask xdigit = _N | _X;
+    // See src/support/android/locale_android.cpp for details!
+    static const mask blank  = 0x100;
 #else
     typedef unsigned long mask;
     static const mask space  = 1<<0;
     static const mask print  = 1<<1;
     static const mask cntrl  = 1<<2;
     static const mask upper  = 1<<3;
     static const mask lower  = 1<<4;
     static const mask alpha  = 1<<5;

src/locale.cpp

locale_t __cloc() {
   // In theory this could create a race condition. In practice
   // the race condition is non-fatal since it will just create
   // a little resource leak. Better approach would be appreciated.
   static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
   return result;
 }
 #endif // __cloc_defined
 
+inline locale_t __new_cloc() {
+  return newlocale(LC_ALL_MASK, "C", 0);
+}
+
 namespace {
 
 struct release
 {
     void operator()(locale::facet* p) {p->__release_shared();}
 };
 
 template <class T, class A0>

 // template <> class collate_byname<char>
 
 collate_byname<char>::collate_byname(const char* n, size_t refs)
     : collate<char>(refs),
       __l(newlocale(LC_ALL_MASK, n, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("collate_byname<char>::collate_byname"
                             " failed to construct for " + string(n));
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 collate_byname<char>::collate_byname(const string& name, size_t refs)
     : collate<char>(refs),
       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("collate_byname<char>::collate_byname"
                             " failed to construct for " + name);
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 collate_byname<char>::~collate_byname()
 {
     freelocale(__l);
 }
 

 // template <> class collate_byname<wchar_t>
 
 collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
     : collate<wchar_t>(refs),
       __l(newlocale(LC_ALL_MASK, n, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
                             " failed to construct for " + string(n));
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
     : collate<wchar_t>(refs),
       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
                             " failed to construct for " + name);
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 collate_byname<wchar_t>::~collate_byname()
 {
     freelocale(__l);
 }
 

 wchar_t
 ctype<wchar_t>::do_toupper(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
       defined(__NetBSD__)
     return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
+#elif defined(__ANDROID__)
+    return isascii(c) ? _toupper_tab_[c + 1] : c;
 #else
     return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c;
 #endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
       defined(__NetBSD__)
         *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low]
                              : *low;
+#elif defined(__ANDROID__)
+        *low = isascii(*low) ? _toupper_tab_[*low + 1] : *low;
 #else
         *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low-L'a'+L'A') : *low;
 #endif
     return low;
 }
 
 wchar_t
 ctype<wchar_t>::do_tolower(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
       defined(__NetBSD__)
     return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
+#elif defined(__ANDROID__)
+    return isascii(c) ? _tolower_tab_[c + 1] : c;
 #else
     return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c;
 #endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
       defined(__NetBSD__)
         *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low]
                              : *low;
+#elif defined(__ANDROID__)
+        *low = isascii(*low) ? _tolower_tab_[*low + 1] : *low;
 #else
         *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-L'A'+L'a' : *low;
 #endif
     return low;
 }
 
 wchar_t
 ctype<wchar_t>::do_widen(char c) const

 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ?
       static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
 #elif defined(__NetBSD__)
     return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
     return isascii(c) ?
       static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
+#elif defined(__ANDROID__)
+    return isascii(c) ? _toupper_tab_[c + 1] : c;
 #else
     return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c;
 #endif
 }
 
 const char*
 ctype<char>::do_toupper(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ?
           static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
 #elif defined(__NetBSD__)
         *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
         *low = isascii(*low) ?
           static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
+#elif defined(__ANDROID__)
+        *low = isascii(*low) ? _toupper_tab_[*low + 1] : *low;
 #else
         *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'a'+'A' : *low;
 #endif
     return low;
 }
 
 char
 ctype<char>::do_tolower(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ?
       static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
 #elif defined(__NetBSD__)
     return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
     return isascii(c) ?
       static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
+#elif defined(__ANDROID__)
+    return isascii(c) ? _tolower_tab_[c + 1] : c;
 #else
     return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c;
 #endif
 }
 
 const char*
 ctype<char>::do_tolower(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
 #elif defined(__NetBSD__)
         *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
         *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
+#elif defined(__ANDROID__)
+        *low = isascii(*low) ? _tolower_tab_[*low + 1] : *low;
 #else
         *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'A'+'a' : *low;
 #endif
     return low;
 }
 
 char
 ctype<char>::do_widen(char c) const

 }
 
 #if defined(__EMSCRIPTEN__)
 extern "C" const unsigned short ** __ctype_b_loc();
 extern "C" const int ** __ctype_tolower_loc();
 extern "C" const int ** __ctype_toupper_loc();
 #endif
 
-#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
+#if defined(__ANDROID__)
+// See src/support/android/android_locale.cpp
+extern "C" const unsigned short* const _ctype_android;
+#endif
+
+#if defined(_LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE)
 const ctype<char>::mask*
 ctype<char>::classic_table()  _NOEXCEPT
 {
     static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl,
#elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
     return _ctype+1; // internal ctype mask table defined in msvcrt.dll
 // This is assumed to be safe, which is a nonsense assumption because we're
 // going to end up dereferencing it later...
 #elif defined(__EMSCRIPTEN__)
     return *__ctype_b_loc();
 #elif defined(_NEWLIB_VERSION)
     // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
     return _ctype_ + 1;
+#elif defined(__ANDROID__)
+    return _ctype_android;
 #elif defined(_AIX)
     return (const unsigned int *)__lc_ctype_ptr->obj->mask;
 #else
     // Platform not supported: abort so the person doing the port knows what to
     // fix
 # warning  ctype<char>::classic_table() is not implemented
     printf("ctype<char>::classic_table() is not implemented\n");
     abort();

 // template <> class ctype_byname<char>
 
 ctype_byname<char>::ctype_byname(const char* name, size_t refs)
     : ctype<char>(0, false, refs),
       __l(newlocale(LC_ALL_MASK, name, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("ctype_byname<char>::ctype_byname"
                             " failed to construct for " + string(name));
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 ctype_byname<char>::ctype_byname(const string& name, size_t refs)
     : ctype<char>(0, false, refs),
       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("ctype_byname<char>::ctype_byname"
                             " failed to construct for " + name);
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 ctype_byname<char>::~ctype_byname()
 {
     freelocale(__l);
 }
 

 // template <> class ctype_byname<wchar_t>
 
 ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
     : ctype<wchar_t>(refs),
       __l(newlocale(LC_ALL_MASK, name, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("ctype_byname<wchar_t>::ctype_byname"
                             " failed to construct for " + string(name));
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
     : ctype<wchar_t>(refs),
       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("ctype_byname<wchar_t>::ctype_byname"
                             " failed to construct for " + name);
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 ctype_byname<wchar_t>::~ctype_byname()
 {
     freelocale(__l);
 }
 

 }
 
 codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
     : locale::facet(refs),
       __l(newlocale(LC_ALL_MASK, nm, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
                             " failed to construct for " + string(nm));
+#else
+        __l = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 codecvt<wchar_t, char, mbstate_t>::~codecvt()
 {
     if (__l != _LIBCPP_GET_C_LOCALE)
         freelocale(__l);
 }

 {
 }
 
 void
 numpunct_byname<char>::__init(const char* nm)
 {
     if (strcmp(nm, "C") != 0)
     {
-        __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+        locale_t l = newlocale(LC_ALL_MASK, nm, 0);
+#if defined(__ANDROID__)
+        if (l == 0)
+            l = __new_cloc();
+#endif
+        __locale_unique_ptr loc(l, freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         if (loc == nullptr)
             throw runtime_error("numpunct_byname<char>::numpunct_byname"
                                 " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
         lconv* lc = localeconv_l(loc.get());
 #else

 {
 }
 
 void
 numpunct_byname<wchar_t>::__init(const char* nm)
 {
     if (strcmp(nm, "C") != 0)
     {
-        __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+        locale_t l = newlocale(LC_ALL_MASK, nm, 0);
+#if defined(__ANDROID__)
+        if (l == 0)
+            l = __new_cloc();
+#endif
+        __locale_unique_ptr loc(l, freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         if (loc == nullptr)
             throw runtime_error("numpunct_byname<char>::numpunct_byname"
                                 " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
         lconv* lc = localeconv_l(loc.get());
 #else

 
 // time_get_byname
 
 __time_get::__time_get(const char* nm)
     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
+    {
+#if !defined(__ANDROID__)
         throw runtime_error("time_get_byname"
                             " failed to construct for " + string(nm));
+#else
+        __loc_ = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 __time_get::__time_get(const string& nm)
     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
+    {
+# if !defined(__ANDROID__)
         throw runtime_error("time_get_byname"
                             " failed to construct for " + nm);
+#else
+        __loc_ = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 __time_get::~__time_get()
 {
     freelocale(__loc_);
 }
 #if defined(__clang__)

 
 // time_put
 
 __time_put::__time_put(const char* nm)
     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
+    {
+# if !defined(__ANDROID__)
         throw runtime_error("time_put_byname"
                             " failed to construct for " + string(nm));
+#else
+        __loc_ = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 __time_put::__time_put(const string& nm)
     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
+    {
+# if !defined(__ANDROID__)
         throw runtime_error("time_put_byname"
                             " failed to construct for " + nm);
+#else
+        __loc_ = __new_cloc();
+#endif
+    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 __time_put::~__time_put()
 {
     if (__loc_ != _LIBCPP_GET_C_LOCALE)
         freelocale(__loc_);
 }
__init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_,
     pat.field[3] = value;
 }
 
 template<>
 void
 moneypunct_byname<char, false>::init(const char* nm)
 {
     typedef moneypunct<char, false> base;
-    __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_t l = newlocale(LC_ALL_MASK, nm, 0);
+#if defined(__ANDROID__)
+    if (l == 0)
+        l = __new_cloc();
+#endif
+    __locale_unique_ptr loc(l, freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
     lconv* lc = localeconv_l(loc.get());
 #else
__init_pat(__neg_format_, __curr_symbol_, false,
                lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
 }
 
 template<>
 void
 moneypunct_byname<char, true>::init(const char* nm)
 {
     typedef moneypunct<char, true> base;
-    __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_t l = newlocale(LC_ALL_MASK, nm, 0);
+#if defined(__ANDROID__)
+    if (l == 0)
+        l = __new_cloc();
+#endif
+    __locale_unique_ptr loc(l, freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
     lconv* lc = localeconv_l(loc.get());
 #else

 #endif // !_LIBCPP_MSVCRT
 }
 
 template<>
 void
 moneypunct_byname<wchar_t, false>::init(const char* nm)
 {
     typedef moneypunct<wchar_t, false> base;
-    __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_t l = newlocale(LC_ALL_MASK, nm, 0);
+#if defined(__ANDROID__)
+    if (l == 0)
+        l = __new_cloc();
+#endif
+    __locale_unique_ptr loc(l, freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
     lconv* lc = localeconv_l(loc.get());
 #else
__init_pat(__neg_format_, __curr_symbol_, false,
                lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
 }
 
 template<>
 void
 moneypunct_byname<wchar_t, true>::init(const char* nm)
 {
     typedef moneypunct<wchar_t, true> base;
-    __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_t l = newlocale(LC_ALL_MASK, nm, 0);
+#if defined(__ANDROID__)
+    if (l == 0)
+        l = __new_cloc();
+#endif
+    __locale_unique_ptr loc(l, freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
 #ifdef _LIBCPP_LOCALE__L_EXTENSIONS
     lconv* lc = localeconv_l(loc.get());
 #else

src/support/android/locale_android.cpp

+// -*- C++ -*-
+//===-------------------- support/win32/locale_win32.cpp ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <ctype.h>
+
+// Bionic exports the non-standard _ctype_ array in <ctype.h>,
+// unfortunately, cannot be used directly for libc++ because it doesn't
+// have a proper bit-flag for blank characters.
+//
+// Note that the header does define a _B flag (as 0x80), but it
+// is only set on the space (32) character, and used to implement
+// isprint() properly. The implementation of isblank() relies on
+// direct comparisons with 9 and 32 instead.
+//
+// The following is a local copy of the Bionic _ctype_ array that has
+// been modified in the following way:
+//
+//   - It stores 16-bit unsigned values, instead of 8-bit char ones.
+//
+//   - Bit flag _BLANK (0x100) is used to indicate blank characters.
+//     It is only set for indices 9 (TAB) and 32 (SPACE).
+//
+//   - Support signed char properly for indexing.
+
+// Used to tag blank characters, this doesn't appear in <ctype.h> nor
+// the original Bionic _ctype_ array.
+#define _BLANK  0x100
+
+// NOTE: A standalone forward declaration is required to ensure that this
+// variable is properly exported with a C name. In other words, this does
+// _not_ work:
+//
+//  extern "C" {
+//  const char* const _ctype_android = ...;
+//  }
+//
+extern "C" const unsigned short* const _ctype_android;
+
+static const unsigned short ctype_android_tab[256+128] = {
+       /* -128..-1 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 80 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 88 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 90 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 98 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* A0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* A8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* B0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* B8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* C0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* C8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* D0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* D8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* E0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* E8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* F0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* F8 */
+       /* 0..127 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C,
+        _C,     _C|_S|_BLANK, _C|_S,  _C|_S,  _C|_S,  _C|_S,  _C,     _C,
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C,
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C,
+  _S|_B|_BLANK, _P,           _P,     _P,     _P,     _P,     _P,     _P,
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P,
+        _N,     _N,           _N,     _N,     _N,     _N,     _N,     _N,
+        _N,     _N,           _P,     _P,     _P,     _P,     _P,     _P,
+        _P,     _U|_X,        _U|_X,  _U|_X,  _U|_X,  _U|_X,  _U|_X,  _U,
+        _U,     _U,           _U,     _U,     _U,     _U,     _U,     _U,
+        _U,     _U,           _U,     _U,     _U,     _U,     _U,     _U,
+        _U,     _U,           _U,     _P,     _P,     _P,     _P,     _P,
+        _P,     _L|_X,        _L|_X,  _L|_X,  _L|_X,  _L|_X,  _L|_X,  _L,
+        _L,     _L,           _L,     _L,     _L,     _L,     _L,     _L,
+        _L,     _L,           _L,     _L,     _L,     _L,     _L,     _L,
+        /* determine printability based on the IS0 8859 8-bit standard */
+        _L,     _L,           _L,     _P,     _P,     _P,     _P,     _C,
+        /* 128..255, same as -128..127 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 80 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 88 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 90 */
+        _C,     _C,           _C,     _C,     _C,     _C,     _C,     _C, /* 98 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* A0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* A8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* B0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* B8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* C0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* C8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* D0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* D8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* E0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* E8 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* F0 */
+        _P,     _P,           _P,     _P,     _P,     _P,     _P,     _P, /* F8 */
+};
+
+const unsigned short* const _ctype_android = ctype_android_tab + 128;