* cardglue.c (open_card): Use shutdown code if possible.
[gnupg.git] / intl / vasnprintf.c
1 /* vsprintf with automatic memory allocation.
2    Copyright (C) 1999, 2002-2003 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or modify it
5    under the terms of the GNU Library General Public License as published
6    by the Free Software Foundation; either version 2, or (at your option)
7    any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with this program; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17    USA.  */
18
19 /* Tell glibc's <stdio.h> to provide a prototype for snprintf().
20    This must come before <config.h> because <config.h> may include
21    <features.h>, and once <features.h> has been included, it's too late.  */
22 #ifndef _GNU_SOURCE
23 # define _GNU_SOURCE    1
24 #endif
25
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
29 #ifndef IN_LIBINTL
30 # include <alloca.h>
31 #endif
32
33 /* Specification.  */
34 #if WIDE_CHAR_VERSION
35 # include "vasnwprintf.h"
36 #else
37 # include "vasnprintf.h"
38 #endif
39
40 #include <stdio.h>      /* snprintf(), sprintf() */
41 #include <stdlib.h>     /* abort(), malloc(), realloc(), free() */
42 #include <string.h>     /* memcpy(), strlen() */
43 #include <errno.h>      /* errno */
44 #include <limits.h>     /* CHAR_BIT */
45 #include <float.h>      /* DBL_MAX_EXP, LDBL_MAX_EXP */
46 #if WIDE_CHAR_VERSION
47 # include "wprintf-parse.h"
48 #else
49 # include "printf-parse.h"
50 #endif
51
52 /* Checked size_t computations.  */
53 #include "xsize.h"
54
55 #ifdef HAVE_WCHAR_T
56 # ifdef HAVE_WCSLEN
57 #  define local_wcslen wcslen
58 # else
59    /* Solaris 2.5.1 has wcslen() in a separate library libw.so. To avoid
60       a dependency towards this library, here is a local substitute.
61       Define this substitute only once, even if this file is included
62       twice in the same compilation unit.  */
63 #  ifndef local_wcslen_defined
64 #   define local_wcslen_defined 1
65 static size_t
66 local_wcslen (const wchar_t *s)
67 {
68   const wchar_t *ptr;
69
70   for (ptr = s; *ptr != (wchar_t) 0; ptr++)
71     ;
72   return ptr - s;
73 }
74 #  endif
75 # endif
76 #endif
77
78 #if WIDE_CHAR_VERSION
79 # define VASNPRINTF vasnwprintf
80 # define CHAR_T wchar_t
81 # define DIRECTIVE wchar_t_directive
82 # define DIRECTIVES wchar_t_directives
83 # define PRINTF_PARSE wprintf_parse
84 # define USE_SNPRINTF 1
85 # if HAVE_DECL__SNWPRINTF
86    /* On Windows, the function swprintf() has a different signature than
87       on Unix; we use the _snwprintf() function instead.  */
88 #  define SNPRINTF _snwprintf
89 # else
90    /* Unix.  */
91 #  define SNPRINTF swprintf
92 # endif
93 #else
94 # define VASNPRINTF vasnprintf
95 # define CHAR_T char
96 # define DIRECTIVE char_directive
97 # define DIRECTIVES char_directives
98 # define PRINTF_PARSE printf_parse
99 # define USE_SNPRINTF (HAVE_DECL__SNPRINTF || HAVE_SNPRINTF)
100 # if HAVE_DECL__SNPRINTF
101    /* Windows.  */
102 #  define SNPRINTF _snprintf
103 # else
104    /* Unix.  */
105 #  define SNPRINTF snprintf
106 # endif
107 #endif
108
109 CHAR_T *
110 VASNPRINTF (CHAR_T *resultbuf, size_t *lengthp, const CHAR_T *format, va_list args)
111 {
112   DIRECTIVES d;
113   arguments a;
114
115   if (PRINTF_PARSE (format, &d, &a) < 0)
116     {
117       errno = EINVAL;
118       return NULL;
119     }
120
121 #define CLEANUP() \
122   free (d.dir);                                                         \
123   if (a.arg)                                                            \
124     free (a.arg);
125
126   if (printf_fetchargs (args, &a) < 0)
127     {
128       CLEANUP ();
129       errno = EINVAL;
130       return NULL;
131     }
132
133   {
134     size_t buf_neededlength;
135     CHAR_T *buf;
136     CHAR_T *buf_malloced;
137     const CHAR_T *cp;
138     size_t i;
139     DIRECTIVE *dp;
140     /* Output string accumulator.  */
141     CHAR_T *result;
142     size_t allocated;
143     size_t length;
144
145     /* Allocate a small buffer that will hold a directive passed to
146        sprintf or snprintf.  */
147     buf_neededlength =
148       xsum4 (7, d.max_width_length, d.max_precision_length, 6);
149 #if HAVE_ALLOCA
150     if (buf_neededlength < 4000 / sizeof (CHAR_T))
151       {
152         buf = (CHAR_T *) alloca (buf_neededlength * sizeof (CHAR_T));
153         buf_malloced = NULL;
154       }
155     else
156 #endif
157       {
158         size_t buf_memsize = xtimes (buf_neededlength, sizeof (CHAR_T));
159         if (size_overflow_p (buf_memsize))
160           goto out_of_memory_1;
161         buf = (CHAR_T *) malloc (buf_memsize);
162         if (buf == NULL)
163           goto out_of_memory_1;
164         buf_malloced = buf;
165       }
166
167     if (resultbuf != NULL)
168       {
169         result = resultbuf;
170         allocated = *lengthp;
171       }
172     else
173       {
174         result = NULL;
175         allocated = 0;
176       }
177     length = 0;
178     /* Invariants:
179        result is either == resultbuf or == NULL or malloc-allocated.
180        If length > 0, then result != NULL.  */
181
182     /* Ensures that allocated >= needed.  Aborts through a jump to
183        out_of_memory if needed is SIZE_MAX or otherwise too big.  */
184 #define ENSURE_ALLOCATION(needed) \
185     if ((needed) > allocated)                                                \
186       {                                                                      \
187         size_t memory_size;                                                  \
188         CHAR_T *memory;                                                      \
189                                                                              \
190         allocated = (allocated > 0 ? xtimes (allocated, 2) : 12);            \
191         if ((needed) > allocated)                                            \
192           allocated = (needed);                                              \
193         memory_size = xtimes (allocated, sizeof (CHAR_T));                   \
194         if (size_overflow_p (memory_size))                                   \
195           goto out_of_memory;                                                \
196         if (result == resultbuf || result == NULL)                           \
197           memory = (CHAR_T *) malloc (memory_size);                          \
198         else                                                                 \
199           memory = (CHAR_T *) realloc (result, memory_size);                 \
200         if (memory == NULL)                                                  \
201           goto out_of_memory;                                                \
202         if (result == resultbuf && length > 0)                               \
203           memcpy (memory, result, length * sizeof (CHAR_T));                 \
204         result = memory;                                                     \
205       }
206
207     for (cp = format, i = 0, dp = &d.dir[0]; ; cp = dp->dir_end, i++, dp++)
208       {
209         if (cp != dp->dir_start)
210           {
211             size_t n = dp->dir_start - cp;
212             size_t augmented_length = xsum (length, n);
213
214             ENSURE_ALLOCATION (augmented_length);
215             memcpy (result + length, cp, n * sizeof (CHAR_T));
216             length = augmented_length;
217           }
218         if (i == d.count)
219           break;
220
221         /* Execute a single directive.  */
222         if (dp->conversion == '%')
223           {
224             size_t augmented_length;
225
226             if (!(dp->arg_index == ARG_NONE))
227               abort ();
228             augmented_length = xsum (length, 1);
229             ENSURE_ALLOCATION (augmented_length);
230             result[length] = '%';
231             length = augmented_length;
232           }
233         else
234           {
235             if (!(dp->arg_index != ARG_NONE))
236               abort ();
237
238             if (dp->conversion == 'n')
239               {
240                 switch (a.arg[dp->arg_index].type)
241                   {
242                   case TYPE_COUNT_SCHAR_POINTER:
243                     *a.arg[dp->arg_index].a.a_count_schar_pointer = length;
244                     break;
245                   case TYPE_COUNT_SHORT_POINTER:
246                     *a.arg[dp->arg_index].a.a_count_short_pointer = length;
247                     break;
248                   case TYPE_COUNT_INT_POINTER:
249                     *a.arg[dp->arg_index].a.a_count_int_pointer = length;
250                     break;
251                   case TYPE_COUNT_LONGINT_POINTER:
252                     *a.arg[dp->arg_index].a.a_count_longint_pointer = length;
253                     break;
254 #ifdef HAVE_LONG_LONG
255                   case TYPE_COUNT_LONGLONGINT_POINTER:
256                     *a.arg[dp->arg_index].a.a_count_longlongint_pointer = length;
257                     break;
258 #endif
259                   default:
260                     abort ();
261                   }
262               }
263             else
264               {
265                 arg_type type = a.arg[dp->arg_index].type;
266                 CHAR_T *p;
267                 unsigned int prefix_count;
268                 int prefixes[2];
269 #if !USE_SNPRINTF
270                 size_t tmp_length;
271                 CHAR_T tmpbuf[700];
272                 CHAR_T *tmp;
273
274                 /* Allocate a temporary buffer of sufficient size for calling
275                    sprintf.  */
276                 {
277                   size_t width;
278                   size_t precision;
279
280                   width = 0;
281                   if (dp->width_start != dp->width_end)
282                     {
283                       if (dp->width_arg_index != ARG_NONE)
284                         {
285                           int arg;
286
287                           if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
288                             abort ();
289                           arg = a.arg[dp->width_arg_index].a.a_int;
290                           width = (arg < 0 ? (unsigned int) (-arg) : arg);
291                         }
292                       else
293                         {
294                           const CHAR_T *digitp = dp->width_start;
295
296                           do
297                             width = xsum (xtimes (width, 10), *digitp++ - '0');
298                           while (digitp != dp->width_end);
299                         }
300                     }
301
302                   precision = 6;
303                   if (dp->precision_start != dp->precision_end)
304                     {
305                       if (dp->precision_arg_index != ARG_NONE)
306                         {
307                           int arg;
308
309                           if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
310                             abort ();
311                           arg = a.arg[dp->precision_arg_index].a.a_int;
312                           precision = (arg < 0 ? 0 : arg);
313                         }
314                       else
315                         {
316                           const CHAR_T *digitp = dp->precision_start + 1;
317
318                           precision = 0;
319                           do
320                             precision = xsum (xtimes (precision, 10), *digitp++ - '0');
321                           while (digitp != dp->precision_end);
322                         }
323                     }
324
325                   switch (dp->conversion)
326                     {
327
328                     case 'd': case 'i': case 'u':
329 # ifdef HAVE_LONG_LONG
330                       if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
331                         tmp_length =
332                           (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
333                                           * 0.30103 /* binary -> decimal */
334                                           * 2 /* estimate for FLAG_GROUP */
335                                          )
336                           + 1 /* turn floor into ceil */
337                           + 1; /* account for leading sign */
338                       else
339 # endif
340                       if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
341                         tmp_length =
342                           (unsigned int) (sizeof (unsigned long) * CHAR_BIT
343                                           * 0.30103 /* binary -> decimal */
344                                           * 2 /* estimate for FLAG_GROUP */
345                                          )
346                           + 1 /* turn floor into ceil */
347                           + 1; /* account for leading sign */
348                       else
349                         tmp_length =
350                           (unsigned int) (sizeof (unsigned int) * CHAR_BIT
351                                           * 0.30103 /* binary -> decimal */
352                                           * 2 /* estimate for FLAG_GROUP */
353                                          )
354                           + 1 /* turn floor into ceil */
355                           + 1; /* account for leading sign */
356                       break;
357
358                     case 'o':
359 # ifdef HAVE_LONG_LONG
360                       if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
361                         tmp_length =
362                           (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
363                                           * 0.333334 /* binary -> octal */
364                                          )
365                           + 1 /* turn floor into ceil */
366                           + 1; /* account for leading sign */
367                       else
368 # endif
369                       if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
370                         tmp_length =
371                           (unsigned int) (sizeof (unsigned long) * CHAR_BIT
372                                           * 0.333334 /* binary -> octal */
373                                          )
374                           + 1 /* turn floor into ceil */
375                           + 1; /* account for leading sign */
376                       else
377                         tmp_length =
378                           (unsigned int) (sizeof (unsigned int) * CHAR_BIT
379                                           * 0.333334 /* binary -> octal */
380                                          )
381                           + 1 /* turn floor into ceil */
382                           + 1; /* account for leading sign */
383                       break;
384
385                     case 'x': case 'X':
386 # ifdef HAVE_LONG_LONG
387                       if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT)
388                         tmp_length =
389                           (unsigned int) (sizeof (unsigned long long) * CHAR_BIT
390                                           * 0.25 /* binary -> hexadecimal */
391                                          )
392                           + 1 /* turn floor into ceil */
393                           + 2; /* account for leading sign or alternate form */
394                       else
395 # endif
396                       if (type == TYPE_LONGINT || type == TYPE_ULONGINT)
397                         tmp_length =
398                           (unsigned int) (sizeof (unsigned long) * CHAR_BIT
399                                           * 0.25 /* binary -> hexadecimal */
400                                          )
401                           + 1 /* turn floor into ceil */
402                           + 2; /* account for leading sign or alternate form */
403                       else
404                         tmp_length =
405                           (unsigned int) (sizeof (unsigned int) * CHAR_BIT
406                                           * 0.25 /* binary -> hexadecimal */
407                                          )
408                           + 1 /* turn floor into ceil */
409                           + 2; /* account for leading sign or alternate form */
410                       break;
411
412                     case 'f': case 'F':
413 # ifdef HAVE_LONG_DOUBLE
414                       if (type == TYPE_LONGDOUBLE)
415                         tmp_length =
416                           (unsigned int) (LDBL_MAX_EXP
417                                           * 0.30103 /* binary -> decimal */
418                                           * 2 /* estimate for FLAG_GROUP */
419                                          )
420                           + 1 /* turn floor into ceil */
421                           + 10; /* sign, decimal point etc. */
422                       else
423 # endif
424                         tmp_length =
425                           (unsigned int) (DBL_MAX_EXP
426                                           * 0.30103 /* binary -> decimal */
427                                           * 2 /* estimate for FLAG_GROUP */
428                                          )
429                           + 1 /* turn floor into ceil */
430                           + 10; /* sign, decimal point etc. */
431                       tmp_length = xsum (tmp_length, precision);
432                       break;
433
434                     case 'e': case 'E': case 'g': case 'G':
435                     case 'a': case 'A':
436                       tmp_length =
437                         12; /* sign, decimal point, exponent etc. */
438                       tmp_length = xsum (tmp_length, precision);
439                       break;
440
441                     case 'c':
442 # if defined HAVE_WINT_T && !WIDE_CHAR_VERSION
443                       if (type == TYPE_WIDE_CHAR)
444                         tmp_length = MB_CUR_MAX;
445                       else
446 # endif
447                         tmp_length = 1;
448                       break;
449
450                     case 's':
451 # ifdef HAVE_WCHAR_T
452                       if (type == TYPE_WIDE_STRING)
453                         {
454                           tmp_length =
455                             local_wcslen (a.arg[dp->arg_index].a.a_wide_string);
456
457 #  if !WIDE_CHAR_VERSION
458                           tmp_length = xtimes (tmp_length, MB_CUR_MAX);
459 #  endif
460                         }
461                       else
462 # endif
463                         tmp_length = strlen (a.arg[dp->arg_index].a.a_string);
464                       break;
465
466                     case 'p':
467                       tmp_length =
468                         (unsigned int) (sizeof (void *) * CHAR_BIT
469                                         * 0.25 /* binary -> hexadecimal */
470                                        )
471                           + 1 /* turn floor into ceil */
472                           + 2; /* account for leading 0x */
473                       break;
474
475                     default:
476                       abort ();
477                     }
478
479                   if (tmp_length < width)
480                     tmp_length = width;
481
482                   tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */
483                 }
484
485                 if (tmp_length <= sizeof (tmpbuf) / sizeof (CHAR_T))
486                   tmp = tmpbuf;
487                 else
488                   {
489                     size_t tmp_memsize = xtimes (tmp_length, sizeof (CHAR_T));
490
491                     if (size_overflow_p (tmp_memsize))
492                       /* Overflow, would lead to out of memory.  */
493                       goto out_of_memory;
494                     tmp = (CHAR_T *) malloc (tmp_memsize);
495                     if (tmp == NULL)
496                       /* Out of memory.  */
497                       goto out_of_memory;
498                   }
499 #endif
500
501                 /* Construct the format string for calling snprintf or
502                    sprintf.  */
503                 p = buf;
504                 *p++ = '%';
505                 if (dp->flags & FLAG_GROUP)
506                   *p++ = '\'';
507                 if (dp->flags & FLAG_LEFT)
508                   *p++ = '-';
509                 if (dp->flags & FLAG_SHOWSIGN)
510                   *p++ = '+';
511                 if (dp->flags & FLAG_SPACE)
512                   *p++ = ' ';
513                 if (dp->flags & FLAG_ALT)
514                   *p++ = '#';
515                 if (dp->flags & FLAG_ZERO)
516                   *p++ = '0';
517                 if (dp->width_start != dp->width_end)
518                   {
519                     size_t n = dp->width_end - dp->width_start;
520                     memcpy (p, dp->width_start, n * sizeof (CHAR_T));
521                     p += n;
522                   }
523                 if (dp->precision_start != dp->precision_end)
524                   {
525                     size_t n = dp->precision_end - dp->precision_start;
526                     memcpy (p, dp->precision_start, n * sizeof (CHAR_T));
527                     p += n;
528                   }
529
530                 switch (type)
531                   {
532 #ifdef HAVE_LONG_LONG
533                   case TYPE_LONGLONGINT:
534                   case TYPE_ULONGLONGINT:
535                     *p++ = 'l';
536                     /*FALLTHROUGH*/
537 #endif
538                   case TYPE_LONGINT:
539                   case TYPE_ULONGINT:
540 #ifdef HAVE_WINT_T
541                   case TYPE_WIDE_CHAR:
542 #endif
543 #ifdef HAVE_WCHAR_T
544                   case TYPE_WIDE_STRING:
545 #endif
546                     *p++ = 'l';
547                     break;
548 #ifdef HAVE_LONG_DOUBLE
549                   case TYPE_LONGDOUBLE:
550                     *p++ = 'L';
551                     break;
552 #endif
553                   default:
554                     break;
555                   }
556                 *p = dp->conversion;
557 #if USE_SNPRINTF
558                 p[1] = '%';
559                 p[2] = 'n';
560                 p[3] = '\0';
561 #else
562                 p[1] = '\0';
563 #endif
564
565                 /* Construct the arguments for calling snprintf or sprintf.  */
566                 prefix_count = 0;
567                 if (dp->width_arg_index != ARG_NONE)
568                   {
569                     if (!(a.arg[dp->width_arg_index].type == TYPE_INT))
570                       abort ();
571                     prefixes[prefix_count++] = a.arg[dp->width_arg_index].a.a_int;
572                   }
573                 if (dp->precision_arg_index != ARG_NONE)
574                   {
575                     if (!(a.arg[dp->precision_arg_index].type == TYPE_INT))
576                       abort ();
577                     prefixes[prefix_count++] = a.arg[dp->precision_arg_index].a.a_int;
578                   }
579
580 #if USE_SNPRINTF
581                 /* Prepare checking whether snprintf returns the count
582                    via %n.  */
583                 ENSURE_ALLOCATION (xsum (length, 1));
584                 result[length] = '\0';
585 #endif
586
587                 for (;;)
588                   {
589                     size_t maxlen;
590                     int count;
591                     int retcount;
592
593                     maxlen = allocated - length;
594                     count = -1;
595                     retcount = 0;
596
597 #if USE_SNPRINTF
598 # define SNPRINTF_BUF(arg) \
599                     switch (prefix_count)                                   \
600                       {                                                     \
601                       case 0:                                               \
602                         retcount = SNPRINTF (result + length, maxlen, buf,  \
603                                              arg, &count);                  \
604                         break;                                              \
605                       case 1:                                               \
606                         retcount = SNPRINTF (result + length, maxlen, buf,  \
607                                              prefixes[0], arg, &count);     \
608                         break;                                              \
609                       case 2:                                               \
610                         retcount = SNPRINTF (result + length, maxlen, buf,  \
611                                              prefixes[0], prefixes[1], arg, \
612                                              &count);                       \
613                         break;                                              \
614                       default:                                              \
615                         abort ();                                           \
616                       }
617 #else
618 # define SNPRINTF_BUF(arg) \
619                     switch (prefix_count)                                   \
620                       {                                                     \
621                       case 0:                                               \
622                         count = sprintf (tmp, buf, arg);                    \
623                         break;                                              \
624                       case 1:                                               \
625                         count = sprintf (tmp, buf, prefixes[0], arg);       \
626                         break;                                              \
627                       case 2:                                               \
628                         count = sprintf (tmp, buf, prefixes[0], prefixes[1],\
629                                          arg);                              \
630                         break;                                              \
631                       default:                                              \
632                         abort ();                                           \
633                       }
634 #endif
635
636                     switch (type)
637                       {
638                       case TYPE_SCHAR:
639                         {
640                           int arg = a.arg[dp->arg_index].a.a_schar;
641                           SNPRINTF_BUF (arg);
642                         }
643                         break;
644                       case TYPE_UCHAR:
645                         {
646                           unsigned int arg = a.arg[dp->arg_index].a.a_uchar;
647                           SNPRINTF_BUF (arg);
648                         }
649                         break;
650                       case TYPE_SHORT:
651                         {
652                           int arg = a.arg[dp->arg_index].a.a_short;
653                           SNPRINTF_BUF (arg);
654                         }
655                         break;
656                       case TYPE_USHORT:
657                         {
658                           unsigned int arg = a.arg[dp->arg_index].a.a_ushort;
659                           SNPRINTF_BUF (arg);
660                         }
661                         break;
662                       case TYPE_INT:
663                         {
664                           int arg = a.arg[dp->arg_index].a.a_int;
665                           SNPRINTF_BUF (arg);
666                         }
667                         break;
668                       case TYPE_UINT:
669                         {
670                           unsigned int arg = a.arg[dp->arg_index].a.a_uint;
671                           SNPRINTF_BUF (arg);
672                         }
673                         break;
674                       case TYPE_LONGINT:
675                         {
676                           long int arg = a.arg[dp->arg_index].a.a_longint;
677                           SNPRINTF_BUF (arg);
678                         }
679                         break;
680                       case TYPE_ULONGINT:
681                         {
682                           unsigned long int arg = a.arg[dp->arg_index].a.a_ulongint;
683                           SNPRINTF_BUF (arg);
684                         }
685                         break;
686 #ifdef HAVE_LONG_LONG
687                       case TYPE_LONGLONGINT:
688                         {
689                           long long int arg = a.arg[dp->arg_index].a.a_longlongint;
690                           SNPRINTF_BUF (arg);
691                         }
692                         break;
693                       case TYPE_ULONGLONGINT:
694                         {
695                           unsigned long long int arg = a.arg[dp->arg_index].a.a_ulonglongint;
696                           SNPRINTF_BUF (arg);
697                         }
698                         break;
699 #endif
700                       case TYPE_DOUBLE:
701                         {
702                           double arg = a.arg[dp->arg_index].a.a_double;
703                           SNPRINTF_BUF (arg);
704                         }
705                         break;
706 #ifdef HAVE_LONG_DOUBLE
707                       case TYPE_LONGDOUBLE:
708                         {
709                           long double arg = a.arg[dp->arg_index].a.a_longdouble;
710                           SNPRINTF_BUF (arg);
711                         }
712                         break;
713 #endif
714                       case TYPE_CHAR:
715                         {
716                           int arg = a.arg[dp->arg_index].a.a_char;
717                           SNPRINTF_BUF (arg);
718                         }
719                         break;
720 #ifdef HAVE_WINT_T
721                       case TYPE_WIDE_CHAR:
722                         {
723                           wint_t arg = a.arg[dp->arg_index].a.a_wide_char;
724                           SNPRINTF_BUF (arg);
725                         }
726                         break;
727 #endif
728                       case TYPE_STRING:
729                         {
730                           const char *arg = a.arg[dp->arg_index].a.a_string;
731                           SNPRINTF_BUF (arg);
732                         }
733                         break;
734 #ifdef HAVE_WCHAR_T
735                       case TYPE_WIDE_STRING:
736                         {
737                           const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string;
738                           SNPRINTF_BUF (arg);
739                         }
740                         break;
741 #endif
742                       case TYPE_POINTER:
743                         {
744                           void *arg = a.arg[dp->arg_index].a.a_pointer;
745                           SNPRINTF_BUF (arg);
746                         }
747                         break;
748                       default:
749                         abort ();
750                       }
751
752 #if USE_SNPRINTF
753                     /* Portability: Not all implementations of snprintf()
754                        are ISO C 99 compliant.  Determine the number of
755                        bytes that snprintf() has produced or would have
756                        produced.  */
757                     if (count >= 0)
758                       {
759                         /* Verify that snprintf() has NUL-terminated its
760                            result.  */
761                         if (count < maxlen && result[length + count] != '\0')
762                           abort ();
763                         /* Portability hack.  */
764                         if (retcount > count)
765                           count = retcount;
766                       }
767                     else
768                       {
769                         /* snprintf() doesn't understand the '%n'
770                            directive.  */
771                         if (p[1] != '\0')
772                           {
773                             /* Don't use the '%n' directive; instead, look
774                                at the snprintf() return value.  */
775                             p[1] = '\0';
776                             continue;
777                           }
778                         else
779                           {
780                             /* Look at the snprintf() return value.  */
781                             if (retcount < 0)
782                               {
783                                 /* HP-UX 10.20 snprintf() is doubly deficient:
784                                    It doesn't understand the '%n' directive,
785                                    *and* it returns -1 (rather than the length
786                                    that would have been required) when the
787                                    buffer is too small.  */
788                                 size_t bigger_need =
789                                   xsum (xtimes (allocated, 2), 12);
790                                 ENSURE_ALLOCATION (bigger_need);
791                                 continue;
792                               }
793                             else
794                               count = retcount;
795                           }
796                       }
797 #endif
798
799                     /* Attempt to handle failure.  */
800                     if (count < 0)
801                       {
802                         if (!(result == resultbuf || result == NULL))
803                           free (result);
804                         if (buf_malloced != NULL)
805                           free (buf_malloced);
806                         CLEANUP ();
807                         errno = EINVAL;
808                         return NULL;
809                       }
810
811 #if !USE_SNPRINTF
812                     if (count >= tmp_length)
813                       /* tmp_length was incorrectly calculated - fix the
814                          code above!  */
815                       abort ();
816 #endif
817
818                     /* Make room for the result.  */
819                     if (count >= maxlen)
820                       {
821                         /* Need at least count bytes.  But allocate
822                            proportionally, to avoid looping eternally if
823                            snprintf() reports a too small count.  */
824                         size_t n =
825                           xmax (xsum (length, count), xtimes (allocated, 2));
826
827                         ENSURE_ALLOCATION (n);
828 #if USE_SNPRINTF
829                         continue;
830 #endif
831                       }
832
833 #if USE_SNPRINTF
834                     /* The snprintf() result did fit.  */
835 #else
836                     /* Append the sprintf() result.  */
837                     memcpy (result + length, tmp, count * sizeof (CHAR_T));
838                     if (tmp != tmpbuf)
839                       free (tmp);
840 #endif
841
842                     length += count;
843                     break;
844                   }
845               }
846           }
847       }
848
849     /* Add the final NUL.  */
850     ENSURE_ALLOCATION (xsum (length, 1));
851     result[length] = '\0';
852
853     if (result != resultbuf && length + 1 < allocated)
854       {
855         /* Shrink the allocated memory if possible.  */
856         CHAR_T *memory;
857
858         memory = (CHAR_T *) realloc (result, (length + 1) * sizeof (CHAR_T));
859         if (memory != NULL)
860           result = memory;
861       }
862
863     if (buf_malloced != NULL)
864       free (buf_malloced);
865     CLEANUP ();
866     *lengthp = length;
867     return result;
868
869   out_of_memory:
870     if (!(result == resultbuf || result == NULL))
871       free (result);
872     if (buf_malloced != NULL)
873       free (buf_malloced);
874   out_of_memory_1:
875     CLEANUP ();
876     errno = ENOMEM;
877     return NULL;
878   }
879 }
880
881 #undef SNPRINTF
882 #undef USE_SNPRINTF
883 #undef PRINTF_PARSE
884 #undef DIRECTIVES
885 #undef DIRECTIVE
886 #undef CHAR_T
887 #undef VASNPRINTF