src/printf.c

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