time/alt_digit.c

   1 /* Helper functions used by strftime/strptime to handle alternate digits.
   2    Copyright (C) 1995-2020 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, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include "../locale/localeinfo.h"
  20 #include <libc-lock.h>
  21 #include <stdlib.h>
  22 #include <wchar.h>
  23 #include <string.h>
  24 #include <stdint.h>
  25
  26 /* Some of the functions here must not be used while setlocale is called.  */
  27 __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden)
  28
  29 #define CURRENT(item) (current->values[_NL_ITEM_INDEX (item)].string)
  30 #define CURRENT_WSTR(item) \
  31   ((wchar_t *) current->values[_NL_ITEM_INDEX (item)].wstr)
  32
  33 static void
  34 _nl_init_alt_digit (struct __locale_data *current)
  35 {
  36   struct lc_time_data *data;
  37
  38   if (current->private.time == NULL)
  39     {
  40       current->private.time = malloc (sizeof *current->private.time);
  41       if (current->private.time == NULL)
  42         return;
  43       memset (current->private.time, 0, sizeof *current->private.time);
  44       current->private.cleanup = &_nl_cleanup_time;
  45     }
  46   data = current->private.time;
  47
  48   if (! data->alt_digits_initialized)
  49     {
  50       const char *ptr = CURRENT (ALT_DIGITS);
  51       size_t cnt;
  52
  53       data->alt_digits_initialized = 1;
  54
  55       if (ptr != NULL)
  56         {
  57           data->alt_digits = malloc (100 * sizeof (const char *));
  58           if (data->alt_digits != NULL)
  59             for (cnt = 0; cnt < 100; ++cnt)
  60               {
  61                 data->alt_digits[cnt] = ptr;
  62
  63                 /* Skip digit format. */
  64                 ptr = strchr (ptr, '\0') + 1;
  65               }
  66         }
  67     }
  68
  69 }
  70
  71 const char *
  72 _nl_get_alt_digit (unsigned int number, struct __locale_data *current)
  73 {
  74   const char *result;
  75
  76   if (number >= 100 || CURRENT (ALT_DIGITS)[0] == '\0')
  77     return NULL;
  78
  79   __libc_rwlock_wrlock (__libc_setlocale_lock);
  80
  81   if (current->private.time == NULL
  82       || ! current->private.time->alt_digits_initialized)
  83     _nl_init_alt_digit (current);
  84
  85   result = ((current->private.time != NULL
  86              && current->private.time->alt_digits != NULL)
  87             ? current->private.time->alt_digits[number]
  88             : NULL);
  89
  90   __libc_rwlock_unlock (__libc_setlocale_lock);
  91
  92   return result;
  93 }
  94
  95
  96 const wchar_t *
  97 _nl_get_walt_digit (unsigned int number, struct __locale_data *current)
  98 {
  99   const wchar_t *result = NULL;
 100   struct lc_time_data *data;
 101
 102   if (number >= 100 || CURRENT_WSTR (_NL_WALT_DIGITS)[0] == L'\0')
 103     return NULL;
 104
 105   __libc_rwlock_wrlock (__libc_setlocale_lock);
 106
 107   if (current->private.time == NULL)
 108     {
 109       current->private.time = malloc (sizeof *current->private.time);
 110       if (current->private.time == NULL)
 111         goto out;
 112       memset (current->private.time, 0, sizeof *current->private.time);
 113       current->private.cleanup = &_nl_cleanup_time;
 114     }
 115   data = current->private.time;
 116
 117   if (! data->walt_digits_initialized)
 118     {
 119       const wchar_t *ptr = CURRENT_WSTR (_NL_WALT_DIGITS);
 120       size_t cnt;
 121
 122       data->walt_digits_initialized = 1;
 123
 124       if (ptr != NULL)
 125         {
 126           data->walt_digits = malloc (100 * sizeof (const uint32_t *));
 127           if (data->walt_digits != NULL)
 128             for (cnt = 0; cnt < 100; ++cnt)
 129               {
 130                 data->walt_digits[cnt] = ptr;
 131
 132                 /* Skip digit format. */
 133                 ptr = __wcschr (ptr, L'\0') + 1;
 134               }
 135         }
 136     }
 137
 138   if (data->walt_digits != NULL)
 139     result = data->walt_digits[number];
 140
 141  out:
 142   __libc_rwlock_unlock (__libc_setlocale_lock);
 143
 144   return (wchar_t *) result;
 145 }
 146
 147
 148 int
 149 _nl_parse_alt_digit (const char **strp, struct __locale_data *current)
 150 {
 151   const char *str = *strp;
 152   int result = -1;
 153   size_t cnt;
 154   size_t maxlen = 0;
 155
 156   if (CURRENT_WSTR (_NL_WALT_DIGITS)[0] == L'\0')
 157     return result;
 158
 159   __libc_rwlock_wrlock (__libc_setlocale_lock);
 160
 161   if (current->private.time == NULL
 162       || ! current->private.time->alt_digits_initialized)
 163     _nl_init_alt_digit (current);
 164
 165   if (current->private.time != NULL
 166       && current->private.time->alt_digits != NULL)
 167     /* Matching is not unambiguous.  The alternative digits could be like
 168        I, II, III, ... and the first one is a substring of the second
 169        and third.  Therefore we must keep on searching until we found
 170        the longest possible match.  Note that this is not specified in
 171        the standard.  */
 172     for (cnt = 0; cnt < 100; ++cnt)
 173       {
 174         const char *const dig = current->private.time->alt_digits[cnt];
 175         size_t len = strlen (dig);
 176
 177         if (len > maxlen && strncmp (dig, str, len) == 0)
 178           {
 179             maxlen = len;
 180             result = (int) cnt;
 181           }
 182       }
 183
 184   __libc_rwlock_unlock (__libc_setlocale_lock);
 185
 186   if (result != -1)
 187     *strp += maxlen;
 188
 189   return result;
 190 }