2 ** The "printf" code that follows dates from the 1980's. It is in
5 **************************************************************************
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
12 #include "sqliteInt.h"
15 ** Conversion types fall into various categories as defined by the
16 ** following enumeration.
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 */
38 #define etINVALID 17 /* Any unrecognized conversion type */
42 ** An "etByte" is an 8-bit unsigned value.
44 typedef unsigned char etByte
;
47 ** Each builtin conversion character (ex: the 'd' in "%d") is described
48 ** by an instance of the following structure
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 */
60 ** Allowed values for et_info.flags
62 #define FLAG_SIGNED 1 /* True if the value to convert is signed */
63 #define FLAG_STRING 4 /* Allow infinite precision */
67 ** The following table is searched linearly, so it is good to put the
68 ** most frequently used conversion types first.
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 },
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 },
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 },
102 /* Floating point constants used for rounding */
103 static const double arRound
[] = {
104 5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05,
105 5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10,
109 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
110 ** conversions will work.
112 #ifndef SQLITE_OMIT_FLOATING_POINT
114 ** "*val" is a double such that 0.1 <= *val < 10.0
115 ** Return the ascii code for the leading digit of *val, then
116 ** multiply "*val" by 10.0 to renormalize.
119 ** input: *val = 3.14159
120 ** output: *val = 1.4159 function return = '3'
122 ** The counter *cnt is incremented each time. After counter exceeds
123 ** 16 (the number of significant digits in a 64-bit float) '0' is
126 static char et_getdigit(LONGDOUBLE_TYPE
*val
, int *cnt
){
129 if( (*cnt
)<=0 ) return '0';
134 *val
= (*val
- d
)*10.0;
137 #endif /* SQLITE_OMIT_FLOATING_POINT */
140 ** Set the StrAccum object to an error mode.
142 static void setStrAccumError(StrAccum
*p
, u8 eError
){
143 assert( eError
==SQLITE_NOMEM
|| eError
==SQLITE_TOOBIG
);
144 p
->accError
= eError
;
145 if( p
->mxAlloc
) sqlite3_str_reset(p
);
146 if( eError
==SQLITE_TOOBIG
) sqlite3ErrorToParser(p
->db
, eError
);
150 ** Extra argument values from a PrintfArguments object
152 static sqlite3_int64
getIntArg(PrintfArguments
*p
){
153 if( p
->nArg
<=p
->nUsed
) return 0;
154 return sqlite3_value_int64(p
->apArg
[p
->nUsed
++]);
156 static double getDoubleArg(PrintfArguments
*p
){
157 if( p
->nArg
<=p
->nUsed
) return 0.0;
158 return sqlite3_value_double(p
->apArg
[p
->nUsed
++]);
160 static char *getTextArg(PrintfArguments
*p
){
161 if( p
->nArg
<=p
->nUsed
) return 0;
162 return (char*)sqlite3_value_text(p
->apArg
[p
->nUsed
++]);
166 ** Allocate memory for a temporary buffer needed for printf rendering.
168 ** If the requested size of the temp buffer is larger than the size
169 ** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error.
170 ** Do the size check before the memory allocation to prevent rogue
171 ** SQL from requesting large allocations using the precision or width
172 ** field of the printf() function.
174 static char *printfTempBuf(sqlite3_str
*pAccum
, sqlite3_int64 n
){
176 if( pAccum
->accError
) return 0;
177 if( n
>pAccum
->nAlloc
&& n
>pAccum
->mxAlloc
){
178 setStrAccumError(pAccum
, SQLITE_TOOBIG
);
181 z
= sqlite3DbMallocRaw(pAccum
->db
, n
);
183 setStrAccumError(pAccum
, SQLITE_NOMEM
);
189 ** On machines with a small stack size, you can redefine the
190 ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
192 #ifndef SQLITE_PRINT_BUF_SIZE
193 # define SQLITE_PRINT_BUF_SIZE 70
195 #define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */
198 ** Hard limit on the precision of floating-point conversions.
200 #ifndef SQLITE_PRINTF_PRECISION_LIMIT
201 # define SQLITE_FP_PRECISION_LIMIT 100000000
205 ** Render a string given by "fmt" into the StrAccum object.
207 void sqlite3_str_vappendf(
208 sqlite3_str
*pAccum
, /* Accumulate results here */
209 const char *fmt
, /* Format string */
210 va_list ap
/* arguments */
212 int c
; /* Next character in the format string */
213 char *bufpt
; /* Pointer to the conversion buffer */
214 int precision
; /* Precision of the current field */
215 int length
; /* Length of the field */
216 int idx
; /* A general purpose loop counter */
217 int width
; /* Width of the current field */
218 etByte flag_leftjustify
; /* True if "-" flag is present */
219 etByte flag_prefix
; /* '+' or ' ' or 0 for prefix */
220 etByte flag_alternateform
; /* True if "#" flag is present */
221 etByte flag_altform2
; /* True if "!" flag is present */
222 etByte flag_zeropad
; /* True if field width constant starts with zero */
223 etByte flag_long
; /* 1 for the "l" flag, 2 for "ll", 0 by default */
224 etByte done
; /* Loop termination flag */
225 etByte cThousand
; /* Thousands separator for %d and %u */
226 etByte xtype
= etINVALID
; /* Conversion paradigm */
227 u8 bArgList
; /* True for SQLITE_PRINTF_SQLFUNC */
228 char prefix
; /* Prefix character. "+" or "-" or " " or '\0'. */
229 sqlite_uint64 longvalue
; /* Value for integer types */
230 LONGDOUBLE_TYPE realvalue
; /* Value for real types */
231 const et_info
*infop
; /* Pointer to the appropriate info structure */
232 char *zOut
; /* Rendering buffer */
233 int nOut
; /* Size of the rendering buffer */
234 char *zExtra
= 0; /* Malloced memory used by some conversion */
235 #ifndef SQLITE_OMIT_FLOATING_POINT
236 int exp
, e2
; /* exponent of real numbers */
237 int nsd
; /* Number of significant digits returned */
238 double rounder
; /* Used for rounding floating point values */
239 etByte flag_dp
; /* True if decimal point should be shown */
240 etByte flag_rtz
; /* True if trailing zeros should be removed */
242 PrintfArguments
*pArgList
= 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
243 char buf
[etBUFSIZE
]; /* Conversion buffer */
245 /* pAccum never starts out with an empty buffer that was obtained from
246 ** malloc(). This precondition is required by the mprintf("%z...")
248 assert( pAccum
->nChar
>0 || (pAccum
->printfFlags
&SQLITE_PRINTF_MALLOCED
)==0 );
251 if( (pAccum
->printfFlags
& SQLITE_PRINTF_SQLFUNC
)!=0 ){
252 pArgList
= va_arg(ap
, PrintfArguments
*);
257 for(; (c
=(*fmt
))!=0; ++fmt
){
261 fmt
= strchrnul(fmt
, '%');
263 do{ fmt
++; }while( *fmt
&& *fmt
!= '%' );
265 sqlite3_str_append(pAccum
, bufpt
, (int)(fmt
- bufpt
));
268 if( (c
=(*++fmt
))==0 ){
269 sqlite3_str_append(pAccum
, "%", 1);
272 /* Find out what flags are present */
273 flag_leftjustify
= flag_prefix
= cThousand
=
274 flag_alternateform
= flag_altform2
= flag_zeropad
= 0;
281 case '-': flag_leftjustify
= 1; break;
282 case '+': flag_prefix
= '+'; break;
283 case ' ': flag_prefix
= ' '; break;
284 case '#': flag_alternateform
= 1; break;
285 case '!': flag_altform2
= 1; break;
286 case '0': flag_zeropad
= 1; break;
287 case ',': cThousand
= ','; break;
288 default: done
= 1; break;
299 case '1': case '2': case '3': case '4': case '5':
300 case '6': case '7': case '8': case '9': {
301 unsigned wx
= c
- '0';
302 while( (c
= *++fmt
)>='0' && c
<='9' ){
303 wx
= wx
*10 + c
- '0';
305 testcase( wx
>0x7fffffff );
306 width
= wx
& 0x7fffffff;
307 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
308 if( width
>SQLITE_PRINTF_PRECISION_LIMIT
){
309 width
= SQLITE_PRINTF_PRECISION_LIMIT
;
312 if( c
!='.' && c
!='l' ){
321 width
= (int)getIntArg(pArgList
);
323 width
= va_arg(ap
,int);
326 flag_leftjustify
= 1;
327 width
= width
>= -2147483647 ? -width
: 0;
329 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
330 if( width
>SQLITE_PRINTF_PRECISION_LIMIT
){
331 width
= SQLITE_PRINTF_PRECISION_LIMIT
;
334 if( (c
= fmt
[1])!='.' && c
!='l' ){
344 precision
= (int)getIntArg(pArgList
);
346 precision
= va_arg(ap
,int);
349 precision
= precision
>= -2147483647 ? -precision
: -1;
354 while( c
>='0' && c
<='9' ){
355 px
= px
*10 + c
- '0';
358 testcase( px
>0x7fffffff );
359 precision
= px
& 0x7fffffff;
361 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
362 if( precision
>SQLITE_PRINTF_PRECISION_LIMIT
){
363 precision
= SQLITE_PRINTF_PRECISION_LIMIT
;
374 }while( !done
&& (c
=(*++fmt
))!=0 );
376 /* Fetch the info entry for the field */
379 for(idx
=0; idx
<ArraySize(fmtinfo
); idx
++){
380 if( c
==fmtinfo
[idx
].fmttype
){
381 infop
= &fmtinfo
[idx
];
388 ** At this point, variables are initialized as follows:
390 ** flag_alternateform TRUE if a '#' is present.
391 ** flag_altform2 TRUE if a '!' is present.
392 ** flag_prefix '+' or ' ' or zero
393 ** flag_leftjustify TRUE if a '-' is present or if the
394 ** field width was negative.
395 ** flag_zeropad TRUE if the width began with 0.
396 ** flag_long 1 for "l", 2 for "ll"
397 ** width The specified field width. This is
398 ** always non-negative. Zero is the default.
399 ** precision The specified precision. The default
401 ** xtype The class of the conversion.
402 ** infop Pointer to the appropriate info struct.
405 assert( precision
>=(-1) );
408 flag_long
= sizeof(char*)==sizeof(i64
) ? 2 :
409 sizeof(char*)==sizeof(long int) ? 1 : 0;
410 /* no break */ deliberate_fall_through
414 /* no break */ deliberate_fall_through
416 if( infop
->flags
& FLAG_SIGNED
){
419 v
= getIntArg(pArgList
);
420 }else if( flag_long
){
424 v
= va_arg(ap
,long int);
430 if( v
==SMALLEST_INT64
){
431 longvalue
= ((u64
)1)<<63;
438 prefix
= flag_prefix
;
442 longvalue
= (u64
)getIntArg(pArgList
);
443 }else if( flag_long
){
445 longvalue
= va_arg(ap
,u64
);
447 longvalue
= va_arg(ap
,unsigned long int);
450 longvalue
= va_arg(ap
,unsigned int);
454 if( longvalue
==0 ) flag_alternateform
= 0;
455 if( flag_zeropad
&& precision
<width
-(prefix
!=0) ){
456 precision
= width
-(prefix
!=0);
458 if( precision
<etBUFSIZE
-10-etBUFSIZE
/3 ){
463 n
= (u64
)precision
+ 10;
464 if( cThousand
) n
+= precision
/3;
465 zOut
= zExtra
= printfTempBuf(pAccum
, n
);
466 if( zOut
==0 ) return;
469 bufpt
= &zOut
[nOut
-1];
470 if( xtype
==etORDINAL
){
471 static const char zOrd
[] = "thstndrd";
472 int x
= (int)(longvalue
% 10);
473 if( x
>=4 || (longvalue
/10)%10==1 ){
476 *(--bufpt
) = zOrd
[x
*2+1];
477 *(--bufpt
) = zOrd
[x
*2];
480 const char *cset
= &aDigits
[infop
->charset
];
481 u8 base
= infop
->base
;
482 do{ /* Convert to ascii */
483 *(--bufpt
) = cset
[longvalue
%base
];
484 longvalue
= longvalue
/base
;
485 }while( longvalue
>0 );
487 length
= (int)(&zOut
[nOut
-1]-bufpt
);
488 while( precision
>length
){
489 *(--bufpt
) = '0'; /* Zero pad */
493 int nn
= (length
- 1)/3; /* Number of "," to insert */
494 int ix
= (length
- 1)%3 + 1;
496 for(idx
=0; nn
>0; idx
++){
497 bufpt
[idx
] = bufpt
[idx
+nn
];
500 bufpt
[++idx
] = cThousand
;
506 if( prefix
) *(--bufpt
) = prefix
; /* Add sign */
507 if( flag_alternateform
&& infop
->prefix
){ /* Add "0" or "0x" */
510 pre
= &aPrefix
[infop
->prefix
];
511 for(; (x
=(*pre
))!=0; pre
++) *(--bufpt
) = x
;
513 length
= (int)(&zOut
[nOut
-1]-bufpt
);
519 realvalue
= getDoubleArg(pArgList
);
521 realvalue
= va_arg(ap
,double);
523 #ifdef SQLITE_OMIT_FLOATING_POINT
526 if( precision
<0 ) precision
= 6; /* Set default precision */
527 #ifdef SQLITE_FP_PRECISION_LIMIT
528 if( precision
>SQLITE_FP_PRECISION_LIMIT
){
529 precision
= SQLITE_FP_PRECISION_LIMIT
;
533 realvalue
= -realvalue
;
536 prefix
= flag_prefix
;
538 if( xtype
==etGENERIC
&& precision
>0 ) precision
--;
539 testcase( precision
>0xfff );
540 idx
= precision
& 0xfff;
541 rounder
= arRound
[idx
%10];
542 while( idx
>=10 ){ rounder
*= 1.0e-10; idx
-= 10; }
543 if( xtype
==etFLOAT
){
544 double rx
= (double)realvalue
;
547 memcpy(&u
, &rx
, sizeof(u
));
548 ex
= -1023 + (int)((u
>>52)&0x7ff);
549 if( precision
+(ex
/3) < 15 ) rounder
+= realvalue
*3e-16;
550 realvalue
+= rounder
;
552 /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
554 if( sqlite3IsNaN((double)realvalue
) ){
560 LONGDOUBLE_TYPE scale
= 1.0;
561 while( realvalue
>=1e100
*scale
&& exp
<=350 ){ scale
*= 1e100
;exp
+=100;}
562 while( realvalue
>=1e10
*scale
&& exp
<=350 ){ scale
*= 1e10
; exp
+=10; }
563 while( realvalue
>=10.0*scale
&& exp
<=350 ){ scale
*= 10.0; exp
++; }
565 while( realvalue
<1e-8 ){ realvalue
*= 1e8
; exp
-=8; }
566 while( realvalue
<1.0 ){ realvalue
*= 10.0; exp
--; }
570 memcpy(buf
+(prefix
!=0),"Inf",4);
571 length
= 3+(prefix
!=0);
577 ** If the field type is etGENERIC, then convert to either etEXP
578 ** or etFLOAT, as appropriate.
580 if( xtype
!=etFLOAT
){
581 realvalue
+= rounder
;
582 if( realvalue
>=10.0 ){ realvalue
*= 0.1; exp
++; }
584 if( xtype
==etGENERIC
){
585 flag_rtz
= !flag_alternateform
;
586 if( exp
<-4 || exp
>precision
){
589 precision
= precision
- exp
;
593 flag_rtz
= flag_altform2
;
601 i64 szBufNeeded
; /* Size of a temporary buffer needed */
602 szBufNeeded
= MAX(e2
,0)+(i64
)precision
+(i64
)width
+15;
603 if( szBufNeeded
> etBUFSIZE
){
604 bufpt
= zExtra
= printfTempBuf(pAccum
, szBufNeeded
);
605 if( bufpt
==0 ) return;
609 nsd
= 16 + flag_altform2
*10;
610 flag_dp
= (precision
>0 ?1:0) | flag_alternateform
| flag_altform2
;
611 /* The sign in front of the number */
615 /* Digits prior to the decimal point */
620 *(bufpt
++) = et_getdigit(&realvalue
,&nsd
);
623 /* The decimal point */
627 /* "0" digits after the decimal point but before the first
628 ** significant digit of the number */
629 for(e2
++; e2
<0; precision
--, e2
++){
630 assert( precision
>0 );
633 /* Significant digits after the decimal point */
634 while( (precision
--)>0 ){
635 *(bufpt
++) = et_getdigit(&realvalue
,&nsd
);
637 /* Remove trailing zeros and the "." if no digits follow the "." */
638 if( flag_rtz
&& flag_dp
){
639 while( bufpt
[-1]=='0' ) *(--bufpt
) = 0;
640 assert( bufpt
>zOut
);
641 if( bufpt
[-1]=='.' ){
649 /* Add the "eNNN" suffix */
651 *(bufpt
++) = aDigits
[infop
->charset
];
653 *(bufpt
++) = '-'; exp
= -exp
;
658 *(bufpt
++) = (char)((exp
/100)+'0'); /* 100's digit */
661 *(bufpt
++) = (char)(exp
/10+'0'); /* 10's digit */
662 *(bufpt
++) = (char)(exp
%10+'0'); /* 1's digit */
666 /* The converted number is in buf[] and zero terminated. Output it.
667 ** Note that the number is in the usual order, not reversed as with
668 ** integer conversions. */
669 length
= (int)(bufpt
-zOut
);
672 /* Special case: Add leading zeros if the flag_zeropad flag is
673 ** set and we are not left justified */
674 if( flag_zeropad
&& !flag_leftjustify
&& length
< width
){
676 int nPad
= width
- length
;
677 for(i
=width
; i
>=nPad
; i
--){
678 bufpt
[i
] = bufpt
[i
-nPad
];
681 while( nPad
-- ) bufpt
[i
++] = '0';
684 #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
688 *(va_arg(ap
,int*)) = pAccum
->nChar
;
699 bufpt
= getTextArg(pArgList
);
702 buf
[0] = c
= *(bufpt
++);
703 if( (c
&0xc0)==0xc0 ){
704 while( length
<4 && (bufpt
[0]&0xc0)==0x80 ){
705 buf
[length
++] = *(bufpt
++);
712 unsigned int ch
= va_arg(ap
,unsigned int);
716 }else if( ch
<0x00800 ){
717 buf
[0] = 0xc0 + (u8
)((ch
>>6)&0x1f);
718 buf
[1] = 0x80 + (u8
)(ch
& 0x3f);
720 }else if( ch
<0x10000 ){
721 buf
[0] = 0xe0 + (u8
)((ch
>>12)&0x0f);
722 buf
[1] = 0x80 + (u8
)((ch
>>6) & 0x3f);
723 buf
[2] = 0x80 + (u8
)(ch
& 0x3f);
726 buf
[0] = 0xf0 + (u8
)((ch
>>18) & 0x07);
727 buf
[1] = 0x80 + (u8
)((ch
>>12) & 0x3f);
728 buf
[2] = 0x80 + (u8
)((ch
>>6) & 0x3f);
729 buf
[3] = 0x80 + (u8
)(ch
& 0x3f);
734 width
-= precision
-1;
735 if( width
>1 && !flag_leftjustify
){
736 sqlite3_str_appendchar(pAccum
, width
-1, ' ');
739 while( precision
-- > 1 ){
740 sqlite3_str_append(pAccum
, buf
, length
);
745 goto adjust_width_for_utf8
;
749 bufpt
= getTextArg(pArgList
);
752 bufpt
= va_arg(ap
,char*);
756 }else if( xtype
==etDYNSTRING
){
761 && pAccum
->accError
==0
763 /* Special optimization for sqlite3_mprintf("%z..."):
764 ** Extend an existing memory allocation rather than creating
766 assert( (pAccum
->printfFlags
&SQLITE_PRINTF_MALLOCED
)==0 );
767 pAccum
->zText
= bufpt
;
768 pAccum
->nAlloc
= sqlite3DbMallocSize(pAccum
->db
, bufpt
);
769 pAccum
->nChar
= 0x7fffffff & (int)strlen(bufpt
);
770 pAccum
->printfFlags
|= SQLITE_PRINTF_MALLOCED
;
778 /* Set length to the number of bytes needed in order to display
779 ** precision characters */
780 unsigned char *z
= (unsigned char*)bufpt
;
781 while( precision
-- > 0 && z
[0] ){
784 length
= (int)(z
- (unsigned char*)bufpt
);
786 for(length
=0; length
<precision
&& bufpt
[length
]; length
++){}
789 length
= 0x7fffffff & (int)strlen(bufpt
);
791 adjust_width_for_utf8
:
792 if( flag_altform2
&& width
>0 ){
793 /* Adjust width to account for extra bytes in UTF-8 characters */
795 while( ii
>=0 ) if( (bufpt
[ii
--] & 0xc0)==0x80 ) width
++;
798 case etSQLESCAPE
: /* %q: Escape ' characters */
799 case etSQLESCAPE2
: /* %Q: Escape ' and enclose in '...' */
800 case etSQLESCAPE3
: { /* %w: Escape " characters */
801 int i
, j
, k
, n
, isnull
;
804 char q
= ((xtype
==etSQLESCAPE3
)?'"':'\''); /* Quote character */
808 escarg
= getTextArg(pArgList
);
810 escarg
= va_arg(ap
,char*);
813 if( isnull
) escarg
= (xtype
==etSQLESCAPE2
? "NULL" : "(NULL)");
814 /* For %q, %Q, and %w, the precision is the number of bytes (or
815 ** characters if the ! flags is present) to use from the input.
816 ** Because of the extra quoting characters inserted, the number
817 ** of output characters may be larger than the precision.
820 for(i
=n
=0; k
!=0 && (ch
=escarg
[i
])!=0; i
++, k
--){
822 if( flag_altform2
&& (ch
&0xc0)==0xc0 ){
823 while( (escarg
[i
+1]&0xc0)==0x80 ){ i
++; }
826 needQuote
= !isnull
&& xtype
==etSQLESCAPE2
;
829 bufpt
= zExtra
= printfTempBuf(pAccum
, n
);
830 if( bufpt
==0 ) return;
835 if( needQuote
) bufpt
[j
++] = q
;
838 bufpt
[j
++] = ch
= escarg
[i
];
839 if( ch
==q
) bufpt
[j
++] = ch
;
841 if( needQuote
) bufpt
[j
++] = q
;
844 goto adjust_width_for_utf8
;
848 if( (pAccum
->printfFlags
& SQLITE_PRINTF_INTERNAL
)==0 ) return;
849 pToken
= va_arg(ap
, Token
*);
850 assert( bArgList
==0 );
851 if( pToken
&& pToken
->n
){
852 sqlite3_str_append(pAccum
, (const char*)pToken
->z
, pToken
->n
);
860 struct SrcList_item
*pItem
;
861 if( (pAccum
->printfFlags
& SQLITE_PRINTF_INTERNAL
)==0 ) return;
862 pSrc
= va_arg(ap
, SrcList
*);
865 assert( bArgList
==0 );
866 assert( k
>=0 && k
<pSrc
->nSrc
);
867 if( pItem
->zDatabase
){
868 sqlite3_str_appendall(pAccum
, pItem
->zDatabase
);
869 sqlite3_str_append(pAccum
, ".", 1);
871 sqlite3_str_appendall(pAccum
, pItem
->zName
);
876 assert( xtype
==etINVALID
);
879 }/* End switch over the format type */
881 ** The text of the conversion is pointed to by "bufpt" and is
882 ** "length" characters long. The field width is "width". Do
883 ** the output. Both length and width are in bytes, not characters,
884 ** at this point. If the "!" flag was present on string conversions
885 ** indicating that width and precision should be expressed in characters,
886 ** then the values have been translated prior to reaching this point.
890 if( !flag_leftjustify
) sqlite3_str_appendchar(pAccum
, width
, ' ');
891 sqlite3_str_append(pAccum
, bufpt
, length
);
892 if( flag_leftjustify
) sqlite3_str_appendchar(pAccum
, width
, ' ');
894 sqlite3_str_append(pAccum
, bufpt
, length
);
898 sqlite3DbFree(pAccum
->db
, zExtra
);
901 }/* End for loop over the format string */
902 } /* End of function */
905 ** Enlarge the memory allocation on a StrAccum object so that it is
906 ** able to accept at least N more bytes of text.
908 ** Return the number of bytes of text that StrAccum is able to accept
909 ** after the attempted enlargement. The value returned might be zero.
911 static int sqlite3StrAccumEnlarge(StrAccum
*p
, int N
){
913 assert( p
->nChar
+(i64
)N
>= p
->nAlloc
); /* Only called if really needed */
915 testcase(p
->accError
==SQLITE_TOOBIG
);
916 testcase(p
->accError
==SQLITE_NOMEM
);
920 setStrAccumError(p
, SQLITE_TOOBIG
);
921 return p
->nAlloc
- p
->nChar
- 1;
923 char *zOld
= isMalloced(p
) ? p
->zText
: 0;
924 i64 szNew
= p
->nChar
;
926 if( szNew
+p
->nChar
<=p
->mxAlloc
){
927 /* Force exponential buffer size growth as long as it does not overflow,
928 ** to avoid having to call this routine too often */
931 if( szNew
> p
->mxAlloc
){
932 sqlite3_str_reset(p
);
933 setStrAccumError(p
, SQLITE_TOOBIG
);
936 p
->nAlloc
= (int)szNew
;
939 zNew
= sqlite3DbRealloc(p
->db
, zOld
, p
->nAlloc
);
941 zNew
= sqlite3Realloc(zOld
, p
->nAlloc
);
944 assert( p
->zText
!=0 || p
->nChar
==0 );
945 if( !isMalloced(p
) && p
->nChar
>0 ) memcpy(zNew
, p
->zText
, p
->nChar
);
947 p
->nAlloc
= sqlite3DbMallocSize(p
->db
, zNew
);
948 p
->printfFlags
|= SQLITE_PRINTF_MALLOCED
;
950 sqlite3_str_reset(p
);
951 setStrAccumError(p
, SQLITE_NOMEM
);
959 ** Append N copies of character c to the given string buffer.
961 void sqlite3_str_appendchar(sqlite3_str
*p
, int N
, char c
){
962 testcase( p
->nChar
+ (i64
)N
> 0x7fffffff );
963 if( p
->nChar
+(i64
)N
>= p
->nAlloc
&& (N
= sqlite3StrAccumEnlarge(p
, N
))<=0 ){
966 while( (N
--)>0 ) p
->zText
[p
->nChar
++] = c
;
970 ** The StrAccum "p" is not large enough to accept N new bytes of z[].
971 ** So enlarge if first, then do the append.
973 ** This is a helper routine to sqlite3_str_append() that does special-case
974 ** work (enlarging the buffer) using tail recursion, so that the
975 ** sqlite3_str_append() routine can use fast calling semantics.
977 static void SQLITE_NOINLINE
enlargeAndAppend(StrAccum
*p
, const char *z
, int N
){
978 N
= sqlite3StrAccumEnlarge(p
, N
);
980 memcpy(&p
->zText
[p
->nChar
], z
, N
);
986 ** Append N bytes of text from z to the StrAccum object. Increase the
987 ** size of the memory allocation for StrAccum if necessary.
989 void sqlite3_str_append(sqlite3_str
*p
, const char *z
, int N
){
990 assert( z
!=0 || N
==0 );
991 assert( p
->zText
!=0 || p
->nChar
==0 || p
->accError
);
993 assert( p
->accError
==0 || p
->nAlloc
==0 || p
->mxAlloc
==0 );
994 if( p
->nChar
+N
>= p
->nAlloc
){
995 enlargeAndAppend(p
,z
,N
);
999 memcpy(&p
->zText
[p
->nChar
-N
], z
, N
);
1004 ** Append the complete text of zero-terminated string z[] to the p string.
1006 void sqlite3_str_appendall(sqlite3_str
*p
, const char *z
){
1007 sqlite3_str_append(p
, z
, sqlite3Strlen30(z
));
1012 ** Finish off a string by making sure it is zero-terminated.
1013 ** Return a pointer to the resulting string. Return a NULL
1014 ** pointer if any kind of error was encountered.
1016 static SQLITE_NOINLINE
char *strAccumFinishRealloc(StrAccum
*p
){
1018 assert( p
->mxAlloc
>0 && !isMalloced(p
) );
1019 zText
= sqlite3DbMallocRaw(p
->db
, p
->nChar
+1 );
1021 memcpy(zText
, p
->zText
, p
->nChar
+1);
1022 p
->printfFlags
|= SQLITE_PRINTF_MALLOCED
;
1024 setStrAccumError(p
, SQLITE_NOMEM
);
1029 char *sqlite3StrAccumFinish(StrAccum
*p
){
1031 p
->zText
[p
->nChar
] = 0;
1032 if( p
->mxAlloc
>0 && !isMalloced(p
) ){
1033 return strAccumFinishRealloc(p
);
1040 ** This singleton is an sqlite3_str object that is returned if
1041 ** sqlite3_malloc() fails to provide space for a real one. This
1042 ** sqlite3_str object accepts no new text and always returns
1043 ** an SQLITE_NOMEM error.
1045 static sqlite3_str sqlite3OomStr
= {
1046 0, 0, 0, 0, 0, SQLITE_NOMEM
, 0
1049 /* Finalize a string created using sqlite3_str_new().
1051 char *sqlite3_str_finish(sqlite3_str
*p
){
1053 if( p
!=0 && p
!=&sqlite3OomStr
){
1054 z
= sqlite3StrAccumFinish(p
);
1062 /* Return any error code associated with p */
1063 int sqlite3_str_errcode(sqlite3_str
*p
){
1064 return p
? p
->accError
: SQLITE_NOMEM
;
1067 /* Return the current length of p in bytes */
1068 int sqlite3_str_length(sqlite3_str
*p
){
1069 return p
? p
->nChar
: 0;
1072 /* Return the current value for p */
1073 char *sqlite3_str_value(sqlite3_str
*p
){
1074 if( p
==0 || p
->nChar
==0 ) return 0;
1075 p
->zText
[p
->nChar
] = 0;
1080 ** Reset an StrAccum string. Reclaim all malloced memory.
1082 void sqlite3_str_reset(StrAccum
*p
){
1083 if( isMalloced(p
) ){
1084 sqlite3DbFree(p
->db
, p
->zText
);
1085 p
->printfFlags
&= ~SQLITE_PRINTF_MALLOCED
;
1093 ** Initialize a string accumulator.
1095 ** p: The accumulator to be initialized.
1096 ** db: Pointer to a database connection. May be NULL. Lookaside
1097 ** memory is used if not NULL. db->mallocFailed is set appropriately
1099 ** zBase: An initial buffer. May be NULL in which case the initial buffer
1101 ** n: Size of zBase in bytes. If total space requirements never exceed
1102 ** n then no memory allocations ever occur.
1103 ** mx: Maximum number of bytes to accumulate. If mx==0 then no memory
1104 ** allocations will ever occur.
1106 void sqlite3StrAccumInit(StrAccum
*p
, sqlite3
*db
, char *zBase
, int n
, int mx
){
1116 /* Allocate and initialize a new dynamic string object */
1117 sqlite3_str
*sqlite3_str_new(sqlite3
*db
){
1118 sqlite3_str
*p
= sqlite3_malloc64(sizeof(*p
));
1120 sqlite3StrAccumInit(p
, 0, 0, 0,
1121 db
? db
->aLimit
[SQLITE_LIMIT_LENGTH
] : SQLITE_MAX_LENGTH
);
1129 ** Print into memory obtained from sqliteMalloc(). Use the internal
1130 ** %-conversion extensions.
1132 char *sqlite3VMPrintf(sqlite3
*db
, const char *zFormat
, va_list ap
){
1134 char zBase
[SQLITE_PRINT_BUF_SIZE
];
1137 sqlite3StrAccumInit(&acc
, db
, zBase
, sizeof(zBase
),
1138 db
->aLimit
[SQLITE_LIMIT_LENGTH
]);
1139 acc
.printfFlags
= SQLITE_PRINTF_INTERNAL
;
1140 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1141 z
= sqlite3StrAccumFinish(&acc
);
1142 if( acc
.accError
==SQLITE_NOMEM
){
1143 sqlite3OomFault(db
);
1149 ** Print into memory obtained from sqliteMalloc(). Use the internal
1150 ** %-conversion extensions.
1152 char *sqlite3MPrintf(sqlite3
*db
, const char *zFormat
, ...){
1155 va_start(ap
, zFormat
);
1156 z
= sqlite3VMPrintf(db
, zFormat
, ap
);
1162 ** Print into memory obtained from sqlite3_malloc(). Omit the internal
1163 ** %-conversion extensions.
1165 char *sqlite3_vmprintf(const char *zFormat
, va_list ap
){
1167 char zBase
[SQLITE_PRINT_BUF_SIZE
];
1170 #ifdef SQLITE_ENABLE_API_ARMOR
1172 (void)SQLITE_MISUSE_BKPT
;
1176 #ifndef SQLITE_OMIT_AUTOINIT
1177 if( sqlite3_initialize() ) return 0;
1179 sqlite3StrAccumInit(&acc
, 0, zBase
, sizeof(zBase
), SQLITE_MAX_LENGTH
);
1180 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1181 z
= sqlite3StrAccumFinish(&acc
);
1186 ** Print into memory obtained from sqlite3_malloc()(). Omit the internal
1187 ** %-conversion extensions.
1189 char *sqlite3_mprintf(const char *zFormat
, ...){
1192 #ifndef SQLITE_OMIT_AUTOINIT
1193 if( sqlite3_initialize() ) return 0;
1195 va_start(ap
, zFormat
);
1196 z
= sqlite3_vmprintf(zFormat
, ap
);
1202 ** sqlite3_snprintf() works like snprintf() except that it ignores the
1203 ** current locale settings. This is important for SQLite because we
1204 ** are not able to use a "," as the decimal point in place of "." as
1205 ** specified by some locales.
1207 ** Oops: The first two arguments of sqlite3_snprintf() are backwards
1208 ** from the snprintf() standard. Unfortunately, it is too late to change
1209 ** this without breaking compatibility, so we just have to live with the
1212 ** sqlite3_vsnprintf() is the varargs version.
1214 char *sqlite3_vsnprintf(int n
, char *zBuf
, const char *zFormat
, va_list ap
){
1216 if( n
<=0 ) return zBuf
;
1217 #ifdef SQLITE_ENABLE_API_ARMOR
1218 if( zBuf
==0 || zFormat
==0 ) {
1219 (void)SQLITE_MISUSE_BKPT
;
1220 if( zBuf
) zBuf
[0] = 0;
1224 sqlite3StrAccumInit(&acc
, 0, zBuf
, n
, 0);
1225 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1226 zBuf
[acc
.nChar
] = 0;
1229 char *sqlite3_snprintf(int n
, char *zBuf
, const char *zFormat
, ...){
1232 va_start(ap
,zFormat
);
1233 z
= sqlite3_vsnprintf(n
, zBuf
, zFormat
, ap
);
1239 ** This is the routine that actually formats the sqlite3_log() message.
1240 ** We house it in a separate routine from sqlite3_log() to avoid using
1241 ** stack space on small-stack systems when logging is disabled.
1243 ** sqlite3_log() must render into a static buffer. It cannot dynamically
1244 ** allocate memory because it might be called while the memory allocator
1247 ** sqlite3_str_vappendf() might ask for *temporary* memory allocations for
1248 ** certain format characters (%q) or for very large precisions or widths.
1249 ** Care must be taken that any sqlite3_log() calls that occur while the
1250 ** memory mutex is held do not use these mechanisms.
1252 static void renderLogMsg(int iErrCode
, const char *zFormat
, va_list ap
){
1253 StrAccum acc
; /* String accumulator */
1254 char zMsg
[SQLITE_PRINT_BUF_SIZE
*3]; /* Complete log message */
1256 sqlite3StrAccumInit(&acc
, 0, zMsg
, sizeof(zMsg
), 0);
1257 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1258 sqlite3GlobalConfig
.xLog(sqlite3GlobalConfig
.pLogArg
, iErrCode
,
1259 sqlite3StrAccumFinish(&acc
));
1263 ** Format and write a message to the log if logging is enabled.
1265 void sqlite3_log(int iErrCode
, const char *zFormat
, ...){
1266 va_list ap
; /* Vararg list */
1267 if( sqlite3GlobalConfig
.xLog
){
1268 va_start(ap
, zFormat
);
1269 renderLogMsg(iErrCode
, zFormat
, ap
);
1274 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
1276 ** A version of printf() that understands %lld. Used for debugging.
1277 ** The printf() built into some versions of windows does not understand %lld
1278 ** and segfaults if you give it a long long int.
1280 void sqlite3DebugPrintf(const char *zFormat
, ...){
1283 char zBuf
[SQLITE_PRINT_BUF_SIZE
*10];
1284 sqlite3StrAccumInit(&acc
, 0, zBuf
, sizeof(zBuf
), 0);
1285 va_start(ap
,zFormat
);
1286 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1288 sqlite3StrAccumFinish(&acc
);
1289 #ifdef SQLITE_OS_TRACE_PROC
1291 extern void SQLITE_OS_TRACE_PROC(const char *zBuf
, int nBuf
);
1292 SQLITE_OS_TRACE_PROC(zBuf
, sizeof(zBuf
));
1295 fprintf(stdout
,"%s", zBuf
);
1303 ** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument
1304 ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
1306 void sqlite3_str_appendf(StrAccum
*p
, const char *zFormat
, ...){
1308 va_start(ap
,zFormat
);
1309 sqlite3_str_vappendf(p
, zFormat
, ap
);