Home | History | Annotate | Download | only in bionic 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  * All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  *  * Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  *  * Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in
     12  *    the documentation and/or other materials provided with the
     13  *    distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
     19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
     20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
     22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
     25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 #include <errno.h>
     30 #include <locale.h>
     31 #include <pthread.h>
     32 #include <stdlib.h>
     33 #include <string.h>
     34 #include <strings.h>
     35 #include <time.h>
     36 #include <wchar.h>
     37 
     38 #include "private/bionic_macros.h"
     39 
     40 #if defined(__BIONIC_BUILD_FOR_ANDROID_SUPPORT)
     41 #define USE_TLS_SLOT 0
     42 #else
     43 #define USE_TLS_SLOT 1
     44 #endif
     45 
     46 #if USE_TLS_SLOT
     47 #include "bionic/pthread_internal.h"
     48 #endif
     49 
     50 // We only support two locales, the "C" locale (also known as "POSIX"),
     51 // and the "C.UTF-8" locale (also known as "en_US.UTF-8").
     52 
     53 static bool __bionic_current_locale_is_utf8 = true;
     54 
     55 struct __locale_t {
     56   size_t mb_cur_max;
     57 
     58   explicit __locale_t(size_t mb_cur_max) : mb_cur_max(mb_cur_max) {
     59   }
     60 
     61   explicit __locale_t(const __locale_t* other) {
     62     if (other == LC_GLOBAL_LOCALE) {
     63       mb_cur_max = __bionic_current_locale_is_utf8 ? 4 : 1;
     64     } else {
     65       mb_cur_max = other->mb_cur_max;
     66     }
     67   }
     68 
     69   BIONIC_DISALLOW_IMPLICIT_CONSTRUCTORS(__locale_t);
     70 };
     71 
     72 size_t __ctype_get_mb_cur_max() {
     73   locale_t l = uselocale(nullptr);
     74   if (l == LC_GLOBAL_LOCALE) {
     75     return __bionic_current_locale_is_utf8 ? 4 : 1;
     76   } else {
     77     return l->mb_cur_max;
     78   }
     79 }
     80 
     81 #if !USE_TLS_SLOT
     82 static thread_local locale_t g_current_locale;
     83 #endif
     84 
     85 static pthread_once_t g_locale_once = PTHREAD_ONCE_INIT;
     86 static lconv g_locale;
     87 
     88 static void __locale_init() {
     89   g_locale.decimal_point = const_cast<char*>(".");
     90 
     91   char* not_available = const_cast<char*>("");
     92   g_locale.thousands_sep = not_available;
     93   g_locale.grouping = not_available;
     94   g_locale.int_curr_symbol = not_available;
     95   g_locale.currency_symbol = not_available;
     96   g_locale.mon_decimal_point = not_available;
     97   g_locale.mon_thousands_sep = not_available;
     98   g_locale.mon_grouping = not_available;
     99   g_locale.positive_sign = not_available;
    100   g_locale.negative_sign = not_available;
    101 
    102   g_locale.int_frac_digits = CHAR_MAX;
    103   g_locale.frac_digits = CHAR_MAX;
    104   g_locale.p_cs_precedes = CHAR_MAX;
    105   g_locale.p_sep_by_space = CHAR_MAX;
    106   g_locale.n_cs_precedes = CHAR_MAX;
    107   g_locale.n_sep_by_space = CHAR_MAX;
    108   g_locale.p_sign_posn = CHAR_MAX;
    109   g_locale.n_sign_posn = CHAR_MAX;
    110   g_locale.int_p_cs_precedes = CHAR_MAX;
    111   g_locale.int_p_sep_by_space = CHAR_MAX;
    112   g_locale.int_n_cs_precedes = CHAR_MAX;
    113   g_locale.int_n_sep_by_space = CHAR_MAX;
    114   g_locale.int_p_sign_posn = CHAR_MAX;
    115   g_locale.int_n_sign_posn = CHAR_MAX;
    116 }
    117 
    118 static bool __is_supported_locale(const char* locale_name) {
    119   return (strcmp(locale_name, "") == 0 ||
    120           strcmp(locale_name, "C") == 0 ||
    121           strcmp(locale_name, "C.UTF-8") == 0 ||
    122           strcmp(locale_name, "en_US.UTF-8") == 0 ||
    123           strcmp(locale_name, "POSIX") == 0);
    124 }
    125 
    126 static bool __is_utf8_locale(const char* locale_name) {
    127   return (*locale_name == '\0' || strstr(locale_name, "UTF-8"));
    128 }
    129 
    130 lconv* localeconv() {
    131   pthread_once(&g_locale_once, __locale_init);
    132   return &g_locale;
    133 }
    134 
    135 locale_t duplocale(locale_t l) {
    136   return new __locale_t(l);
    137 }
    138 
    139 void freelocale(locale_t l) {
    140   delete l;
    141 }
    142 
    143 locale_t newlocale(int category_mask, const char* locale_name, locale_t /*base*/) {
    144   // Are 'category_mask' and 'locale_name' valid?
    145   if ((category_mask & ~LC_ALL_MASK) != 0 || locale_name == nullptr) {
    146     errno = EINVAL;
    147     return nullptr;
    148   }
    149 
    150   if (!__is_supported_locale(locale_name)) {
    151     errno = ENOENT;
    152     return nullptr;
    153   }
    154 
    155   return new __locale_t(__is_utf8_locale(locale_name) ? 4 : 1);
    156 }
    157 
    158 char* setlocale(int category, const char* locale_name) {
    159   // Is 'category' valid?
    160   if (category < LC_CTYPE || category > LC_IDENTIFICATION) {
    161     errno = EINVAL;
    162     return nullptr;
    163   }
    164 
    165   // Caller wants to set the locale rather than just query?
    166   if (locale_name != nullptr) {
    167     if (!__is_supported_locale(locale_name)) {
    168       // We don't support this locale.
    169       errno = ENOENT;
    170       return nullptr;
    171     }
    172     __bionic_current_locale_is_utf8 = __is_utf8_locale(locale_name);
    173   }
    174 
    175   return const_cast<char*>(__bionic_current_locale_is_utf8 ? "C.UTF-8" : "C");
    176 }
    177 
    178 static locale_t* get_current_locale_ptr() {
    179 #if USE_TLS_SLOT
    180   return &__get_bionic_tls().locale;
    181 #else
    182   return &g_current_locale;
    183 #endif
    184 }
    185 
    186 locale_t uselocale(locale_t new_locale) {
    187   locale_t old_locale = *get_current_locale_ptr();
    188 
    189   // If this is the first call to uselocale(3) on this thread, we return LC_GLOBAL_LOCALE.
    190   if (old_locale == nullptr) {
    191     old_locale = LC_GLOBAL_LOCALE;
    192   }
    193 
    194   if (new_locale != nullptr) {
    195     *get_current_locale_ptr() = new_locale;
    196   }
    197 
    198   return old_locale;
    199 }
    200