lib/strfmon_l.c

   1 /* strfmon_l override.
   2    Copyright (C) 2017-2024 Free Software Foundation, Inc.
   3
   4    This file is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    License, or (at your option) any later version.
   8
   9    This file is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 #include <config.h>
  18
  19 /* Specification.  */
  20 #include <monetary.h>
  21
  22 #include <errno.h>
  23 #include <locale.h>
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #undef strfmon_l
  29
  30 /* This override can only support a limited number of arguments.  */
  31 #define MAX_ARGS 16
  32
  33 /* A parsed directive.  */
  34 typedef struct
  35 {
  36   bool needs_long_double;
  37   const char *conversion_ptr;
  38 }
  39 directive_t;
  40
  41 /* A parsed format string.  */
  42 typedef struct
  43 {
  44   size_t count;
  45   directive_t dir[MAX_ARGS];
  46 }
  47 directives_t;
  48
  49 /* Parses a monetary format string.
  50    Returns 0 and fills *DIRECTIVESP if valid.
  51    Returns -1 if invalid.  */
  52 static int
  53 fmon_parse (const char *format, directives_t *directivesp)
  54 {
  55   size_t count = 0;
  56   const char *cp = format;
  57
  58   while (*cp != '\0')
  59     {
  60       if (*cp++ == '%')
  61         {
  62           /* Parse flags.  */
  63           while (*cp == '=' || *cp == '^' || *cp == '+' || *cp == '('
  64                  || *cp == '!' || *cp == '-')
  65             {
  66               if (*cp == '=')
  67                 {
  68                   cp++;
  69                   if (*cp == '\0')
  70                     return -1;
  71                 }
  72               cp++;
  73             }
  74           /* Parse field width.  */
  75           while (*cp >= '0' && *cp <= '9')
  76             cp++;
  77           /* Parse left precision.  */
  78           if (*cp == '#')
  79             {
  80               cp++;
  81               while (*cp >= '0' && *cp <= '9')
  82                 cp++;
  83             }
  84           /* Parse right precision.  */
  85           if (*cp == '.')
  86             {
  87               cp++;
  88               while (*cp >= '0' && *cp <= '9')
  89                 cp++;
  90             }
  91           /* Now comes the conversion specifier.  */
  92           if (*cp != '%')
  93             {
  94               if (count == MAX_ARGS)
  95                 /* Too many arguments.  */
  96                 return -1;
  97
  98               /* glibc supports an 'L' modifier before the conversion specifier.  */
  99               if (*cp == 'L')
 100                 {
 101                   cp++;
 102                   directivesp->dir[count].needs_long_double = true;
 103                 }
 104               else
 105                 directivesp->dir[count].needs_long_double = false;
 106               if (!(*cp == 'i' || *cp == 'n'))
 107                 return -1;
 108               directivesp->dir[count].conversion_ptr = cp;
 109               count++;
 110             }
 111           cp++;
 112         }
 113     }
 114
 115   directivesp->count = count;
 116   return 0;
 117 }
 118
 119 ssize_t
 120 rpl_strfmon_l (char *s, size_t maxsize, locale_t locale, const char *format, ...)
 121 {
 122   /* Work around glibc 2.23 bug
 123      <https://sourceware.org/bugzilla/show_bug.cgi?id=19633>.  */
 124   va_list argptr;
 125   locale_t orig_locale;
 126   directives_t directives;
 127   ssize_t result;
 128
 129   orig_locale = uselocale ((locale_t)0);
 130
 131   if (uselocale (locale) == (locale_t)0)
 132     /* errno is set.  */
 133     return -1;
 134
 135   /* The format string may consume 'double' or 'long double' arguments.
 136      In order not to have to link with libffcall or libffi, convert all
 137      arguments to 'long double', and use a modified format string that
 138      requests 'long double' arguments.  But since 'long double' arguments
 139      are only supported on glibc, do so only if the original format string
 140      consumes at least one 'long double' argument.  */
 141   if (fmon_parse (format, &directives) < 0)
 142     {
 143       errno = EINVAL;
 144       result = -1;
 145     }
 146   else
 147     {
 148       bool use_long_double;
 149       unsigned int i;
 150
 151       use_long_double = false;
 152       for (i = 0; i < directives.count; i++)
 153         if (directives.dir[i].needs_long_double)
 154           {
 155             use_long_double = true;
 156             break;
 157           }
 158
 159       va_start (argptr, format);
 160
 161       if (use_long_double)
 162         {
 163           char *ld_format;
 164
 165           /* Allocate room for the modified format string.  */
 166           ld_format = (char *) malloc (strlen (format) + directives.count + 1);
 167           if (ld_format == NULL)
 168             {
 169               errno = ENOMEM;
 170               result = -1;
 171             }
 172           else
 173             {
 174               long double args[MAX_ARGS];
 175
 176               /* Create the modified format string.  */
 177               {
 178                 const char *p = format;
 179                 char *dest = ld_format;
 180                 for (i = 0; i < directives.count; i++)
 181                   {
 182                     const char *q = directives.dir[i].conversion_ptr;
 183                     memcpy (dest, p, q - p);
 184                     dest += q - p;
 185                     if (!directives.dir[i].needs_long_double)
 186                       *dest++ = 'L';
 187                     p = q;
 188                   }
 189                 strcpy (dest, p);
 190               }
 191
 192               /* Set up arguments array.  */
 193               for (i = 0; i < directives.count; i++)
 194                 args[i] = (directives.dir[i].needs_long_double
 195                            ? va_arg (argptr, long double)
 196                            : (long double) va_arg (argptr, double));
 197               /* Avoid uninitialized memory references.  */
 198               for (; i < MAX_ARGS; i++)
 199                 args[i] = 0.0L;
 200
 201               result = strfmon_l (s, maxsize, locale, ld_format,
 202                                   args[0], args[1], args[2], args[3], args[4],
 203                                   args[5], args[6], args[7], args[8], args[9],
 204                                   args[10], args[11], args[12], args[13],
 205                                   args[14], args[15]);
 206
 207               free (ld_format);
 208             }
 209         }
 210       else
 211         {
 212           double args[MAX_ARGS];
 213
 214           /* Set up arguments array.  */
 215           for (i = 0; i < directives.count; i++)
 216             args[i] = va_arg (argptr, double);
 217           /* Avoid uninitialized memory references.  */
 218           for (; i < MAX_ARGS; i++)
 219             args[i] = 0.0;
 220
 221           result = strfmon_l (s, maxsize, locale, format,
 222                               args[0], args[1], args[2], args[3], args[4],
 223                               args[5], args[6], args[7], args[8], args[9],
 224                               args[10], args[11], args[12], args[13], args[14],
 225                               args[15]);
 226         }
 227
 228       va_end (argptr);
 229     }
 230
 231   if (uselocale (orig_locale) == (locale_t)0)
 232     /* errno is set.  */
 233     return -1;
 234
 235   return result;
 236 }