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