locale/lc-time.c

   1 /* Define current locale data for LC_TIME category.
   2    Copyright (C) 1995-1999, 2000 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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 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           if (eras != NULL)
  73             {
  74               free (eras);
  75               eras = NULL;
  76             }
  77         }
  78       else
  79         {
  80           if (num_eras != new_num_eras)
  81             eras = (struct era_entry *) realloc (eras,
  82                                                  new_num_eras
  83                                                  * sizeof (struct era_entry));
  84           if (eras == NULL)
  85             {
  86               num_eras = 0;
  87               eras = NULL;
  88             }
  89           else
  90             {
  91               const char *ptr = _NL_CURRENT (LC_TIME, _NL_TIME_ERA_ENTRIES);
  92               num_eras = new_num_eras;
  93
  94               for (cnt = 0; cnt < num_eras; ++cnt)
  95                 {
  96                   const char *base_ptr = ptr;
  97                   memcpy ((void *) (eras + cnt), (const void *) ptr,
  98                           sizeof (uint32_t) * 8);
  99
 100                   if (ERA_DATE_CMP(eras[cnt].start_date,
 101                                    eras[cnt].stop_date))
 102                     if (eras[cnt].direction == (uint32_t) '+')
 103                       eras[cnt].absolute_direction = 1;
 104                     else
 105                       eras[cnt].absolute_direction = -1;
 106                   else
 107                     if (eras[cnt].direction == (uint32_t) '+')
 108                       eras[cnt].absolute_direction = -1;
 109                     else
 110                       eras[cnt].absolute_direction = 1;
 111
 112                   /* Skip numeric values.  */
 113                   ptr += sizeof (uint32_t) * 8;
 114
 115                   /* Set and skip era name.  */
 116                   eras[cnt].era_name = ptr;
 117                   ptr = strchr (ptr, '\0') + 1;
 118
 119                   /* Set and skip era format.  */
 120                   eras[cnt].era_format = ptr;
 121                   ptr = strchr (ptr, '\0') + 1;
 122
 123                   ptr += 3 - (((ptr - (const char *) base_ptr) + 3) & 3);
 124
 125                   /* Set and skip wide era name.  */
 126                   eras[cnt].era_wname = (wchar_t *) ptr;
 127                   ptr = (char *) (wcschr ((wchar_t *) ptr, '\0') + 1);
 128
 129                   /* Set and skip wide era format.  */
 130                   eras[cnt].era_wformat = (wchar_t *) ptr;
 131                   ptr = (char *) (wcschr ((wchar_t *) ptr, '\0') + 1);
 132                 }
 133             }
 134         }
 135
 136       era_initialized = 1;
 137     }
 138
 139   __libc_lock_unlock (__libc_setlocale_lock);
 140 }
 141
 142
 143 struct era_entry *
 144 _nl_get_era_entry (const struct tm *tp)
 145 {
 146   struct era_entry *result;
 147   int32_t tdate[3];
 148   size_t cnt;
 149
 150   tdate[0] = tp->tm_year;
 151   tdate[1] = tp->tm_mon;
 152   tdate[2] = tp->tm_mday;
 153
 154   if (era_initialized == 0)
 155     _nl_init_era_entries ();
 156
 157   /* Now compare date with the available eras.  */
 158   for (cnt = 0; cnt < num_eras; ++cnt)
 159     if ((ERA_DATE_CMP(eras[cnt].start_date, tdate)
 160          && ERA_DATE_CMP(tdate, eras[cnt].stop_date))
 161         || (ERA_DATE_CMP(eras[cnt].stop_date, tdate)
 162             && ERA_DATE_CMP(tdate, eras[cnt].start_date)))
 163       break;
 164
 165   result = cnt < num_eras ? &eras[cnt] : NULL;
 166
 167   return result;
 168 }
 169
 170
 171 struct era_entry *
 172 _nl_select_era_entry (int cnt)
 173 {
 174   if (era_initialized == 0)
 175     _nl_init_era_entries ();
 176
 177   return &eras[cnt];
 178 }
 179
 180
 181 const char *
 182 _nl_get_alt_digit (unsigned int number)
 183 {
 184   const char *result;
 185
 186   __libc_lock_lock (__libc_setlocale_lock);
 187
 188   if (alt_digits_initialized == 0)
 189     {
 190       alt_digits_initialized = 1;
 191
 192       if (alt_digits == NULL)
 193         alt_digits = malloc (100 * sizeof (const char *));
 194
 195       if (alt_digits != NULL)
 196         {
 197           const char *ptr = _NL_CURRENT (LC_TIME, ALT_DIGITS);
 198           size_t cnt;
 199
 200           if (alt_digits != NULL)
 201             for (cnt = 0; cnt < 100; ++cnt)
 202               {
 203                 alt_digits[cnt] = ptr;
 204
 205                 /* Skip digit format. */
 206                 ptr = strchr (ptr, '\0') + 1;
 207               }
 208         }
 209     }
 210
 211   result = alt_digits != NULL && number < 100 ? alt_digits[number] : NULL;
 212
 213   __libc_lock_unlock (__libc_setlocale_lock);
 214
 215   return result;
 216 }
 217
 218
 219 const wchar_t *
 220 _nl_get_walt_digit (unsigned int number)
 221 {
 222   const wchar_t *result;
 223
 224   __libc_lock_lock (__libc_setlocale_lock);
 225
 226   if (walt_digits_initialized == 0)
 227     {
 228       walt_digits_initialized = 1;
 229
 230       if (walt_digits == NULL)
 231         walt_digits = malloc (100 * sizeof (const uint32_t *));
 232
 233       if (walt_digits != NULL)
 234         {
 235           const wchar_t *ptr = _NL_CURRENT_WSTR (LC_TIME, _NL_WALT_DIGITS);
 236           size_t cnt;
 237
 238           for (cnt = 0; cnt < 100; ++cnt)
 239             {
 240               walt_digits[cnt] = ptr;
 241
 242               /* Skip digit format. */
 243               ptr = wcschr (ptr, L'\0') + 1;
 244             }
 245         }
 246     }
 247
 248   result = walt_digits != NULL && number < 100 ? walt_digits[number] : NULL;
 249
 250   __libc_lock_unlock (__libc_setlocale_lock);
 251
 252   return (wchar_t *) result;
 253 }