stdlib/strfmon_l.c

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