/* vsprintf with automatic memory allocation.

   Copyright (C) 1999, 2002-2026 Free Software Foundation, Inc.

   This file is free software: you can redistribute it and/or modify

   it under the terms of the GNU Lesser General Public License as

   published by the Free Software Foundation; either version 2.1 of the

   License, or (at your option) any later version.

   This file is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License

   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

/* This file can be parametrized with the following macros:

     VASNPRINTF         The name of the function being defined.

     FCHAR_T            The element type of the format string.

     DCHAR_T            The element type of the destination (result) string.

     FCHAR_T_ONLY_ASCII Set to 1 to enable verification that all characters

                        in the format string are ASCII. MUST be set if

                        FCHAR_T and DCHAR_T are not the same type.

     DIRECTIVE          Structure denoting a format directive.

                        Depends on FCHAR_T.

     DIRECTIVES         Structure denoting the set of format directives of a

                        format string.  Depends on FCHAR_T.

     PRINTF_PARSE       Function that parses a format string.

                        Depends on FCHAR_T.

     DCHAR_CPY          memcpy like function for DCHAR_T[] arrays.

     DCHAR_SET          memset like function for DCHAR_T[] arrays.

     DCHAR_STRLEN       strlen like function for DCHAR_T[] arrays.

     DCHAR_MBSNLEN      mbsnlen like function for DCHAR_T[] arrays.

     SNPRINTF           The system's snprintf (or similar) function.

                        This may be either snprintf or swprintf.

     TCHAR_T            The element type of the argument and result string

                        of the said SNPRINTF function.  This may be either

                        char or wchar_t.  The code exploits that

                        sizeof (TCHAR_T) | sizeof (DCHAR_T) and

                        alignof (TCHAR_T) <= alignof (DCHAR_T).

     DCHAR_IS_TCHAR     Set to 1 if DCHAR_T and TCHAR_T are the same type.

     DCHAR_CONV_FROM_ENCODING A function to convert from char[] to DCHAR[].

     DCHAR_IS_UINT8_T   Set to 1 if DCHAR_T is uint8_t.

     DCHAR_IS_UINT16_T  Set to 1 if DCHAR_T is uint16_t.

     DCHAR_IS_UINT32_T  Set to 1 if DCHAR_T is uint32_t.

     ENABLE_UNISTDIO    Set to 1 to enable the unistdio extensions.

     ENABLE_WCHAR_FALLBACK  Set to 1 to avoid EILSEQ during conversion of wide

                        characters (wchar_t) and wide character strings

                        (wchar_t[]) to multibyte sequences.  The fallback is the

                        hexadecimal escape syntax (\unnnn or \Unnnnnnnn) or,

                        if wchar_t is not Unicode encoded, \wnnnn or \Wnnnnnnnn.

 */

/* Tell glibc's <stdio.h> to provide a prototype for snprintf().

   This must come before <config.h> because <config.h> may include

   <features.h>, and once <features.h> has been included, it's too late.  */

#ifndef _GNU_SOURCE

# define _GNU_SOURCE    1

#endif

#ifndef VASNPRINTF

# include <config.h>

#endif

/* As of GCC 11.2.1, gcc -Wanalyzer-too-complex reports that main's

   use of CHECK macros expands to code that is too complicated for gcc

   -fanalyzer.  Suppress the resulting bogus warnings.  */

#if _GL_GNUC_PREREQ (10, 0)

# pragma GCC diagnostic ignored "-Wanalyzer-null-argument"

#endif

#include <alloca.h>

/* Specification.  */

#ifndef VASNPRINTF

# if WIDE_CHAR_VERSION

#  include "vasnwprintf.h"

# else

#  include "vasnprintf.h"

# endif

#endif

#include <locale.h>     /* localeconv() */

#include <stdint.h>     /* PTRDIFF_MAX */

#include <stdio.h>      /* snprintf(), sprintf() */

#include <stdlib.h>     /* abort(), malloc(), realloc(), free() */

#include <string.h>     /* memcpy(), strlen() */

#include <wchar.h>      /* mbstate_t, mbrtowc(), mbrlen(), wcrtomb(), mbszero() */

#include <errno.h>      /* errno */

#include <limits.h>     /* CHAR_BIT, INT_MAX, INT_WIDTH, LONG_WIDTH */

#include <float.h>      /* DBL_MAX_EXP, LDBL_MAX_EXP, LDBL_MANT_DIG */

#if HAVE_NL_LANGINFO || __GLIBC__ >= 2 || defined __CYGWIN__

# include <langinfo.h>

#endif

#ifndef VASNPRINTF

# if WIDE_CHAR_VERSION

#  include "wprintf-parse.h"

# else

#  include "printf-parse.h"

# endif

#endif

/* Checked size_t computations.  */

#include "xsize.h"

#include "attribute.h"

#if NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE || (NEED_WPRINTF_DIRECTIVE_LA && WIDE_CHAR_VERSION)

# include <math.h>

# include "float+.h"

#endif

#if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE

# include <math.h>

# include "isnand-nolibm.h"

#endif

#if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || (NEED_WPRINTF_DIRECTIVE_LA && WIDE_CHAR_VERSION)

# include <math.h>

# include "isnanl-nolibm.h"

# include "fpucw.h"

#endif

#if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE

# include <math.h>

# include "isnand-nolibm.h"

# include "printf-frexp.h"

#endif

#if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || (NEED_WPRINTF_DIRECTIVE_LA && WIDE_CHAR_VERSION)

# include <math.h>

# include "isnanl-nolibm.h"

# include "printf-frexpl.h"

# include "fpucw.h"

#endif

#if HAVE_SAME_LONG_DOUBLE_AS_DOUBLE

/* Override macros from fpucw.h.  */

# undef DECL_LONG_DOUBLE_ROUNDING

# define DECL_LONG_DOUBLE_ROUNDING

# undef BEGIN_LONG_DOUBLE_ROUNDING

# define BEGIN_LONG_DOUBLE_ROUNDING()

# undef END_LONG_DOUBLE_ROUNDING

# define END_LONG_DOUBLE_ROUNDING()

#endif

/* Default parameters.  */

#ifndef VASNPRINTF

# if WIDE_CHAR_VERSION

#  define VASNPRINTF vasnwprintf

#  define FCHAR_T wchar_t

#  define DCHAR_T wchar_t

#  define DIRECTIVE wchar_t_directive

#  define DIRECTIVES wchar_t_directives

#  define PRINTF_PARSE wprintf_parse

#  define DCHAR_CPY wmemcpy

#  define DCHAR_SET wmemset

# else

#  define VASNPRINTF vasnprintf

#  define FCHAR_T char

#  define DCHAR_T char

#  define TCHAR_T char

#  define DCHAR_IS_TCHAR 1

#  define DIRECTIVE char_directive

#  define DIRECTIVES char_directives

#  define PRINTF_PARSE printf_parse

#  define DCHAR_CPY memcpy

#  define DCHAR_SET memset

# endif

#endif

#if WIDE_CHAR_VERSION

  /* DCHAR_T is wchar_t.  */

# if HAVE_DECL__SNWPRINTF || (HAVE_SWPRINTF && HAVE_WORKING_SWPRINTF)

#  define TCHAR_T wchar_t

#  define DCHAR_IS_TCHAR 1

#  define USE_SNPRINTF 1

#  if HAVE_DECL__SNWPRINTF

    /* On Windows, the function swprintf() has a different signature than

       on Unix; we use the function _snwprintf() or - on mingw - snwprintf()

       instead.  The mingw function snwprintf() has fewer bugs than the

       MSVCRT function _snwprintf(), so prefer that.  */

#   if defined __MINGW32__

#    define SNPRINTF snwprintf

#   else

#    define SNPRINTF _snwprintf

#    define USE_MSVC__SNPRINTF 1

#   endif

#  else

    /* Unix.  */

#   define SNPRINTF swprintf

#  endif

# else

   /* Old platforms such as NetBSD 3.0, OpenBSD 3.8, HP-UX 11.00.  */

#   define TCHAR_T char

# endif

#endif

#ifndef DCHAR_STRLEN

# if WIDE_CHAR_VERSION

#  define DCHAR_STRLEN local_wcslen

# else

#  define DCHAR_STRLEN strlen

# endif

#endif

#ifndef DCHAR_MBSNLEN

# if WIDE_CHAR_VERSION

#  define DCHAR_MBSNLEN wcsnlen

# else

#  define DCHAR_MBSNLEN mbsnlen

# endif

#endif

#if !WIDE_CHAR_VERSION || !DCHAR_IS_TCHAR

  /* TCHAR_T is char.  */

  /* Use snprintf if it exists under the name 'snprintf' or '_snprintf'.

     But don't use it on BeOS, since BeOS snprintf produces no output if the

     size argument is >= 0x3000000.

     Also don't use it on Linux libc5, since there snprintf with size = 1

     writes any output without bounds, like sprintf.  */

# if (HAVE_DECL__SNPRINTF || HAVE_SNPRINTF) && !defined __BEOS__ && !(__GNU_LIBRARY__ == 1)

#  define USE_SNPRINTF 1

# else

#  define USE_SNPRINTF 0

# endif

# if HAVE_DECL__SNPRINTF

   /* Windows.  The mingw function snprintf() has fewer bugs than the MSVCRT

      function _snprintf(), so prefer that.  */

#  if defined __MINGW32__

#   define SNPRINTF snprintf

    /* Here we need to call the native snprintf, not rpl_snprintf.  */

#   undef snprintf

#  else

    /* MSVC versions < 14 did not have snprintf, only _snprintf.  */

#   define SNPRINTF _snprintf

#   define USE_MSVC__SNPRINTF 1

#  endif

# else

   /* Unix.  */

#  define SNPRINTF snprintf

   /* Here we need to call the native snprintf, not rpl_snprintf.  */

#  undef snprintf

# endif

#endif

/* Here we need to call the native sprintf, not rpl_sprintf.  */

#undef sprintf

/* macOS 12's "warning: 'sprintf' is deprecated" is pointless,

   as sprintf is used safely here.  */

#if defined __APPLE__ && defined __MACH__ && _GL_GNUC_PREREQ (4, 2)

# pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#endif

/* GCC >= 4.0 with -Wall emits unjustified "... may be used uninitialized"

   warnings in this file.  Use -Dlint to suppress them.  */

#if defined GCC_LINT || defined lint

# define IF_LINT(Code) Code

#else

# define IF_LINT(Code) /* empty */

#endif

/* Here we need only the most basic fields of 'struct lconv', and can

   therefore use the system's localeconv() function, without needing a

   dependency on module 'localeconv'.  */

#undef localeconv

/* Avoid some warnings from "gcc -Wshadow".

   This file doesn't use the exp() and remainder() functions.  */

#undef exp

#define exp expo

#undef remainder

#define remainder rem

#if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || (PTRDIFF_MAX > INT_MAX)) && !WIDE_CHAR_VERSION

# if (HAVE_STRNLEN && !defined _AIX)

#  define local_strnlen strnlen

# else

#  ifndef local_strnlen_defined

#   define local_strnlen_defined 1

static size_t

local_strnlen (const char *string, size_t maxlen)

{

  const char *end = memchr (string, '\0', maxlen);

  return end ? (size_t) (end - string) : maxlen;

}

#  endif

# endif

#endif

#if ((!USE_SNPRINTF || WIDE_CHAR_VERSION || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || (PTRDIFF_MAX > INT_MAX) || !DCHAR_IS_TCHAR || NEED_WPRINTF_DIRECTIVE_LC) && WIDE_CHAR_VERSION) || ((!USE_SNPRINTF || (PTRDIFF_MAX > INT_MAX) || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || NEED_PRINTF_DIRECTIVE_LS) && !WIDE_CHAR_VERSION && DCHAR_IS_TCHAR)

# if HAVE_WCSLEN

#  define local_wcslen wcslen

# else

   /* Solaris 2.5.1 has wcslen() in a separate library libw.so. To avoid

      a dependency towards this library, here is a local substitute.

      Define this substitute only once, even if this file is included

      twice in the same compilation unit.  */

#  ifndef local_wcslen_defined

#   define local_wcslen_defined 1

static size_t

local_wcslen (const wchar_t *s)

{

  const wchar_t *ptr;

  for (ptr = s; *ptr != (wchar_t) 0; ptr++)

    ;

  return ptr - s;

}

#  endif

# endif

#endif

#if (!USE_SNPRINTF || (WIDE_CHAR_VERSION && DCHAR_IS_TCHAR) || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF) && WIDE_CHAR_VERSION

# if HAVE_WCSNLEN && HAVE_DECL_WCSNLEN

#  define local_wcsnlen wcsnlen

# else

#  ifndef local_wcsnlen_defined

#   define local_wcsnlen_defined 1

static size_t

local_wcsnlen (const wchar_t *s, size_t maxlen)

{

  const wchar_t *ptr;

  for (ptr = s; maxlen > 0 && *ptr != (wchar_t) 0; ptr++, maxlen--)

    ;

  return ptr - s;

}

#  endif

# endif

#endif

#if ((!USE_SNPRINTF || (PTRDIFF_MAX > INT_MAX) || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || NEED_PRINTF_DIRECTIVE_LS || ENABLE_WCHAR_FALLBACK) || ((NEED_PRINTF_DIRECTIVE_LC || ENABLE_WCHAR_FALLBACK) && HAVE_WINT_T)) && !WIDE_CHAR_VERSION

# if ENABLE_WCHAR_FALLBACK

static size_t

wctomb_fallback (char *s, wchar_t wc)

{

  static char const hex[16] = "0123456789ABCDEF";

  s[0] = '\\';

  if (sizeof (wchar_t) > 2 && wc > 0xffff)

    {

#  if __STDC_ISO_10646__ || (__GLIBC__ >= 2) || (defined _WIN32 || defined __CYGWIN__)

      s[1] = 'U';

#  else

      s[1] = 'W';

#  endif

      s[2] = hex[(wc & 0xf0000000U) >> 28];

      s[3] = hex[(wc & 0xf000000U) >> 24];

      s[4] = hex[(wc & 0xf00000U) >> 20];

      s[5] = hex[(wc & 0xf0000U) >> 16];

      s[6] = hex[(wc & 0xf000U) >> 12];

      s[7] = hex[(wc & 0xf00U) >> 8];

      s[8] = hex[(wc & 0xf0U) >> 4];

      s[9] = hex[wc & 0xfU];

      return 10;

    }

  else

    {

#  if __STDC_ISO_10646__ || (__GLIBC__ >= 2) || (defined _WIN32 || defined __CYGWIN__)

      s[1] = 'u';

#  else

      s[1] = 'w';

#  endif

      s[2] = hex[(wc & 0xf000U) >> 12];

      s[3] = hex[(wc & 0xf00U) >> 8];

      s[4] = hex[(wc & 0xf0U) >> 4];

      s[5] = hex[wc & 0xfU];

      return 6;

    }

}

#  if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t

static size_t

local_wcrtomb (char *s, wchar_t wc, mbstate_t *ps)

{

  size_t count = wcrtomb (s, wc, ps);

  if (count == (size_t)(-1))

    count = wctomb_fallback (s, wc);

  return count;

}

#  else

static int

local_wctomb (char *s, wchar_t wc)

{

  int count = wctomb (s, wc);

  if (count < 0)

    count = wctomb_fallback (s, wc);

  return count;

}

#   define local_wcrtomb(S, WC, PS)  local_wctomb ((S), (WC))

#  endif

# else

#  if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t

#   define local_wcrtomb(S, WC, PS)  wcrtomb ((S), (WC), (PS))

#  else

#   define local_wcrtomb(S, WC, PS)  wctomb ((S), (WC))

#  endif

# endif

#endif

#if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE || (NEED_WPRINTF_DIRECTIVE_LA && WIDE_CHAR_VERSION) || (NEED_PRINTF_FLAG_ALT_PRECISION_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION || NEED_PRINTF_FLAG_GROUPING || NEED_PRINTF_FLAG_GROUPING_INT)

/* Determine the decimal-point character according to the current locale.  */

# ifndef decimal_point_char_defined

#  define decimal_point_char_defined 1

static char

decimal_point_char (void)

{

  const char *point;

  /* Determine it in a multithread-safe way.  We know nl_langinfo is

     multithread-safe on glibc systems and Mac OS X systems, but is not required

     to be multithread-safe by POSIX.  sprintf(), however, is multithread-safe.

     localeconv() is rarely multithread-safe.  */

#  if HAVE_NL_LANGINFO && (__GLIBC__ || defined __UCLIBC__ || (defined __APPLE__ && defined __MACH__))

  point = nl_langinfo (RADIXCHAR);

#  elif 1

  char pointbuf[5];

  sprintf (pointbuf, "%#.0f", 1.0);

  point = &pointbuf[1];

#  else

  point = localeconv () -> decimal_point;

#  endif

  /* The decimal point is always a single byte: either '.' or ','.  */

  return (point[0] != '\0' ? point[0] : '.');

}

# endif

#endif

#if (!WIDE_CHAR_VERSION && (NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE)) || ((!WIDE_CHAR_VERSION || !DCHAR_IS_TCHAR) && (NEED_PRINTF_FLAG_ALT_PRECISION_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION || NEED_PRINTF_FLAG_GROUPING || NEED_PRINTF_FLAG_GROUPING_INT))

/* Determine the thousands-separator character according to the current

   locale.

   It is a single multibyte character.

   In glibc: 35x ".", 90x ",", 23x U+202F, 1x U+2019, 1x U+066C, on other

   systems also U+00A0.  */

# ifndef thousands_separator_char_defined

#  define thousands_separator_char_defined 1

static const char *

thousands_separator_char (char stackbuf[10])

{

  /* Determine it in a multithread-safe way.

     We know nl_langinfo is multithread-safe on glibc systems, on Mac OS X

     systems, and on NetBSD, but is not required to be multithread-safe by

     POSIX.

     localeconv() is not guaranteed to be multithread-safe by POSIX either;

     however, on native Windows it is (cf. test-localeconv-mt).

     sprintf(), however, is multithread-safe.  */

#  if HAVE_NL_LANGINFO && (__GLIBC__ || defined __UCLIBC__ || (defined __APPLE__ && defined __MACH__) || defined __NetBSD__)

  return nl_langinfo (THOUSEP);

#  elif defined _WIN32 && !defined __CYGWIN__

  return localeconv () -> thousands_sep;

#  else

  sprintf (stackbuf, "%'.0f", 1000.0);

  /* Now stackbuf = "1<thousep>000".  */

  stackbuf[strlen (stackbuf) - 3] = '\0';

#   if defined __sun

  /* Solaris specific hack: Replace wrong result (0xC2 means U+00A0).  */

  if (streq (&stackbuf[1], "\302"))

    strcpy (&stackbuf[1], MB_CUR_MAX > 1 ? "\302\240" : "\240");

#   endif

  return &stackbuf[1];

#  endif

}

# endif

#endif

#if !WIDE_CHAR_VERSION && defined DCHAR_CONV_FROM_ENCODING && (NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE)

/* Determine the thousands-separator character, as a DCHAR_T[] array,

   according to the current locale.

   It is a single Unicode character.  */

# ifndef thousands_separator_DCHAR_defined

#  define thousands_separator_DCHAR_defined 1

static const DCHAR_T *

thousands_separator_DCHAR (DCHAR_T stackbuf[10])

{

  /* Determine it in a multithread-safe way.  */

  char tmpbuf[10];

  const char *tmp = thousands_separator_char (tmpbuf);

  if (*tmp != '\0')

    {

      /* Convert it from char[] to DCHAR_T[].  */

      size_t converted_len = 10;

      DCHAR_T *converted =

        DCHAR_CONV_FROM_ENCODING (locale_charset (),

                                  iconveh_question_mark,

                                  tmp, strlen (tmp) + 1,

                                  NULL,

                                  stackbuf, &converted_len);

      if (converted != NULL)

        {

          if (converted != stackbuf)

            /* It should not be so long.  */

            abort ();

          return stackbuf;

        }

    }

  stackbuf[0] = 0;

  return stackbuf;

}

# endif

#endif

/* Maximum number of 'char' in the char[] or DCHAR_T[] representation of the

   thousands separator.  */

#define THOUSEP_CHAR_MAXLEN 3

#if WIDE_CHAR_VERSION && ((NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE) || ((NEED_PRINTF_FLAG_ALT_PRECISION_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION || NEED_PRINTF_FLAG_GROUPING || NEED_PRINTF_FLAG_GROUPING_INT) && DCHAR_IS_TCHAR))

/* Determine the thousands-separator character, as a wide character, according

   to the current locale.

   It is a single wide character.  */

# ifndef thousands_separator_wchar_defined

#  define thousands_separator_wchar_defined 1

static const wchar_t *

thousands_separator_wchar (wchar_t stackbuf[10])

{

#  if __GLIBC__ >= 2 || defined __CYGWIN__

  /* On glibc, in the unibyte locale fr_FR, the *wprintf routines use U+202F

     as separator, which cannot be represented in the locale encoding.  */

  stackbuf[0] =

    (wchar_t) (unsigned long) nl_langinfo (_NL_NUMERIC_THOUSANDS_SEP_WC);

  stackbuf[1] = L'\0';

  return stackbuf;

#  elif defined _WIN32 && !defined __CYGWIN__

  const char *tmp = localeconv () -> thousands_sep;

  if (*tmp != '\0')

    {

      mbstate_t state;

      mbszero (&state);

      if ((int) mbrtowc (&stackbuf[0], tmp, strlen (tmp), &state) > 0)

        stackbuf[1] = L'\0';

      else

        stackbuf[0] = L'\0';

    }

  else

    stackbuf[0] = L'\0';

  return stackbuf;

#  elif defined __sun

  /* Use sprintf, because swprintf retrieves a wrong value for the

     thousands-separator wide character (e.g. (wchar_t) 0xffffffa0).  */

  char tmp[10];

  sprintf (tmp, "%'.0f", 1000.0);

  /* Now tmp = L"1<thousep>000".  */

  tmp[strlen (tmp) - 3] = '\0';

  /* Solaris specific hack: Replace wrong result (0xC2 means U+00A0).  */

  if (streq (&tmp[1], "\302"))

    strcpy (&tmp[1], MB_CUR_MAX > 1 ? "\302\240" : "\240");

  if (tmp[1] != '\0')

    {

      mbstate_t state;

      mbszero (&state);

      if ((int) mbrtowc (&stackbuf[0], &tmp[1], strlen (&tmp[1]), &state) > 0)

        stackbuf[1] = L'\0';

      else

        stackbuf[0] = L'\0';

    }

  else

    stackbuf[0] = L'\0';

  return stackbuf;

#  else

  swprintf (stackbuf, 10, L"%'.0f", 1000.0);

  /* Now stackbuf = L"1<thousep>000".  */

  stackbuf[local_wcslen (stackbuf) - 3] = '\0';

  return &stackbuf[1];

#  endif

}

# endif

#endif

/* Maximum number of 'wchar_t' in the wchar_t[] representation of the thousands

   separator.  */

#define THOUSEP_WCHAR_MAXLEN 1

#if (NEED_PRINTF_DOUBLE || NEED_PRINTF_LONG_DOUBLE) || (NEED_PRINTF_FLAG_ALT_PRECISION_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION || NEED_PRINTF_FLAG_GROUPING || NEED_PRINTF_FLAG_GROUPING_INT)

# ifndef grouping_rule_defined

#  define grouping_rule_defined 1

/* Determine the grouping rule.

 * As specified in POSIX

 * <https://pubs.opengroup.org/onlinepubs/9799919799/functions/localeconv.html>

 * <https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap07.html#tag_07_03_04>

 * it is a string whose elements are 'signed char' values, where

 * "Each integer specifies the number of digits in each group, with the initial

 *  integer defining the size of the group immediately preceding the decimal

 *  delimiter, and the following integers defining the preceding groups.  If

 *  the last integer is not -1, then the size of the previous group (if any)

 *  shall be repeatedly used for the remainder of the digits.  If the last

 *  integer is -1, then no further grouping shall be performed."

 * Platforms that have locales with grouping:

 *   glibc, FreeBSD, NetBSD, AIX, Solaris, Cygwin, Haiku.

 * Platforms that don't:

 *   musl libc, macOS, OpenBSD, Android, mingw, MSVC.

 * Typical grouping rules on glibc:

 *   136x 3     (fr_FR etc.)

 *   4x 4       (cmn_TW etc.)

 *   9x 3;2     (ta_IN etc.)

 *   1x 2;2;2;3 (umn_US)

 *   21x -1     (C etc.)

 */

static const signed char *

grouping_rule (void)

{

  /* We know nl_langinfo is multithread-safe on glibc systems and on Cygwin,

     but is not required to be multithread-safe by POSIX.

     localeconv() is not guaranteed to be multithread-safe by POSIX either;

     however, on all known systems it is (cf. test-localeconv-mt).  */

#  if __GLIBC__ >= 2

  return (const signed char *) nl_langinfo (GROUPING);

#  elif defined __CYGWIN__

  return (const signed char *) nl_langinfo (_NL_NUMERIC_GROUPING);

#  else

  return (const signed char *) localeconv () -> grouping;

#  endif

}

/* Determines the number of thousands-separators to be inserted in a digit

   sequence with ndigits digits (before the decimal point).  */

static size_t

num_thousands_separators (const signed char *grouping, size_t ndigits)

{

  const signed char *g = grouping;

  int h = *g;

  if (h <= 0 || ndigits == 0)

    return 0;

  size_t insert = 0;

  for (;;)

    {

      /* Invariant: here h == *g, h > 0, ndigits > 0.  */

      if (g[1] == 0)

        /* h repeats endlessly.  */

        return insert + (ndigits - 1) / h;

      /* h does not repeat.  */

      if (ndigits <= h)

        return insert;

      ndigits -= h;

      insert++;

      g++;

      h = *g;

      if (h < 0)

        /* No further grouping.  */

        return insert;

    }

}

# endif

#endif

#if NEED_PRINTF_INFINITE_DOUBLE && !NEED_PRINTF_DOUBLE

/* Equivalent to !isfinite(x) || x == 0, but does not require libm.  */

static int

is_infinite_or_zero (double x)

{

  return isnand (x) || x + x == x;

}

#endif

#if NEED_PRINTF_INFINITE_LONG_DOUBLE && !NEED_PRINTF_LONG_DOUBLE

/* Equivalent to !isfinite(x) || x == 0, but does not require libm.  */

static int

is_infinite_or_zerol (long double x)

{

  return isnanl (x) || x + x == x;

}

#endif

#if NEED_PRINTF_LONG_DOUBLE

/* Like frexpl, except that it supports even "unsupported" numbers.  */

# if (LDBL_MANT_DIG == 64 && (defined __ia64 || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))) && (defined __APPLE__ && defined __MACH__)

/* Don't assume that frexpl can handle pseudo-denormals; it does not on

   macOS 12/x86_64.  Therefore test for a pseudo-denormal explicitly.  */

static

long double safe_frexpl (long double x, int *exp)

{

  union

    {

      long double value;

      struct { unsigned int mant_word[2]; unsigned short sign_exp_word; } r;

    }

  u;

  u.value = x;

  if (u.r.sign_exp_word == 0 && (u.r.mant_word[1] & 0x80000000u) != 0)

    {

      /* Pseudo-Denormal.  */

      *exp = LDBL_MIN_EXP;

      u.r.sign_exp_word = 1 - LDBL_MIN_EXP;

      return u.value;

    }

  else

    return frexpl (x, exp);

}

# else

#  define safe_frexpl frexpl

# endif

#endif

#if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE

/* An indicator for a failed memory allocation.  */

# define NOMEM_PTR ((void *) (-1))

/* Converting 'long double' to decimal without rare rounding bugs requires

   real bignums.  We use the naming conventions of GNU gmp, but vastly simpler

   (and slower) algorithms.  */

typedef unsigned int mp_limb_t;

# define GMP_LIMB_BITS 32

static_assert (sizeof (mp_limb_t) * CHAR_BIT == GMP_LIMB_BITS);

typedef unsigned long long mp_twolimb_t;

# define GMP_TWOLIMB_BITS 64

static_assert (sizeof (mp_twolimb_t) * CHAR_BIT == GMP_TWOLIMB_BITS);

/* Representation of a bignum >= 0.  */

typedef struct

{

  size_t nlimbs;

  mp_limb_t *limbs; /* Bits in little-endian order, allocated with malloc().  */

} mpn_t;

/* Compute the product of two bignums >= 0.

   Return the allocated memory (possibly NULL) in case of success, NOMEM_PTR

   in case of memory allocation failure.  */

static void *

multiply (mpn_t src1, mpn_t src2, mpn_t *dest)

{

  const mp_limb_t *p1;

  const mp_limb_t *p2;

  size_t len1;

  size_t len2;

  if (src1.nlimbs <= src2.nlimbs)

    {

      len1 = src1.nlimbs;

      p1 = src1.limbs;

      len2 = src2.nlimbs;

      p2 = src2.limbs;

    }

  else

    {

      len1 = src2.nlimbs;

      p1 = src2.limbs;

      len2 = src1.nlimbs;

      p2 = src1.limbs;

    }

  /* Now 0 <= len1 <= len2.  */

  if (len1 == 0)

    {

      /* src1 or src2 is zero.  */

      dest->nlimbs = 0;

      dest->limbs = NULL;

    }

  else

    {

      /* Here 1 <= len1 <= len2.  */

      size_t dlen;

      mp_limb_t *dp;

      dlen = len1 + len2;

      dp = (mp_limb_t *) malloc (dlen * sizeof (mp_limb_t));

      if (dp == NULL)

        return NOMEM_PTR;

      for (size_t k = len2; k > 0; )

        dp[--k] = 0;

      for (size_t i = 0; i < len1; i++)

        {

          mp_limb_t digit1 = p1[i];

          mp_twolimb_t carry = 0;

          for (size_t j = 0; j < len2; j++)

            {

              mp_limb_t digit2 = p2[j];

              carry += (mp_twolimb_t) digit1 * (mp_twolimb_t) digit2;

              carry += dp[i + j];

              dp[i + j] = (mp_limb_t) carry;

              carry = carry >> GMP_LIMB_BITS;

            }

          dp[i + len2] = (mp_limb_t) carry;

        }

      /* Normalise.  */

      while (dlen > 0 && dp[dlen - 1] == 0)

        dlen--;

      dest->nlimbs = dlen;

      dest->limbs = dp;

    }

  return dest->limbs;

}

/* Compute the quotient of a bignum a >= 0 and a bignum b > 0.

   a is written as  a = q * b + r  with 0 <= r < b.  q is the quotient, r

   the remainder.

   Finally, round-to-even is performed: If r > b/2 or if r = b/2 and q is odd,

   q is incremented.

   Return the allocated memory (possibly NULL) in case of success, NOMEM_PTR

   in case of memory allocation failure.  */

static void *

divide (mpn_t a, mpn_t b, mpn_t *q)

{

  /* Algorithm:

     First normalise a and b: a=[a[m-1],...,a[0]], b=[b[n-1],...,b[0]]

     with m>=0 and n>0 (in base beta = 2^GMP_LIMB_BITS).

     If m<n, then q:=0 and r:=a.

     If m>=n=1, perform a single-precision division:

       r:=0, j:=m,

       while j>0 do

         {Here (q[m-1]*beta^(m-1)+...+q[j]*beta^j) * b[0] + r*beta^j =

               = a[m-1]*beta^(m-1)+...+a[j]*beta^j und 0<=r<b[0]<beta}

         j:=j-1, r:=r*beta+a[j], q[j]:=floor(r/b[0]), r:=r-b[0]*q[j].

       Normalise [q[m-1],...,q[0]], yields q.

     If m>=n>1, perform a multiple-precision division:

       We have a/b < beta^(m-n+1).

       s:=intDsize-1-(highest bit in b[n-1]), 0<=s<intDsize.

       Shift a and b left by s bits, copying them. r:=a.

       r=[r[m],...,r[0]], b=[b[n-1],...,b[0]] with b[n-1]>=beta/2.

       For j=m-n,...,0: {Here 0 <= r < b*beta^(j+1).}

         Compute q* :

           q* := floor((r[j+n]*beta+r[j+n-1])/b[n-1]).

           In case of overflow (q* >= beta) set q* := beta-1.

           Compute c2 := ((r[j+n]*beta+r[j+n-1]) - q* * b[n-1])*beta + r[j+n-2]

           and c3 := b[n-2] * q*.

           {We have 0 <= c2 < 2*beta^2, even 0 <= c2 < beta^2 if no overflow

            occurred.  Furthermore 0 <= c3 < beta^2.

            If there was overflow and

            r[j+n]*beta+r[j+n-1] - q* * b[n-1] >= beta, i.e. c2 >= beta^2,

            the next test can be skipped.}

           While c3 > c2, {Here 0 <= c2 < c3 < beta^2}

             Put q* := q* - 1, c2 := c2 + b[n-1]*beta, c3 := c3 - b[n-2].

           If q* > 0:

             Put r := r - b * q* * beta^j. In detail:

               [r[n+j],...,r[j]] := [r[n+j],...,r[j]] - q* * [b[n-1],...,b[0]].

               hence: u:=0, for i:=0 to n-1 do

                              u := u + q* * b[i],

                              r[j+i]:=r[j+i]-(u mod beta) (+ beta, if carry),

                              u:=u div beta (+ 1, if carry in subtraction)

                      r[n+j]:=r[n+j]-u.

               {Since always u = (q* * [b[i-1],...,b[0]] div beta^i) + 1

                               < q* + 1 <= beta,

                the carry u does not overflow.}

             If a negative carry occurs, put q* := q* - 1

               and [r[n+j],...,r[j]] := [r[n+j],...,r[j]] + [0,b[n-1],...,b[0]].

         Set q[j] := q*.

       Normalise [q[m-n],..,q[0]]; this yields the quotient q.

       Shift [r[n-1],...,r[0]] right by s bits and normalise; this yields the

       rest r.

       The room for q[j] can be allocated at the memory location of r[n+j].

     Finally, round-to-even:

       Shift r left by 1 bit.

       If r > b or if r = b and q[0] is odd, q := q+1.

   */

  const mp_limb_t *a_ptr = a.limbs;

  size_t a_len = a.nlimbs;

  const mp_limb_t *b_ptr = b.limbs;

  size_t b_len = b.nlimbs;

  mp_limb_t *tmp_roomptr = NULL;

  mp_limb_t *q_ptr;

  size_t q_len;

  mp_limb_t *r_ptr;

  size_t r_len;

  /* Allocate room for a_len+2 digits.

     (Need a_len+1 digits for the real division and 1 more digit for the

     final rounding of q.)  */

  mp_limb_t *roomptr = (mp_limb_t *) malloc ((a_len + 2) * sizeof (mp_limb_t));

  if (roomptr == NULL)

    return NOMEM_PTR;

  /* Normalise a.  */

  while (a_len > 0 && a_ptr[a_len - 1] == 0)

    a_len--;

  /* Normalise b.  */

  for (;;)

    {

      if (b_len == 0)

        /* Division by zero.  */

        abort ();

      if (b_ptr[b_len - 1] == 0)

        b_len--;

      else

        break;

    }

  /* Here m = a_len >= 0 and n = b_len > 0.  */

  if (a_len < b_len)

    {

      /* m<n: trivial case.  q=0, r := copy of a.  */

      r_ptr = roomptr;

      r_len = a_len;

      memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));

      q_ptr = roomptr + a_len;

      q_len = 0;

    }

  else if (b_len == 1)

    {

      /* n=1: single precision division.

         beta^(m-1) <= a < beta^m  ==>  beta^(m-2) <= a/b < beta^m  */

      r_ptr = roomptr;

      q_ptr = roomptr + 1;

      {

        mp_limb_t den = b_ptr[0];

        mp_limb_t remainder = 0;

        const mp_limb_t *sourceptr = a_ptr + a_len;

        mp_limb_t *destptr = q_ptr + a_len;

        for (size_t count = a_len; count > 0; count--)

          {

            mp_twolimb_t num =

              ((mp_twolimb_t) remainder << GMP_LIMB_BITS) | *--sourceptr;

            *--destptr = num / den;

            remainder = num % den;

          }

        /* Normalise and store r.  */

        if (remainder > 0)

          {

            r_ptr[0] = remainder;

            r_len = 1;

          }

        else

          r_len = 0;

        /* Normalise q.  */

        q_len = a_len;

        if (q_ptr[q_len - 1] == 0)

          q_len--;

      }

    }

  else

    {

      /* n>1: multiple precision division.

         beta^(m-1) <= a < beta^m, beta^(n-1) <= b < beta^n  ==>

         beta^(m-n-1) <= a/b < beta^(m-n+1).  */

      /* Determine s.  */

      size_t s;

      {

        mp_limb_t msd = b_ptr[b_len - 1]; /* = b[n-1], > 0 */

        /* Determine s = GMP_LIMB_BITS - integer_length (msd).

           Code copied from gnulib's integer_length.c.  */

# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) \

     || (__clang_major__ >= 4)

        s = __builtin_clz (msd);

# else

#  if defined DBL_EXPBIT0_WORD && defined DBL_EXPBIT0_BIT

        if (GMP_LIMB_BITS <= DBL_MANT_BIT)

          {

            /* Use 'double' operations.

               Assumes an IEEE 754 'double' implementation.  */

#   define DBL_EXP_MASK ((DBL_MAX_EXP - DBL_MIN_EXP) | 7)

#   define DBL_EXP_BIAS (DBL_EXP_MASK / 2 - 1)

#   define NWORDS \

     ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))

            union { double value; unsigned int word[NWORDS]; } m;

            /* Use a single integer to floating-point conversion.  */

            m.value = msd;

            s = GMP_LIMB_BITS

                - (((m.word[DBL_EXPBIT0_WORD] >> DBL_EXPBIT0_BIT) & DBL_EXP_MASK)

                   - DBL_EXP_BIAS);

          }

        else

#   undef NWORDS

#  endif

          {

            s = 31;

            if (msd >= 0x10000)

              {

                msd = msd >> 16;

                s -= 16;

              }

            if (msd >= 0x100)

              {

                msd = msd >> 8;

                s -= 8;

              }

            if (msd >= 0x10)

              {

                msd = msd >> 4;

                s -= 4;

              }

            if (msd >= 0x4)

              {

                msd = msd >> 2;

                s -= 2;

              }

            if (msd >= 0x2)

              {

                msd = msd >> 1;

                s -= 1;

              }

          }

# endif

      }

      /* 0 <= s < GMP_LIMB_BITS.

         Copy b, shifting it left by s bits.  */

      if (s > 0)

        {

          tmp_roomptr = (mp_limb_t *) malloc (b_len * sizeof (mp_limb_t));

          if (tmp_roomptr == NULL)

            {

              free (roomptr);

              return NOMEM_PTR;

            }

          {

            const mp_limb_t *sourceptr = b_ptr;

            mp_limb_t *destptr = tmp_roomptr;

            mp_twolimb_t accu = 0;

            for (size_t count = b_len; count > 0; count--)

              {

                accu += (mp_twolimb_t) *sourceptr++ << s;

                *destptr++ = (mp_limb_t) accu;

                accu = accu >> GMP_LIMB_BITS;

              }

            /* accu must be zero, since that was how s was determined.  */

            if (accu != 0)

              abort ();

          }

          b_ptr = tmp_roomptr;

        }

      /* Copy a, shifting it left by s bits, yields r.

         Memory layout:

         At the beginning: r = roomptr[0..a_len],

         at the end: r = roomptr[0..b_len-1], q = roomptr[b_len..a_len]  */

      r_ptr = roomptr;

      if (s == 0)

        {

          memcpy (r_ptr, a_ptr, a_len * sizeof (mp_limb_t));

          r_ptr[a_len] = 0;

        }

      else

        {

          const mp_limb_t *sourceptr = a_ptr;

          mp_limb_t *destptr = r_ptr;

          mp_twolimb_t accu = 0;

          for (size_t count = a_len; count > 0; count--)

            {

              accu += (mp_twolimb_t) *sourceptr++ << s;

              *destptr++ = (mp_limb_t) accu;

              accu = accu >> GMP_LIMB_BITS;

            }

          *destptr++ = (mp_limb_t) accu;

        }

      q_ptr = roomptr + b_len;

      q_len = a_len - b_len + 1; /* q will have m-n+1 limbs */

      {

        size_t j = a_len - b_len; /* m-n */

        mp_limb_t b_msd = b_ptr[b_len - 1]; /* b[n-1] */

        mp_limb_t b_2msd = b_ptr[b_len - 2]; /* b[n-2] */

        mp_twolimb_t b_msdd = /* b[n-1]*beta+b[n-2] */

          ((mp_twolimb_t) b_msd << GMP_LIMB_BITS) | b_2msd;

        /* Division loop, traversed m-n+1 times.

           j counts down, b is unchanged, beta/2 <= b[n-1] < beta.  */

        for (;;)

          {

            mp_limb_t q_star;

            mp_limb_t c1;

            if (r_ptr[j + b_len] < b_msd) /* r[j+n] < b[n-1] ? */

              {

                /* Divide r[j+n]*beta+r[j+n-1] by b[n-1], no overflow.  */

                mp_twolimb_t num =

                  ((mp_twolimb_t) r_ptr[j + b_len] << GMP_LIMB_BITS)

                  | r_ptr[j + b_len - 1];

                q_star = num / b_msd;

                c1 = num % b_msd;

              }

            else

              {

                /* Overflow, hence r[j+n]*beta+r[j+n-1] >= beta*b[n-1].  */

                q_star = (mp_limb_t)~(mp_limb_t)0; /* q* = beta-1 */

                /* Test whether r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] >= beta

                   <==> r[j+n]*beta+r[j+n-1] + b[n-1] >= beta*b[n-1]+beta

                   <==> b[n-1] < floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta)

                        {<= beta !}.

                   If yes, jump directly to the subtraction loop.

                   (Otherwise, r[j+n]*beta+r[j+n-1] - (beta-1)*b[n-1] < beta

                    <==> floor((r[j+n]*beta+r[j+n-1]+b[n-1])/beta) = b[n-1] ) */

                if (r_ptr[j + b_len] > b_msd

                    || (c1 = r_ptr[j + b_len - 1] + b_msd) < b_msd)

                  /* r[j+n] >= b[n-1]+1 or

                     r[j+n] = b[n-1] and the addition r[j+n-1]+b[n-1] gives a

                     carry.  */

                  goto subtract;

              }

            /* q_star = q*,

               c1 = (r[j+n]*beta+r[j+n-1]) - q* * b[n-1] (>=0, <beta).  */

            {

              mp_twolimb_t c2 = /* c1*beta+r[j+n-2] */

                ((mp_twolimb_t) c1 << GMP_LIMB_BITS) | r_ptr[j + b_len - 2];

              mp_twolimb_t c3 = /* b[n-2] * q* */

                (mp_twolimb_t) b_2msd * (mp_twolimb_t) q_star;

              /* While c2 < c3, increase c2 and decrease c3.

                 Consider c3-c2.  While it is > 0, decrease it by

                 b[n-1]*beta+b[n-2].  Because of b[n-1]*beta+b[n-2] >= beta^2/2

                 this can happen only twice.  */

              if (c3 > c2)

                {

                  q_star = q_star - 1; /* q* := q* - 1 */

                  if (c3 - c2 > b_msdd)

                    q_star = q_star - 1; /* q* := q* - 1 */

                }

            }

            if (q_star > 0)

              subtract:

              {

                /* Subtract r := r - b * q* * beta^j.  */

                mp_limb_t cr;

                {

                  const mp_limb_t *sourceptr = b_ptr;

                  mp_limb_t *destptr = r_ptr + j;

                  mp_twolimb_t carry = 0;

                  for (size_t count = b_len; count > 0; count--)

                    {

                      /* Here 0 <= carry <= q*.  */

                      carry =

                        carry

                        + (mp_twolimb_t) q_star * (mp_twolimb_t) *sourceptr++

                        + (mp_limb_t) ~(*destptr);

                      /* Here 0 <= carry <= beta*q* + beta-1.  */

                      *destptr++ = ~(mp_limb_t) carry;

                      carry = carry >> GMP_LIMB_BITS; /* <= q* */

                    }

                  cr = (mp_limb_t) carry;

                }

                /* Subtract cr from r_ptr[j + b_len], then forget about

                   r_ptr[j + b_len].  */

                if (cr > r_ptr[j + b_len])

                  {

                    /* Subtraction gave a carry.  */

                    q_star = q_star - 1; /* q* := q* - 1 */

                    /* Add b back.  */

                    {

                      const mp_limb_t *sourceptr = b_ptr;

                      mp_limb_t *destptr = r_ptr + j;

                      mp_limb_t carry = 0;

                      for (size_t count = b_len; count > 0; count--)

                        {

                          mp_limb_t source1 = *sourceptr++;

                          mp_limb_t source2 = *destptr;

                          *destptr++ = source1 + source2 + carry;

                          carry =

                            (carry

                             ? source1 >= (mp_limb_t) ~source2

                             : source1 > (mp_limb_t) ~source2);

                        }

                    }

                    /* Forget about the carry and about r[j+n].  */