stdlib/strfmon_l.c

   1 /* Formatting a monetary value according to the given locale.
   2    Copyright (C) 1996-2023 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 <ctype.h>
  20 #include <errno.h>
  21 #include <langinfo.h>
  22 #include <locale.h>
  23 #include <monetary.h>
  24 #include "../libio/libioP.h"
  25 #include "../libio/strfile.h"
  26 #include <printf.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include "../locale/localeinfo.h"
  31 #include <bits/floatn.h>
  32 #include <stdio-common/grouping_iterator.h>
  33 #include <printf_buffer.h>
  34
  35 #define to_digit(Ch) ((Ch) - '0')
  36
  37
  38 /* We use this code also for the extended locale handling where the
  39    function gets as an additional argument the locale which has to be
  40    used.  To access the values we have to redefine the _NL_CURRENT
  41    macro.  */
  42 #undef _NL_CURRENT
  43 #define _NL_CURRENT(category, item) \
  44   (current->values[_NL_ITEM_INDEX (item)].string)
  45
  46
  47 /* We have to overcome some problems with this implementation.  On the
  48    one hand the strfmon() function is specified in XPG4 and of course
  49    it has to follow this.  But on the other hand POSIX.2 specifies
  50    some information in the LC_MONETARY category which should be used,
  51    too.  Some of the information contradicts the information which can
  52    be specified in format string.  */
  53 static void
  54 __vstrfmon_l_buffer (struct __printf_buffer *buf, locale_t loc,
  55                      const char *fmt, va_list ap, unsigned int flags)
  56 {
  57   struct __locale_data *current = loc->__locales[LC_MONETARY];
  58   struct printf_info info;
  59
  60   /* Loop through the format-string.  */
  61   while (*fmt != '\0' && !__printf_buffer_has_failed (buf))
  62     {
  63       /* The floating-point value to output.  */
  64       union
  65       {
  66         double dbl;
  67         long double ldbl;
  68 #if __HAVE_DISTINCT_FLOAT128
  69         _Float128 f128;
  70 #endif
  71       }
  72       fpnum;
  73       int int_format;
  74       int print_curr_symbol;
  75       int left_prec;
  76       int left_pad;
  77       int right_prec;
  78       int group;
  79       char pad;
  80       int is_long_double;
  81       int is_binary128;
  82       int p_sign_posn;
  83       int n_sign_posn;
  84       int sign_posn;
  85       int other_sign_posn;
  86       int left;
  87       int is_negative;
  88       int sep_by_space;
  89       int other_sep_by_space;
  90       int cs_precedes;
  91       int other_cs_precedes;
  92       const char *sign_string;
  93       const char *other_sign_string;
  94       const char *currency_symbol;
  95       size_t currency_symbol_len;
  96       long int width;
  97       const void *ptr;
  98       char space_char;
  99
 100       /* Process all character which do not introduce a format
 101          specification.  */
 102       if (*fmt != '%')
 103         {
 104           __printf_buffer_putc (buf, *fmt++);
 105           continue;
 106         }
 107
 108       /* "%%" means a single '%' character.  */
 109       if (fmt[1] == '%')
 110         {
 111           __printf_buffer_putc (buf, *++fmt);
 112           ++fmt;
 113           continue;
 114         }
 115
 116       /* Defaults for formatting.  */
 117       int_format = 0;                   /* Use international curr. symbol */
 118       print_curr_symbol = 1;            /* Print the currency symbol.  */
 119       left_prec = -1;                   /* No left precision specified.  */
 120       right_prec = -1;                  /* No right precision specified.  */
 121       group = 1;                        /* Print digits grouped.  */
 122       pad = ' ';                        /* Fill character is <SP>.  */
 123       is_long_double = 0;               /* Double argument by default.  */
 124       is_binary128 = 0;                 /* Long double argument by default.  */
 125       p_sign_posn = -2;                 /* This indicates whether the */
 126       n_sign_posn = -2;                 /* '(' flag is given.  */
 127       width = -1;                       /* No width specified so far.  */
 128       left = 0;                         /* Right justified by default.  */
 129
 130       /* Parse group characters.  */
 131       while (1)
 132         {
 133           switch (*++fmt)
 134             {
 135             case '=':                   /* Set fill character.  */
 136               pad = *++fmt;
 137               if (pad == '\0')
 138                 {
 139                   /* Premature EOS.  */
 140                   __set_errno (EINVAL);
 141                   __printf_buffer_mark_failed (buf);
 142                   return;
 143                 }
 144               continue;
 145             case '^':                   /* Don't group digits.  */
 146               group = 0;
 147               continue;
 148             case '+':                   /* Use +/- for sign of number.  */
 149               if (n_sign_posn != -2)
 150                 {
 151                   __set_errno (EINVAL);
 152                   __printf_buffer_mark_failed (buf);
 153                   return;
 154                 }
 155               p_sign_posn = *_NL_CURRENT (LC_MONETARY, P_SIGN_POSN);
 156               n_sign_posn = *_NL_CURRENT (LC_MONETARY, N_SIGN_POSN);
 157               continue;
 158             case '(':                   /* Use ( ) for negative sign.  */
 159               if (n_sign_posn != -2)
 160                 {
 161                   __set_errno (EINVAL);
 162                   __printf_buffer_mark_failed (buf);
 163                   return;
 164                 }
 165               p_sign_posn = 0;
 166               n_sign_posn = 0;
 167               continue;
 168             case '!':                   /* Don't print the currency symbol.  */
 169               print_curr_symbol = 0;
 170               continue;
 171             case '-':                   /* Print left justified.  */
 172               left = 1;
 173               continue;
 174             default:
 175               /* Will stop the loop.  */;
 176             }
 177           break;
 178         }
 179
 180       if (isdigit (*fmt))
 181         {
 182           /* Parse field width.  */
 183           width = to_digit (*fmt);
 184
 185           while (isdigit (*++fmt))
 186             {
 187               int val = to_digit (*fmt);
 188
 189               if (width > LONG_MAX / 10
 190                   || (width == LONG_MAX && val > LONG_MAX % 10))
 191                 {
 192                   __set_errno (E2BIG);
 193                   __printf_buffer_mark_failed (buf);
 194                   return;
 195                 }
 196
 197               width = width * 10 + val;
 198             }
 199         }
 200
 201       /* Recognize left precision.  */
 202       if (*fmt == '#')
 203         {
 204           if (!isdigit (*++fmt))
 205             {
 206               __set_errno (EINVAL);
 207               __printf_buffer_mark_failed (buf);
 208               return;
 209             }
 210           left_prec = to_digit (*fmt);
 211
 212           while (isdigit (*++fmt))
 213             {
 214               left_prec *= 10;
 215               left_prec += to_digit (*fmt);
 216             }
 217         }
 218
 219       /* Recognize right precision.  */
 220       if (*fmt == '.')
 221         {
 222           if (!isdigit (*++fmt))
 223             {
 224               __set_errno (EINVAL);
 225               __printf_buffer_mark_failed (buf);
 226               return;
 227             }
 228           right_prec = to_digit (*fmt);
 229
 230           while (isdigit (*++fmt))
 231             {
 232               right_prec *= 10;
 233               right_prec += to_digit (*fmt);
 234             }
 235         }
 236
 237       /* Handle modifier.  This is an extension.  */
 238       if (*fmt == 'L')
 239         {
 240           ++fmt;
 241           if (__glibc_likely ((flags & STRFMON_LDBL_IS_DBL) == 0))
 242             is_long_double = 1;
 243 #if __HAVE_DISTINCT_FLOAT128
 244           if (__glibc_likely ((flags & STRFMON_LDBL_USES_FLOAT128) != 0))
 245             is_binary128 = is_long_double;
 246 #endif
 247         }
 248
 249       /* Handle format specifier.  */
 250       char int_symbol[4];
 251       switch (*fmt++)
 252         {
 253         case 'i': {             /* Use international currency symbol.  */
 254           const char *int_curr_symbol;
 255
 256           int_curr_symbol = _NL_CURRENT (LC_MONETARY, INT_CURR_SYMBOL);
 257           strncpy(int_symbol, int_curr_symbol, 3);
 258           int_symbol[3] = '\0';
 259
 260           currency_symbol_len = 3;
 261           currency_symbol = &int_symbol[0];
 262           space_char = int_curr_symbol[3];
 263           int_format = 1;
 264           break;
 265         }
 266         case 'n':               /* Use national currency symbol.  */
 267           currency_symbol = _NL_CURRENT (LC_MONETARY, CURRENCY_SYMBOL);
 268           currency_symbol_len = strlen (currency_symbol);
 269           space_char = ' ';
 270           int_format = 0;
 271           break;
 272         default:                /* Any unrecognized format is an error.  */
 273           __set_errno (EINVAL);
 274           __printf_buffer_mark_failed (buf);
 275           return;
 276         }
 277
 278       /* If not specified by the format string now find the values for
 279          the format specification.  */
 280       if (p_sign_posn == -2)
 281         p_sign_posn = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SIGN_POSN : P_SIGN_POSN);
 282       if (n_sign_posn == -2)
 283         n_sign_posn = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SIGN_POSN : N_SIGN_POSN);
 284
 285       if (right_prec == -1)
 286         {
 287           right_prec = *_NL_CURRENT (LC_MONETARY, int_format ? INT_FRAC_DIGITS : FRAC_DIGITS);
 288
 289           if (right_prec == '\377')
 290             right_prec = 2;
 291         }
 292
 293       /* If we have to print the digits grouped determine how many
 294          extra characters this means.  */
 295       if (group && left_prec != -1)
 296         {
 297           struct grouping_iterator it;
 298           __grouping_iterator_init (&it, LC_MONETARY, loc, left_prec);
 299           left_prec += it.separators;
 300         }
 301
 302       /* Now it's time to get the value.  */
 303       if (is_long_double == 1)
 304         {
 305 #if __HAVE_DISTINCT_FLOAT128
 306           if (is_binary128 == 1)
 307             {
 308               fpnum.f128 = va_arg (ap, _Float128);
 309               is_negative = fpnum.f128 < 0;
 310               if (is_negative)
 311                 fpnum.f128 = -fpnum.f128;
 312             }
 313           else
 314 #endif
 315           {
 316             fpnum.ldbl = va_arg (ap, long double);
 317             is_negative = fpnum.ldbl < 0;
 318             if (is_negative)
 319               fpnum.ldbl = -fpnum.ldbl;
 320           }
 321         }
 322       else
 323         {
 324           fpnum.dbl = va_arg (ap, double);
 325           is_negative = fpnum.dbl < 0;
 326           if (is_negative)
 327             fpnum.dbl = -fpnum.dbl;
 328         }
 329
 330       /* We now know the sign of the value and can determine the format.  */
 331       if (is_negative)
 332         {
 333           sign_string = _NL_CURRENT (LC_MONETARY, NEGATIVE_SIGN);
 334           /* If the locale does not specify a character for the
 335              negative sign we use a '-'.  */
 336           if (*sign_string == '\0')
 337             sign_string = (const char *) "-";
 338           cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_CS_PRECEDES : N_CS_PRECEDES);
 339           sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SEP_BY_SPACE : N_SEP_BY_SPACE);
 340           sign_posn = n_sign_posn;
 341
 342           other_sign_string = _NL_CURRENT (LC_MONETARY, POSITIVE_SIGN);
 343           other_cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_CS_PRECEDES : P_CS_PRECEDES);
 344           other_sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SEP_BY_SPACE : P_SEP_BY_SPACE);
 345           other_sign_posn = p_sign_posn;
 346         }
 347       else
 348         {
 349           sign_string = _NL_CURRENT (LC_MONETARY, POSITIVE_SIGN);
 350           cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_CS_PRECEDES : P_CS_PRECEDES);
 351           sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_P_SEP_BY_SPACE : P_SEP_BY_SPACE);
 352           sign_posn = p_sign_posn;
 353
 354           other_sign_string = _NL_CURRENT (LC_MONETARY, NEGATIVE_SIGN);
 355           if (*other_sign_string == '\0')
 356             other_sign_string = (const char *) "-";
 357           other_cs_precedes = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_CS_PRECEDES : N_CS_PRECEDES);
 358           other_sep_by_space = *_NL_CURRENT (LC_MONETARY, int_format ? INT_N_SEP_BY_SPACE : N_SEP_BY_SPACE);
 359           other_sign_posn = n_sign_posn;
 360         }
 361
 362       /* Set default values for unspecified information.  */
 363       if (cs_precedes != 0)
 364         cs_precedes = 1;
 365       if (other_cs_precedes != 0)
 366         other_cs_precedes = 1;
 367       if (sep_by_space == '\377')
 368         sep_by_space = 0;
 369       if (other_sep_by_space == '\377')
 370         other_sep_by_space = 0;
 371       if (sign_posn == '\377')
 372         sign_posn = 1;
 373       if (other_sign_posn == '\377')
 374         other_sign_posn = 1;
 375
 376       /* Check for degenerate cases */
 377       if (sep_by_space == 2)
 378         {
 379           if (sign_posn == 0
 380               || (sign_posn == 1 && !cs_precedes)
 381               || (sign_posn == 2 && cs_precedes))
 382             /* sign and symbol are not adjacent, so no separator */
 383             sep_by_space = 0;
 384         }
 385       if (other_sep_by_space == 2)
 386         {
 387           if (other_sign_posn == 0
 388               || (other_sign_posn == 1 && !other_cs_precedes)
 389               || (other_sign_posn == 2 && other_cs_precedes))
 390             /* sign and symbol are not adjacent, so no separator */
 391             other_sep_by_space = 0;
 392         }
 393
 394       /* Set the left precision and padding needed for alignment */
 395       if (left_prec == -1)
 396         {
 397           left_prec = 0;
 398           left_pad = 0;
 399         }
 400       else
 401         {
 402           /* Set left_pad to number of spaces needed to align positive
 403              and negative formats */
 404
 405           int left_bytes = 0;
 406           int other_left_bytes = 0;
 407
 408           /* Work out number of bytes for currency string and separator
 409              preceding the value */
 410           if (cs_precedes)
 411             {
 412               left_bytes += currency_symbol_len;
 413               if (sep_by_space != 0)
 414                 ++left_bytes;
 415             }
 416
 417           if (other_cs_precedes)
 418             {
 419               other_left_bytes += currency_symbol_len;
 420               if (other_sep_by_space != 0)
 421                 ++other_left_bytes;
 422             }
 423
 424           /* Work out number of bytes for the sign (or left parenthesis)
 425              preceding the value */
 426           if (sign_posn == 0 && is_negative)
 427             ++left_bytes;
 428           else if (sign_posn == 1)
 429             left_bytes += strlen (sign_string);
 430           else if (cs_precedes && (sign_posn == 3 || sign_posn == 4))
 431             left_bytes += strlen (sign_string);
 432
 433           if (other_sign_posn == 0 && !is_negative)
 434             ++other_left_bytes;
 435           else if (other_sign_posn == 1)
 436             other_left_bytes += strlen (other_sign_string);
 437           else if (other_cs_precedes
 438                    && (other_sign_posn == 3 || other_sign_posn == 4))
 439             other_left_bytes += strlen (other_sign_string);
 440
 441           /* Compare the number of bytes preceding the value for
 442              each format, and set the padding accordingly */
 443           if (other_left_bytes > left_bytes)
 444             left_pad = other_left_bytes - left_bytes;
 445           else
 446             left_pad = 0;
 447         }
 448
 449       /* Perhaps we'll someday make these things configurable so
 450          better start using symbolic names now.  */
 451 #define left_paren '('
 452 #define right_paren ')'
 453
 454       char *startp = buf->write_ptr;
 455
 456       __printf_buffer_pad (buf, ' ', left_pad);
 457
 458       if (sign_posn == 0 && is_negative)
 459         __printf_buffer_putc (buf, left_paren);
 460
 461       if (cs_precedes)
 462         {
 463           if (sign_posn != 0 && sign_posn != 2 && sign_posn != 4
 464               && sign_posn != 5)
 465             {
 466               __printf_buffer_puts (buf, sign_string);
 467               if (sep_by_space == 2)
 468                 __printf_buffer_putc (buf, ' ');
 469             }
 470
 471           if (print_curr_symbol)
 472             __printf_buffer_puts (buf, currency_symbol);
 473
 474           if (sign_posn == 4)
 475             {
 476               if (print_curr_symbol && sep_by_space == 2)
 477                 __printf_buffer_putc (buf, space_char);
 478               __printf_buffer_puts (buf, sign_string);
 479               if (sep_by_space == 1)
 480                 /* POSIX.2 and SUS are not clear on this case, but C99
 481                    says a space follows the adjacent-symbol-and-sign */
 482                 __printf_buffer_putc (buf, ' ');
 483             }
 484           else
 485             if (print_curr_symbol && sep_by_space == 1)
 486               __printf_buffer_putc (buf, space_char);
 487         }
 488       else
 489         if (sign_posn != 0 && sign_posn != 2 && sign_posn != 3
 490             && sign_posn != 4 && sign_posn != 5)
 491           __printf_buffer_puts (buf, sign_string);
 492
 493       /* Print the number.  */
 494       memset (&info, '\0', sizeof (info));
 495       info.prec = right_prec;
 496       info.width = left_prec + (right_prec ? (right_prec + 1) : 0);
 497       info.spec = 'f';
 498       info.is_long_double = is_long_double;
 499       info.is_binary128 = is_binary128;
 500       info.group = group;
 501       info.pad = pad;
 502       info.extra = 1;           /* This means use values from LC_MONETARY.  */
 503
 504       ptr = &fpnum;
 505       __printf_fp_l_buffer (buf, loc, &info, &ptr);
 506       if (__printf_buffer_has_failed (buf))
 507         return;
 508
 509       if (!cs_precedes)
 510         {
 511           if (sign_posn == 3)
 512             {
 513               if (sep_by_space == 1)
 514                 __printf_buffer_putc (buf, ' ');
 515               __printf_buffer_puts (buf, sign_string);
 516             }
 517
 518           if (print_curr_symbol)
 519             {
 520               if ((sign_posn == 3 && sep_by_space == 2)
 521                   || (sign_posn == 4 && sep_by_space == 1)
 522                   || (sign_posn == 2 && sep_by_space == 1)
 523                   || (sign_posn == 1 && sep_by_space == 1)
 524                   || (sign_posn == 0 && sep_by_space == 1))
 525                 __printf_buffer_putc (buf, space_char);
 526               __printf_buffer_write (buf, currency_symbol,
 527                                        __strnlen (currency_symbol,
 528                                                   currency_symbol_len));
 529             }
 530
 531           if (sign_posn == 4)
 532             {
 533               if (sep_by_space == 2)
 534                 __printf_buffer_putc (buf, ' ');
 535               __printf_buffer_puts (buf, sign_string);
 536             }
 537         }
 538
 539       if (sign_posn == 2)
 540         {
 541           if (sep_by_space == 2)
 542             __printf_buffer_putc (buf, ' ');
 543           __printf_buffer_puts (buf, sign_string);
 544         }
 545
 546       if (sign_posn == 0 && is_negative)
 547         __printf_buffer_putc (buf, right_paren);
 548
 549       /* Now test whether the output width is filled.  */
 550       if (buf->write_ptr - startp < width)
 551         {
 552           size_t pad_width = width - (buf->write_ptr - startp);
 553           __printf_buffer_pad (buf, ' ', pad_width);
 554           if (__printf_buffer_has_failed (buf))
 555             /* Implies length check.  */
 556             return;
 557           /* Left padding is already in the correct position.
 558              Otherwise move the field contents in place.  */
 559           if (!left)
 560             {
 561               memmove (startp + pad_width, startp, buf->write_ptr - startp);
 562               memset (startp, ' ', pad_width);
 563             }
 564         }
 565     }
 566 }
 567
 568 ssize_t
 569 __vstrfmon_l_internal (char *s, size_t maxsize, locale_t loc,
 570                        const char *format, va_list ap, unsigned int flags)
 571 {
 572   struct __printf_buffer buf;
 573   __printf_buffer_init (&buf, s, maxsize, __printf_buffer_mode_strfmon);
 574   __vstrfmon_l_buffer (&buf, loc, format, ap, flags);
 575   __printf_buffer_putc (&buf, '\0'); /* Terminate the string.  */
 576   if (__printf_buffer_has_failed (&buf))
 577     return -1;
 578   else
 579     return buf.write_ptr - buf.write_base - 1; /* Exclude NUL byte.  */
 580 }
 581
 582 ssize_t
 583 ___strfmon_l (char *s, size_t maxsize, locale_t loc, const char *format, ...)
 584 {
 585   va_list ap;
 586
 587   va_start (ap, format);
 588
 589   ssize_t res = __vstrfmon_l_internal (s, maxsize, loc, format, ap, 0);
 590
 591   va_end (ap);
 592
 593   return res;
 594 }
 595 ldbl_strong_alias (___strfmon_l, __strfmon_l)
 596 ldbl_weak_alias (___strfmon_l, strfmon_l)