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