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