src/printf.c

   1 /*
   2 ** The "printf" code that follows dates from the 1980's.  It is in
   3 ** the public domain.
   4 **
   5 **************************************************************************
   6 **
   7 ** This file contains code for a set of "printf"-like routines.  These
   8 ** routines format strings much like the printf() from the standard C
   9 ** library, though the implementation here has enhancements to support
  10 ** SQLite.
  11 */
  12 #include "sqliteInt.h"
  13
  14 /*
  15 ** Conversion types fall into various categories as defined by the
  16 ** following enumeration.
  17 */
  18 #define etRADIX       0 /* non-decimal integer types.  %x %o */
  19 #define etFLOAT       1 /* Floating point.  %f */
  20 #define etEXP         2 /* Exponentional notation. %e and %E */
  21 #define etGENERIC     3 /* Floating or exponential, depending on exponent. %g */
  22 #define etSIZE        4 /* Return number of characters processed so far. %n */
  23 #define etSTRING      5 /* Strings. %s */
  24 #define etDYNSTRING   6 /* Dynamically allocated strings. %z */
  25 #define etPERCENT     7 /* Percent symbol. %% */
  26 #define etCHARX       8 /* Characters. %c */
  27 /* The rest are extensions, not normally found in printf() */
  28 #define etSQLESCAPE   9 /* Strings with '\'' doubled.  %q */
  29 #define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '',
  30                           NULL pointers replaced by SQL NULL.  %Q */
  31 #define etTOKEN      11 /* a pointer to a Token structure */
  32 #define etSRCLIST    12 /* a pointer to a SrcList */
  33 #define etPOINTER    13 /* The %p conversion */
  34 #define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
  35 #define etORDINAL    15 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */
  36 #define etDECIMAL    16 /* %d or %u, but not %x, %o */
  37
  38 #define etINVALID    17 /* Any unrecognized conversion type */
  39
  40
  41 /*
  42 ** An "etByte" is an 8-bit unsigned value.
  43 */
  44 typedef unsigned char etByte;
  45
  46 /*
  47 ** Each builtin conversion character (ex: the 'd' in "%d") is described
  48 ** by an instance of the following structure
  49 */
  50 typedef struct et_info {   /* Information about each format field */
  51   char fmttype;            /* The format field code letter */
  52   etByte base;             /* The base for radix conversion */
  53   etByte flags;            /* One or more of FLAG_ constants below */
  54   etByte type;             /* Conversion paradigm */
  55   etByte charset;          /* Offset into aDigits[] of the digits string */
  56   etByte prefix;           /* Offset into aPrefix[] of the prefix string */
  57 } et_info;
  58
  59 /*
  60 ** Allowed values for et_info.flags
  61 */
  62 #define FLAG_SIGNED    1     /* True if the value to convert is signed */
  63 #define FLAG_STRING    4     /* Allow infinite precision */
  64
  65
  66 /*
  67 ** The following table is searched linearly, so it is good to put the
  68 ** most frequently used conversion types first.
  69 */
  70 static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
  71 static const char aPrefix[] = "-x0\000X0";
  72 static const et_info fmtinfo[] = {
  73   {  'd', 10, 1, etDECIMAL,    0,  0 },
  74   {  's',  0, 4, etSTRING,     0,  0 },
  75   {  'g',  0, 1, etGENERIC,    30, 0 },
  76   {  'z',  0, 4, etDYNSTRING,  0,  0 },
  77   {  'q',  0, 4, etSQLESCAPE,  0,  0 },
  78   {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },
  79   {  'w',  0, 4, etSQLESCAPE3, 0,  0 },
  80   {  'c',  0, 0, etCHARX,      0,  0 },
  81   {  'o',  8, 0, etRADIX,      0,  2 },
  82   {  'u', 10, 0, etDECIMAL,    0,  0 },
  83   {  'x', 16, 0, etRADIX,      16, 1 },
  84   {  'X', 16, 0, etRADIX,      0,  4 },
  85 #ifndef SQLITE_OMIT_FLOATING_POINT
  86   {  'f',  0, 1, etFLOAT,      0,  0 },
  87   {  'e',  0, 1, etEXP,        30, 0 },
  88   {  'E',  0, 1, etEXP,        14, 0 },
  89   {  'G',  0, 1, etGENERIC,    14, 0 },
  90 #endif
  91   {  'i', 10, 1, etDECIMAL,    0,  0 },
  92   {  'n',  0, 0, etSIZE,       0,  0 },
  93   {  '%',  0, 0, etPERCENT,    0,  0 },
  94   {  'p', 16, 0, etPOINTER,    0,  1 },
  95
  96   /* All the rest are undocumented and are for internal use only */
  97   {  'T',  0, 0, etTOKEN,      0,  0 },
  98   {  'S',  0, 0, etSRCLIST,    0,  0 },
  99   {  'r', 10, 1, etORDINAL,    0,  0 },
 100 };
 101
 102 /* Floating point constants used for rounding */
 103 static const double arRound[] = {
 104   5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05,
 105   5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10,
 106 };
 107
 108 /*
 109 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
 110 ** conversions will work.
 111 */
 112 #ifndef SQLITE_OMIT_FLOATING_POINT
 113 /*
 114 ** "*val" is a double such that 0.1 <= *val < 10.0
 115 ** Return the ascii code for the leading digit of *val, then
 116 ** multiply "*val" by 10.0 to renormalize.
 117 **
 118 ** Example:
 119 **     input:     *val = 3.14159
 120 **     output:    *val = 1.4159    function return = '3'
 121 **
 122 ** The counter *cnt is incremented each time.  After counter exceeds
 123 ** 16 (the number of significant digits in a 64-bit float) '0' is
 124 ** always returned.
 125 */
 126 static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
 127   int digit;
 128   LONGDOUBLE_TYPE d;
 129   if( (*cnt)<=0 ) return '0';
 130   (*cnt)--;
 131   digit = (int)*val;
 132   d = digit;
 133   digit += '0';
 134   *val = (*val - d)*10.0;
 135   return (char)digit;
 136 }
 137 #endif /* SQLITE_OMIT_FLOATING_POINT */
 138
 139 /*
 140 ** Set the StrAccum object to an error mode.
 141 */
 142 static void setStrAccumError(StrAccum *p, u8 eError){
 143   assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG );
 144   p->accError = eError;
 145   if( p->mxAlloc ) sqlite3_str_reset(p);
 146   if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError);
 147 }
 148
 149 /*
 150 ** Extra argument values from a PrintfArguments object
 151 */
 152 static sqlite3_int64 getIntArg(PrintfArguments *p){
 153   if( p->nArg<=p->nUsed ) return 0;
 154   return sqlite3_value_int64(p->apArg[p->nUsed++]);
 155 }
 156 static double getDoubleArg(PrintfArguments *p){
 157   if( p->nArg<=p->nUsed ) return 0.0;
 158   return sqlite3_value_double(p->apArg[p->nUsed++]);
 159 }
 160 static char *getTextArg(PrintfArguments *p){
 161   if( p->nArg<=p->nUsed ) return 0;
 162   return (char*)sqlite3_value_text(p->apArg[p->nUsed++]);
 163 }
 164
 165 /*
 166 ** Allocate memory for a temporary buffer needed for printf rendering.
 167 **
 168 ** If the requested size of the temp buffer is larger than the size
 169 ** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error.
 170 ** Do the size check before the memory allocation to prevent rogue
 171 ** SQL from requesting large allocations using the precision or width
 172 ** field of the printf() function.
 173 */
 174 static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){
 175   char *z;
 176   if( pAccum->accError ) return 0;
 177   if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){
 178     setStrAccumError(pAccum, SQLITE_TOOBIG);
 179     return 0;
 180   }
 181   z = sqlite3DbMallocRaw(pAccum->db, n);
 182   if( z==0 ){
 183     setStrAccumError(pAccum, SQLITE_NOMEM);
 184   }
 185   return z;
 186 }
 187
 188 /*
 189 ** On machines with a small stack size, you can redefine the
 190 ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
 191 */
 192 #ifndef SQLITE_PRINT_BUF_SIZE
 193 # define SQLITE_PRINT_BUF_SIZE 70
 194 #endif
 195 #define etBUFSIZE SQLITE_PRINT_BUF_SIZE  /* Size of the output buffer */
 196
 197 /*
 198 ** Hard limit on the precision of floating-point conversions.
 199 */
 200 #ifndef SQLITE_PRINTF_PRECISION_LIMIT
 201 # define SQLITE_FP_PRECISION_LIMIT 100000000
 202 #endif
 203
 204 /*
 205 ** Render a string given by "fmt" into the StrAccum object.
 206 */
 207 void sqlite3_str_vappendf(
 208   sqlite3_str *pAccum,       /* Accumulate results here */
 209   const char *fmt,           /* Format string */
 210   va_list ap                 /* arguments */
 211 ){
 212   int c;                     /* Next character in the format string */
 213   char *bufpt;               /* Pointer to the conversion buffer */
 214   int precision;             /* Precision of the current field */
 215   int length;                /* Length of the field */
 216   int idx;                   /* A general purpose loop counter */
 217   int width;                 /* Width of the current field */
 218   etByte flag_leftjustify;   /* True if "-" flag is present */
 219   etByte flag_prefix;        /* '+' or ' ' or 0 for prefix */
 220   etByte flag_alternateform; /* True if "#" flag is present */
 221   etByte flag_altform2;      /* True if "!" flag is present */
 222   etByte flag_zeropad;       /* True if field width constant starts with zero */
 223   etByte flag_long;          /* 1 for the "l" flag, 2 for "ll", 0 by default */
 224   etByte done;               /* Loop termination flag */
 225   etByte cThousand;          /* Thousands separator for %d and %u */
 226   etByte xtype = etINVALID;  /* Conversion paradigm */
 227   u8 bArgList;               /* True for SQLITE_PRINTF_SQLFUNC */
 228   char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
 229   sqlite_uint64 longvalue;   /* Value for integer types */
 230   LONGDOUBLE_TYPE realvalue; /* Value for real types */
 231   const et_info *infop;      /* Pointer to the appropriate info structure */
 232   char *zOut;                /* Rendering buffer */
 233   int nOut;                  /* Size of the rendering buffer */
 234   char *zExtra = 0;          /* Malloced memory used by some conversion */
 235 #ifndef SQLITE_OMIT_FLOATING_POINT
 236   int  exp, e2;              /* exponent of real numbers */
 237   int nsd;                   /* Number of significant digits returned */
 238   double rounder;            /* Used for rounding floating point values */
 239   etByte flag_dp;            /* True if decimal point should be shown */
 240   etByte flag_rtz;           /* True if trailing zeros should be removed */
 241 #endif
 242   PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
 243   char buf[etBUFSIZE];       /* Conversion buffer */
 244
 245   /* pAccum never starts out with an empty buffer that was obtained from
 246   ** malloc().  This precondition is required by the mprintf("%z...")
 247   ** optimization. */
 248   assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
 249
 250   bufpt = 0;
 251   if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){
 252     pArgList = va_arg(ap, PrintfArguments*);
 253     bArgList = 1;
 254   }else{
 255     bArgList = 0;
 256   }
 257   for(; (c=(*fmt))!=0; ++fmt){
 258     if( c!='%' ){
 259       bufpt = (char *)fmt;
 260 #if HAVE_STRCHRNUL
 261       fmt = strchrnul(fmt, '%');
 262 #else
 263       do{ fmt++; }while( *fmt && *fmt != '%' );
 264 #endif
 265       sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt));
 266       if( *fmt==0 ) break;
 267     }
 268     if( (c=(*++fmt))==0 ){
 269       sqlite3_str_append(pAccum, "%", 1);
 270       break;
 271     }
 272     /* Find out what flags are present */
 273     flag_leftjustify = flag_prefix = cThousand =
 274      flag_alternateform = flag_altform2 = flag_zeropad = 0;
 275     done = 0;
 276     width = 0;
 277     flag_long = 0;
 278     precision = -1;
 279     do{
 280       switch( c ){
 281         case '-':   flag_leftjustify = 1;     break;
 282         case '+':   flag_prefix = '+';        break;
 283         case ' ':   flag_prefix = ' ';        break;
 284         case '#':   flag_alternateform = 1;   break;
 285         case '!':   flag_altform2 = 1;        break;
 286         case '0':   flag_zeropad = 1;         break;
 287         case ',':   cThousand = ',';          break;
 288         default:    done = 1;                 break;
 289         case 'l': {
 290           flag_long = 1;
 291           c = *++fmt;
 292           if( c=='l' ){
 293             c = *++fmt;
 294             flag_long = 2;
 295           }
 296           done = 1;
 297           break;
 298         }
 299         case '1': case '2': case '3': case '4': case '5':
 300         case '6': case '7': case '8': case '9': {
 301           unsigned wx = c - '0';
 302           while( (c = *++fmt)>='0' && c<='9' ){
 303             wx = wx*10 + c - '0';
 304           }
 305           testcase( wx>0x7fffffff );
 306           width = wx & 0x7fffffff;
 307 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
 308           if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
 309             width = SQLITE_PRINTF_PRECISION_LIMIT;
 310           }
 311 #endif
 312           if( c!='.' && c!='l' ){
 313             done = 1;
 314           }else{
 315             fmt--;
 316           }
 317           break;
 318         }
 319         case '*': {
 320           if( bArgList ){
 321             width = (int)getIntArg(pArgList);
 322           }else{
 323             width = va_arg(ap,int);
 324           }
 325           if( width<0 ){
 326             flag_leftjustify = 1;
 327             width = width >= -2147483647 ? -width : 0;
 328           }
 329 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
 330           if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
 331             width = SQLITE_PRINTF_PRECISION_LIMIT;
 332           }
 333 #endif
 334           if( (c = fmt[1])!='.' && c!='l' ){
 335             c = *++fmt;
 336             done = 1;
 337           }
 338           break;
 339         }
 340         case '.': {
 341           c = *++fmt;
 342           if( c=='*' ){
 343             if( bArgList ){
 344               precision = (int)getIntArg(pArgList);
 345             }else{
 346               precision = va_arg(ap,int);
 347             }
 348             if( precision<0 ){
 349               precision = precision >= -2147483647 ? -precision : -1;
 350             }
 351             c = *++fmt;
 352           }else{
 353             unsigned px = 0;
 354             while( c>='0' && c<='9' ){
 355               px = px*10 + c - '0';
 356               c = *++fmt;
 357             }
 358             testcase( px>0x7fffffff );
 359             precision = px & 0x7fffffff;
 360           }
 361 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
 362           if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){
 363             precision = SQLITE_PRINTF_PRECISION_LIMIT;
 364           }
 365 #endif
 366           if( c=='l' ){
 367             --fmt;
 368           }else{
 369             done = 1;
 370           }
 371           break;
 372         }
 373       }
 374     }while( !done && (c=(*++fmt))!=0 );
 375
 376     /* Fetch the info entry for the field */
 377     infop = &fmtinfo[0];
 378     xtype = etINVALID;
 379     for(idx=0; idx<ArraySize(fmtinfo); idx++){
 380       if( c==fmtinfo[idx].fmttype ){
 381         infop = &fmtinfo[idx];
 382         xtype = infop->type;
 383         break;
 384       }
 385     }
 386
 387     /*
 388     ** At this point, variables are initialized as follows:
 389     **
 390     **   flag_alternateform          TRUE if a '#' is present.
 391     **   flag_altform2               TRUE if a '!' is present.
 392     **   flag_prefix                 '+' or ' ' or zero
 393     **   flag_leftjustify            TRUE if a '-' is present or if the
 394     **                               field width was negative.
 395     **   flag_zeropad                TRUE if the width began with 0.
 396     **   flag_long                   1 for "l", 2 for "ll"
 397     **   width                       The specified field width.  This is
 398     **                               always non-negative.  Zero is the default.
 399     **   precision                   The specified precision.  The default
 400     **                               is -1.
 401     **   xtype                       The class of the conversion.
 402     **   infop                       Pointer to the appropriate info struct.
 403     */
 404     assert( width>=0 );
 405     assert( precision>=(-1) );
 406     switch( xtype ){
 407       case etPOINTER:
 408         flag_long = sizeof(char*)==sizeof(i64) ? 2 :
 409                      sizeof(char*)==sizeof(long int) ? 1 : 0;
 410         /* Fall through into the next case */
 411       case etORDINAL:
 412       case etRADIX:
 413         cThousand = 0;
 414         /* Fall through into the next case */
 415       case etDECIMAL:
 416         if( infop->flags & FLAG_SIGNED ){
 417           i64 v;
 418           if( bArgList ){
 419             v = getIntArg(pArgList);
 420           }else if( flag_long ){
 421             if( flag_long==2 ){
 422               v = va_arg(ap,i64) ;
 423             }else{
 424               v = va_arg(ap,long int);
 425             }
 426           }else{
 427             v = va_arg(ap,int);
 428           }
 429           if( v<0 ){
 430             if( v==SMALLEST_INT64 ){
 431               longvalue = ((u64)1)<<63;
 432             }else{
 433               longvalue = -v;
 434             }
 435             prefix = '-';
 436           }else{
 437             longvalue = v;
 438             prefix = flag_prefix;
 439           }
 440         }else{
 441           if( bArgList ){
 442             longvalue = (u64)getIntArg(pArgList);
 443           }else if( flag_long ){
 444             if( flag_long==2 ){
 445               longvalue = va_arg(ap,u64);
 446             }else{
 447               longvalue = va_arg(ap,unsigned long int);
 448             }
 449           }else{
 450             longvalue = va_arg(ap,unsigned int);
 451           }
 452           prefix = 0;
 453         }
 454         if( longvalue==0 ) flag_alternateform = 0;
 455         if( flag_zeropad && precision<width-(prefix!=0) ){
 456           precision = width-(prefix!=0);
 457         }
 458         if( precision<etBUFSIZE-10-etBUFSIZE/3 ){
 459           nOut = etBUFSIZE;
 460           zOut = buf;
 461         }else{
 462           u64 n;
 463           n = (u64)precision + 10;
 464           if( cThousand ) n += precision/3;
 465           zOut = zExtra = printfTempBuf(pAccum, n);
 466           if( zOut==0 ) return;
 467           nOut = (int)n;
 468         }
 469         bufpt = &zOut[nOut-1];
 470         if( xtype==etORDINAL ){
 471           static const char zOrd[] = "thstndrd";
 472           int x = (int)(longvalue % 10);
 473           if( x>=4 || (longvalue/10)%10==1 ){
 474             x = 0;
 475           }
 476           *(--bufpt) = zOrd[x*2+1];
 477           *(--bufpt) = zOrd[x*2];
 478         }
 479         {
 480           const char *cset = &aDigits[infop->charset];
 481           u8 base = infop->base;
 482           do{                                           /* Convert to ascii */
 483             *(--bufpt) = cset[longvalue%base];
 484             longvalue = longvalue/base;
 485           }while( longvalue>0 );
 486         }
 487         length = (int)(&zOut[nOut-1]-bufpt);
 488         while( precision>length ){
 489           *(--bufpt) = '0';                             /* Zero pad */
 490           length++;
 491         }
 492         if( cThousand ){
 493           int nn = (length - 1)/3;  /* Number of "," to insert */
 494           int ix = (length - 1)%3 + 1;
 495           bufpt -= nn;
 496           for(idx=0; nn>0; idx++){
 497             bufpt[idx] = bufpt[idx+nn];
 498             ix--;
 499             if( ix==0 ){
 500               bufpt[++idx] = cThousand;
 501               nn--;
 502               ix = 3;
 503             }
 504           }
 505         }
 506         if( prefix ) *(--bufpt) = prefix;               /* Add sign */
 507         if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
 508           const char *pre;
 509           char x;
 510           pre = &aPrefix[infop->prefix];
 511           for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
 512         }
 513         length = (int)(&zOut[nOut-1]-bufpt);
 514         break;
 515       case etFLOAT:
 516       case etEXP:
 517       case etGENERIC:
 518         if( bArgList ){
 519           realvalue = getDoubleArg(pArgList);
 520         }else{
 521           realvalue = va_arg(ap,double);
 522         }
 523 #ifdef SQLITE_OMIT_FLOATING_POINT
 524         length = 0;
 525 #else
 526         if( precision<0 ) precision = 6;         /* Set default precision */
 527 #ifdef SQLITE_FP_PRECISION_LIMIT
 528         if( precision>SQLITE_FP_PRECISION_LIMIT ){
 529           precision = SQLITE_FP_PRECISION_LIMIT;
 530         }
 531 #endif
 532         if( realvalue<0.0 ){
 533           realvalue = -realvalue;
 534           prefix = '-';
 535         }else{
 536           prefix = flag_prefix;
 537         }
 538         if( xtype==etGENERIC && precision>0 ) precision--;
 539         testcase( precision>0xfff );
 540         idx = precision & 0xfff;
 541         rounder = arRound[idx%10];
 542         while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; }
 543         if( xtype==etFLOAT ){
 544           double rx = (double)realvalue;
 545           sqlite3_uint64 u;
 546           int ex;
 547           memcpy(&u, &rx, sizeof(u));
 548           ex = -1023 + (int)((u>>52)&0x7ff);
 549           if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16;
 550           realvalue += rounder;
 551         }
 552         /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
 553         exp = 0;
 554         if( sqlite3IsNaN((double)realvalue) ){
 555           bufpt = "NaN";
 556           length = 3;
 557           break;
 558         }
 559         if( realvalue>0.0 ){
 560           LONGDOUBLE_TYPE scale = 1.0;
 561           while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;}
 562           while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; }
 563           while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; }
 564           realvalue /= scale;
 565           while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
 566           while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
 567           if( exp>350 ){
 568             bufpt = buf;
 569             buf[0] = prefix;
 570             memcpy(buf+(prefix!=0),"Inf",4);
 571             length = 3+(prefix!=0);
 572             break;
 573           }
 574         }
 575         bufpt = buf;
 576         /*
 577         ** If the field type is etGENERIC, then convert to either etEXP
 578         ** or etFLOAT, as appropriate.
 579         */
 580         if( xtype!=etFLOAT ){
 581           realvalue += rounder;
 582           if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
 583         }
 584         if( xtype==etGENERIC ){
 585           flag_rtz = !flag_alternateform;
 586           if( exp<-4 || exp>precision ){
 587             xtype = etEXP;
 588           }else{
 589             precision = precision - exp;
 590             xtype = etFLOAT;
 591           }
 592         }else{
 593           flag_rtz = flag_altform2;
 594         }
 595         if( xtype==etEXP ){
 596           e2 = 0;
 597         }else{
 598           e2 = exp;
 599         }
 600         {
 601           i64 szBufNeeded;           /* Size of a temporary buffer needed */
 602           szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15;
 603           if( szBufNeeded > etBUFSIZE ){
 604             bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded);
 605             if( bufpt==0 ) return;
 606           }
 607         }
 608         zOut = bufpt;
 609         nsd = 16 + flag_altform2*10;
 610         flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
 611         /* The sign in front of the number */
 612         if( prefix ){
 613           *(bufpt++) = prefix;
 614         }
 615         /* Digits prior to the decimal point */
 616         if( e2<0 ){
 617           *(bufpt++) = '0';
 618         }else{
 619           for(; e2>=0; e2--){
 620             *(bufpt++) = et_getdigit(&realvalue,&nsd);
 621           }
 622         }
 623         /* The decimal point */
 624         if( flag_dp ){
 625           *(bufpt++) = '.';
 626         }
 627         /* "0" digits after the decimal point but before the first
 628         ** significant digit of the number */
 629         for(e2++; e2<0; precision--, e2++){
 630           assert( precision>0 );
 631           *(bufpt++) = '0';
 632         }
 633         /* Significant digits after the decimal point */
 634         while( (precision--)>0 ){
 635           *(bufpt++) = et_getdigit(&realvalue,&nsd);
 636         }
 637         /* Remove trailing zeros and the "." if no digits follow the "." */
 638         if( flag_rtz && flag_dp ){
 639           while( bufpt[-1]=='0' ) *(--bufpt) = 0;
 640           assert( bufpt>zOut );
 641           if( bufpt[-1]=='.' ){
 642             if( flag_altform2 ){
 643               *(bufpt++) = '0';
 644             }else{
 645               *(--bufpt) = 0;
 646             }
 647           }
 648         }
 649         /* Add the "eNNN" suffix */
 650         if( xtype==etEXP ){
 651           *(bufpt++) = aDigits[infop->charset];
 652           if( exp<0 ){
 653             *(bufpt++) = '-'; exp = -exp;
 654           }else{
 655             *(bufpt++) = '+';
 656           }
 657           if( exp>=100 ){
 658             *(bufpt++) = (char)((exp/100)+'0');        /* 100's digit */
 659             exp %= 100;
 660           }
 661           *(bufpt++) = (char)(exp/10+'0');             /* 10's digit */
 662           *(bufpt++) = (char)(exp%10+'0');             /* 1's digit */
 663         }
 664         *bufpt = 0;
 665
 666         /* The converted number is in buf[] and zero terminated. Output it.
 667         ** Note that the number is in the usual order, not reversed as with
 668         ** integer conversions. */
 669         length = (int)(bufpt-zOut);
 670         bufpt = zOut;
 671
 672         /* Special case:  Add leading zeros if the flag_zeropad flag is
 673         ** set and we are not left justified */
 674         if( flag_zeropad && !flag_leftjustify && length < width){
 675           int i;
 676           int nPad = width - length;
 677           for(i=width; i>=nPad; i--){
 678             bufpt[i] = bufpt[i-nPad];
 679           }
 680           i = prefix!=0;
 681           while( nPad-- ) bufpt[i++] = '0';
 682           length = width;
 683         }
 684 #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
 685         break;
 686       case etSIZE:
 687         if( !bArgList ){
 688           *(va_arg(ap,int*)) = pAccum->nChar;
 689         }
 690         length = width = 0;
 691         break;
 692       case etPERCENT:
 693         buf[0] = '%';
 694         bufpt = buf;
 695         length = 1;
 696         break;
 697       case etCHARX:
 698         if( bArgList ){
 699           bufpt = getTextArg(pArgList);
 700           length = 1;
 701           if( bufpt ){
 702             buf[0] = c = *(bufpt++);
 703             if( (c&0xc0)==0xc0 ){
 704               while( length<4 && (bufpt[0]&0xc0)==0x80 ){
 705                 buf[length++] = *(bufpt++);
 706               }
 707             }
 708           }else{
 709             buf[0] = 0;
 710           }
 711         }else{
 712           unsigned int ch = va_arg(ap,unsigned int);
 713           if( ch<0x00080 ){
 714             buf[0] = ch & 0xff;
 715             length = 1;
 716           }else if( ch<0x00800 ){
 717             buf[0] = 0xc0 + (u8)((ch>>6)&0x1f);
 718             buf[1] = 0x80 + (u8)(ch & 0x3f);
 719             length = 2;
 720           }else if( ch<0x10000 ){
 721             buf[0] = 0xe0 + (u8)((ch>>12)&0x0f);
 722             buf[1] = 0x80 + (u8)((ch>>6) & 0x3f);
 723             buf[2] = 0x80 + (u8)(ch & 0x3f);
 724             length = 3;
 725           }else{
 726             buf[0] = 0xf0 + (u8)((ch>>18) & 0x07);
 727             buf[1] = 0x80 + (u8)((ch>>12) & 0x3f);
 728             buf[2] = 0x80 + (u8)((ch>>6) & 0x3f);
 729             buf[3] = 0x80 + (u8)(ch & 0x3f);
 730             length = 4;
 731           }
 732         }
 733         if( precision>1 ){
 734           width -= precision-1;
 735           if( width>1 && !flag_leftjustify ){
 736             sqlite3_str_appendchar(pAccum, width-1, ' ');
 737             width = 0;
 738           }
 739           while( precision-- > 1 ){
 740             sqlite3_str_append(pAccum, buf, length);
 741           }
 742         }
 743         bufpt = buf;
 744         flag_altform2 = 1;
 745         goto adjust_width_for_utf8;
 746       case etSTRING:
 747       case etDYNSTRING:
 748         if( bArgList ){
 749           bufpt = getTextArg(pArgList);
 750           xtype = etSTRING;
 751         }else{
 752           bufpt = va_arg(ap,char*);
 753         }
 754         if( bufpt==0 ){
 755           bufpt = "";
 756         }else if( xtype==etDYNSTRING ){
 757           if( pAccum->nChar==0
 758            && pAccum->mxAlloc
 759            && width==0
 760            && precision<0
 761            && pAccum->accError==0
 762           ){
 763             /* Special optimization for sqlite3_mprintf("%z..."):
 764             ** Extend an existing memory allocation rather than creating
 765             ** a new one. */
 766             assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
 767             pAccum->zText = bufpt;
 768             pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt);
 769             pAccum->nChar = 0x7fffffff & (int)strlen(bufpt);
 770             pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED;
 771             length = 0;
 772             break;
 773           }
 774           zExtra = bufpt;
 775         }
 776         if( precision>=0 ){
 777           if( flag_altform2 ){
 778             /* Set length to the number of bytes needed in order to display
 779             ** precision characters */
 780             unsigned char *z = (unsigned char*)bufpt;
 781             while( precision-- > 0 && z[0] ){
 782               SQLITE_SKIP_UTF8(z);
 783             }
 784             length = (int)(z - (unsigned char*)bufpt);
 785           }else{
 786             for(length=0; length<precision && bufpt[length]; length++){}
 787           }
 788         }else{
 789           length = 0x7fffffff & (int)strlen(bufpt);
 790         }
 791       adjust_width_for_utf8:
 792         if( flag_altform2 && width>0 ){
 793           /* Adjust width to account for extra bytes in UTF-8 characters */
 794           int ii = length - 1;
 795           while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++;
 796         }
 797         break;
 798       case etSQLESCAPE:           /* %q: Escape ' characters */
 799       case etSQLESCAPE2:          /* %Q: Escape ' and enclose in '...' */
 800       case etSQLESCAPE3: {        /* %w: Escape " characters */
 801         int i, j, k, n, isnull;
 802         int needQuote;
 803         char ch;
 804         char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
 805         char *escarg;
 806
 807         if( bArgList ){
 808           escarg = getTextArg(pArgList);
 809         }else{
 810           escarg = va_arg(ap,char*);
 811         }
 812         isnull = escarg==0;
 813         if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
 814         /* For %q, %Q, and %w, the precision is the number of bytes (or
 815         ** characters if the ! flags is present) to use from the input.
 816         ** Because of the extra quoting characters inserted, the number
 817         ** of output characters may be larger than the precision.
 818         */
 819         k = precision;
 820         for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
 821           if( ch==q )  n++;
 822           if( flag_altform2 && (ch&0xc0)==0xc0 ){
 823             while( (escarg[i+1]&0xc0)==0x80 ){ i++; }
 824           }
 825         }
 826         needQuote = !isnull && xtype==etSQLESCAPE2;
 827         n += i + 3;
 828         if( n>etBUFSIZE ){
 829           bufpt = zExtra = printfTempBuf(pAccum, n);
 830           if( bufpt==0 ) return;
 831         }else{
 832           bufpt = buf;
 833         }
 834         j = 0;
 835         if( needQuote ) bufpt[j++] = q;
 836         k = i;
 837         for(i=0; i<k; i++){
 838           bufpt[j++] = ch = escarg[i];
 839           if( ch==q ) bufpt[j++] = ch;
 840         }
 841         if( needQuote ) bufpt[j++] = q;
 842         bufpt[j] = 0;
 843         length = j;
 844         goto adjust_width_for_utf8;
 845       }
 846       case etTOKEN: {
 847         Token *pToken;
 848         if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
 849         pToken = va_arg(ap, Token*);
 850         assert( bArgList==0 );
 851         if( pToken && pToken->n ){
 852           sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
 853         }
 854         length = width = 0;
 855         break;
 856       }
 857       case etSRCLIST: {
 858         SrcList *pSrc;
 859         int k;
 860         struct SrcList_item *pItem;
 861         if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
 862         pSrc = va_arg(ap, SrcList*);
 863         k = va_arg(ap, int);
 864         pItem = &pSrc->a[k];
 865         assert( bArgList==0 );
 866         assert( k>=0 && k<pSrc->nSrc );
 867         if( pItem->zDatabase ){
 868           sqlite3_str_appendall(pAccum, pItem->zDatabase);
 869           sqlite3_str_append(pAccum, ".", 1);
 870         }
 871         sqlite3_str_appendall(pAccum, pItem->zName);
 872         length = width = 0;
 873         break;
 874       }
 875       default: {
 876         assert( xtype==etINVALID );
 877         return;
 878       }
 879     }/* End switch over the format type */
 880     /*
 881     ** The text of the conversion is pointed to by "bufpt" and is
 882     ** "length" characters long.  The field width is "width".  Do
 883     ** the output.  Both length and width are in bytes, not characters,
 884     ** at this point.  If the "!" flag was present on string conversions
 885     ** indicating that width and precision should be expressed in characters,
 886     ** then the values have been translated prior to reaching this point.
 887     */
 888     width -= length;
 889     if( width>0 ){
 890       if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
 891       sqlite3_str_append(pAccum, bufpt, length);
 892       if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
 893     }else{
 894       sqlite3_str_append(pAccum, bufpt, length);
 895     }
 896
 897     if( zExtra ){
 898       sqlite3DbFree(pAccum->db, zExtra);
 899       zExtra = 0;
 900     }
 901   }/* End for loop over the format string */
 902 } /* End of function */
 903
 904 /*
 905 ** Enlarge the memory allocation on a StrAccum object so that it is
 906 ** able to accept at least N more bytes of text.
 907 **
 908 ** Return the number of bytes of text that StrAccum is able to accept
 909 ** after the attempted enlargement.  The value returned might be zero.
 910 */
 911 static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
 912   char *zNew;
 913   assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
 914   if( p->accError ){
 915     testcase(p->accError==SQLITE_TOOBIG);
 916     testcase(p->accError==SQLITE_NOMEM);
 917     return 0;
 918   }
 919   if( p->mxAlloc==0 ){
 920     setStrAccumError(p, SQLITE_TOOBIG);
 921     return p->nAlloc - p->nChar - 1;
 922   }else{
 923     char *zOld = isMalloced(p) ? p->zText : 0;
 924     i64 szNew = p->nChar;
 925     szNew += N + 1;
 926     if( szNew+p->nChar<=p->mxAlloc ){
 927       /* Force exponential buffer size growth as long as it does not overflow,
 928       ** to avoid having to call this routine too often */
 929       szNew += p->nChar;
 930     }
 931     if( szNew > p->mxAlloc ){
 932       sqlite3_str_reset(p);
 933       setStrAccumError(p, SQLITE_TOOBIG);
 934       return 0;
 935     }else{
 936       p->nAlloc = (int)szNew;
 937     }
 938     if( p->db ){
 939       zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
 940     }else{
 941       zNew = sqlite3Realloc(zOld, p->nAlloc);
 942     }
 943     if( zNew ){
 944       assert( p->zText!=0 || p->nChar==0 );
 945       if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
 946       p->zText = zNew;
 947       p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
 948       p->printfFlags |= SQLITE_PRINTF_MALLOCED;
 949     }else{
 950       sqlite3_str_reset(p);
 951       setStrAccumError(p, SQLITE_NOMEM);
 952       return 0;
 953     }
 954   }
 955   return N;
 956 }
 957
 958 /*
 959 ** Append N copies of character c to the given string buffer.
 960 */
 961 void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){
 962   testcase( p->nChar + (i64)N > 0x7fffffff );
 963   if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
 964     return;
 965   }
 966   while( (N--)>0 ) p->zText[p->nChar++] = c;
 967 }
 968
 969 /*
 970 ** The StrAccum "p" is not large enough to accept N new bytes of z[].
 971 ** So enlarge if first, then do the append.
 972 **
 973 ** This is a helper routine to sqlite3_str_append() that does special-case
 974 ** work (enlarging the buffer) using tail recursion, so that the
 975 ** sqlite3_str_append() routine can use fast calling semantics.
 976 */
 977 static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
 978   N = sqlite3StrAccumEnlarge(p, N);
 979   if( N>0 ){
 980     memcpy(&p->zText[p->nChar], z, N);
 981     p->nChar += N;
 982   }
 983 }
 984
 985 /*
 986 ** Append N bytes of text from z to the StrAccum object.  Increase the
 987 ** size of the memory allocation for StrAccum if necessary.
 988 */
 989 void sqlite3_str_append(sqlite3_str *p, const char *z, int N){
 990   assert( z!=0 || N==0 );
 991   assert( p->zText!=0 || p->nChar==0 || p->accError );
 992   assert( N>=0 );
 993   assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 );
 994   if( p->nChar+N >= p->nAlloc ){
 995     enlargeAndAppend(p,z,N);
 996   }else if( N ){
 997     assert( p->zText );
 998     p->nChar += N;
 999     memcpy(&p->zText[p->nChar-N], z, N);
1000   }
1001 }
1002
1003 /*
1004 ** Append the complete text of zero-terminated string z[] to the p string.
1005 */
1006 void sqlite3_str_appendall(sqlite3_str *p, const char *z){
1007   sqlite3_str_append(p, z, sqlite3Strlen30(z));
1008 }
1009
1010
1011 /*
1012 ** Finish off a string by making sure it is zero-terminated.
1013 ** Return a pointer to the resulting string.  Return a NULL
1014 ** pointer if any kind of error was encountered.
1015 */
1016 static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){
1017   char *zText;
1018   assert( p->mxAlloc>0 && !isMalloced(p) );
1019   zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
1020   if( zText ){
1021     memcpy(zText, p->zText, p->nChar+1);
1022     p->printfFlags |= SQLITE_PRINTF_MALLOCED;
1023   }else{
1024     setStrAccumError(p, SQLITE_NOMEM);
1025   }
1026   p->zText = zText;
1027   return zText;
1028 }
1029 char *sqlite3StrAccumFinish(StrAccum *p){
1030   if( p->zText ){
1031     p->zText[p->nChar] = 0;
1032     if( p->mxAlloc>0 && !isMalloced(p) ){
1033       return strAccumFinishRealloc(p);
1034     }
1035   }
1036   return p->zText;
1037 }
1038
1039 /*
1040 ** This singleton is an sqlite3_str object that is returned if
1041 ** sqlite3_malloc() fails to provide space for a real one.  This
1042 ** sqlite3_str object accepts no new text and always returns
1043 ** an SQLITE_NOMEM error.
1044 */
1045 static sqlite3_str sqlite3OomStr = {
1046    0, 0, 0, 0, 0, SQLITE_NOMEM, 0
1047 };
1048
1049 /* Finalize a string created using sqlite3_str_new().
1050 */
1051 char *sqlite3_str_finish(sqlite3_str *p){
1052   char *z;
1053   if( p!=0 && p!=&sqlite3OomStr ){
1054     z = sqlite3StrAccumFinish(p);
1055     sqlite3_free(p);
1056   }else{
1057     z = 0;
1058   }
1059   return z;
1060 }
1061
1062 /* Return any error code associated with p */
1063 int sqlite3_str_errcode(sqlite3_str *p){
1064   return p ? p->accError : SQLITE_NOMEM;
1065 }
1066
1067 /* Return the current length of p in bytes */
1068 int sqlite3_str_length(sqlite3_str *p){
1069   return p ? p->nChar : 0;
1070 }
1071
1072 /* Return the current value for p */
1073 char *sqlite3_str_value(sqlite3_str *p){
1074   if( p==0 || p->nChar==0 ) return 0;
1075   p->zText[p->nChar] = 0;
1076   return p->zText;
1077 }
1078
1079 /*
1080 ** Reset an StrAccum string.  Reclaim all malloced memory.
1081 */
1082 void sqlite3_str_reset(StrAccum *p){
1083   if( isMalloced(p) ){
1084     sqlite3DbFree(p->db, p->zText);
1085     p->printfFlags &= ~SQLITE_PRINTF_MALLOCED;
1086   }
1087   p->nAlloc = 0;
1088   p->nChar = 0;
1089   p->zText = 0;
1090 }
1091
1092 /*
1093 ** Initialize a string accumulator.
1094 **
1095 ** p:     The accumulator to be initialized.
1096 ** db:    Pointer to a database connection.  May be NULL.  Lookaside
1097 **        memory is used if not NULL. db->mallocFailed is set appropriately
1098 **        when not NULL.
1099 ** zBase: An initial buffer.  May be NULL in which case the initial buffer
1100 **        is malloced.
1101 ** n:     Size of zBase in bytes.  If total space requirements never exceed
1102 **        n then no memory allocations ever occur.
1103 ** mx:    Maximum number of bytes to accumulate.  If mx==0 then no memory
1104 **        allocations will ever occur.
1105 */
1106 void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){
1107   p->zText = zBase;
1108   p->db = db;
1109   p->nAlloc = n;
1110   p->mxAlloc = mx;
1111   p->nChar = 0;
1112   p->accError = 0;
1113   p->printfFlags = 0;
1114 }
1115
1116 /* Allocate and initialize a new dynamic string object */
1117 sqlite3_str *sqlite3_str_new(sqlite3 *db){
1118   sqlite3_str *p = sqlite3_malloc64(sizeof(*p));
1119   if( p ){
1120     sqlite3StrAccumInit(p, 0, 0, 0,
1121             db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH);
1122   }else{
1123     p = &sqlite3OomStr;
1124   }
1125   return p;
1126 }
1127
1128 /*
1129 ** Print into memory obtained from sqliteMalloc().  Use the internal
1130 ** %-conversion extensions.
1131 */
1132 char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
1133   char *z;
1134   char zBase[SQLITE_PRINT_BUF_SIZE];
1135   StrAccum acc;
1136   assert( db!=0 );
1137   sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
1138                       db->aLimit[SQLITE_LIMIT_LENGTH]);
1139   acc.printfFlags = SQLITE_PRINTF_INTERNAL;
1140   sqlite3_str_vappendf(&acc, zFormat, ap);
1141   z = sqlite3StrAccumFinish(&acc);
1142   if( acc.accError==SQLITE_NOMEM ){
1143     sqlite3OomFault(db);
1144   }
1145   return z;
1146 }
1147
1148 /*
1149 ** Print into memory obtained from sqliteMalloc().  Use the internal
1150 ** %-conversion extensions.
1151 */
1152 char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
1153   va_list ap;
1154   char *z;
1155   va_start(ap, zFormat);
1156   z = sqlite3VMPrintf(db, zFormat, ap);
1157   va_end(ap);
1158   return z;
1159 }
1160
1161 /*
1162 ** Print into memory obtained from sqlite3_malloc().  Omit the internal
1163 ** %-conversion extensions.
1164 */
1165 char *sqlite3_vmprintf(const char *zFormat, va_list ap){
1166   char *z;
1167   char zBase[SQLITE_PRINT_BUF_SIZE];
1168   StrAccum acc;
1169
1170 #ifdef SQLITE_ENABLE_API_ARMOR
1171   if( zFormat==0 ){
1172     (void)SQLITE_MISUSE_BKPT;
1173     return 0;
1174   }
1175 #endif
1176 #ifndef SQLITE_OMIT_AUTOINIT
1177   if( sqlite3_initialize() ) return 0;
1178 #endif
1179   sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
1180   sqlite3_str_vappendf(&acc, zFormat, ap);
1181   z = sqlite3StrAccumFinish(&acc);
1182   return z;
1183 }
1184
1185 /*
1186 ** Print into memory obtained from sqlite3_malloc()().  Omit the internal
1187 ** %-conversion extensions.
1188 */
1189 char *sqlite3_mprintf(const char *zFormat, ...){
1190   va_list ap;
1191   char *z;
1192 #ifndef SQLITE_OMIT_AUTOINIT
1193   if( sqlite3_initialize() ) return 0;
1194 #endif
1195   va_start(ap, zFormat);
1196   z = sqlite3_vmprintf(zFormat, ap);
1197   va_end(ap);
1198   return z;
1199 }
1200
1201 /*
1202 ** sqlite3_snprintf() works like snprintf() except that it ignores the
1203 ** current locale settings.  This is important for SQLite because we
1204 ** are not able to use a "," as the decimal point in place of "." as
1205 ** specified by some locales.
1206 **
1207 ** Oops:  The first two arguments of sqlite3_snprintf() are backwards
1208 ** from the snprintf() standard.  Unfortunately, it is too late to change
1209 ** this without breaking compatibility, so we just have to live with the
1210 ** mistake.
1211 **
1212 ** sqlite3_vsnprintf() is the varargs version.
1213 */
1214 char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
1215   StrAccum acc;
1216   if( n<=0 ) return zBuf;
1217 #ifdef SQLITE_ENABLE_API_ARMOR
1218   if( zBuf==0 || zFormat==0 ) {
1219     (void)SQLITE_MISUSE_BKPT;
1220     if( zBuf ) zBuf[0] = 0;
1221     return zBuf;
1222   }
1223 #endif
1224   sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);
1225   sqlite3_str_vappendf(&acc, zFormat, ap);
1226   zBuf[acc.nChar] = 0;
1227   return zBuf;
1228 }
1229 char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
1230   char *z;
1231   va_list ap;
1232   va_start(ap,zFormat);
1233   z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
1234   va_end(ap);
1235   return z;
1236 }
1237
1238 /*
1239 ** This is the routine that actually formats the sqlite3_log() message.
1240 ** We house it in a separate routine from sqlite3_log() to avoid using
1241 ** stack space on small-stack systems when logging is disabled.
1242 **
1243 ** sqlite3_log() must render into a static buffer.  It cannot dynamically
1244 ** allocate memory because it might be called while the memory allocator
1245 ** mutex is held.
1246 **
1247 ** sqlite3_str_vappendf() might ask for *temporary* memory allocations for
1248 ** certain format characters (%q) or for very large precisions or widths.
1249 ** Care must be taken that any sqlite3_log() calls that occur while the
1250 ** memory mutex is held do not use these mechanisms.
1251 */
1252 static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
1253   StrAccum acc;                          /* String accumulator */
1254   char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */
1255
1256   sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0);
1257   sqlite3_str_vappendf(&acc, zFormat, ap);
1258   sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
1259                            sqlite3StrAccumFinish(&acc));
1260 }
1261
1262 /*
1263 ** Format and write a message to the log if logging is enabled.
1264 */
1265 void sqlite3_log(int iErrCode, const char *zFormat, ...){
1266   va_list ap;                             /* Vararg list */
1267   if( sqlite3GlobalConfig.xLog ){
1268     va_start(ap, zFormat);
1269     renderLogMsg(iErrCode, zFormat, ap);
1270     va_end(ap);
1271   }
1272 }
1273
1274 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
1275 /*
1276 ** A version of printf() that understands %lld.  Used for debugging.
1277 ** The printf() built into some versions of windows does not understand %lld
1278 ** and segfaults if you give it a long long int.
1279 */
1280 void sqlite3DebugPrintf(const char *zFormat, ...){
1281   va_list ap;
1282   StrAccum acc;
1283   char zBuf[SQLITE_PRINT_BUF_SIZE*10];
1284   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
1285   va_start(ap,zFormat);
1286   sqlite3_str_vappendf(&acc, zFormat, ap);
1287   va_end(ap);
1288   sqlite3StrAccumFinish(&acc);
1289 #ifdef SQLITE_OS_TRACE_PROC
1290   {
1291     extern void SQLITE_OS_TRACE_PROC(const char *zBuf, int nBuf);
1292     SQLITE_OS_TRACE_PROC(zBuf, sizeof(zBuf));
1293   }
1294 #else
1295   fprintf(stdout,"%s", zBuf);
1296   fflush(stdout);
1297 #endif
1298 }
1299 #endif
1300
1301
1302 /*
1303 ** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument
1304 ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
1305 */
1306 void sqlite3_str_appendf(StrAccum *p, const char *zFormat, ...){
1307   va_list ap;
1308   va_start(ap,zFormat);
1309   sqlite3_str_vappendf(p, zFormat, ap);
1310   va_end(ap);
1311 }