stdlib/strfmon_l.c

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