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 /* Integer types.  %d, %x, %o, and so forth */
  19 #define etFLOAT       1 /* Floating point.  %f */
  20 #define etEXP         2 /* Exponentional notation. %e and %E */
  21 #define etGENERIC     3 /* Floating or exponential, depending on exponent. %g */
  22 #define etSIZE        4 /* Return number of characters processed so far. %n */
  23 #define etSTRING      5 /* Strings. %s */
  24 #define etDYNSTRING   6 /* Dynamically allocated strings. %z */
  25 #define etPERCENT     7 /* Percent symbol. %% */
  26 #define etCHARX       8 /* Characters. %c */
  27 /* The rest are extensions, not normally found in printf() */
  28 #define etSQLESCAPE   9 /* Strings with '\'' doubled.  %q */
  29 #define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '',
  30                           NULL pointers replaced by SQL NULL.  %Q */
  31 #define etTOKEN      11 /* a pointer to a Token structure */
  32 #define etSRCLIST    12 /* a pointer to a SrcList */
  33 #define etPOINTER    13 /* The %p conversion */
  34 #define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
  35 #define etORDINAL    15 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */
  36
  37 #define etINVALID    16 /* Any unrecognized conversion type */
  38
  39
  40 /*
  41 ** An "etByte" is an 8-bit unsigned value.
  42 */
  43 typedef unsigned char etByte;
  44
  45 /*
  46 ** Each builtin conversion character (ex: the 'd' in "%d") is described
  47 ** by an instance of the following structure
  48 */
  49 typedef struct et_info {   /* Information about each format field */
  50   char fmttype;            /* The format field code letter */
  51   etByte base;             /* The base for radix conversion */
  52   etByte flags;            /* One or more of FLAG_ constants below */
  53   etByte type;             /* Conversion paradigm */
  54   etByte charset;          /* Offset into aDigits[] of the digits string */
  55   etByte prefix;           /* Offset into aPrefix[] of the prefix string */
  56 } et_info;
  57
  58 /*
  59 ** Allowed values for et_info.flags
  60 */
  61 #define FLAG_SIGNED  1     /* True if the value to convert is signed */
  62 #define FLAG_INTERN  2     /* True if for internal use only */
  63 #define FLAG_STRING  4     /* Allow infinity 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, etRADIX,      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, etRADIX,      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, etRADIX,      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 have the FLAG_INTERN bit set and are thus for internal
  97 ** use only */
  98   {  'T',  0, 2, etTOKEN,      0,  0 },
  99   {  'S',  0, 2, etSRCLIST,    0,  0 },
 100   {  'r', 10, 3, etORDINAL,    0,  0 },
 101 };
 102
 103 /*
 104 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
 105 ** conversions will work.
 106 */
 107 #ifndef SQLITE_OMIT_FLOATING_POINT
 108 /*
 109 ** "*val" is a double such that 0.1 <= *val < 10.0
 110 ** Return the ascii code for the leading digit of *val, then
 111 ** multiply "*val" by 10.0 to renormalize.
 112 **
 113 ** Example:
 114 **     input:     *val = 3.14159
 115 **     output:    *val = 1.4159    function return = '3'
 116 **
 117 ** The counter *cnt is incremented each time.  After counter exceeds
 118 ** 16 (the number of significant digits in a 64-bit float) '0' is
 119 ** always returned.
 120 */
 121 static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
 122   int digit;
 123   LONGDOUBLE_TYPE d;
 124   if( (*cnt)<=0 ) return '0';
 125   (*cnt)--;
 126   digit = (int)*val;
 127   d = digit;
 128   digit += '0';
 129   *val = (*val - d)*10.0;
 130   return (char)digit;
 131 }
 132 #endif /* SQLITE_OMIT_FLOATING_POINT */
 133
 134 /*
 135 ** Set the StrAccum object to an error mode.
 136 */
 137 static void setStrAccumError(StrAccum *p, u8 eError){
 138   assert( eError==STRACCUM_NOMEM || eError==STRACCUM_TOOBIG );
 139   p->accError = eError;
 140   p->nAlloc = 0;
 141 }
 142
 143 /*
 144 ** Extra argument values from a PrintfArguments object
 145 */
 146 static sqlite3_int64 getIntArg(PrintfArguments *p){
 147   if( p->nArg<=p->nUsed ) return 0;
 148   return sqlite3_value_int64(p->apArg[p->nUsed++]);
 149 }
 150 static double getDoubleArg(PrintfArguments *p){
 151   if( p->nArg<=p->nUsed ) return 0.0;
 152   return sqlite3_value_double(p->apArg[p->nUsed++]);
 153 }
 154 static char *getTextArg(PrintfArguments *p){
 155   if( p->nArg<=p->nUsed ) return 0;
 156   return (char*)sqlite3_value_text(p->apArg[p->nUsed++]);
 157 }
 158
 159
 160 /*
 161 ** On machines with a small stack size, you can redefine the
 162 ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
 163 */
 164 #ifndef SQLITE_PRINT_BUF_SIZE
 165 # define SQLITE_PRINT_BUF_SIZE 70
 166 #endif
 167 #define etBUFSIZE SQLITE_PRINT_BUF_SIZE  /* Size of the output buffer */
 168
 169 /*
 170 ** Render a string given by "fmt" into the StrAccum object.
 171 */
 172 void sqlite3VXPrintf(
 173   StrAccum *pAccum,          /* Accumulate results here */
 174   const char *fmt,           /* Format string */
 175   va_list ap                 /* arguments */
 176 ){
 177   int c;                     /* Next character in the format string */
 178   char *bufpt;               /* Pointer to the conversion buffer */
 179   int precision;             /* Precision of the current field */
 180   int length;                /* Length of the field */
 181   int idx;                   /* A general purpose loop counter */
 182   int width;                 /* Width of the current field */
 183   etByte flag_leftjustify;   /* True if "-" flag is present */
 184   etByte flag_plussign;      /* True if "+" flag is present */
 185   etByte flag_blanksign;     /* True if " " flag is present */
 186   etByte flag_alternateform; /* True if "#" flag is present */
 187   etByte flag_altform2;      /* True if "!" flag is present */
 188   etByte flag_zeropad;       /* True if field width constant starts with zero */
 189   etByte flag_long;          /* True if "l" flag is present */
 190   etByte flag_longlong;      /* True if the "ll" flag is present */
 191   etByte done;               /* Loop termination flag */
 192   etByte xtype = etINVALID;  /* Conversion paradigm */
 193   u8 bArgList;               /* True for SQLITE_PRINTF_SQLFUNC */
 194   u8 useIntern;              /* Ok to use internal conversions (ex: %T) */
 195   char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
 196   sqlite_uint64 longvalue;   /* Value for integer types */
 197   LONGDOUBLE_TYPE realvalue; /* Value for real types */
 198   const et_info *infop;      /* Pointer to the appropriate info structure */
 199   char *zOut;                /* Rendering buffer */
 200   int nOut;                  /* Size of the rendering buffer */
 201   char *zExtra = 0;          /* Malloced memory used by some conversion */
 202 #ifndef SQLITE_OMIT_FLOATING_POINT
 203   int  exp, e2;              /* exponent of real numbers */
 204   int nsd;                   /* Number of significant digits returned */
 205   double rounder;            /* Used for rounding floating point values */
 206   etByte flag_dp;            /* True if decimal point should be shown */
 207   etByte flag_rtz;           /* True if trailing zeros should be removed */
 208 #endif
 209   PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
 210   char buf[etBUFSIZE];       /* Conversion buffer */
 211
 212   bufpt = 0;
 213   if( pAccum->printfFlags ){
 214     if( (bArgList = (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){
 215       pArgList = va_arg(ap, PrintfArguments*);
 216     }
 217     useIntern = pAccum->printfFlags & SQLITE_PRINTF_INTERNAL;
 218   }else{
 219     bArgList = useIntern = 0;
 220   }
 221   for(; (c=(*fmt))!=0; ++fmt){
 222     if( c!='%' ){
 223       bufpt = (char *)fmt;
 224 #if HAVE_STRCHRNUL
 225       fmt = strchrnul(fmt, '%');
 226 #else
 227       do{ fmt++; }while( *fmt && *fmt != '%' );
 228 #endif
 229       sqlite3StrAccumAppend(pAccum, bufpt, (int)(fmt - bufpt));
 230       if( *fmt==0 ) break;
 231     }
 232     if( (c=(*++fmt))==0 ){
 233       sqlite3StrAccumAppend(pAccum, "%", 1);
 234       break;
 235     }
 236     /* Find out what flags are present */
 237     flag_leftjustify = flag_plussign = flag_blanksign =
 238      flag_alternateform = flag_altform2 = flag_zeropad = 0;
 239     done = 0;
 240     do{
 241       switch( c ){
 242         case '-':   flag_leftjustify = 1;     break;
 243         case '+':   flag_plussign = 1;        break;
 244         case ' ':   flag_blanksign = 1;       break;
 245         case '#':   flag_alternateform = 1;   break;
 246         case '!':   flag_altform2 = 1;        break;
 247         case '0':   flag_zeropad = 1;         break;
 248         default:    done = 1;                 break;
 249       }
 250     }while( !done && (c=(*++fmt))!=0 );
 251     /* Get the field width */
 252     if( c=='*' ){
 253       if( bArgList ){
 254         width = (int)getIntArg(pArgList);
 255       }else{
 256         width = va_arg(ap,int);
 257       }
 258       if( width<0 ){
 259         flag_leftjustify = 1;
 260         width = width >= -2147483647 ? -width : 0;
 261       }
 262       c = *++fmt;
 263     }else{
 264       unsigned wx = 0;
 265       while( c>='0' && c<='9' ){
 266         wx = wx*10 + c - '0';
 267         c = *++fmt;
 268       }
 269       testcase( wx>0x7fffffff );
 270       width = wx & 0x7fffffff;
 271     }
 272     assert( width>=0 );
 273 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
 274     if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
 275       width = SQLITE_PRINTF_PRECISION_LIMIT;
 276     }
 277 #endif
 278
 279     /* Get the precision */
 280     if( c=='.' ){
 281       c = *++fmt;
 282       if( c=='*' ){
 283         if( bArgList ){
 284           precision = (int)getIntArg(pArgList);
 285         }else{
 286           precision = va_arg(ap,int);
 287         }
 288         c = *++fmt;
 289         if( precision<0 ){
 290           precision = precision >= -2147483647 ? -precision : -1;
 291         }
 292       }else{
 293         unsigned px = 0;
 294         while( c>='0' && c<='9' ){
 295           px = px*10 + c - '0';
 296           c = *++fmt;
 297         }
 298         testcase( px>0x7fffffff );
 299         precision = px & 0x7fffffff;
 300       }
 301     }else{
 302       precision = -1;
 303     }
 304     assert( precision>=(-1) );
 305 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
 306     if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){
 307       precision = SQLITE_PRINTF_PRECISION_LIMIT;
 308     }
 309 #endif
 310
 311
 312     /* Get the conversion type modifier */
 313     if( c=='l' ){
 314       flag_long = 1;
 315       c = *++fmt;
 316       if( c=='l' ){
 317         flag_longlong = 1;
 318         c = *++fmt;
 319       }else{
 320         flag_longlong = 0;
 321       }
 322     }else{
 323       flag_long = flag_longlong = 0;
 324     }
 325     /* Fetch the info entry for the field */
 326     infop = &fmtinfo[0];
 327     xtype = etINVALID;
 328     for(idx=0; idx<ArraySize(fmtinfo); idx++){
 329       if( c==fmtinfo[idx].fmttype ){
 330         infop = &fmtinfo[idx];
 331         if( useIntern || (infop->flags & FLAG_INTERN)==0 ){
 332           xtype = infop->type;
 333         }else{
 334           return;
 335         }
 336         break;
 337       }
 338     }
 339
 340     /*
 341     ** At this point, variables are initialized as follows:
 342     **
 343     **   flag_alternateform          TRUE if a '#' is present.
 344     **   flag_altform2               TRUE if a '!' is present.
 345     **   flag_plussign               TRUE if a '+' is present.
 346     **   flag_leftjustify            TRUE if a '-' is present or if the
 347     **                               field width was negative.
 348     **   flag_zeropad                TRUE if the width began with 0.
 349     **   flag_long                   TRUE if the letter 'l' (ell) prefixed
 350     **                               the conversion character.
 351     **   flag_longlong               TRUE if the letter 'll' (ell ell) prefixed
 352     **                               the conversion character.
 353     **   flag_blanksign              TRUE if a ' ' is present.
 354     **   width                       The specified field width.  This is
 355     **                               always non-negative.  Zero is the default.
 356     **   precision                   The specified precision.  The default
 357     **                               is -1.
 358     **   xtype                       The class of the conversion.
 359     **   infop                       Pointer to the appropriate info struct.
 360     */
 361     switch( xtype ){
 362       case etPOINTER:
 363         flag_longlong = sizeof(char*)==sizeof(i64);
 364         flag_long = sizeof(char*)==sizeof(long int);
 365         /* Fall through into the next case */
 366       case etORDINAL:
 367       case etRADIX:
 368         if( infop->flags & FLAG_SIGNED ){
 369           i64 v;
 370           if( bArgList ){
 371             v = getIntArg(pArgList);
 372           }else if( flag_longlong ){
 373             v = va_arg(ap,i64);
 374           }else if( flag_long ){
 375             v = va_arg(ap,long int);
 376           }else{
 377             v = va_arg(ap,int);
 378           }
 379           if( v<0 ){
 380             if( v==SMALLEST_INT64 ){
 381               longvalue = ((u64)1)<<63;
 382             }else{
 383               longvalue = -v;
 384             }
 385             prefix = '-';
 386           }else{
 387             longvalue = v;
 388             if( flag_plussign )        prefix = '+';
 389             else if( flag_blanksign )  prefix = ' ';
 390             else                       prefix = 0;
 391           }
 392         }else{
 393           if( bArgList ){
 394             longvalue = (u64)getIntArg(pArgList);
 395           }else if( flag_longlong ){
 396             longvalue = va_arg(ap,u64);
 397           }else if( flag_long ){
 398             longvalue = va_arg(ap,unsigned long int);
 399           }else{
 400             longvalue = va_arg(ap,unsigned int);
 401           }
 402           prefix = 0;
 403         }
 404         if( longvalue==0 ) flag_alternateform = 0;
 405         if( flag_zeropad && precision<width-(prefix!=0) ){
 406           precision = width-(prefix!=0);
 407         }
 408         if( precision<etBUFSIZE-10 ){
 409           nOut = etBUFSIZE;
 410           zOut = buf;
 411         }else{
 412           nOut = precision + 10;
 413           zOut = zExtra = sqlite3Malloc( nOut );
 414           if( zOut==0 ){
 415             setStrAccumError(pAccum, STRACCUM_NOMEM);
 416             return;
 417           }
 418         }
 419         bufpt = &zOut[nOut-1];
 420         if( xtype==etORDINAL ){
 421           static const char zOrd[] = "thstndrd";
 422           int x = (int)(longvalue % 10);
 423           if( x>=4 || (longvalue/10)%10==1 ){
 424             x = 0;
 425           }
 426           *(--bufpt) = zOrd[x*2+1];
 427           *(--bufpt) = zOrd[x*2];
 428         }
 429         {
 430           const char *cset = &aDigits[infop->charset];
 431           u8 base = infop->base;
 432           do{                                           /* Convert to ascii */
 433             *(--bufpt) = cset[longvalue%base];
 434             longvalue = longvalue/base;
 435           }while( longvalue>0 );
 436         }
 437         length = (int)(&zOut[nOut-1]-bufpt);
 438         for(idx=precision-length; idx>0; idx--){
 439           *(--bufpt) = '0';                             /* Zero pad */
 440         }
 441         if( prefix ) *(--bufpt) = prefix;               /* Add sign */
 442         if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
 443           const char *pre;
 444           char x;
 445           pre = &aPrefix[infop->prefix];
 446           for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
 447         }
 448         length = (int)(&zOut[nOut-1]-bufpt);
 449         break;
 450       case etFLOAT:
 451       case etEXP:
 452       case etGENERIC:
 453         if( bArgList ){
 454           realvalue = getDoubleArg(pArgList);
 455         }else{
 456           realvalue = va_arg(ap,double);
 457         }
 458 #ifdef SQLITE_OMIT_FLOATING_POINT
 459         length = 0;
 460 #else
 461         if( precision<0 ) precision = 6;         /* Set default precision */
 462         if( realvalue<0.0 ){
 463           realvalue = -realvalue;
 464           prefix = '-';
 465         }else{
 466           if( flag_plussign )          prefix = '+';
 467           else if( flag_blanksign )    prefix = ' ';
 468           else                         prefix = 0;
 469         }
 470         if( xtype==etGENERIC && precision>0 ) precision--;
 471         testcase( precision>0xfff );
 472         for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){}
 473         if( xtype==etFLOAT ) realvalue += rounder;
 474         /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
 475         exp = 0;
 476         if( sqlite3IsNaN((double)realvalue) ){
 477           bufpt = "NaN";
 478           length = 3;
 479           break;
 480         }
 481         if( realvalue>0.0 ){
 482           LONGDOUBLE_TYPE scale = 1.0;
 483           while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;}
 484           while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; }
 485           while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; }
 486           realvalue /= scale;
 487           while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
 488           while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
 489           if( exp>350 ){
 490             bufpt = buf;
 491             buf[0] = prefix;
 492             memcpy(buf+(prefix!=0),"Inf",4);
 493             length = 3+(prefix!=0);
 494             break;
 495           }
 496         }
 497         bufpt = buf;
 498         /*
 499         ** If the field type is etGENERIC, then convert to either etEXP
 500         ** or etFLOAT, as appropriate.
 501         */
 502         if( xtype!=etFLOAT ){
 503           realvalue += rounder;
 504           if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
 505         }
 506         if( xtype==etGENERIC ){
 507           flag_rtz = !flag_alternateform;
 508           if( exp<-4 || exp>precision ){
 509             xtype = etEXP;
 510           }else{
 511             precision = precision - exp;
 512             xtype = etFLOAT;
 513           }
 514         }else{
 515           flag_rtz = flag_altform2;
 516         }
 517         if( xtype==etEXP ){
 518           e2 = 0;
 519         }else{
 520           e2 = exp;
 521         }
 522         if( MAX(e2,0)+(i64)precision+(i64)width > etBUFSIZE - 15 ){
 523           bufpt = zExtra
 524               = sqlite3Malloc( MAX(e2,0)+(i64)precision+(i64)width+15 );
 525           if( bufpt==0 ){
 526             setStrAccumError(pAccum, STRACCUM_NOMEM);
 527             return;
 528           }
 529         }
 530         zOut = bufpt;
 531         nsd = 16 + flag_altform2*10;
 532         flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
 533         /* The sign in front of the number */
 534         if( prefix ){
 535           *(bufpt++) = prefix;
 536         }
 537         /* Digits prior to the decimal point */
 538         if( e2<0 ){
 539           *(bufpt++) = '0';
 540         }else{
 541           for(; e2>=0; e2--){
 542             *(bufpt++) = et_getdigit(&realvalue,&nsd);
 543           }
 544         }
 545         /* The decimal point */
 546         if( flag_dp ){
 547           *(bufpt++) = '.';
 548         }
 549         /* "0" digits after the decimal point but before the first
 550         ** significant digit of the number */
 551         for(e2++; e2<0; precision--, e2++){
 552           assert( precision>0 );
 553           *(bufpt++) = '0';
 554         }
 555         /* Significant digits after the decimal point */
 556         while( (precision--)>0 ){
 557           *(bufpt++) = et_getdigit(&realvalue,&nsd);
 558         }
 559         /* Remove trailing zeros and the "." if no digits follow the "." */
 560         if( flag_rtz && flag_dp ){
 561           while( bufpt[-1]=='0' ) *(--bufpt) = 0;
 562           assert( bufpt>zOut );
 563           if( bufpt[-1]=='.' ){
 564             if( flag_altform2 ){
 565               *(bufpt++) = '0';
 566             }else{
 567               *(--bufpt) = 0;
 568             }
 569           }
 570         }
 571         /* Add the "eNNN" suffix */
 572         if( xtype==etEXP ){
 573           *(bufpt++) = aDigits[infop->charset];
 574           if( exp<0 ){
 575             *(bufpt++) = '-'; exp = -exp;
 576           }else{
 577             *(bufpt++) = '+';
 578           }
 579           if( exp>=100 ){
 580             *(bufpt++) = (char)((exp/100)+'0');        /* 100's digit */
 581             exp %= 100;
 582           }
 583           *(bufpt++) = (char)(exp/10+'0');             /* 10's digit */
 584           *(bufpt++) = (char)(exp%10+'0');             /* 1's digit */
 585         }
 586         *bufpt = 0;
 587
 588         /* The converted number is in buf[] and zero terminated. Output it.
 589         ** Note that the number is in the usual order, not reversed as with
 590         ** integer conversions. */
 591         length = (int)(bufpt-zOut);
 592         bufpt = zOut;
 593
 594         /* Special case:  Add leading zeros if the flag_zeropad flag is
 595         ** set and we are not left justified */
 596         if( flag_zeropad && !flag_leftjustify && length < width){
 597           int i;
 598           int nPad = width - length;
 599           for(i=width; i>=nPad; i--){
 600             bufpt[i] = bufpt[i-nPad];
 601           }
 602           i = prefix!=0;
 603           while( nPad-- ) bufpt[i++] = '0';
 604           length = width;
 605         }
 606 #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
 607         break;
 608       case etSIZE:
 609         if( !bArgList ){
 610           *(va_arg(ap,int*)) = pAccum->nChar;
 611         }
 612         length = width = 0;
 613         break;
 614       case etPERCENT:
 615         buf[0] = '%';
 616         bufpt = buf;
 617         length = 1;
 618         break;
 619       case etCHARX:
 620         if( bArgList ){
 621           bufpt = getTextArg(pArgList);
 622           c = bufpt ? bufpt[0] : 0;
 623         }else{
 624           c = va_arg(ap,int);
 625         }
 626         if( precision>1 ){
 627           width -= precision-1;
 628           if( width>1 && !flag_leftjustify ){
 629             sqlite3AppendChar(pAccum, width-1, ' ');
 630             width = 0;
 631           }
 632           sqlite3AppendChar(pAccum, precision-1, c);
 633         }
 634         length = 1;
 635         buf[0] = c;
 636         bufpt = buf;
 637         break;
 638       case etSTRING:
 639       case etDYNSTRING:
 640         if( bArgList ){
 641           bufpt = getTextArg(pArgList);
 642           xtype = etSTRING;
 643         }else{
 644           bufpt = va_arg(ap,char*);
 645         }
 646         if( bufpt==0 ){
 647           bufpt = "";
 648         }else if( xtype==etDYNSTRING ){
 649           zExtra = bufpt;
 650         }
 651         if( precision>=0 ){
 652           for(length=0; length<precision && bufpt[length]; length++){}
 653         }else{
 654           length = sqlite3Strlen30(bufpt);
 655         }
 656         break;
 657       case etSQLESCAPE:           /* Escape ' characters */
 658       case etSQLESCAPE2:          /* Escape ' and enclose in '...' */
 659       case etSQLESCAPE3: {        /* Escape " characters */
 660         int i, j, k, n, isnull;
 661         int needQuote;
 662         char ch;
 663         char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
 664         char *escarg;
 665
 666         if( bArgList ){
 667           escarg = getTextArg(pArgList);
 668         }else{
 669           escarg = va_arg(ap,char*);
 670         }
 671         isnull = escarg==0;
 672         if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
 673         k = precision;
 674         for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
 675           if( ch==q )  n++;
 676         }
 677         needQuote = !isnull && xtype==etSQLESCAPE2;
 678         n += i + 3;
 679         if( n>etBUFSIZE ){
 680           bufpt = zExtra = sqlite3Malloc( n );
 681           if( bufpt==0 ){
 682             setStrAccumError(pAccum, STRACCUM_NOMEM);
 683             return;
 684           }
 685         }else{
 686           bufpt = buf;
 687         }
 688         j = 0;
 689         if( needQuote ) bufpt[j++] = q;
 690         k = i;
 691         for(i=0; i<k; i++){
 692           bufpt[j++] = ch = escarg[i];
 693           if( ch==q ) bufpt[j++] = ch;
 694         }
 695         if( needQuote ) bufpt[j++] = q;
 696         bufpt[j] = 0;
 697         length = j;
 698         /* The precision in %q and %Q means how many input characters to
 699         ** consume, not the length of the output...
 700         ** if( precision>=0 && precision<length ) length = precision; */
 701         break;
 702       }
 703       case etTOKEN: {
 704         Token *pToken = va_arg(ap, Token*);
 705         assert( bArgList==0 );
 706         if( pToken && pToken->n ){
 707           sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
 708         }
 709         length = width = 0;
 710         break;
 711       }
 712       case etSRCLIST: {
 713         SrcList *pSrc = va_arg(ap, SrcList*);
 714         int k = va_arg(ap, int);
 715         struct SrcList_item *pItem = &pSrc->a[k];
 716         assert( bArgList==0 );
 717         assert( k>=0 && k<pSrc->nSrc );
 718         if( pItem->zDatabase ){
 719           sqlite3StrAccumAppendAll(pAccum, pItem->zDatabase);
 720           sqlite3StrAccumAppend(pAccum, ".", 1);
 721         }
 722         sqlite3StrAccumAppendAll(pAccum, pItem->zName);
 723         length = width = 0;
 724         break;
 725       }
 726       default: {
 727         assert( xtype==etINVALID );
 728         return;
 729       }
 730     }/* End switch over the format type */
 731     /*
 732     ** The text of the conversion is pointed to by "bufpt" and is
 733     ** "length" characters long.  The field width is "width".  Do
 734     ** the output.
 735     */
 736     width -= length;
 737     if( width>0 && !flag_leftjustify ) sqlite3AppendChar(pAccum, width, ' ');
 738     sqlite3StrAccumAppend(pAccum, bufpt, length);
 739     if( width>0 && flag_leftjustify ) sqlite3AppendChar(pAccum, width, ' ');
 740
 741     if( zExtra ){
 742       sqlite3DbFree(pAccum->db, zExtra);
 743       zExtra = 0;
 744     }
 745   }/* End for loop over the format string */
 746 } /* End of function */
 747
 748 /*
 749 ** Enlarge the memory allocation on a StrAccum object so that it is
 750 ** able to accept at least N more bytes of text.
 751 **
 752 ** Return the number of bytes of text that StrAccum is able to accept
 753 ** after the attempted enlargement.  The value returned might be zero.
 754 */
 755 static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
 756   char *zNew;
 757   assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
 758   if( p->accError ){
 759     testcase(p->accError==STRACCUM_TOOBIG);
 760     testcase(p->accError==STRACCUM_NOMEM);
 761     return 0;
 762   }
 763   if( p->mxAlloc==0 ){
 764     N = p->nAlloc - p->nChar - 1;
 765     setStrAccumError(p, STRACCUM_TOOBIG);
 766     return N;
 767   }else{
 768     char *zOld = isMalloced(p) ? p->zText : 0;
 769     i64 szNew = p->nChar;
 770     assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
 771     szNew += N + 1;
 772     if( szNew+p->nChar<=p->mxAlloc ){
 773       /* Force exponential buffer size growth as long as it does not overflow,
 774       ** to avoid having to call this routine too often */
 775       szNew += p->nChar;
 776     }
 777     if( szNew > p->mxAlloc ){
 778       sqlite3StrAccumReset(p);
 779       setStrAccumError(p, STRACCUM_TOOBIG);
 780       return 0;
 781     }else{
 782       p->nAlloc = (int)szNew;
 783     }
 784     if( p->db ){
 785       zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
 786     }else{
 787       zNew = sqlite3_realloc64(zOld, p->nAlloc);
 788     }
 789     if( zNew ){
 790       assert( p->zText!=0 || p->nChar==0 );
 791       if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
 792       p->zText = zNew;
 793       p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
 794       p->printfFlags |= SQLITE_PRINTF_MALLOCED;
 795     }else{
 796       sqlite3StrAccumReset(p);
 797       setStrAccumError(p, STRACCUM_NOMEM);
 798       return 0;
 799     }
 800   }
 801   return N;
 802 }
 803
 804 /*
 805 ** Append N copies of character c to the given string buffer.
 806 */
 807 void sqlite3AppendChar(StrAccum *p, int N, char c){
 808   testcase( p->nChar + (i64)N > 0x7fffffff );
 809   if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
 810     return;
 811   }
 812   assert( (p->zText==p->zBase)==!isMalloced(p) );
 813   while( (N--)>0 ) p->zText[p->nChar++] = c;
 814 }
 815
 816 /*
 817 ** The StrAccum "p" is not large enough to accept N new bytes of z[].
 818 ** So enlarge if first, then do the append.
 819 **
 820 ** This is a helper routine to sqlite3StrAccumAppend() that does special-case
 821 ** work (enlarging the buffer) using tail recursion, so that the
 822 ** sqlite3StrAccumAppend() routine can use fast calling semantics.
 823 */
 824 static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
 825   N = sqlite3StrAccumEnlarge(p, N);
 826   if( N>0 ){
 827     memcpy(&p->zText[p->nChar], z, N);
 828     p->nChar += N;
 829   }
 830   assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
 831 }
 832
 833 /*
 834 ** Append N bytes of text from z to the StrAccum object.  Increase the
 835 ** size of the memory allocation for StrAccum if necessary.
 836 */
 837 void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
 838   assert( z!=0 || N==0 );
 839   assert( p->zText!=0 || p->nChar==0 || p->accError );
 840   assert( N>=0 );
 841   assert( p->accError==0 || p->nAlloc==0 );
 842   if( p->nChar+N >= p->nAlloc ){
 843     enlargeAndAppend(p,z,N);
 844   }else{
 845     assert( p->zText );
 846     p->nChar += N;
 847     memcpy(&p->zText[p->nChar-N], z, N);
 848   }
 849 }
 850
 851 /*
 852 ** Append the complete text of zero-terminated string z[] to the p string.
 853 */
 854 void sqlite3StrAccumAppendAll(StrAccum *p, const char *z){
 855   sqlite3StrAccumAppend(p, z, sqlite3Strlen30(z));
 856 }
 857
 858
 859 /*
 860 ** Finish off a string by making sure it is zero-terminated.
 861 ** Return a pointer to the resulting string.  Return a NULL
 862 ** pointer if any kind of error was encountered.
 863 */
 864 char *sqlite3StrAccumFinish(StrAccum *p){
 865   if( p->zText ){
 866     assert( (p->zText==p->zBase)==!isMalloced(p) );
 867     p->zText[p->nChar] = 0;
 868     if( p->mxAlloc>0 && !isMalloced(p) ){
 869       p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
 870       if( p->zText ){
 871         memcpy(p->zText, p->zBase, p->nChar+1);
 872         p->printfFlags |= SQLITE_PRINTF_MALLOCED;
 873       }else{
 874         setStrAccumError(p, STRACCUM_NOMEM);
 875       }
 876     }
 877   }
 878   return p->zText;
 879 }
 880
 881 /*
 882 ** Reset an StrAccum string.  Reclaim all malloced memory.
 883 */
 884 void sqlite3StrAccumReset(StrAccum *p){
 885   assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
 886   if( isMalloced(p) ){
 887     sqlite3DbFree(p->db, p->zText);
 888     p->printfFlags &= ~SQLITE_PRINTF_MALLOCED;
 889   }
 890   p->zText = 0;
 891 }
 892
 893 /*
 894 ** Initialize a string accumulator.
 895 **
 896 ** p:     The accumulator to be initialized.
 897 ** db:    Pointer to a database connection.  May be NULL.  Lookaside
 898 **        memory is used if not NULL. db->mallocFailed is set appropriately
 899 **        when not NULL.
 900 ** zBase: An initial buffer.  May be NULL in which case the initial buffer
 901 **        is malloced.
 902 ** n:     Size of zBase in bytes.  If total space requirements never exceed
 903 **        n then no memory allocations ever occur.
 904 ** mx:    Maximum number of bytes to accumulate.  If mx==0 then no memory
 905 **        allocations will ever occur.
 906 */
 907 void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){
 908   p->zText = p->zBase = zBase;
 909   p->db = db;
 910   p->nChar = 0;
 911   p->nAlloc = n;
 912   p->mxAlloc = mx;
 913   p->accError = 0;
 914   p->printfFlags = 0;
 915 }
 916
 917 /*
 918 ** Print into memory obtained from sqliteMalloc().  Use the internal
 919 ** %-conversion extensions.
 920 */
 921 char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
 922   char *z;
 923   char zBase[SQLITE_PRINT_BUF_SIZE];
 924   StrAccum acc;
 925   assert( db!=0 );
 926   sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
 927                       db->aLimit[SQLITE_LIMIT_LENGTH]);
 928   acc.printfFlags = SQLITE_PRINTF_INTERNAL;
 929   sqlite3VXPrintf(&acc, zFormat, ap);
 930   z = sqlite3StrAccumFinish(&acc);
 931   if( acc.accError==STRACCUM_NOMEM ){
 932     sqlite3OomFault(db);
 933   }
 934   return z;
 935 }
 936
 937 /*
 938 ** Print into memory obtained from sqliteMalloc().  Use the internal
 939 ** %-conversion extensions.
 940 */
 941 char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
 942   va_list ap;
 943   char *z;
 944   va_start(ap, zFormat);
 945   z = sqlite3VMPrintf(db, zFormat, ap);
 946   va_end(ap);
 947   return z;
 948 }
 949
 950 /*
 951 ** Print into memory obtained from sqlite3_malloc().  Omit the internal
 952 ** %-conversion extensions.
 953 */
 954 char *sqlite3_vmprintf(const char *zFormat, va_list ap){
 955   char *z;
 956   char zBase[SQLITE_PRINT_BUF_SIZE];
 957   StrAccum acc;
 958
 959 #ifdef SQLITE_ENABLE_API_ARMOR
 960   if( zFormat==0 ){
 961     (void)SQLITE_MISUSE_BKPT;
 962     return 0;
 963   }
 964 #endif
 965 #ifndef SQLITE_OMIT_AUTOINIT
 966   if( sqlite3_initialize() ) return 0;
 967 #endif
 968   sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
 969   sqlite3VXPrintf(&acc, zFormat, ap);
 970   z = sqlite3StrAccumFinish(&acc);
 971   return z;
 972 }
 973
 974 /*
 975 ** Print into memory obtained from sqlite3_malloc()().  Omit the internal
 976 ** %-conversion extensions.
 977 */
 978 char *sqlite3_mprintf(const char *zFormat, ...){
 979   va_list ap;
 980   char *z;
 981 #ifndef SQLITE_OMIT_AUTOINIT
 982   if( sqlite3_initialize() ) return 0;
 983 #endif
 984   va_start(ap, zFormat);
 985   z = sqlite3_vmprintf(zFormat, ap);
 986   va_end(ap);
 987   return z;
 988 }
 989
 990 /*
 991 ** sqlite3_snprintf() works like snprintf() except that it ignores the
 992 ** current locale settings.  This is important for SQLite because we
 993 ** are not able to use a "," as the decimal point in place of "." as
 994 ** specified by some locales.
 995 **
 996 ** Oops:  The first two arguments of sqlite3_snprintf() are backwards
 997 ** from the snprintf() standard.  Unfortunately, it is too late to change
 998 ** this without breaking compatibility, so we just have to live with the
 999 ** mistake.
1000 **
1001 ** sqlite3_vsnprintf() is the varargs version.
1002 */
1003 char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
1004   StrAccum acc;
1005   if( n<=0 ) return zBuf;
1006 #ifdef SQLITE_ENABLE_API_ARMOR
1007   if( zBuf==0 || zFormat==0 ) {
1008     (void)SQLITE_MISUSE_BKPT;
1009     if( zBuf ) zBuf[0] = 0;
1010     return zBuf;
1011   }
1012 #endif
1013   sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);
1014   sqlite3VXPrintf(&acc, zFormat, ap);
1015   return sqlite3StrAccumFinish(&acc);
1016 }
1017 char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
1018   char *z;
1019   va_list ap;
1020   va_start(ap,zFormat);
1021   z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
1022   va_end(ap);
1023   return z;
1024 }
1025
1026 /*
1027 ** This is the routine that actually formats the sqlite3_log() message.
1028 ** We house it in a separate routine from sqlite3_log() to avoid using
1029 ** stack space on small-stack systems when logging is disabled.
1030 **
1031 ** sqlite3_log() must render into a static buffer.  It cannot dynamically
1032 ** allocate memory because it might be called while the memory allocator
1033 ** mutex is held.
1034 **
1035 ** sqlite3VXPrintf() might ask for *temporary* memory allocations for
1036 ** certain format characters (%q) or for very large precisions or widths.
1037 ** Care must be taken that any sqlite3_log() calls that occur while the
1038 ** memory mutex is held do not use these mechanisms.
1039 */
1040 static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
1041   StrAccum acc;                          /* String accumulator */
1042   char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */
1043
1044   sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0);
1045   sqlite3VXPrintf(&acc, zFormat, ap);
1046   sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
1047                            sqlite3StrAccumFinish(&acc));
1048 }
1049
1050 /*
1051 ** Format and write a message to the log if logging is enabled.
1052 */
1053 void sqlite3_log(int iErrCode, const char *zFormat, ...){
1054   va_list ap;                             /* Vararg list */
1055   if( sqlite3GlobalConfig.xLog ){
1056     va_start(ap, zFormat);
1057     renderLogMsg(iErrCode, zFormat, ap);
1058     va_end(ap);
1059   }
1060 }
1061
1062 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
1063 /*
1064 ** A version of printf() that understands %lld.  Used for debugging.
1065 ** The printf() built into some versions of windows does not understand %lld
1066 ** and segfaults if you give it a long long int.
1067 */
1068 void sqlite3DebugPrintf(const char *zFormat, ...){
1069   va_list ap;
1070   StrAccum acc;
1071   char zBuf[500];
1072   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
1073   va_start(ap,zFormat);
1074   sqlite3VXPrintf(&acc, zFormat, ap);
1075   va_end(ap);
1076   sqlite3StrAccumFinish(&acc);
1077   fprintf(stdout,"%s", zBuf);
1078   fflush(stdout);
1079 }
1080 #endif
1081
1082
1083 /*
1084 ** variable-argument wrapper around sqlite3VXPrintf().  The bFlags argument
1085 ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
1086 */
1087 void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
1088   va_list ap;
1089   va_start(ap,zFormat);
1090   sqlite3VXPrintf(p, zFormat, ap);
1091   va_end(ap);
1092 }