locale/lc-time.c

   1 /* Define current locale data for LC_TIME category.
   2    Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <bits/libc-lock.h>
  21 #include <endian.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <wchar.h>
  26 #include "localeinfo.h"
  27
  28 _NL_CURRENT_DEFINE (LC_TIME);
  29
  30 /* Some of the functions here must not be used while setlocale is called.  */
  31 __libc_lock_define (extern, __libc_setlocale_lock)
  32
  33
  34 static int era_initialized;
  35
  36 static struct era_entry *eras;
  37 static size_t num_eras;
  38 static int alt_digits_initialized;
  39 static const char **alt_digits;
  40
  41
  42 static int walt_digits_initialized;
  43 static const wchar_t **walt_digits;
  44
  45
  46 void
  47 _nl_postload_time (void)
  48 {
  49   /* Prepare lazy initialization of `era' and `alt_digits' array.  */
  50   era_initialized = 0;
  51   alt_digits_initialized = 0;
  52   walt_digits_initialized = 0;
  53 }
  54
  55 #define ERA_DATE_CMP(a, b) \
  56   (a[0] < b[0] || (a[0] == b[0] && (a[1] < b[1]                               \
  57                                     || (a[1] == b[1] && a[2] <= b[2]))))
  58
  59 static void
  60 _nl_init_era_entries (void)
  61 {
  62   size_t cnt;
  63
  64   __libc_lock_lock (__libc_setlocale_lock);
  65
  66   if (era_initialized == 0)
  67     {
  68       size_t new_num_eras = _NL_CURRENT_WORD (LC_TIME,
  69                                               _NL_TIME_ERA_NUM_ENTRIES);
  70       if (new_num_eras == 0)
  71         {
  72           free (eras);
  73           eras = NULL;
  74         }
  75       else
  76         {
  77           if (num_eras != new_num_eras)
  78             eras = (struct era_entry *) realloc (eras,
  79                                                  new_num_eras
  80                                                  * sizeof (struct era_entry));
  81           if (eras == NULL)
  82             {
  83               num_eras = 0;
  84               eras = NULL;
  85             }
  86           else
  87             {
  88               const char *ptr = _NL_CURRENT (LC_TIME, _NL_TIME_ERA_ENTRIES);
  89               num_eras = new_num_eras;
  90
  91               for (cnt = 0; cnt < num_eras; ++cnt)
  92                 {
  93                   const char *base_ptr = ptr;
  94                   memcpy ((void *) (eras + cnt), (const void *) ptr,
  95                           sizeof (uint32_t) * 8);
  96
  97                   if (ERA_DATE_CMP(eras[cnt].start_date,
  98                                    eras[cnt].stop_date))
  99                     if (eras[cnt].direction == (uint32_t) '+')
 100                       eras[cnt].absolute_direction = 1;
 101                     else
 102                       eras[cnt].absolute_direction = -1;
 103                   else
 104                     if (eras[cnt].direction == (uint32_t) '+')
 105                       eras[cnt].absolute_direction = -1;
 106                     else
 107                       eras[cnt].absolute_direction = 1;
 108
 109                   /* Skip numeric values.  */
 110                   ptr += sizeof (uint32_t) * 8;
 111
 112                   /* Set and skip era name.  */
 113                   eras[cnt].era_name = ptr;
 114                   ptr = strchr (ptr, '\0') + 1;
 115
 116                   /* Set and skip era format.  */
 117                   eras[cnt].era_format = ptr;
 118                   ptr = strchr (ptr, '\0') + 1;
 119
 120                   ptr += 3 - (((ptr - (const char *) base_ptr) + 3) & 3);
 121
 122                   /* Set and skip wide era name.  */
 123                   eras[cnt].era_wname = (wchar_t *) ptr;
 124                   ptr = (char *) (wcschr ((wchar_t *) ptr, L'\0') + 1);
 125
 126                   /* Set and skip wide era format.  */
 127                   eras[cnt].era_wformat = (wchar_t *) ptr;
 128                   ptr = (char *) (wcschr ((wchar_t *) ptr, L'\0') + 1);
 129                 }
 130             }
 131         }
 132
 133       era_initialized = 1;
 134     }
 135
 136   __libc_lock_unlock (__libc_setlocale_lock);
 137 }
 138
 139
 140 struct era_entry *
 141 _nl_get_era_entry (const struct tm *tp)
 142 {
 143   struct era_entry *result;
 144   int32_t tdate[3];
 145   size_t cnt;
 146
 147   tdate[0] = tp->tm_year;
 148   tdate[1] = tp->tm_mon;
 149   tdate[2] = tp->tm_mday;
 150
 151   if (era_initialized == 0)
 152     _nl_init_era_entries ();
 153
 154   /* Now compare date with the available eras.  */
 155   for (cnt = 0; cnt < num_eras; ++cnt)
 156     if ((ERA_DATE_CMP(eras[cnt].start_date, tdate)
 157          && ERA_DATE_CMP(tdate, eras[cnt].stop_date))
 158         || (ERA_DATE_CMP(eras[cnt].stop_date, tdate)
 159             && ERA_DATE_CMP(tdate, eras[cnt].start_date)))
 160       break;
 161
 162   result = cnt < num_eras ? &eras[cnt] : NULL;
 163
 164   return result;
 165 }
 166
 167
 168 struct era_entry *
 169 _nl_select_era_entry (int cnt)
 170 {
 171   if (era_initialized == 0)
 172     _nl_init_era_entries ();
 173
 174   return &eras[cnt];
 175 }
 176
 177
 178 const char *
 179 _nl_get_alt_digit (unsigned int number)
 180 {
 181   const char *result;
 182
 183   __libc_lock_lock (__libc_setlocale_lock);
 184
 185   if (alt_digits_initialized == 0)
 186     {
 187       alt_digits_initialized = 1;
 188
 189       if (alt_digits == NULL)
 190         alt_digits = malloc (100 * sizeof (const char *));
 191
 192       if (alt_digits != NULL)
 193         {
 194           const char *ptr = _NL_CURRENT (LC_TIME, ALT_DIGITS);
 195           size_t cnt;
 196
 197           if (alt_digits != NULL)
 198             for (cnt = 0; cnt < 100; ++cnt)
 199               {
 200                 alt_digits[cnt] = ptr;
 201
 202                 /* Skip digit format. */
 203                 ptr = strchr (ptr, '\0') + 1;
 204               }
 205         }
 206     }
 207
 208   result = alt_digits != NULL && number < 100 ? alt_digits[number] : NULL;
 209
 210   __libc_lock_unlock (__libc_setlocale_lock);
 211
 212   return result;
 213 }
 214
 215
 216 const wchar_t *
 217 _nl_get_walt_digit (unsigned int number)
 218 {
 219   const wchar_t *result;
 220
 221   __libc_lock_lock (__libc_setlocale_lock);
 222
 223   if (walt_digits_initialized == 0)
 224     {
 225       walt_digits_initialized = 1;
 226
 227       if (walt_digits == NULL)
 228         walt_digits = malloc (100 * sizeof (const uint32_t *));
 229
 230       if (walt_digits != NULL)
 231         {
 232           const wchar_t *ptr = _NL_CURRENT_WSTR (LC_TIME, _NL_WALT_DIGITS);
 233           size_t cnt;
 234
 235           for (cnt = 0; cnt < 100; ++cnt)
 236             {
 237               walt_digits[cnt] = ptr;
 238
 239               /* Skip digit format. */
 240               ptr = wcschr (ptr, L'\0') + 1;
 241             }
 242         }
 243     }
 244
 245   result = walt_digits != NULL && number < 100 ? walt_digits[number] : NULL;
 246
 247   __libc_lock_unlock (__libc_setlocale_lock);
 248
 249   return (wchar_t *) result;
 250 }
 251
 252
 253 int
 254 _nl_parse_alt_digit (const char **strp)
 255 {
 256   const char *str = *strp;
 257   int result = -1;
 258   size_t cnt;
 259   size_t maxlen = 0;
 260
 261   __libc_lock_lock (__libc_setlocale_lock);
 262
 263   if (alt_digits_initialized == 0)
 264     {
 265       alt_digits_initialized = 1;
 266
 267       if (alt_digits == NULL)
 268         alt_digits = malloc (100 * sizeof (const char *));
 269
 270       if (alt_digits != NULL)
 271         {
 272           const char *ptr = _NL_CURRENT (LC_TIME, ALT_DIGITS);
 273
 274           if (alt_digits != NULL)
 275             for (cnt = 0; cnt < 100; ++cnt)
 276               {
 277                 alt_digits[cnt] = ptr;
 278
 279                 /* Skip digit format. */
 280                 ptr = strchr (ptr, '\0') + 1;
 281               }
 282         }
 283     }
 284
 285   /* Matching is not unambiguos.  The alternative digits could be like
 286      I, II, III, ... and the first one is a substring of the second
 287      and third.  Therefore we must keep on searching until we found
 288      the longest possible match.  Note that this is not specified in
 289      the standard.  */
 290   for (cnt = 0; cnt < 100; ++cnt)
 291     {
 292       size_t len = strlen (alt_digits[cnt]);
 293
 294       if (len > maxlen && strncmp (alt_digits[cnt], str, len) == 0)
 295         {
 296           maxlen = len;
 297           result = (int) cnt;
 298         }
 299     }
 300
 301   __libc_lock_unlock (__libc_setlocale_lock);
 302
 303   if (result != -1)
 304     *strp += maxlen;
 305
 306   return result;
 307 }
 308
 309
 310 static void
 311 free_mem (void)
 312 {
 313   free (alt_digits);
 314   free (walt_digits);
 315 }
 316 text_set_element (__libc_subfreeres, free_mem);