src/third_party/sqlite/src/src/printf.c

   1 /*
   2 ** The "printf" code that follows dates from the 1980's.  It is in
   3 ** the public domain.  The original comments are included here for
   4 ** completeness.  They are very out-of-date but might be useful as
   5 ** an historical reference.  Most of the "enhancements" have been backed
   6 ** out so that the functionality is now the same as standard printf().
   7 **
   8 **************************************************************************
   9 **
  10 ** The following modules is an enhanced replacement for the "printf" subroutines
  11 ** found in the standard C library.  The following enhancements are
  12 ** supported:
  13 **
  14 **      +  Additional functions.  The standard set of "printf" functions
  15 **         includes printf, fprintf, sprintf, vprintf, vfprintf, and
  16 **         vsprintf.  This module adds the following:
  17 **
  18 **           *  snprintf -- Works like sprintf, but has an extra argument
  19 **                          which is the size of the buffer written to.
  20 **
  21 **           *  mprintf --  Similar to sprintf.  Writes output to memory
  22 **                          obtained from malloc.
  23 **
  24 **           *  xprintf --  Calls a function to dispose of output.
  25 **
  26 **           *  nprintf --  No output, but returns the number of characters
  27 **                          that would have been output by printf.
  28 **
  29 **           *  A v- version (ex: vsnprintf) of every function is also
  30 **              supplied.
  31 **
  32 **      +  A few extensions to the formatting notation are supported:
  33 **
  34 **           *  The "=" flag (similar to "-") causes the output to be
  35 **              be centered in the appropriately sized field.
  36 **
  37 **           *  The %b field outputs an integer in binary notation.
  38 **
  39 **           *  The %c field now accepts a precision.  The character output
  40 **              is repeated by the number of times the precision specifies.
  41 **
  42 **           *  The %' field works like %c, but takes as its character the
  43 **              next character of the format string, instead of the next
  44 **              argument.  For example,  printf("%.78'-")  prints 78 minus
  45 **              signs, the same as  printf("%.78c",'-').
  46 **
  47 **      +  When compiled using GCC on a SPARC, this version of printf is
  48 **         faster than the library printf for SUN OS 4.1.
  49 **
  50 **      +  All functions are fully reentrant.
  51 **
  52 */
  53 #include "sqliteInt.h"
  54
  55 /*
  56 ** Conversion types fall into various categories as defined by the
  57 ** following enumeration.
  58 */
  59 #define etRADIX       1 /* Integer types.  %d, %x, %o, and so forth */
  60 #define etFLOAT       2 /* Floating point.  %f */
  61 #define etEXP         3 /* Exponentional notation. %e and %E */
  62 #define etGENERIC     4 /* Floating or exponential, depending on exponent. %g */
  63 #define etSIZE        5 /* Return number of characters processed so far. %n */
  64 #define etSTRING      6 /* Strings. %s */
  65 #define etDYNSTRING   7 /* Dynamically allocated strings. %z */
  66 #define etPERCENT     8 /* Percent symbol. %% */
  67 #define etCHARX       9 /* Characters. %c */
  68 /* The rest are extensions, not normally found in printf() */
  69 #define etSQLESCAPE  10 /* Strings with '\'' doubled.  %q */
  70 #define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '',
  71                           NULL pointers replaced by SQL NULL.  %Q */
  72 #define etTOKEN      12 /* a pointer to a Token structure */
  73 #define etSRCLIST    13 /* a pointer to a SrcList */
  74 #define etPOINTER    14 /* The %p conversion */
  75 #define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */
  76 #define etORDINAL    16 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */
  77
  78 #define etINVALID     0 /* Any unrecognized conversion type */
  79
  80
  81 /*
  82 ** An "etByte" is an 8-bit unsigned value.
  83 */
  84 typedef unsigned char etByte;
  85
  86 /*
  87 ** Each builtin conversion character (ex: the 'd' in "%d") is described
  88 ** by an instance of the following structure
  89 */
  90 typedef struct et_info {   /* Information about each format field */
  91   char fmttype;            /* The format field code letter */
  92   etByte base;             /* The base for radix conversion */
  93   etByte flags;            /* One or more of FLAG_ constants below */
  94   etByte type;             /* Conversion paradigm */
  95   etByte charset;          /* Offset into aDigits[] of the digits string */
  96   etByte prefix;           /* Offset into aPrefix[] of the prefix string */
  97 } et_info;
  98
  99 /*
 100 ** Allowed values for et_info.flags
 101 */
 102 #define FLAG_SIGNED  1     /* True if the value to convert is signed */
 103 #define FLAG_INTERN  2     /* True if for internal use only */
 104 #define FLAG_STRING  4     /* Allow infinity precision */
 105
 106
 107 /*
 108 ** The following table is searched linearly, so it is good to put the
 109 ** most frequently used conversion types first.
 110 */
 111 static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
 112 static const char aPrefix[] = "-x0\000X0";
 113 static const et_info fmtinfo[] = {
 114   {  'd', 10, 1, etRADIX,      0,  0 },
 115   {  's',  0, 4, etSTRING,     0,  0 },
 116   {  'g',  0, 1, etGENERIC,    30, 0 },
 117   {  'z',  0, 4, etDYNSTRING,  0,  0 },
 118   {  'q',  0, 4, etSQLESCAPE,  0,  0 },
 119   {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },
 120   {  'w',  0, 4, etSQLESCAPE3, 0,  0 },
 121   {  'c',  0, 0, etCHARX,      0,  0 },
 122   {  'o',  8, 0, etRADIX,      0,  2 },
 123   {  'u', 10, 0, etRADIX,      0,  0 },
 124   {  'x', 16, 0, etRADIX,      16, 1 },
 125   {  'X', 16, 0, etRADIX,      0,  4 },
 126 #ifndef SQLITE_OMIT_FLOATING_POINT
 127   {  'f',  0, 1, etFLOAT,      0,  0 },
 128   {  'e',  0, 1, etEXP,        30, 0 },
 129   {  'E',  0, 1, etEXP,        14, 0 },
 130   {  'G',  0, 1, etGENERIC,    14, 0 },
 131 #endif
 132   {  'i', 10, 1, etRADIX,      0,  0 },
 133   {  'n',  0, 0, etSIZE,       0,  0 },
 134   {  '%',  0, 0, etPERCENT,    0,  0 },
 135   {  'p', 16, 0, etPOINTER,    0,  1 },
 136
 137 /* All the rest have the FLAG_INTERN bit set and are thus for internal
 138 ** use only */
 139   {  'T',  0, 2, etTOKEN,      0,  0 },
 140   {  'S',  0, 2, etSRCLIST,    0,  0 },
 141   {  'r', 10, 3, etORDINAL,    0,  0 },
 142 };
 143
 144 /*
 145 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
 146 ** conversions will work.
 147 */
 148 #ifndef SQLITE_OMIT_FLOATING_POINT
 149 /*
 150 ** "*val" is a double such that 0.1 <= *val < 10.0
 151 ** Return the ascii code for the leading digit of *val, then
 152 ** multiply "*val" by 10.0 to renormalize.
 153 **
 154 ** Example:
 155 **     input:     *val = 3.14159
 156 **     output:    *val = 1.4159    function return = '3'
 157 **
 158 ** The counter *cnt is incremented each time.  After counter exceeds
 159 ** 16 (the number of significant digits in a 64-bit float) '0' is
 160 ** always returned.
 161 */
 162 static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
 163   int digit;
 164   LONGDOUBLE_TYPE d;
 165   if( (*cnt)++ >= 16 ) return '0';
 166   digit = (int)*val;
 167   d = digit;
 168   digit += '0';
 169   *val = (*val - d)*10.0;
 170   return (char)digit;
 171 }
 172 #endif /* SQLITE_OMIT_FLOATING_POINT */
 173
 174 /*
 175 ** Append N space characters to the given string buffer.
 176 */
 177 static void appendSpace(StrAccum *pAccum, int N){
 178   static const char zSpaces[] = "                             ";
 179   while( N>=(int)sizeof(zSpaces)-1 ){
 180     sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
 181     N -= sizeof(zSpaces)-1;
 182   }
 183   if( N>0 ){
 184     sqlite3StrAccumAppend(pAccum, zSpaces, N);
 185   }
 186 }
 187
 188 /*
 189 ** On machines with a small stack size, you can redefine the
 190 ** SQLITE_PRINT_BUF_SIZE to be less than 350.
 191 */
 192 #ifndef SQLITE_PRINT_BUF_SIZE
 193 # if defined(SQLITE_SMALL_STACK)
 194 #   define SQLITE_PRINT_BUF_SIZE 50
 195 # else
 196 #   define SQLITE_PRINT_BUF_SIZE 350
 197 # endif
 198 #endif
 199 #define etBUFSIZE SQLITE_PRINT_BUF_SIZE  /* Size of the output buffer */
 200
 201 /*
 202 ** The root program.  All variations call this core.
 203 **
 204 ** INPUTS:
 205 **   func   This is a pointer to a function taking three arguments
 206 **            1. A pointer to anything.  Same as the "arg" parameter.
 207 **            2. A pointer to the list of characters to be output
 208 **               (Note, this list is NOT null terminated.)
 209 **            3. An integer number of characters to be output.
 210 **               (Note: This number might be zero.)
 211 **
 212 **   arg    This is the pointer to anything which will be passed as the
 213 **          first argument to "func".  Use it for whatever you like.
 214 **
 215 **   fmt    This is the format string, as in the usual print.
 216 **
 217 **   ap     This is a pointer to a list of arguments.  Same as in
 218 **          vfprint.
 219 **
 220 ** OUTPUTS:
 221 **          The return value is the total number of characters sent to
 222 **          the function "func".  Returns -1 on a error.
 223 **
 224 ** Note that the order in which automatic variables are declared below
 225 ** seems to make a big difference in determining how fast this beast
 226 ** will run.
 227 */
 228 void sqlite3VXPrintf(
 229   StrAccum *pAccum,                  /* Accumulate results here */
 230   int useExtended,                   /* Allow extended %-conversions */
 231   const char *fmt,                   /* Format string */
 232   va_list ap                         /* arguments */
 233 ){
 234   int c;                     /* Next character in the format string */
 235   char *bufpt;               /* Pointer to the conversion buffer */
 236   int precision;             /* Precision of the current field */
 237   int length;                /* Length of the field */
 238   int idx;                   /* A general purpose loop counter */
 239   int width;                 /* Width of the current field */
 240   etByte flag_leftjustify;   /* True if "-" flag is present */
 241   etByte flag_plussign;      /* True if "+" flag is present */
 242   etByte flag_blanksign;     /* True if " " flag is present */
 243   etByte flag_alternateform; /* True if "#" flag is present */
 244   etByte flag_altform2;      /* True if "!" flag is present */
 245   etByte flag_zeropad;       /* True if field width constant starts with zero */
 246   etByte flag_long;          /* True if "l" flag is present */
 247   etByte flag_longlong;      /* True if the "ll" flag is present */
 248   etByte done;               /* Loop termination flag */
 249   sqlite_uint64 longvalue;   /* Value for integer types */
 250   LONGDOUBLE_TYPE realvalue; /* Value for real types */
 251   const et_info *infop;      /* Pointer to the appropriate info structure */
 252   char buf[etBUFSIZE];       /* Conversion buffer */
 253   char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
 254   etByte xtype = 0;          /* Conversion paradigm */
 255   char *zExtra;              /* Extra memory used for etTCLESCAPE conversions */
 256 #ifndef SQLITE_OMIT_FLOATING_POINT
 257   int  exp, e2;              /* exponent of real numbers */
 258   double rounder;            /* Used for rounding floating point values */
 259   etByte flag_dp;            /* True if decimal point should be shown */
 260   etByte flag_rtz;           /* True if trailing zeros should be removed */
 261   etByte flag_exp;           /* True to force display of the exponent */
 262   int nsd;                   /* Number of significant digits returned */
 263 #endif
 264
 265   length = 0;
 266   bufpt = 0;
 267   for(; (c=(*fmt))!=0; ++fmt){
 268     if( c!='%' ){
 269       int amt;
 270       bufpt = (char *)fmt;
 271       amt = 1;
 272       while( (c=(*++fmt))!='%' && c!=0 ) amt++;
 273       sqlite3StrAccumAppend(pAccum, bufpt, amt);
 274       if( c==0 ) break;
 275     }
 276     if( (c=(*++fmt))==0 ){
 277       sqlite3StrAccumAppend(pAccum, "%", 1);
 278       break;
 279     }
 280     /* Find out what flags are present */
 281     flag_leftjustify = flag_plussign = flag_blanksign =
 282      flag_alternateform = flag_altform2 = flag_zeropad = 0;
 283     done = 0;
 284     do{
 285       switch( c ){
 286         case '-':   flag_leftjustify = 1;     break;
 287         case '+':   flag_plussign = 1;        break;
 288         case ' ':   flag_blanksign = 1;       break;
 289         case '#':   flag_alternateform = 1;   break;
 290         case '!':   flag_altform2 = 1;        break;
 291         case '0':   flag_zeropad = 1;         break;
 292         default:    done = 1;                 break;
 293       }
 294     }while( !done && (c=(*++fmt))!=0 );
 295     /* Get the field width */
 296     width = 0;
 297     if( c=='*' ){
 298       width = va_arg(ap,int);
 299       if( width<0 ){
 300         flag_leftjustify = 1;
 301         width = -width;
 302       }
 303       c = *++fmt;
 304     }else{
 305       while( c>='0' && c<='9' ){
 306         width = width*10 + c - '0';
 307         c = *++fmt;
 308       }
 309     }
 310     if( width > etBUFSIZE-10 ){
 311       width = etBUFSIZE-10;
 312     }
 313     /* Get the precision */
 314     if( c=='.' ){
 315       precision = 0;
 316       c = *++fmt;
 317       if( c=='*' ){
 318         precision = va_arg(ap,int);
 319         if( precision<0 ) precision = -precision;
 320         c = *++fmt;
 321       }else{
 322         while( c>='0' && c<='9' ){
 323           precision = precision*10 + c - '0';
 324           c = *++fmt;
 325         }
 326       }
 327     }else{
 328       precision = -1;
 329     }
 330     /* Get the conversion type modifier */
 331     if( c=='l' ){
 332       flag_long = 1;
 333       c = *++fmt;
 334       if( c=='l' ){
 335         flag_longlong = 1;
 336         c = *++fmt;
 337       }else{
 338         flag_longlong = 0;
 339       }
 340     }else{
 341       flag_long = flag_longlong = 0;
 342     }
 343     /* Fetch the info entry for the field */
 344     infop = &fmtinfo[0];
 345     xtype = etINVALID;
 346     for(idx=0; idx<ArraySize(fmtinfo); idx++){
 347       if( c==fmtinfo[idx].fmttype ){
 348         infop = &fmtinfo[idx];
 349         if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
 350           xtype = infop->type;
 351         }else{
 352           return;
 353         }
 354         break;
 355       }
 356     }
 357     zExtra = 0;
 358
 359
 360     /* Limit the precision to prevent overflowing buf[] during conversion */
 361     if( precision>etBUFSIZE-40 && (infop->flags & FLAG_STRING)==0 ){
 362       precision = etBUFSIZE-40;
 363     }
 364
 365     /*
 366     ** At this point, variables are initialized as follows:
 367     **
 368     **   flag_alternateform          TRUE if a '#' is present.
 369     **   flag_altform2               TRUE if a '!' is present.
 370     **   flag_plussign               TRUE if a '+' is present.
 371     **   flag_leftjustify            TRUE if a '-' is present or if the
 372     **                               field width was negative.
 373     **   flag_zeropad                TRUE if the width began with 0.
 374     **   flag_long                   TRUE if the letter 'l' (ell) prefixed
 375     **                               the conversion character.
 376     **   flag_longlong               TRUE if the letter 'll' (ell ell) prefixed
 377     **                               the conversion character.
 378     **   flag_blanksign              TRUE if a ' ' is present.
 379     **   width                       The specified field width.  This is
 380     **                               always non-negative.  Zero is the default.
 381     **   precision                   The specified precision.  The default
 382     **                               is -1.
 383     **   xtype                       The class of the conversion.
 384     **   infop                       Pointer to the appropriate info struct.
 385     */
 386     switch( xtype ){
 387       case etPOINTER:
 388         flag_longlong = sizeof(char*)==sizeof(i64);
 389         flag_long = sizeof(char*)==sizeof(long int);
 390         /* Fall through into the next case */
 391       case etORDINAL:
 392       case etRADIX:
 393         if( infop->flags & FLAG_SIGNED ){
 394           i64 v;
 395           if( flag_longlong ){
 396             v = va_arg(ap,i64);
 397           }else if( flag_long ){
 398             v = va_arg(ap,long int);
 399           }else{
 400             v = va_arg(ap,int);
 401           }
 402           if( v<0 ){
 403             if( v==SMALLEST_INT64 ){
 404               longvalue = ((u64)1)<<63;
 405             }else{
 406               longvalue = -v;
 407             }
 408             prefix = '-';
 409           }else{
 410             longvalue = v;
 411             if( flag_plussign )        prefix = '+';
 412             else if( flag_blanksign )  prefix = ' ';
 413             else                       prefix = 0;
 414           }
 415         }else{
 416           if( flag_longlong ){
 417             longvalue = va_arg(ap,u64);
 418           }else if( flag_long ){
 419             longvalue = va_arg(ap,unsigned long int);
 420           }else{
 421             longvalue = va_arg(ap,unsigned int);
 422           }
 423           prefix = 0;
 424         }
 425         if( longvalue==0 ) flag_alternateform = 0;
 426         if( flag_zeropad && precision<width-(prefix!=0) ){
 427           precision = width-(prefix!=0);
 428         }
 429         bufpt = &buf[etBUFSIZE-1];
 430         if( xtype==etORDINAL ){
 431           static const char zOrd[] = "thstndrd";
 432           int x = (int)(longvalue % 10);
 433           if( x>=4 || (longvalue/10)%10==1 ){
 434             x = 0;
 435           }
 436           buf[etBUFSIZE-3] = zOrd[x*2];
 437           buf[etBUFSIZE-2] = zOrd[x*2+1];
 438           bufpt -= 2;
 439         }
 440         {
 441           register const char *cset;      /* Use registers for speed */
 442           register int base;
 443           cset = &aDigits[infop->charset];
 444           base = infop->base;
 445           do{                                           /* Convert to ascii */
 446             *(--bufpt) = cset[longvalue%base];
 447             longvalue = longvalue/base;
 448           }while( longvalue>0 );
 449         }
 450         length = (int)(&buf[etBUFSIZE-1]-bufpt);
 451         for(idx=precision-length; idx>0; idx--){
 452           *(--bufpt) = '0';                             /* Zero pad */
 453         }
 454         if( prefix ) *(--bufpt) = prefix;               /* Add sign */
 455         if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
 456           const char *pre;
 457           char x;
 458           pre = &aPrefix[infop->prefix];
 459           for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
 460         }
 461         length = (int)(&buf[etBUFSIZE-1]-bufpt);
 462         break;
 463       case etFLOAT:
 464       case etEXP:
 465       case etGENERIC:
 466         realvalue = va_arg(ap,double);
 467 #ifdef SQLITE_OMIT_FLOATING_POINT
 468         length = 0;
 469 #else
 470         if( precision<0 ) precision = 6;         /* Set default precision */
 471         if( precision>etBUFSIZE/2-10 ) precision = etBUFSIZE/2-10;
 472         if( realvalue<0.0 ){
 473           realvalue = -realvalue;
 474           prefix = '-';
 475         }else{
 476           if( flag_plussign )          prefix = '+';
 477           else if( flag_blanksign )    prefix = ' ';
 478           else                         prefix = 0;
 479         }
 480         if( xtype==etGENERIC && precision>0 ) precision--;
 481 #if 0
 482         /* Rounding works like BSD when the constant 0.4999 is used.  Wierd! */
 483         for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
 484 #else
 485         /* It makes more sense to use 0.5 */
 486         for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
 487 #endif
 488         if( xtype==etFLOAT ) realvalue += rounder;
 489         /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
 490         exp = 0;
 491         if( sqlite3IsNaN((double)realvalue) ){
 492           bufpt = "NaN";
 493           length = 3;
 494           break;
 495         }
 496         if( realvalue>0.0 ){
 497           while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }
 498           while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
 499           while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
 500           while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
 501           while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
 502           if( exp>350 ){
 503             if( prefix=='-' ){
 504               bufpt = "-Inf";
 505             }else if( prefix=='+' ){
 506               bufpt = "+Inf";
 507             }else{
 508               bufpt = "Inf";
 509             }
 510             length = sqlite3Strlen30(bufpt);
 511             break;
 512           }
 513         }
 514         bufpt = buf;
 515         /*
 516         ** If the field type is etGENERIC, then convert to either etEXP
 517         ** or etFLOAT, as appropriate.
 518         */
 519         flag_exp = xtype==etEXP;
 520         if( xtype!=etFLOAT ){
 521           realvalue += rounder;
 522           if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
 523         }
 524         if( xtype==etGENERIC ){
 525           flag_rtz = !flag_alternateform;
 526           if( exp<-4 || exp>precision ){
 527             xtype = etEXP;
 528           }else{
 529             precision = precision - exp;
 530             xtype = etFLOAT;
 531           }
 532         }else{
 533           flag_rtz = 0;
 534         }
 535         if( xtype==etEXP ){
 536           e2 = 0;
 537         }else{
 538           e2 = exp;
 539         }
 540         nsd = 0;
 541         flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
 542         /* The sign in front of the number */
 543         if( prefix ){
 544           *(bufpt++) = prefix;
 545         }
 546         /* Digits prior to the decimal point */
 547         if( e2<0 ){
 548           *(bufpt++) = '0';
 549         }else{
 550           for(; e2>=0; e2--){
 551             *(bufpt++) = et_getdigit(&realvalue,&nsd);
 552           }
 553         }
 554         /* The decimal point */
 555         if( flag_dp ){
 556           *(bufpt++) = '.';
 557         }
 558         /* "0" digits after the decimal point but before the first
 559         ** significant digit of the number */
 560         for(e2++; e2<0; precision--, e2++){
 561           assert( precision>0 );
 562           *(bufpt++) = '0';
 563         }
 564         /* Significant digits after the decimal point */
 565         while( (precision--)>0 ){
 566           *(bufpt++) = et_getdigit(&realvalue,&nsd);
 567         }
 568         /* Remove trailing zeros and the "." if no digits follow the "." */
 569         if( flag_rtz && flag_dp ){
 570           while( bufpt[-1]=='0' ) *(--bufpt) = 0;
 571           assert( bufpt>buf );
 572           if( bufpt[-1]=='.' ){
 573             if( flag_altform2 ){
 574               *(bufpt++) = '0';
 575             }else{
 576               *(--bufpt) = 0;
 577             }
 578           }
 579         }
 580         /* Add the "eNNN" suffix */
 581         if( flag_exp || xtype==etEXP ){
 582           *(bufpt++) = aDigits[infop->charset];
 583           if( exp<0 ){
 584             *(bufpt++) = '-'; exp = -exp;
 585           }else{
 586             *(bufpt++) = '+';
 587           }
 588           if( exp>=100 ){
 589             *(bufpt++) = (char)((exp/100)+'0');        /* 100's digit */
 590             exp %= 100;
 591           }
 592           *(bufpt++) = (char)(exp/10+'0');             /* 10's digit */
 593           *(bufpt++) = (char)(exp%10+'0');             /* 1's digit */
 594         }
 595         *bufpt = 0;
 596
 597         /* The converted number is in buf[] and zero terminated. Output it.
 598         ** Note that the number is in the usual order, not reversed as with
 599         ** integer conversions. */
 600         length = (int)(bufpt-buf);
 601         bufpt = buf;
 602
 603         /* Special case:  Add leading zeros if the flag_zeropad flag is
 604         ** set and we are not left justified */
 605         if( flag_zeropad && !flag_leftjustify && length < width){
 606           int i;
 607           int nPad = width - length;
 608           for(i=width; i>=nPad; i--){
 609             bufpt[i] = bufpt[i-nPad];
 610           }
 611           i = prefix!=0;
 612           while( nPad-- ) bufpt[i++] = '0';
 613           length = width;
 614         }
 615 #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
 616         break;
 617       case etSIZE:
 618         *(va_arg(ap,int*)) = pAccum->nChar;
 619         length = width = 0;
 620         break;
 621       case etPERCENT:
 622         buf[0] = '%';
 623         bufpt = buf;
 624         length = 1;
 625         break;
 626       case etCHARX:
 627         c = va_arg(ap,int);
 628         buf[0] = (char)c;
 629         if( precision>=0 ){
 630           for(idx=1; idx<precision; idx++) buf[idx] = (char)c;
 631           length = precision;
 632         }else{
 633           length =1;
 634         }
 635         bufpt = buf;
 636         break;
 637       case etSTRING:
 638       case etDYNSTRING:
 639         bufpt = va_arg(ap,char*);
 640         if( bufpt==0 ){
 641           bufpt = "";
 642         }else if( xtype==etDYNSTRING ){
 643           zExtra = bufpt;
 644         }
 645         if( precision>=0 ){
 646           for(length=0; length<precision && bufpt[length]; length++){}
 647         }else{
 648           length = sqlite3Strlen30(bufpt);
 649         }
 650         break;
 651       case etSQLESCAPE:
 652       case etSQLESCAPE2:
 653       case etSQLESCAPE3: {
 654         int i, j, k, n, isnull;
 655         int needQuote;
 656         char ch;
 657         char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
 658         char *escarg = va_arg(ap,char*);
 659         isnull = escarg==0;
 660         if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
 661         k = precision;
 662         for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
 663           if( ch==q )  n++;
 664         }
 665         needQuote = !isnull && xtype==etSQLESCAPE2;
 666         n += i + 1 + needQuote*2;
 667         if( n>etBUFSIZE ){
 668           bufpt = zExtra = sqlite3Malloc( n );
 669           if( bufpt==0 ){
 670             pAccum->mallocFailed = 1;
 671             return;
 672           }
 673         }else{
 674           bufpt = buf;
 675         }
 676         j = 0;
 677         if( needQuote ) bufpt[j++] = q;
 678         k = i;
 679         for(i=0; i<k; i++){
 680           bufpt[j++] = ch = escarg[i];
 681           if( ch==q ) bufpt[j++] = ch;
 682         }
 683         if( needQuote ) bufpt[j++] = q;
 684         bufpt[j] = 0;
 685         length = j;
 686         /* The precision in %q and %Q means how many input characters to
 687         ** consume, not the length of the output...
 688         ** if( precision>=0 && precision<length ) length = precision; */
 689         break;
 690       }
 691       case etTOKEN: {
 692         Token *pToken = va_arg(ap, Token*);
 693         if( pToken ){
 694           sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
 695         }
 696         length = width = 0;
 697         break;
 698       }
 699       case etSRCLIST: {
 700         SrcList *pSrc = va_arg(ap, SrcList*);
 701         int k = va_arg(ap, int);
 702         struct SrcList_item *pItem = &pSrc->a[k];
 703         assert( k>=0 && k<pSrc->nSrc );
 704         if( pItem->zDatabase ){
 705           sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);
 706           sqlite3StrAccumAppend(pAccum, ".", 1);
 707         }
 708         sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
 709         length = width = 0;
 710         break;
 711       }
 712       default: {
 713         assert( xtype==etINVALID );
 714         return;
 715       }
 716     }/* End switch over the format type */
 717     /*
 718     ** The text of the conversion is pointed to by "bufpt" and is
 719     ** "length" characters long.  The field width is "width".  Do
 720     ** the output.
 721     */
 722     if( !flag_leftjustify ){
 723       register int nspace;
 724       nspace = width-length;
 725       if( nspace>0 ){
 726         appendSpace(pAccum, nspace);
 727       }
 728     }
 729     if( length>0 ){
 730       sqlite3StrAccumAppend(pAccum, bufpt, length);
 731     }
 732     if( flag_leftjustify ){
 733       register int nspace;
 734       nspace = width-length;
 735       if( nspace>0 ){
 736         appendSpace(pAccum, nspace);
 737       }
 738     }
 739     if( zExtra ){
 740       sqlite3_free(zExtra);
 741     }
 742   }/* End for loop over the format string */
 743 } /* End of function */
 744
 745 /*
 746 ** Append N bytes of text from z to the StrAccum object.
 747 */
 748 void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
 749   assert( z!=0 || N==0 );
 750   if( p->tooBig | p->mallocFailed ){
 751     testcase(p->tooBig);
 752     testcase(p->mallocFailed);
 753     return;
 754   }
 755   if( N<0 ){
 756     N = sqlite3Strlen30(z);
 757   }
 758   if( N==0 || NEVER(z==0) ){
 759     return;
 760   }
 761   if( p->nChar+N >= p->nAlloc ){
 762     char *zNew;
 763     if( !p->useMalloc ){
 764       p->tooBig = 1;
 765       N = p->nAlloc - p->nChar - 1;
 766       if( N<=0 ){
 767         return;
 768       }
 769     }else{
 770       char *zOld = (p->zText==p->zBase ? 0 : p->zText);
 771       i64 szNew = p->nChar;
 772       szNew += N + 1;
 773       if( szNew > p->mxAlloc ){
 774         sqlite3StrAccumReset(p);
 775         p->tooBig = 1;
 776         return;
 777       }else{
 778         p->nAlloc = (int)szNew;
 779       }
 780       if( p->useMalloc==1 ){
 781         zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
 782       }else{
 783         zNew = sqlite3_realloc(zOld, p->nAlloc);
 784       }
 785       if( zNew ){
 786         if( zOld==0 ) memcpy(zNew, p->zText, p->nChar);
 787         p->zText = zNew;
 788       }else{
 789         p->mallocFailed = 1;
 790         sqlite3StrAccumReset(p);
 791         return;
 792       }
 793     }
 794   }
 795   memcpy(&p->zText[p->nChar], z, N);
 796   p->nChar += N;
 797 }
 798
 799 /*
 800 ** Finish off a string by making sure it is zero-terminated.
 801 ** Return a pointer to the resulting string.  Return a NULL
 802 ** pointer if any kind of error was encountered.
 803 */
 804 char *sqlite3StrAccumFinish(StrAccum *p){
 805   if( p->zText ){
 806     p->zText[p->nChar] = 0;
 807     if( p->useMalloc && p->zText==p->zBase ){
 808       if( p->useMalloc==1 ){
 809         p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
 810       }else{
 811         p->zText = sqlite3_malloc(p->nChar+1);
 812       }
 813       if( p->zText ){
 814         memcpy(p->zText, p->zBase, p->nChar+1);
 815       }else{
 816         p->mallocFailed = 1;
 817       }
 818     }
 819   }
 820   return p->zText;
 821 }
 822
 823 /*
 824 ** Reset an StrAccum string.  Reclaim all malloced memory.
 825 */
 826 void sqlite3StrAccumReset(StrAccum *p){
 827   if( p->zText!=p->zBase ){
 828     if( p->useMalloc==1 ){
 829       sqlite3DbFree(p->db, p->zText);
 830     }else{
 831       sqlite3_free(p->zText);
 832     }
 833   }
 834   p->zText = 0;
 835 }
 836
 837 /*
 838 ** Initialize a string accumulator
 839 */
 840 void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
 841   p->zText = p->zBase = zBase;
 842   p->db = 0;
 843   p->nChar = 0;
 844   p->nAlloc = n;
 845   p->mxAlloc = mx;
 846   p->useMalloc = 1;
 847   p->tooBig = 0;
 848   p->mallocFailed = 0;
 849 }
 850
 851 /*
 852 ** Print into memory obtained from sqliteMalloc().  Use the internal
 853 ** %-conversion extensions.
 854 */
 855 char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
 856   char *z;
 857   char zBase[SQLITE_PRINT_BUF_SIZE];
 858   StrAccum acc;
 859   assert( db!=0 );
 860   sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
 861                       db->aLimit[SQLITE_LIMIT_LENGTH]);
 862   acc.db = db;
 863   sqlite3VXPrintf(&acc, 1, zFormat, ap);
 864   z = sqlite3StrAccumFinish(&acc);
 865   if( acc.mallocFailed ){
 866     db->mallocFailed = 1;
 867   }
 868   return z;
 869 }
 870
 871 /*
 872 ** Print into memory obtained from sqliteMalloc().  Use the internal
 873 ** %-conversion extensions.
 874 */
 875 char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
 876   va_list ap;
 877   char *z;
 878   va_start(ap, zFormat);
 879   z = sqlite3VMPrintf(db, zFormat, ap);
 880   va_end(ap);
 881   return z;
 882 }
 883
 884 /*
 885 ** Like sqlite3MPrintf(), but call sqlite3DbFree() on zStr after formatting
 886 ** the string and before returnning.  This routine is intended to be used
 887 ** to modify an existing string.  For example:
 888 **
 889 **       x = sqlite3MPrintf(db, x, "prefix %s suffix", x);
 890 **
 891 */
 892 char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zFormat, ...){
 893   va_list ap;
 894   char *z;
 895   va_start(ap, zFormat);
 896   z = sqlite3VMPrintf(db, zFormat, ap);
 897   va_end(ap);
 898   sqlite3DbFree(db, zStr);
 899   return z;
 900 }
 901
 902 /*
 903 ** Print into memory obtained from sqlite3_malloc().  Omit the internal
 904 ** %-conversion extensions.
 905 */
 906 char *sqlite3_vmprintf(const char *zFormat, va_list ap){
 907   char *z;
 908   char zBase[SQLITE_PRINT_BUF_SIZE];
 909   StrAccum acc;
 910 #ifndef SQLITE_OMIT_AUTOINIT
 911   if( sqlite3_initialize() ) return 0;
 912 #endif
 913   sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
 914   acc.useMalloc = 2;
 915   sqlite3VXPrintf(&acc, 0, zFormat, ap);
 916   z = sqlite3StrAccumFinish(&acc);
 917   return z;
 918 }
 919
 920 /*
 921 ** Print into memory obtained from sqlite3_malloc()().  Omit the internal
 922 ** %-conversion extensions.
 923 */
 924 char *sqlite3_mprintf(const char *zFormat, ...){
 925   va_list ap;
 926   char *z;
 927 #ifndef SQLITE_OMIT_AUTOINIT
 928   if( sqlite3_initialize() ) return 0;
 929 #endif
 930   va_start(ap, zFormat);
 931   z = sqlite3_vmprintf(zFormat, ap);
 932   va_end(ap);
 933   return z;
 934 }
 935
 936 /*
 937 ** sqlite3_snprintf() works like snprintf() except that it ignores the
 938 ** current locale settings.  This is important for SQLite because we
 939 ** are not able to use a "," as the decimal point in place of "." as
 940 ** specified by some locales.
 941 **
 942 ** Oops:  The first two arguments of sqlite3_snprintf() are backwards
 943 ** from the snprintf() standard.  Unfortunately, it is too late to change
 944 ** this without breaking compatibility, so we just have to live with the
 945 ** mistake.
 946 **
 947 ** sqlite3_vsnprintf() is the varargs version.
 948 */
 949 char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
 950   StrAccum acc;
 951   if( n<=0 ) return zBuf;
 952   sqlite3StrAccumInit(&acc, zBuf, n, 0);
 953   acc.useMalloc = 0;
 954   sqlite3VXPrintf(&acc, 0, zFormat, ap);
 955   return sqlite3StrAccumFinish(&acc);
 956 }
 957 char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
 958   char *z;
 959   va_list ap;
 960   va_start(ap,zFormat);
 961   z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
 962   va_end(ap);
 963   return z;
 964 }
 965
 966 /*
 967 ** This is the routine that actually formats the sqlite3_log() message.
 968 ** We house it in a separate routine from sqlite3_log() to avoid using
 969 ** stack space on small-stack systems when logging is disabled.
 970 **
 971 ** sqlite3_log() must render into a static buffer.  It cannot dynamically
 972 ** allocate memory because it might be called while the memory allocator
 973 ** mutex is held.
 974 */
 975 static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
 976   StrAccum acc;                          /* String accumulator */
 977   char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */
 978
 979   sqlite3StrAccumInit(&acc, zMsg, sizeof(zMsg), 0);
 980   acc.useMalloc = 0;
 981   sqlite3VXPrintf(&acc, 0, zFormat, ap);
 982   sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
 983                            sqlite3StrAccumFinish(&acc));
 984 }
 985
 986 /*
 987 ** Format and write a message to the log if logging is enabled.
 988 */
 989 void sqlite3_log(int iErrCode, const char *zFormat, ...){
 990   va_list ap;                             /* Vararg list */
 991   if( sqlite3GlobalConfig.xLog ){
 992     va_start(ap, zFormat);
 993     renderLogMsg(iErrCode, zFormat, ap);
 994     va_end(ap);
 995   }
 996 }
 997
 998 #if defined(SQLITE_DEBUG)
 999 /*
1000 ** A version of printf() that understands %lld.  Used for debugging.
1001 ** The printf() built into some versions of windows does not understand %lld
1002 ** and segfaults if you give it a long long int.
1003 */
1004 void sqlite3DebugPrintf(const char *zFormat, ...){
1005   va_list ap;
1006   StrAccum acc;
1007   char zBuf[500];
1008   sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);
1009   acc.useMalloc = 0;
1010   va_start(ap,zFormat);
1011   sqlite3VXPrintf(&acc, 0, zFormat, ap);
1012   va_end(ap);
1013   sqlite3StrAccumFinish(&acc);
1014   fprintf(stdout,"%s", zBuf);
1015   fflush(stdout);
1016 }
1017 #endif
1018
1019 #ifndef SQLITE_OMIT_TRACE
1020 /*
1021 ** variable-argument wrapper around sqlite3VXPrintf().
1022 */
1023 void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
1024   va_list ap;
1025   va_start(ap,zFormat);
1026   sqlite3VXPrintf(p, 1, zFormat, ap);
1027   va_end(ap);
1028 }
1029 #endif