1 /************************************************************************

     2  *

     3  * printf.cpp - definitions of the rw_printf family of functions

     4  *

     5  * $Id: printf.cpp 351515 2005-12-01 23:19:44Z sebor $

     6  *

     7  ************************************************************************

     8  *

     9  * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

    10  * Software division. Licensed under the Apache License, Version 2.0 (the

    11  * "License");  you may  not use this file except  in compliance with the

    12  * License.    You    may   obtain   a   copy   of    the   License    at

    13  * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

    14  * applicable law  or agreed to  in writing,  software  distributed under

    15  * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

    16  * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

    17  * for the specific language governing permissions  and limitations under

    18  * the License.

    19  * 

    20  **************************************************************************/

    21 

    22 // expand _TEST_EXPORT macros

    23 #define _RWSTD_TEST_SRC

    24 #include <testdefs.h>

    25 #include <printf.h>

    26 

    27 #include <assert.h>   // for assert

    28 #include <errno.h>    // for errno, errno constants

    29 #include <float.h>    // for floating point macros

    30 #include <locale.h>

    31 #ifndef __SYMBIAN32__

    32 #include <signal.h>   // for signal constant

    33 #endif

    34 #include <stdarg.h>   // for va_list, va_start, ...

    35 #include <stddef.h>

    36 #include <stdio.h>

    37 #include <stdlib.h>

    38 #include <string.h>

    39 #include <wchar.h>

    40 

    41 #if (defined (_WIN32) || defined (_WIN64)) && !defined(__SYMBIAN32__)

    42    // define macros to enable Win98 + WinNT support in <windows.h>

    43 #  define _WIN32_WINNT 0x0410

    44 #  define WINVER       0x400

    45 #  include <windows.h>   // for IsDebuggerPresent()

    46 #else

    47 #  include <dlfcn.h>

    48 #endif   // _WIN{32,64}

    49 

    50 #include <ios>

    51 #include <iostream>

    52 #include <locale>

    53 //#include <string>

    54 #include <string.h>

    55 

    56 #ifdef __ARMCC__

    57 #pragma diag_suppress 61

    58 #pragma diag_suppress 63

    59 #endif

    60 

    61 #define _RWSTD_NO_EXT_BIN_IO

    62 #define _RWSTD_NO_EXT_REENTRANT_IO

    63 

    64 #ifndef __SYMBIAN32__

    65 

    66 _RWSTD_NAMESPACE (__rw) {

    67 

    68 _RWSTD_EXPORT _RWSTD_SSIZE_T

    69  __rw_memattr (const void*, size_t, int);

    70 

    71 }

    72 

    73 #endif

    74 

    75 /********************************************************************/

    76 

    77 static const union {

    78     int           ival;

    79     unsigned char bytes [sizeof (int)];

    80 } _rw_one = { 1 };

    81 

    82 static const int

    83 _rw_big_endian = '\0' == _rw_one.bytes [0];

    84 

    85 

    86 /********************************************************************/

    87 

    88 struct FmtSpec;

    89 

    90 static int

    91 _rw_fmtlong (const FmtSpec&, char**, size_t*, long);

    92 

    93 #ifdef _RWSTD_LONG_LONG

    94 

    95 static int

    96 _rw_fmtllong (const FmtSpec&, char**, size_t*, _RWSTD_LONG_LONG);

    97 

    98 #endif   // _RWSTD_LONG_LONG

    99 

   100 static int

   101 _rw_fmtinteger (FmtSpec*, size_t, char**, size_t*, va_list*);

   102 

   103 static int

   104 _rw_fmtfloating (const FmtSpec&, char**, size_t*, const void*);

   105 

   106 _RWSTD_INTERNAL int

   107 _rw_fmtptr (const FmtSpec&, char**, size_t*, const void*);

   108 

   109 typedef void (*funptr_t)();

   110 

   111 static int

   112 _rw_fmtfunptr (const FmtSpec&, char**, size_t*, funptr_t);

   113 

   114 struct DummyStruct;

   115 typedef void (DummyStruct::*memptr_t)() const;

   116 

   117 static int

   118 _rw_fmtmemptr (const FmtSpec&, char**, size_t*, memptr_t);

   119 

   120 static int

   121 _rw_fmtstr (const FmtSpec&, char**, size_t*, const char*, size_t);

   122 

   123 static int

   124 _rw_fmtchr (const FmtSpec&, char**, size_t*, int);

   125 

   126 static int

   127 _rw_fmtwchr (const FmtSpec&, char**, size_t*, wint_t);

   128 

   129 static int

   130 _rw_fmtwstr (const FmtSpec&, char**, size_t*, const wchar_t*, size_t);

   131 

   132 static int

   133 _rw_fmterrno (const FmtSpec&, char**, size_t*, int);

   134 

   135 static int

   136 _rw_fmtopenmode (const FmtSpec&, char**, size_t*, int);

   137 

   138 static int

   139 _rw_fmtevent (const FmtSpec&, char**, size_t*, int);

   140 

   141 static int

   142 _rw_fmtmonpat (const FmtSpec&, char**, size_t*, const char [4]);

   143 

   144 static int

   145 _rw_fmtsignal (const FmtSpec&, char**, size_t*, int);

   146 

   147 /********************************************************************/

   148 

   149 struct FmtSpec

   150 {

   151     // optional flags

   152     unsigned fl_minus  : 1;

   153     unsigned fl_plus   : 1;

   154     unsigned fl_pound  : 1;

   155     unsigned fl_space  : 1;

   156     unsigned fl_zero   : 1;

   157 

   158     // optional modifiers

   159     unsigned mod_A     : 1;    // extension (Arrays)

   160     unsigned mod_h     : 1;    // short modifier

   161     unsigned mod_hh    : 1;    // char modifier

   162     unsigned mod_l     : 1;    // long modifier

   163     unsigned mod_ll    : 1;    // long long modifier

   164     unsigned mod_j     : 1;    // intmax_t modifier

   165     unsigned mod_z     : 1;    // size_t modifier

   166     unsigned mod_t     : 1;    // ptrdiff_t modifier

   167     unsigned mod_L     : 1;    // long double modifier

   168     unsigned mod_I     : 1;    // extension

   169 

   170     unsigned cond       : 1;   // have an if/else clause

   171     unsigned cond_true  : 1;   // if/else clause is active (true)

   172     unsigned cond_begin : 1;   // beginning of an if/else clause

   173     unsigned cond_end   : 1;   // end of an if/else clause

   174 

   175     // note that the signedness of a bitfield is implementation-defined

   176     // unless explicitly declared signed or unsigned

   177 

   178     // extension: 8, 16, 32, and 64 bit integer width modifier

   179     signed int iwidth : 4;

   180 

   181     // extension: optional numerical base 2 - 36

   182     signed int base   : 7;

   183 

   184     // extension: optional parameter number

   185     long paramno;

   186 

   187     // optional width and precision

   188     int width;

   189     int prec;

   190 

   191     // extension: string argument

   192     char *strarg;

   193 

   194     // required conversion specifier

   195     int cvtspec;

   196 

   197     // extension: fill character

   198     int fill;

   199 

   200     union {

   201 

   202 #ifndef _RWSTD_NO_LONG_DOUBLE

   203 

   204         long double      ldbl;

   205 

   206 #endif   // _RWSTD_NO_LONG_DOUBLE

   207 

   208 #ifdef _RWSTD_LONG_LONG

   209 

   210         _RWSTD_LONG_LONG llong;

   211 

   212 #endif   // _RWSTD_LONG_LONG

   213 

   214         void*            ptr;

   215 

   216         int              i;

   217         long             lng;

   218 

   219         _RWSTD_INT32_T   i32;

   220 

   221 #ifdef _RWSTD_INT64_T

   222         _RWSTD_INT64_T   i64;

   223 #endif   // _RWSTD_INT64_T

   224 

   225         ptrdiff_t        diff;

   226         size_t           size;

   227         wint_t           wi;

   228 

   229         double           dbl;

   230         memptr_t         memptr;

   231         funptr_t         funptr;

   232     } param;

   233 };

   234 

   235 /********************************************************************/

   236 

   237 /*

   238 

   239   C99 format specifier:

   240 

   241   % flags width [ . prec ] mod cvtspec

   242 

   243 

   244   GNU glibc format specifier:

   245 

   246   % [ paramno $] flags width [ . prec ] mod cvtspec

   247   or

   248   % [ paramno $] flags width . * [ paramno $] mod cvtspec

   249 

   250 

   251   Extended format specifier:

   252 

   253   % { [ paramno $] [ flags ] [ width [. prec ]] mod cvtspec }

   254   or

   255   % { [ paramno $] [ flags ] [@ base [. width [. prec ]]] mod cvtspec }

   256   or

   257   % { $ envvar }

   258 

   259 

   260 */

   261 

   262 static int

   263 _rw_fmtspec (FmtSpec *pspec, bool ext, const char *fmt, va_list *pva)

   264 {

   265     assert (0 != pspec);

   266     assert (0 != fmt);

   267     assert (0 != pva);

   268 

   269     memset (pspec, 0, sizeof *pspec);

   270 

   271     pspec->iwidth  = -1;   // integer width not specified

   272     pspec->width   = -1;   // width not specified

   273     pspec->prec    = -1;   // precision not specified

   274     pspec->base    = -1;   // base not specified

   275     pspec->paramno = -1;   // paramno not specified

   276 

   277     const char* const fmtbeg = fmt;

   278 

   279     if (ext) {

   280         if ('$' == *fmt) {

   281 

   282             ++fmt;

   283 

   284             const char *str;

   285             if ('*' == *fmt) {

   286                 str = va_arg (*pva, char*);

   287                 if (!str)

   288                     str = "";

   289                 ++fmt;

   290             }

   291             else {

   292                 str  = fmt;

   293                 fmt += strlen (fmt);

   294             }

   295 

   296             char *tmp = (char*)malloc (strlen (str));

   297             pspec->strarg = strcpy (tmp, str);

   298 

   299             return int (fmt - fmtbeg);

   300         }

   301     }

   302 

   303     // extension: extract the parameter number (if followed by '$')

   304     if ('1' <= *fmt && *fmt <= '9') {

   305         char *end;

   306         const long tmp = strtol (fmt, &end, 10);

   307 

   308         fmt = end;

   309 

   310         if ('$' == *fmt) {

   311             pspec->paramno = tmp;

   312             ++fmt;

   313         }

   314         else {

   315             // when not followed by '$' interpret the number

   316             // as the width (i.e., that follows the empty set

   317             // of flags)

   318             pspec->width = int (tmp);

   319         }

   320     }

   321 

   322     if (-1 == pspec->width) {

   323         // extract any number of optional flags

   324         for ( ; ; ++fmt) {

   325             switch (*fmt) {

   326             case '-': pspec->fl_minus = true; continue;

   327             case '+': pspec->fl_plus = true; continue;

   328             case '#': pspec->fl_pound = true; continue;

   329             case ' ': pspec->fl_space = true; continue;

   330             case '0': pspec->fl_zero = true; continue;

   331             }

   332             break;

   333         }

   334     }

   335 

   336     if (ext && '@' == *fmt) {

   337 

   338         ++fmt;

   339 

   340         // extract the numerical base

   341         if ('0' <= fmt [1] && fmt [1] <= '9') {

   342             char *end;

   343             pspec->base = int (strtol (fmt, &end, 10));

   344             fmt         = end;

   345         }

   346         else if ('*' == *fmt) {

   347             pspec->base = va_arg (*pva, int);

   348             ++fmt;

   349         }

   350 

   351         if ('.' == *fmt)

   352             ++fmt;

   353     }

   354 

   355     if (-1 == pspec->width) {

   356         // extract the optional width

   357         if ('0' <= *fmt && *fmt <= '9') {

   358             char *end;

   359             pspec->width = int (strtol (fmt, &end, 10));

   360             fmt          = end;

   361         }

   362         else if ('*' == *fmt) {

   363             pspec->width = va_arg (*pva, int);

   364 

   365             if (pspec->width < 0) {

   366                 // 7.19.6.1, p5 of ISO/IEC 9899:1999:

   367                 //   A negative field width argument is taken

   368                 //   as a - flag followed by a positive field width.

   369                 pspec->width    = -pspec->width;

   370                 pspec->fl_minus = true;

   371             }

   372 

   373             ++fmt;

   374         }

   375     }

   376 

   377     // extract the optional precision

   378     if ('.' == *fmt) {

   379 

   380         ++fmt;

   381 

   382         if ('0' <= *fmt && *fmt <= '9') {

   383             char *end;

   384             pspec->prec = int (strtol (fmt, &end, 10));

   385             fmt         = end;

   386         }

   387         else if ('*' == *fmt) {

   388             pspec->prec = va_arg (*pva, int);

   389             ++fmt;

   390         }

   391     }

   392 

   393     // extract an optional modifier

   394     switch (*fmt) {

   395     case 'A':

   396         if (ext) {

   397             ++fmt;

   398             pspec->mod_A = true;

   399             break;

   400         }

   401         // fall thru

   402 

   403     case 'h':

   404         if ('h' == fmt [1]) {

   405             ++fmt;

   406             pspec->mod_hh = true;

   407         }

   408         else

   409             pspec->mod_h = true;

   410         ++fmt;

   411         break;

   412 

   413     case 'l':

   414         if ('l' == fmt [1]) {

   415             ++fmt;

   416             pspec->mod_ll = true;

   417         }

   418         else

   419             pspec->mod_l = true;

   420         ++fmt;

   421         break;

   422 

   423     case 'j': pspec->mod_j = true; ++fmt; break;

   424     case 'z': pspec->mod_z = true; ++fmt; break;

   425     case 't': pspec->mod_t = true; ++fmt; break;

   426     case 'L': pspec->mod_L = true; ++fmt; break;

   427 

   428     case 'I':

   429         if (ext) {

   430 

   431             ++fmt;

   432 

   433             if ('8' == *fmt) {

   434                 pspec->iwidth = 1;

   435                 ++fmt;

   436             }

   437             else if ('1' == fmt [0] && '6' == fmt [1]) {

   438                 pspec->iwidth = 2;

   439                 fmt += 2;

   440             }

   441             else if ('3' == fmt [0] && '2' == fmt [1]) {

   442                 pspec->iwidth = 3;

   443                 fmt += 2;

   444             }

   445             else if ('6' == fmt [0] && '4' == fmt [1]) {

   446                 pspec->iwidth = 4;

   447                 fmt += 2;

   448             }

   449             else {

   450                 pspec->mod_I = true;

   451             }

   452             break;

   453         }

   454     }

   455 

   456     pspec->cvtspec = *fmt;

   457 

   458     if (pspec->cvtspec)

   459         ++fmt;

   460 

   461     return int (fmt - fmtbeg);

   462 }

   463 

   464 /********************************************************************/

   465 

   466 _RWSTD_INTERNAL char*

   467 _rw_bufcat (char **pbuf, size_t *pbufsize, const char *str, size_t len)

   468 {

   469     assert (0 != pbuf);

   470     assert (0 != pbufsize);

   471 

   472           size_t buflen = *pbuf ? strlen (*pbuf) : 0;

   473     const size_t bufree = *pbuf ? *pbufsize - buflen : 0;

   474 

   475     if (bufree <= len || !*pbuf) {

   476 

   477         // for guard block

   478         static const char deadbeef[] = "\xde\xad\xbe\xef";

   479 

   480         size_t newbufsize = *pbufsize * 2 + 4;

   481 

   482         if (newbufsize <= buflen + len + 4)

   483             newbufsize = 2 * (buflen + len + 1) + 4;

   484 

   485         char* const newbuf = (char*)malloc (newbufsize);

   486 

   487         // return 0 on failure to allocate, let caller deal with it

   488         if (0 == newbuf)

   489             return 0;

   490 

   491         memcpy (newbuf, *pbuf, buflen);

   492 

   493         // append a guard block to the end of the buffer

   494         memcpy (newbuf + newbufsize - 4, deadbeef, 4);

   495 

   496         if (*pbuf) {

   497             // verify that we didn't write past the end of the buffer

   498             assert (0 == memcmp (*pbuf + *pbufsize, deadbeef, 4));

   499             free (*pbuf);

   500         }

   501 

   502         *pbuf     = newbuf;

   503         *pbufsize = newbufsize - 4;

   504 

   505         (*pbuf)[buflen] = '\0';

   506     }

   507 

   508     if (0 != str) {

   509         memcpy (*pbuf + buflen, str, len);

   510         buflen += len;

   511         (*pbuf)[buflen] = '\0';

   512     }

   513 

   514     return *pbuf + buflen;

   515 }

   516 

   517 /********************************************************************/

   518 

   519 // rw_asnprintf_cb is called to format a character string according

   520 // to the single format specifier `fmt' to the end of the provided

   521 // buffer `*pbuf'; the function can reallocate the buffer

   522 // returns the number of characters appended to the buffer

   523 extern int

   524 (*rw_vasnprintf_cb)(FmtSpec*, size_t, char**, size_t*, const char*, va_list*);

   525 

   526 /********************************************************************/

   527 

   528 static int

   529 _rw_vasnprintf_c99 (FmtSpec *pspec, size_t paramno,

   530                     char **pbuf, size_t *pbufsize, va_list *pva)

   531 {

   532     _RWSTD_UNUSED (paramno);

   533 

   534     _RWSTD_ASSERT (0 != pspec);

   535 

   536     int len = -1;

   537 

   538     FmtSpec &spec = pspec [paramno];

   539 

   540 #define PARAM(T, name)   \

   541   (0 < spec.paramno ? pspec [spec.paramno - 1].param.name : va_arg (*pva, T))

   542 

   543     switch (spec.cvtspec) {

   544 

   545     case 'd':

   546     case 'i':

   547     case 'o':

   548     case 'x':

   549     case 'X':

   550     case 'u':

   551         len = _rw_fmtinteger (pspec, paramno, pbuf, pbufsize, pva);

   552         break;

   553 

   554     case 'e':

   555     case 'E':

   556     case 'f':

   557     case 'F':

   558     case 'g':

   559     case 'G':

   560         if (spec.mod_L) {

   561             spec.param.ldbl = PARAM (long double, ldbl);

   562             len = _rw_fmtfloating (spec, pbuf, pbufsize, &spec.param.ldbl);

   563         }

   564         else {

   565             spec.param.dbl = PARAM (double, dbl);

   566             len = _rw_fmtfloating (spec, pbuf, pbufsize, &spec.param.dbl);

   567         }

   568         break;

   569 

   570     case 'a':

   571         assert (!"%a not implemented");

   572         break;

   573 

   574     case 'A':

   575         assert (!"%A not implemented");

   576         break;

   577 

   578     case 'c':

   579         // If no l length modifier is present, the int argument is converted

   580         // to an unsigned char, and the resulting character is written. If

   581         // an l length modifier is present, the wint_t argument is converted

   582         // as if by an ls conversion specification with no precision and an

   583         // argument that points to the initial element of a two-element array

   584         // of wchar_t, the first element containing the wint_t argument to

   585         // the lc conversion specification and the second a null wide

   586         // character.

   587         if (spec.mod_l) {

   588             spec.param.wi = PARAM (wint_t, wi);

   589             len = _rw_fmtwchr (spec, pbuf, pbufsize, spec.param.wi);

   590         }

   591         else {

   592             spec.param.i = PARAM (int, i);

   593             len = _rw_fmtchr (spec, pbuf, pbufsize, spec.param.i);

   594         }

   595         break;

   596 

   597     case 's':

   598         if (spec.mod_l) {

   599             spec.param.ptr = PARAM (wchar_t*, ptr);

   600             const wchar_t* const str = (wchar_t*)spec.param.ptr;

   601             len = _rw_fmtwstr (spec, pbuf, pbufsize, str, _RWSTD_SIZE_MAX);

   602         }

   603         else {

   604             spec.param.ptr = PARAM (char*, ptr);

   605             const char* const str = (char*)spec.param.ptr;

   606             len = _rw_fmtstr (spec, pbuf, pbufsize, str, _RWSTD_SIZE_MAX);

   607         }

   608         break;

   609 

   610     case 'p': {

   611         // The argument shall be a pointer to void. The value of the pointer

   612         // is converted to a sequence of printing characters, in an

   613         // implementation-defined manner.

   614         spec.param.ptr = PARAM (char*, ptr);

   615         len = _rw_fmtptr (spec, pbuf, pbufsize, spec.param.ptr);

   616         break;

   617     }

   618 

   619     case 'm': {   // %m (popular extension)

   620         spec.param.i = errno;

   621         len = _rw_fmterrno (spec, pbuf, pbufsize, spec.param.i);

   622         break;

   623     }

   624 

   625     case 'n': {

   626         // The argument shall be a pointer to signed integer into which

   627         // is written the number of characters written to the output

   628         // stream so far by this call to fprintf. No argument is converted,

   629         // but one is consumed. If the conversion specification includes

   630         // any flags, a field width, or a precision, the behavior is

   631         // undefined.

   632 

   633         assert (0 != pbuf);

   634         assert (0 != *pbuf);

   635 

   636         len = int (strlen (*pbuf));

   637 

   638         spec.param.ptr = PARAM (void*, ptr);

   639 

   640         if (spec.mod_hh) {

   641             unsigned char* const ptr = (unsigned char*)spec.param.ptr;

   642 

   643             assert (0 != ptr);

   644 

   645             *ptr = len;

   646         }

   647         else if (spec.mod_h) {

   648             short* const ptr = (short*)spec.param.ptr;

   649 

   650             assert (0 != ptr);

   651 

   652             *ptr = len;

   653         }

   654         else if (spec.mod_L) {

   655 #ifdef _RWSTD_LONG_LONG

   656             _RWSTD_LONG_LONG* const ptr = (_RWSTD_LONG_LONG*)spec.param.ptr;

   657 

   658             assert (0 != ptr);

   659 

   660             *ptr = len;

   661 #else   // if !defined (_RWSTD_LONG_LONG)

   662             assert (!"%Ln not implemented");

   663 #endif   // _RWSTD_LONG_LONG

   664         }

   665         else if (spec.mod_l) {

   666             long* const ptr = (long*)spec.param.ptr;

   667 

   668             assert (0 != ptr);

   669 

   670             *ptr = len;

   671         }

   672         else if (spec.mod_t) {

   673             ptrdiff_t* const ptr = (ptrdiff_t*)spec.param.ptr;

   674 

   675             assert (0 != ptr);

   676 

   677             *ptr = ptrdiff_t (unsigned (len));

   678         }

   679         else {

   680             int* const ptr = (int*)spec.param.ptr;

   681 

   682             assert (0 != ptr);

   683 

   684             *ptr = len;

   685         }

   686         break;

   687     }

   688 

   689     case '%':

   690         break;

   691     }

   692 

   693     return len;

   694 }

   695 

   696 /********************************************************************/

   697 

   698 _TEST_EXPORT int

   699 rw_vasnprintf (char **pbuf, size_t *pbufsize, const char *fmt, va_list varg)

   700 {

   701     va_list *pva;

   702 

   703 #ifdef va_copy

   704     // create a copy of va whose address can be passed to a function

   705     // taking a va_list* so that it can modify the original; note that

   706     // passing &va is not portable since when declared as a function

   707     // argument, va_list that is an array type decays into a pointer

   708     // and the address of the pointer will not match va_list* (as is

   709     // the case on EM64T)

   710     va_list vacpy;

   711     va_copy (vacpy, varg);

   712     pva = &vacpy;

   713 

   714 #else   // if !defined (va_copy)

   715 

   716 #  if 2 < __GNUG__

   717 

   718     // use the gcc 3.x builtin when the va_copy macro is not defined

   719     // (e.g., with gcc -ansi or Intel C++ icc -ansi or -strict_ansi)

   720     va_list vacpy;

   721     __builtin_va_copy (vacpy, varg);

   722     pva = &vacpy;

   723 

   724 #  else   // if !defined (__GNUG__)

   725 

   726     // use varg (in)directly and assume it's safe (e.g., HP aCC on PA)

   727     pva = &varg;

   728 

   729 #  endif   // 2 < __GNUG__

   730 

   731 #endif   // va_copy

   732 

   733 // do not use varg of vacpy below this point -- use *pva instead

   734 #define varg  DONT_TOUCH_ME

   735 #define vacpy DONT_TOUCH_ME

   736 

   737     assert (0 != pbuf);

   738 

   739     // save the initial value of `pbuf'

   740     char* const pbuf_save = *pbuf;

   741 

   742     if (*pbuf)

   743         **pbuf = '\0';

   744 

   745     // local buffer for a small number of conversion specifiers

   746     // will grow dynamically if their number exceeds its capacity

   747     FmtSpec specbuf [32];

   748     FmtSpec *pspec = specbuf;

   749 

   750     // local buffer for backtrack offsets implementing conditionals

   751     int backtrack [32];

   752     int nextoff = 0;

   753 

   754     size_t default_bufsize = 1024;

   755 

   756     if (0 == pbufsize)

   757         pbufsize = &default_bufsize;

   758 

   759     char fmtspec [64];

   760 

   761     char *next = *pbuf;

   762 

   763     size_t spec_bufsize = sizeof specbuf / sizeof *specbuf;

   764     size_t paramno = 0;

   765 

   766     for (const char *fc = fmt; *fc; ) {

   767 

   768         const char* const pcnt = strchr (fc, '%');

   769 

   770         size_t nchars = pcnt ? pcnt - fmt : strlen (fc);

   771 

   772         next = _rw_bufcat (pbuf, pbufsize, fmt, nchars);

   773         if (0 == next)

   774             goto fail;

   775 

   776         assert (0 != *pbuf);

   777         assert (0 != *pbufsize);

   778 

   779         if (0 == pcnt)

   780             break;

   781 

   782         fc = pcnt + 1;

   783 

   784         if ('%' == *fc) {

   785             // handle "%%"

   786             next = _rw_bufcat (pbuf, pbufsize, "%", 1);

   787             if (0 == next)

   788                 goto fail;

   789 

   790             fmt = ++fc;

   791             continue;

   792         }

   793 

   794         if (spec_bufsize == paramno) {

   795             // grow the buffer of conversion specifiers

   796             FmtSpec *tmp = (FmtSpec*)malloc (spec_bufsize * 2);

   797             if (tmp) {

   798                 memcpy (tmp, pspec, spec_bufsize);

   799                 if (pspec != specbuf)

   800                     free (pspec);

   801                 pspec = tmp;

   802             }

   803             else

   804                 goto fail;

   805         }

   806 

   807         if ('{' == *fc) {

   808             const char* const endbrace = strchr (++fc, '}');

   809 

   810             assert (0 != endbrace);

   811 

   812             const size_t fmtlen = endbrace - fc;

   813 

   814             memcpy (fmtspec, fc, fmtlen);

   815             fmtspec [fmtlen] = '\0';

   816 

   817             // compute the length of the buffer so far

   818             const size_t buflen = next - *pbuf;

   819 

   820             assert (0 != rw_vasnprintf_cb);

   821 

   822             // initiaze the current format specification, setting

   823             // all unused bits to 0

   824             const int speclen =

   825                 _rw_fmtspec (pspec + paramno, true, fc, pva);

   826 

   827             _RWSTD_UNUSED (speclen);

   828 

   829             // copy the current backtrack offset if one exists

   830             // and set the condition and condition true bits

   831             if (nextoff) {

   832 

   833                 // set the condition valid bit

   834                 pspec [paramno].cond = 1;

   835 

   836                 if (backtrack [nextoff - 1] < 0) {

   837                     // negative offset indicates an active clause

   838                     pspec [paramno].cond_true = 1;

   839                 }

   840                 else {

   841                     // non-negative offset indicates an inactive clause

   842                     // no-op

   843                 }

   844             }

   845 

   846             // append formatted string to the end of the buffer

   847             // reallocating it if necessary; callee may change

   848             // the specification as necessary (e.g., based on

   849             // the if/else clause)

   850 

   851             int len =

   852                 rw_vasnprintf_cb (pspec, paramno, pbuf, pbufsize,

   853                                   fmtspec, pva);

   854 

   855             // the callback returns a negative value on error

   856             if (len < 0)

   857                 goto fail;

   858 

   859             assert (size_t (len) < *pbufsize);

   860             assert (strlen (*pbuf) < *pbufsize);

   861 

   862             const size_t offinx = nextoff - 1;

   863 

   864             if (pspec [paramno].cond_end && pspec [paramno].cond_begin) {

   865                 // change from an if to an else clause

   866 

   867                 assert (0 < nextoff);

   868                 assert (0 == len);

   869 

   870                 if (pspec [paramno].cond_true) {

   871                     // change from an inactive if to an active else

   872                     // (same as the end of an inactive clause)

   873 

   874                     assert (0 <= backtrack [offinx]);

   875 

   876                     // set the length so as to backtrack to the position

   877                     // saved on the top of the backtrack stack 

   878                     len = -int (buflen) + backtrack [offinx];

   879 

   880                     // invert the offset to indicate an active clause

   881                     backtrack [offinx] = ~backtrack [offinx];

   882                 }

   883                 else {

   884                     // change from an active if to an inactive else

   885                     assert (backtrack [offinx] < 0);

   886 

   887                     // save the current length of the buffer

   888                     // as the new backtrack offset

   889                     backtrack [offinx] = int (buflen);

   890                 }

   891             }

   892             else if (pspec [paramno].cond_begin) {

   893                 // start of a new if clause

   894 

   895                 // push it on the stack of backtracking offsets using

   896                 // negative values to indicate active clauses and

   897                 // non-negative values inactive ones

   898                 if (pspec [paramno].cond_true)

   899                     backtrack [nextoff++] = ~int (buflen);

   900                 else

   901                     backtrack [nextoff++] = int (buflen);

   902             }

   903             else if (pspec [paramno].cond_end) {

   904                 // the end of an if/else clause

   905 

   906                 if (!pspec [paramno].cond_true) {

   907                     // the end of an inactive clause

   908 

   909                     assert (backtrack [offinx] <= int (buflen));

   910 

   911                     // set the length so as to backtrack to the position

   912                     // saved on the top of the backtrack stack 

   913                     len = -int (buflen) + backtrack [offinx];

   914                 }

   915 

   916                 // pop it off the top of the stack

   917                 --nextoff;

   918             }

   919 

   920             assert (len + buflen < *pbufsize);

   921 

   922             // adjust the next pointer to point to the terminating

   923             // NUL in the (possibly reallocated) buffer

   924             next  = *pbuf + buflen + len;

   925             *next = '\0';

   926             fc    = endbrace + 1;

   927         }

   928         else {

   929             const int speclen =

   930                 _rw_fmtspec (pspec + paramno, false, fc, pva);

   931 

   932             if (speclen) {

   933 

   934                 const int len =

   935                     _rw_vasnprintf_c99 (pspec, paramno, pbuf, pbufsize, pva);

   936 

   937                 if (-1 == len)

   938                     goto fail;

   939 

   940                 // discard positional specifiers

   941                 if (-1 == pspec [paramno].paramno)

   942                     ++paramno;

   943 

   944                 next = _rw_bufcat (pbuf, pbufsize, 0, size_t (len));

   945                 if (0 == next)

   946                     goto fail;

   947 

   948                 next += len;

   949                 fc   += speclen;

   950             }

   951             else {

   952                 next = _rw_bufcat (pbuf, pbufsize, "%", 1);

   953                 if (0 == next)

   954                     goto fail;

   955             }

   956         }

   957 

   958         fmt = fc;

   959     }

   960 

   961     // deallocate if dynamically allocated

   962     if (pspec != specbuf)

   963         free (pspec);

   964 

   965     return int (next - *pbuf);

   966 

   967 fail: // function failed

   968 

   969     fprintf (stderr, "%s:%d: rw_vasnprintf(%p, %p, \"%s\", va_list) "

   970              "error: errno = %d: %s\n",

   971              __FILE__, __LINE__, (void*)pbuf, (void*)pbufsize, fmt,

   972              errno, strerror (errno));

   973 

   974     if (pspec != specbuf)

   975         free (pspec);

   976 

   977     if (*pbuf != pbuf_save) {

   978         // free any allocated memory

   979         free (*pbuf);

   980         *pbuf = 0;

   981     }

   982 

   983     return -1;

   984 

   985 #undef varg

   986 #undef vacpy

   987 

   988 }

   989 

   990 /********************************************************************/

   991 

   992 static const char _rw_digits[] = {

   993     "0123456789abcdefghijklmnopqrstuvwxyz"

   994     "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

   995 };

   996 

   997 static int

   998 _rw_fmtlong (const FmtSpec &spec, char **pbuf, size_t *pbufsize, long val)

   999 {

  1000     char buffer [130];   // big enough for a 128-bit long in base 2

  1001     char *end = buffer;

  1002 

  1003     long upoff = 0;

  1004     const char *pfx = 0;

  1005 

  1006     if ('X' == spec.cvtspec)

  1007         upoff  = 36;

  1008 

  1009     if (spec.fl_pound) {

  1010         if (16 == spec.base)

  1011             pfx = upoff ? "0X" : "0x";

  1012         else if (8 == spec.base && val)

  1013             pfx = "0";

  1014     }

  1015 

  1016     const int base = 1 < spec.base && spec.base < 37 ? spec.base : 10;

  1017 

  1018     typedef unsigned long ULong;

  1019 

  1020     ULong uval;

  1021 

  1022     bool neg;

  1023 

  1024     if (val < 0) {

  1025         neg  = 'd' == spec.cvtspec || 'i' == spec.cvtspec;

  1026         uval = ULong (neg ? -val : val);

  1027     }

  1028     else {

  1029         neg  = false;

  1030         uval = ULong (val);

  1031     }

  1032 

  1033     do {

  1034         *end++ = _rw_digits [upoff + uval % base];

  1035     } while (uval /= base);

  1036 

  1037     int size = int (end - buffer);

  1038 

  1039     // insert as many zeros as specified by precision

  1040     if (-1 < spec.prec && size < spec.prec) {

  1041         // FIXME: prevent buffer overrun

  1042         for (int i = size; i != spec.prec; ++i)

  1043             *end++ = '0';

  1044     }

  1045 

  1046     // insert octal or hex prefix for non-zero values

  1047     if (pfx && val) {

  1048         if (pfx [1])

  1049             *end++ = pfx [1];

  1050         *end++ = pfx [0];

  1051     }

  1052 

  1053     if (neg)

  1054         *end++ = '-';

  1055     else if (spec.fl_plus && ('d' == spec.cvtspec || 'i' == spec.cvtspec))

  1056         *end++ = '+';

  1057 

  1058     if (0 == spec.prec && 0 == val) {

  1059         // 7.19.6.1 of ISO/IEC 9899:1999:

  1060         //   The result of converting a zero value with a precision

  1061         //   of zero is no characters.

  1062         end = buffer;

  1063     }

  1064 

  1065     *end = '\0';

  1066 

  1067     size = int (end - buffer);

  1068 

  1069     for (char *pc = buffer; pc < end; ++pc) {

  1070         const char tmp = *pc;

  1071         *pc = *--end;

  1072         *end = tmp;

  1073     }

  1074 

  1075     // reset precision to -1 (already handled above)

  1076     FmtSpec newspec (spec);

  1077     newspec.fl_pound = 0;

  1078     newspec.prec = -1;

  1079 

  1080     // handle justification by formatting the resulting string

  1081     return _rw_fmtstr (newspec, pbuf, pbufsize, buffer, size_t (size));

  1082 }

  1083 

  1084 /********************************************************************/

  1085 

  1086 #ifdef _RWSTD_LONG_LONG

  1087 

  1088 static int

  1089 _rw_fmtllong (const FmtSpec &spec,

  1090              char **pbuf, size_t *pbufsize, _RWSTD_LONG_LONG val)

  1091 {

  1092     char buffer [130];   // big enough for a 128-bit long long in base 2

  1093     char *end = buffer;

  1094 

  1095     long upoff = 0;

  1096     const char *pfx = 0;

  1097 

  1098     if ('X' == spec.cvtspec)

  1099         upoff  = 36;

  1100 

  1101     if (spec.fl_pound) {

  1102         if (16 == spec.base)

  1103             pfx = upoff ? "0X" : "0x";

  1104         else if (8 == spec.base && val)

  1105             pfx = "0";

  1106     }

  1107 

  1108     const int base = 1 < spec.base && spec.base < 37 ? spec.base : 10;

  1109 

  1110     typedef unsigned _RWSTD_LONG_LONG ULLong;

  1111 

  1112     ULLong uval;

  1113 

  1114     bool neg;

  1115 

  1116     if (val < 0) {

  1117         neg  = 'd' == spec.cvtspec || 'i' == spec.cvtspec;

  1118         uval = ULLong (neg ? -val : val);

  1119     }

  1120     else {

  1121         neg  = false;

  1122         uval = ULLong (val);

  1123     }

  1124 

  1125     do {

  1126         *end++ = _rw_digits [upoff + uval % base];

  1127     } while (uval /= base);

  1128 

  1129     if (pfx) {

  1130         if (pfx [1])

  1131             *end++ = pfx [1];

  1132         *end++ = pfx [0];

  1133     }

  1134