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 etSRCITEM 12 /* a pointer to a SrcItem */
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, etSRCITEM
, 0, 0 },
99 { 'r', 10, 1, etORDINAL
, 0, 0 },
104 ** %S Takes a pointer to SrcItem. Shows name or database.name
105 ** %!S Like %S but prefer the zName over the zAlias
109 ** Set the StrAccum object to an error mode.
111 void sqlite3StrAccumSetError(StrAccum
*p
, u8 eError
){
112 assert( eError
==SQLITE_NOMEM
|| eError
==SQLITE_TOOBIG
);
113 p
->accError
= eError
;
114 if( p
->mxAlloc
) sqlite3_str_reset(p
);
115 if( eError
==SQLITE_TOOBIG
) sqlite3ErrorToParser(p
->db
, eError
);
119 ** Extra argument values from a PrintfArguments object
121 static sqlite3_int64
getIntArg(PrintfArguments
*p
){
122 if( p
->nArg
<=p
->nUsed
) return 0;
123 return sqlite3_value_int64(p
->apArg
[p
->nUsed
++]);
125 static double getDoubleArg(PrintfArguments
*p
){
126 if( p
->nArg
<=p
->nUsed
) return 0.0;
127 return sqlite3_value_double(p
->apArg
[p
->nUsed
++]);
129 static char *getTextArg(PrintfArguments
*p
){
130 if( p
->nArg
<=p
->nUsed
) return 0;
131 return (char*)sqlite3_value_text(p
->apArg
[p
->nUsed
++]);
135 ** Allocate memory for a temporary buffer needed for printf rendering.
137 ** If the requested size of the temp buffer is larger than the size
138 ** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error.
139 ** Do the size check before the memory allocation to prevent rogue
140 ** SQL from requesting large allocations using the precision or width
141 ** field of the printf() function.
143 static char *printfTempBuf(sqlite3_str
*pAccum
, sqlite3_int64 n
){
145 if( pAccum
->accError
) return 0;
146 if( n
>pAccum
->nAlloc
&& n
>pAccum
->mxAlloc
){
147 sqlite3StrAccumSetError(pAccum
, SQLITE_TOOBIG
);
150 z
= sqlite3DbMallocRaw(pAccum
->db
, n
);
152 sqlite3StrAccumSetError(pAccum
, SQLITE_NOMEM
);
158 ** On machines with a small stack size, you can redefine the
159 ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
161 #ifndef SQLITE_PRINT_BUF_SIZE
162 # define SQLITE_PRINT_BUF_SIZE 70
164 #define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */
167 ** Hard limit on the precision of floating-point conversions.
169 #ifndef SQLITE_PRINTF_PRECISION_LIMIT
170 # define SQLITE_FP_PRECISION_LIMIT 100000000
174 ** Render a string given by "fmt" into the StrAccum object.
176 void sqlite3_str_vappendf(
177 sqlite3_str
*pAccum
, /* Accumulate results here */
178 const char *fmt
, /* Format string */
179 va_list ap
/* arguments */
181 int c
; /* Next character in the format string */
182 char *bufpt
; /* Pointer to the conversion buffer */
183 int precision
; /* Precision of the current field */
184 int length
; /* Length of the field */
185 int idx
; /* A general purpose loop counter */
186 int width
; /* Width of the current field */
187 etByte flag_leftjustify
; /* True if "-" flag is present */
188 etByte flag_prefix
; /* '+' or ' ' or 0 for prefix */
189 etByte flag_alternateform
; /* True if "#" flag is present */
190 etByte flag_altform2
; /* True if "!" flag is present */
191 etByte flag_zeropad
; /* True if field width constant starts with zero */
192 etByte flag_long
; /* 1 for the "l" flag, 2 for "ll", 0 by default */
193 etByte done
; /* Loop termination flag */
194 etByte cThousand
; /* Thousands separator for %d and %u */
195 etByte xtype
= etINVALID
; /* Conversion paradigm */
196 u8 bArgList
; /* True for SQLITE_PRINTF_SQLFUNC */
197 char prefix
; /* Prefix character. "+" or "-" or " " or '\0'. */
198 sqlite_uint64 longvalue
; /* Value for integer types */
199 double realvalue
; /* Value for real types */
200 const et_info
*infop
; /* Pointer to the appropriate info structure */
201 char *zOut
; /* Rendering buffer */
202 int nOut
; /* Size of the rendering buffer */
203 char *zExtra
= 0; /* Malloced memory used by some conversion */
204 int exp
, e2
; /* exponent of real numbers */
205 etByte flag_dp
; /* True if decimal point should be shown */
206 etByte flag_rtz
; /* True if trailing zeros should be removed */
208 PrintfArguments
*pArgList
= 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
209 char buf
[etBUFSIZE
]; /* Conversion buffer */
211 /* pAccum never starts out with an empty buffer that was obtained from
212 ** malloc(). This precondition is required by the mprintf("%z...")
214 assert( pAccum
->nChar
>0 || (pAccum
->printfFlags
&SQLITE_PRINTF_MALLOCED
)==0 );
217 if( (pAccum
->printfFlags
& SQLITE_PRINTF_SQLFUNC
)!=0 ){
218 pArgList
= va_arg(ap
, PrintfArguments
*);
223 for(; (c
=(*fmt
))!=0; ++fmt
){
227 fmt
= strchrnul(fmt
, '%');
229 do{ fmt
++; }while( *fmt
&& *fmt
!= '%' );
231 sqlite3_str_append(pAccum
, bufpt
, (int)(fmt
- bufpt
));
234 if( (c
=(*++fmt
))==0 ){
235 sqlite3_str_append(pAccum
, "%", 1);
238 /* Find out what flags are present */
239 flag_leftjustify
= flag_prefix
= cThousand
=
240 flag_alternateform
= flag_altform2
= flag_zeropad
= 0;
247 case '-': flag_leftjustify
= 1; break;
248 case '+': flag_prefix
= '+'; break;
249 case ' ': flag_prefix
= ' '; break;
250 case '#': flag_alternateform
= 1; break;
251 case '!': flag_altform2
= 1; break;
252 case '0': flag_zeropad
= 1; break;
253 case ',': cThousand
= ','; break;
254 default: done
= 1; break;
265 case '1': case '2': case '3': case '4': case '5':
266 case '6': case '7': case '8': case '9': {
267 unsigned wx
= c
- '0';
268 while( (c
= *++fmt
)>='0' && c
<='9' ){
269 wx
= wx
*10 + c
- '0';
271 testcase( wx
>0x7fffffff );
272 width
= wx
& 0x7fffffff;
273 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
274 if( width
>SQLITE_PRINTF_PRECISION_LIMIT
){
275 width
= SQLITE_PRINTF_PRECISION_LIMIT
;
278 if( c
!='.' && c
!='l' ){
287 width
= (int)getIntArg(pArgList
);
289 width
= va_arg(ap
,int);
292 flag_leftjustify
= 1;
293 width
= width
>= -2147483647 ? -width
: 0;
295 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
296 if( width
>SQLITE_PRINTF_PRECISION_LIMIT
){
297 width
= SQLITE_PRINTF_PRECISION_LIMIT
;
300 if( (c
= fmt
[1])!='.' && c
!='l' ){
310 precision
= (int)getIntArg(pArgList
);
312 precision
= va_arg(ap
,int);
315 precision
= precision
>= -2147483647 ? -precision
: -1;
320 while( c
>='0' && c
<='9' ){
321 px
= px
*10 + c
- '0';
324 testcase( px
>0x7fffffff );
325 precision
= px
& 0x7fffffff;
327 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
328 if( precision
>SQLITE_PRINTF_PRECISION_LIMIT
){
329 precision
= SQLITE_PRINTF_PRECISION_LIMIT
;
340 }while( !done
&& (c
=(*++fmt
))!=0 );
342 /* Fetch the info entry for the field */
345 for(idx
=0; idx
<ArraySize(fmtinfo
); idx
++){
346 if( c
==fmtinfo
[idx
].fmttype
){
347 infop
= &fmtinfo
[idx
];
354 ** At this point, variables are initialized as follows:
356 ** flag_alternateform TRUE if a '#' is present.
357 ** flag_altform2 TRUE if a '!' is present.
358 ** flag_prefix '+' or ' ' or zero
359 ** flag_leftjustify TRUE if a '-' is present or if the
360 ** field width was negative.
361 ** flag_zeropad TRUE if the width began with 0.
362 ** flag_long 1 for "l", 2 for "ll"
363 ** width The specified field width. This is
364 ** always non-negative. Zero is the default.
365 ** precision The specified precision. The default
367 ** xtype The class of the conversion.
368 ** infop Pointer to the appropriate info struct.
371 assert( precision
>=(-1) );
374 flag_long
= sizeof(char*)==sizeof(i64
) ? 2 :
375 sizeof(char*)==sizeof(long int) ? 1 : 0;
376 /* no break */ deliberate_fall_through
380 /* no break */ deliberate_fall_through
382 if( infop
->flags
& FLAG_SIGNED
){
385 v
= getIntArg(pArgList
);
386 }else if( flag_long
){
390 v
= va_arg(ap
,long int);
396 testcase( v
==SMALLEST_INT64
);
403 prefix
= flag_prefix
;
407 longvalue
= (u64
)getIntArg(pArgList
);
408 }else if( flag_long
){
410 longvalue
= va_arg(ap
,u64
);
412 longvalue
= va_arg(ap
,unsigned long int);
415 longvalue
= va_arg(ap
,unsigned int);
419 if( longvalue
==0 ) flag_alternateform
= 0;
420 if( flag_zeropad
&& precision
<width
-(prefix
!=0) ){
421 precision
= width
-(prefix
!=0);
423 if( precision
<etBUFSIZE
-10-etBUFSIZE
/3 ){
428 n
= (u64
)precision
+ 10;
429 if( cThousand
) n
+= precision
/3;
430 zOut
= zExtra
= printfTempBuf(pAccum
, n
);
431 if( zOut
==0 ) return;
434 bufpt
= &zOut
[nOut
-1];
435 if( xtype
==etORDINAL
){
436 static const char zOrd
[] = "thstndrd";
437 int x
= (int)(longvalue
% 10);
438 if( x
>=4 || (longvalue
/10)%10==1 ){
441 *(--bufpt
) = zOrd
[x
*2+1];
442 *(--bufpt
) = zOrd
[x
*2];
445 const char *cset
= &aDigits
[infop
->charset
];
446 u8 base
= infop
->base
;
447 do{ /* Convert to ascii */
448 *(--bufpt
) = cset
[longvalue
%base
];
449 longvalue
= longvalue
/base
;
450 }while( longvalue
>0 );
452 length
= (int)(&zOut
[nOut
-1]-bufpt
);
453 while( precision
>length
){
454 *(--bufpt
) = '0'; /* Zero pad */
458 int nn
= (length
- 1)/3; /* Number of "," to insert */
459 int ix
= (length
- 1)%3 + 1;
461 for(idx
=0; nn
>0; idx
++){
462 bufpt
[idx
] = bufpt
[idx
+nn
];
465 bufpt
[++idx
] = cThousand
;
471 if( prefix
) *(--bufpt
) = prefix
; /* Add sign */
472 if( flag_alternateform
&& infop
->prefix
){ /* Add "0" or "0x" */
475 pre
= &aPrefix
[infop
->prefix
];
476 for(; (x
=(*pre
))!=0; pre
++) *(--bufpt
) = x
;
478 length
= (int)(&zOut
[nOut
-1]-bufpt
);
488 realvalue
= getDoubleArg(pArgList
);
490 realvalue
= va_arg(ap
,double);
492 if( precision
<0 ) precision
= 6; /* Set default precision */
493 #ifdef SQLITE_FP_PRECISION_LIMIT
494 if( precision
>SQLITE_FP_PRECISION_LIMIT
){
495 precision
= SQLITE_FP_PRECISION_LIMIT
;
498 if( xtype
==etFLOAT
){
500 }else if( xtype
==etGENERIC
){
501 if( precision
==0 ) precision
= 1;
504 iRound
= precision
+1;
506 sqlite3FpDecode(&s
, realvalue
, iRound
, flag_altform2
? 26 : 16);
508 if( s
.isSpecial
==2 ){
509 bufpt
= flag_zeropad
? "null" : "NaN";
510 length
= sqlite3Strlen30(bufpt
);
512 }else if( flag_zeropad
){
517 memcpy(buf
, "-Inf", 5);
521 }else if( flag_prefix
){
522 buf
[0] = flag_prefix
;
526 length
= sqlite3Strlen30(bufpt
);
533 prefix
= flag_prefix
;
537 if( xtype
==etGENERIC
&& precision
>0 ) precision
--;
540 ** If the field type is etGENERIC, then convert to either etEXP
541 ** or etFLOAT, as appropriate.
543 if( xtype
==etGENERIC
){
544 flag_rtz
= !flag_alternateform
;
545 if( exp
<-4 || exp
>precision
){
548 precision
= precision
- exp
;
552 flag_rtz
= flag_altform2
;
561 i64 szBufNeeded
; /* Size of a temporary buffer needed */
562 szBufNeeded
= MAX(e2
,0)+(i64
)precision
+(i64
)width
+15;
563 if( cThousand
&& e2
>0 ) szBufNeeded
+= (e2
+2)/3;
564 if( szBufNeeded
> etBUFSIZE
){
565 bufpt
= zExtra
= printfTempBuf(pAccum
, szBufNeeded
);
566 if( bufpt
==0 ) return;
570 flag_dp
= (precision
>0 ?1:0) | flag_alternateform
| flag_altform2
;
571 /* The sign in front of the number */
575 /* Digits prior to the decimal point */
581 *(bufpt
++) = j
<s
.n
? s
.z
[j
++] : '0';
582 if( cThousand
&& (e2
%3)==0 && e2
>1 ) *(bufpt
++) = ',';
585 /* The decimal point */
589 /* "0" digits after the decimal point but before the first
590 ** significant digit of the number */
591 for(e2
++; e2
<0 && precision
>0; precision
--, e2
++){
594 /* Significant digits after the decimal point */
595 while( (precision
--)>0 ){
596 *(bufpt
++) = j
<s
.n
? s
.z
[j
++] : '0';
598 /* Remove trailing zeros and the "." if no digits follow the "." */
599 if( flag_rtz
&& flag_dp
){
600 while( bufpt
[-1]=='0' ) *(--bufpt
) = 0;
601 assert( bufpt
>zOut
);
602 if( bufpt
[-1]=='.' ){
610 /* Add the "eNNN" suffix */
613 *(bufpt
++) = aDigits
[infop
->charset
];
615 *(bufpt
++) = '-'; exp
= -exp
;
620 *(bufpt
++) = (char)((exp
/100)+'0'); /* 100's digit */
623 *(bufpt
++) = (char)(exp
/10+'0'); /* 10's digit */
624 *(bufpt
++) = (char)(exp
%10+'0'); /* 1's digit */
628 /* The converted number is in buf[] and zero terminated. Output it.
629 ** Note that the number is in the usual order, not reversed as with
630 ** integer conversions. */
631 length
= (int)(bufpt
-zOut
);
634 /* Special case: Add leading zeros if the flag_zeropad flag is
635 ** set and we are not left justified */
636 if( flag_zeropad
&& !flag_leftjustify
&& length
< width
){
638 int nPad
= width
- length
;
639 for(i
=width
; i
>=nPad
; i
--){
640 bufpt
[i
] = bufpt
[i
-nPad
];
643 while( nPad
-- ) bufpt
[i
++] = '0';
650 *(va_arg(ap
,int*)) = pAccum
->nChar
;
661 bufpt
= getTextArg(pArgList
);
664 buf
[0] = c
= *(bufpt
++);
665 if( (c
&0xc0)==0xc0 ){
666 while( length
<4 && (bufpt
[0]&0xc0)==0x80 ){
667 buf
[length
++] = *(bufpt
++);
674 unsigned int ch
= va_arg(ap
,unsigned int);
678 }else if( ch
<0x00800 ){
679 buf
[0] = 0xc0 + (u8
)((ch
>>6)&0x1f);
680 buf
[1] = 0x80 + (u8
)(ch
& 0x3f);
682 }else if( ch
<0x10000 ){
683 buf
[0] = 0xe0 + (u8
)((ch
>>12)&0x0f);
684 buf
[1] = 0x80 + (u8
)((ch
>>6) & 0x3f);
685 buf
[2] = 0x80 + (u8
)(ch
& 0x3f);
688 buf
[0] = 0xf0 + (u8
)((ch
>>18) & 0x07);
689 buf
[1] = 0x80 + (u8
)((ch
>>12) & 0x3f);
690 buf
[2] = 0x80 + (u8
)((ch
>>6) & 0x3f);
691 buf
[3] = 0x80 + (u8
)(ch
& 0x3f);
697 width
-= precision
-1;
698 if( width
>1 && !flag_leftjustify
){
699 sqlite3_str_appendchar(pAccum
, width
-1, ' ');
702 sqlite3_str_append(pAccum
, buf
, length
);
704 while( precision
> 1 ){
706 if( nPrior
> precision
-1 ) nPrior
= precision
- 1;
707 nCopyBytes
= length
*nPrior
;
708 if( nCopyBytes
+ pAccum
->nChar
>= pAccum
->nAlloc
){
709 sqlite3StrAccumEnlarge(pAccum
, nCopyBytes
);
711 if( pAccum
->accError
) break;
712 sqlite3_str_append(pAccum
,
713 &pAccum
->zText
[pAccum
->nChar
-nCopyBytes
], nCopyBytes
);
720 goto adjust_width_for_utf8
;
724 bufpt
= getTextArg(pArgList
);
727 bufpt
= va_arg(ap
,char*);
731 }else if( xtype
==etDYNSTRING
){
736 && pAccum
->accError
==0
738 /* Special optimization for sqlite3_mprintf("%z..."):
739 ** Extend an existing memory allocation rather than creating
741 assert( (pAccum
->printfFlags
&SQLITE_PRINTF_MALLOCED
)==0 );
742 pAccum
->zText
= bufpt
;
743 pAccum
->nAlloc
= sqlite3DbMallocSize(pAccum
->db
, bufpt
);
744 pAccum
->nChar
= 0x7fffffff & (int)strlen(bufpt
);
745 pAccum
->printfFlags
|= SQLITE_PRINTF_MALLOCED
;
753 /* Set length to the number of bytes needed in order to display
754 ** precision characters */
755 unsigned char *z
= (unsigned char*)bufpt
;
756 while( precision
-- > 0 && z
[0] ){
759 length
= (int)(z
- (unsigned char*)bufpt
);
761 for(length
=0; length
<precision
&& bufpt
[length
]; length
++){}
764 length
= 0x7fffffff & (int)strlen(bufpt
);
766 adjust_width_for_utf8
:
767 if( flag_altform2
&& width
>0 ){
768 /* Adjust width to account for extra bytes in UTF-8 characters */
770 while( ii
>=0 ) if( (bufpt
[ii
--] & 0xc0)==0x80 ) width
++;
773 case etSQLESCAPE
: /* %q: Escape ' characters */
774 case etSQLESCAPE2
: /* %Q: Escape ' and enclose in '...' */
775 case etSQLESCAPE3
: { /* %w: Escape " characters */
777 int needQuote
, isnull
;
779 char q
= ((xtype
==etSQLESCAPE3
)?'"':'\''); /* Quote character */
783 escarg
= getTextArg(pArgList
);
785 escarg
= va_arg(ap
,char*);
788 if( isnull
) escarg
= (xtype
==etSQLESCAPE2
? "NULL" : "(NULL)");
789 /* For %q, %Q, and %w, the precision is the number of bytes (or
790 ** characters if the ! flags is present) to use from the input.
791 ** Because of the extra quoting characters inserted, the number
792 ** of output characters may be larger than the precision.
795 for(i
=n
=0; k
!=0 && (ch
=escarg
[i
])!=0; i
++, k
--){
797 if( flag_altform2
&& (ch
&0xc0)==0xc0 ){
798 while( (escarg
[i
+1]&0xc0)==0x80 ){ i
++; }
801 needQuote
= !isnull
&& xtype
==etSQLESCAPE2
;
804 bufpt
= zExtra
= printfTempBuf(pAccum
, n
);
805 if( bufpt
==0 ) return;
810 if( needQuote
) bufpt
[j
++] = q
;
813 bufpt
[j
++] = ch
= escarg
[i
];
814 if( ch
==q
) bufpt
[j
++] = ch
;
816 if( needQuote
) bufpt
[j
++] = q
;
819 goto adjust_width_for_utf8
;
822 if( (pAccum
->printfFlags
& SQLITE_PRINTF_INTERNAL
)==0 ) return;
823 if( flag_alternateform
){
824 /* %#T means an Expr pointer that uses Expr.u.zToken */
825 Expr
*pExpr
= va_arg(ap
,Expr
*);
826 if( ALWAYS(pExpr
) && ALWAYS(!ExprHasProperty(pExpr
,EP_IntValue
)) ){
827 sqlite3_str_appendall(pAccum
, (const char*)pExpr
->u
.zToken
);
828 sqlite3RecordErrorOffsetOfExpr(pAccum
->db
, pExpr
);
831 /* %T means a Token pointer */
832 Token
*pToken
= va_arg(ap
, Token
*);
833 assert( bArgList
==0 );
834 if( pToken
&& pToken
->n
){
835 sqlite3_str_append(pAccum
, (const char*)pToken
->z
, pToken
->n
);
836 sqlite3RecordErrorByteOffset(pAccum
->db
, pToken
->z
);
844 if( (pAccum
->printfFlags
& SQLITE_PRINTF_INTERNAL
)==0 ) return;
845 pItem
= va_arg(ap
, SrcItem
*);
846 assert( bArgList
==0 );
847 if( pItem
->zAlias
&& !flag_altform2
){
848 sqlite3_str_appendall(pAccum
, pItem
->zAlias
);
849 }else if( pItem
->zName
){
850 if( pItem
->zDatabase
){
851 sqlite3_str_appendall(pAccum
, pItem
->zDatabase
);
852 sqlite3_str_append(pAccum
, ".", 1);
854 sqlite3_str_appendall(pAccum
, pItem
->zName
);
855 }else if( pItem
->zAlias
){
856 sqlite3_str_appendall(pAccum
, pItem
->zAlias
);
858 Select
*pSel
= pItem
->pSelect
;
860 if( pSel
->selFlags
& SF_NestedFrom
){
861 sqlite3_str_appendf(pAccum
, "(join-%u)", pSel
->selId
);
863 sqlite3_str_appendf(pAccum
, "(subquery-%u)", pSel
->selId
);
870 assert( xtype
==etINVALID
);
873 }/* End switch over the format type */
875 ** The text of the conversion is pointed to by "bufpt" and is
876 ** "length" characters long. The field width is "width". Do
877 ** the output. Both length and width are in bytes, not characters,
878 ** at this point. If the "!" flag was present on string conversions
879 ** indicating that width and precision should be expressed in characters,
880 ** then the values have been translated prior to reaching this point.
884 if( !flag_leftjustify
) sqlite3_str_appendchar(pAccum
, width
, ' ');
885 sqlite3_str_append(pAccum
, bufpt
, length
);
886 if( flag_leftjustify
) sqlite3_str_appendchar(pAccum
, width
, ' ');
888 sqlite3_str_append(pAccum
, bufpt
, length
);
892 sqlite3DbFree(pAccum
->db
, zExtra
);
895 }/* End for loop over the format string */
896 } /* End of function */
900 ** The z string points to the first character of a token that is
901 ** associated with an error. If db does not already have an error
902 ** byte offset recorded, try to compute the error byte offset for
903 ** z and set the error byte offset in db.
905 void sqlite3RecordErrorByteOffset(sqlite3
*db
, const char *z
){
910 if( NEVER(db
==0) ) return;
911 if( db
->errByteOffset
!=(-2) ) return;
913 if( NEVER(pParse
==0) ) return;
914 zText
=pParse
->zTail
;
915 if( NEVER(zText
==0) ) return;
916 zEnd
= &zText
[strlen(zText
)];
917 if( SQLITE_WITHIN(z
,zText
,zEnd
) ){
918 db
->errByteOffset
= (int)(z
-zText
);
923 ** If pExpr has a byte offset for the start of a token, record that as
924 ** as the error offset.
926 void sqlite3RecordErrorOffsetOfExpr(sqlite3
*db
, const Expr
*pExpr
){
928 && (ExprHasProperty(pExpr
,EP_OuterON
|EP_InnerON
) || pExpr
->w
.iOfst
<=0)
930 pExpr
= pExpr
->pLeft
;
932 if( pExpr
==0 ) return;
933 db
->errByteOffset
= pExpr
->w
.iOfst
;
937 ** Enlarge the memory allocation on a StrAccum object so that it is
938 ** able to accept at least N more bytes of text.
940 ** Return the number of bytes of text that StrAccum is able to accept
941 ** after the attempted enlargement. The value returned might be zero.
943 int sqlite3StrAccumEnlarge(StrAccum
*p
, i64 N
){
945 assert( p
->nChar
+N
>= p
->nAlloc
); /* Only called if really needed */
947 testcase(p
->accError
==SQLITE_TOOBIG
);
948 testcase(p
->accError
==SQLITE_NOMEM
);
952 sqlite3StrAccumSetError(p
, SQLITE_TOOBIG
);
953 return p
->nAlloc
- p
->nChar
- 1;
955 char *zOld
= isMalloced(p
) ? p
->zText
: 0;
956 i64 szNew
= p
->nChar
+ N
+ 1;
957 if( szNew
+p
->nChar
<=p
->mxAlloc
){
958 /* Force exponential buffer size growth as long as it does not overflow,
959 ** to avoid having to call this routine too often */
962 if( szNew
> p
->mxAlloc
){
963 sqlite3_str_reset(p
);
964 sqlite3StrAccumSetError(p
, SQLITE_TOOBIG
);
967 p
->nAlloc
= (int)szNew
;
970 zNew
= sqlite3DbRealloc(p
->db
, zOld
, p
->nAlloc
);
972 zNew
= sqlite3Realloc(zOld
, p
->nAlloc
);
975 assert( p
->zText
!=0 || p
->nChar
==0 );
976 if( !isMalloced(p
) && p
->nChar
>0 ) memcpy(zNew
, p
->zText
, p
->nChar
);
978 p
->nAlloc
= sqlite3DbMallocSize(p
->db
, zNew
);
979 p
->printfFlags
|= SQLITE_PRINTF_MALLOCED
;
981 sqlite3_str_reset(p
);
982 sqlite3StrAccumSetError(p
, SQLITE_NOMEM
);
986 assert( N
>=0 && N
<=0x7fffffff );
991 ** Append N copies of character c to the given string buffer.
993 void sqlite3_str_appendchar(sqlite3_str
*p
, int N
, char c
){
994 testcase( p
->nChar
+ (i64
)N
> 0x7fffffff );
995 if( p
->nChar
+(i64
)N
>= p
->nAlloc
&& (N
= sqlite3StrAccumEnlarge(p
, N
))<=0 ){
998 while( (N
--)>0 ) p
->zText
[p
->nChar
++] = c
;
1002 ** The StrAccum "p" is not large enough to accept N new bytes of z[].
1003 ** So enlarge if first, then do the append.
1005 ** This is a helper routine to sqlite3_str_append() that does special-case
1006 ** work (enlarging the buffer) using tail recursion, so that the
1007 ** sqlite3_str_append() routine can use fast calling semantics.
1009 static void SQLITE_NOINLINE
enlargeAndAppend(StrAccum
*p
, const char *z
, int N
){
1010 N
= sqlite3StrAccumEnlarge(p
, N
);
1012 memcpy(&p
->zText
[p
->nChar
], z
, N
);
1018 ** Append N bytes of text from z to the StrAccum object. Increase the
1019 ** size of the memory allocation for StrAccum if necessary.
1021 void sqlite3_str_append(sqlite3_str
*p
, const char *z
, int N
){
1022 assert( z
!=0 || N
==0 );
1023 assert( p
->zText
!=0 || p
->nChar
==0 || p
->accError
);
1025 assert( p
->accError
==0 || p
->nAlloc
==0 || p
->mxAlloc
==0 );
1026 if( p
->nChar
+N
>= p
->nAlloc
){
1027 enlargeAndAppend(p
,z
,N
);
1031 memcpy(&p
->zText
[p
->nChar
-N
], z
, N
);
1036 ** Append the complete text of zero-terminated string z[] to the p string.
1038 void sqlite3_str_appendall(sqlite3_str
*p
, const char *z
){
1039 sqlite3_str_append(p
, z
, sqlite3Strlen30(z
));
1044 ** Finish off a string by making sure it is zero-terminated.
1045 ** Return a pointer to the resulting string. Return a NULL
1046 ** pointer if any kind of error was encountered.
1048 static SQLITE_NOINLINE
char *strAccumFinishRealloc(StrAccum
*p
){
1050 assert( p
->mxAlloc
>0 && !isMalloced(p
) );
1051 zText
= sqlite3DbMallocRaw(p
->db
, p
->nChar
+1 );
1053 memcpy(zText
, p
->zText
, p
->nChar
+1);
1054 p
->printfFlags
|= SQLITE_PRINTF_MALLOCED
;
1056 sqlite3StrAccumSetError(p
, SQLITE_NOMEM
);
1061 char *sqlite3StrAccumFinish(StrAccum
*p
){
1063 p
->zText
[p
->nChar
] = 0;
1064 if( p
->mxAlloc
>0 && !isMalloced(p
) ){
1065 return strAccumFinishRealloc(p
);
1072 ** Use the content of the StrAccum passed as the second argument
1073 ** as the result of an SQL function.
1075 void sqlite3ResultStrAccum(sqlite3_context
*pCtx
, StrAccum
*p
){
1077 sqlite3_result_error_code(pCtx
, p
->accError
);
1078 sqlite3_str_reset(p
);
1079 }else if( isMalloced(p
) ){
1080 sqlite3_result_text(pCtx
, p
->zText
, p
->nChar
, SQLITE_DYNAMIC
);
1082 sqlite3_result_text(pCtx
, "", 0, SQLITE_STATIC
);
1083 sqlite3_str_reset(p
);
1088 ** This singleton is an sqlite3_str object that is returned if
1089 ** sqlite3_malloc() fails to provide space for a real one. This
1090 ** sqlite3_str object accepts no new text and always returns
1091 ** an SQLITE_NOMEM error.
1093 static sqlite3_str sqlite3OomStr
= {
1094 0, 0, 0, 0, 0, SQLITE_NOMEM
, 0
1097 /* Finalize a string created using sqlite3_str_new().
1099 char *sqlite3_str_finish(sqlite3_str
*p
){
1101 if( p
!=0 && p
!=&sqlite3OomStr
){
1102 z
= sqlite3StrAccumFinish(p
);
1110 /* Return any error code associated with p */
1111 int sqlite3_str_errcode(sqlite3_str
*p
){
1112 return p
? p
->accError
: SQLITE_NOMEM
;
1115 /* Return the current length of p in bytes */
1116 int sqlite3_str_length(sqlite3_str
*p
){
1117 return p
? p
->nChar
: 0;
1120 /* Return the current value for p */
1121 char *sqlite3_str_value(sqlite3_str
*p
){
1122 if( p
==0 || p
->nChar
==0 ) return 0;
1123 p
->zText
[p
->nChar
] = 0;
1128 ** Reset an StrAccum string. Reclaim all malloced memory.
1130 void sqlite3_str_reset(StrAccum
*p
){
1131 if( isMalloced(p
) ){
1132 sqlite3DbFree(p
->db
, p
->zText
);
1133 p
->printfFlags
&= ~SQLITE_PRINTF_MALLOCED
;
1141 ** Initialize a string accumulator.
1143 ** p: The accumulator to be initialized.
1144 ** db: Pointer to a database connection. May be NULL. Lookaside
1145 ** memory is used if not NULL. db->mallocFailed is set appropriately
1147 ** zBase: An initial buffer. May be NULL in which case the initial buffer
1149 ** n: Size of zBase in bytes. If total space requirements never exceed
1150 ** n then no memory allocations ever occur.
1151 ** mx: Maximum number of bytes to accumulate. If mx==0 then no memory
1152 ** allocations will ever occur.
1154 void sqlite3StrAccumInit(StrAccum
*p
, sqlite3
*db
, char *zBase
, int n
, int mx
){
1164 /* Allocate and initialize a new dynamic string object */
1165 sqlite3_str
*sqlite3_str_new(sqlite3
*db
){
1166 sqlite3_str
*p
= sqlite3_malloc64(sizeof(*p
));
1168 sqlite3StrAccumInit(p
, 0, 0, 0,
1169 db
? db
->aLimit
[SQLITE_LIMIT_LENGTH
] : SQLITE_MAX_LENGTH
);
1177 ** Print into memory obtained from sqliteMalloc(). Use the internal
1178 ** %-conversion extensions.
1180 char *sqlite3VMPrintf(sqlite3
*db
, const char *zFormat
, va_list ap
){
1182 char zBase
[SQLITE_PRINT_BUF_SIZE
];
1185 sqlite3StrAccumInit(&acc
, db
, zBase
, sizeof(zBase
),
1186 db
->aLimit
[SQLITE_LIMIT_LENGTH
]);
1187 acc
.printfFlags
= SQLITE_PRINTF_INTERNAL
;
1188 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1189 z
= sqlite3StrAccumFinish(&acc
);
1190 if( acc
.accError
==SQLITE_NOMEM
){
1191 sqlite3OomFault(db
);
1197 ** Print into memory obtained from sqliteMalloc(). Use the internal
1198 ** %-conversion extensions.
1200 char *sqlite3MPrintf(sqlite3
*db
, const char *zFormat
, ...){
1203 va_start(ap
, zFormat
);
1204 z
= sqlite3VMPrintf(db
, zFormat
, ap
);
1210 ** Print into memory obtained from sqlite3_malloc(). Omit the internal
1211 ** %-conversion extensions.
1213 char *sqlite3_vmprintf(const char *zFormat
, va_list ap
){
1215 char zBase
[SQLITE_PRINT_BUF_SIZE
];
1218 #ifdef SQLITE_ENABLE_API_ARMOR
1220 (void)SQLITE_MISUSE_BKPT
;
1224 #ifndef SQLITE_OMIT_AUTOINIT
1225 if( sqlite3_initialize() ) return 0;
1227 sqlite3StrAccumInit(&acc
, 0, zBase
, sizeof(zBase
), SQLITE_MAX_LENGTH
);
1228 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1229 z
= sqlite3StrAccumFinish(&acc
);
1234 ** Print into memory obtained from sqlite3_malloc()(). Omit the internal
1235 ** %-conversion extensions.
1237 char *sqlite3_mprintf(const char *zFormat
, ...){
1240 #ifndef SQLITE_OMIT_AUTOINIT
1241 if( sqlite3_initialize() ) return 0;
1243 va_start(ap
, zFormat
);
1244 z
= sqlite3_vmprintf(zFormat
, ap
);
1250 ** sqlite3_snprintf() works like snprintf() except that it ignores the
1251 ** current locale settings. This is important for SQLite because we
1252 ** are not able to use a "," as the decimal point in place of "." as
1253 ** specified by some locales.
1255 ** Oops: The first two arguments of sqlite3_snprintf() are backwards
1256 ** from the snprintf() standard. Unfortunately, it is too late to change
1257 ** this without breaking compatibility, so we just have to live with the
1260 ** sqlite3_vsnprintf() is the varargs version.
1262 char *sqlite3_vsnprintf(int n
, char *zBuf
, const char *zFormat
, va_list ap
){
1264 if( n
<=0 ) return zBuf
;
1265 #ifdef SQLITE_ENABLE_API_ARMOR
1266 if( zBuf
==0 || zFormat
==0 ) {
1267 (void)SQLITE_MISUSE_BKPT
;
1268 if( zBuf
) zBuf
[0] = 0;
1272 sqlite3StrAccumInit(&acc
, 0, zBuf
, n
, 0);
1273 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1274 zBuf
[acc
.nChar
] = 0;
1277 char *sqlite3_snprintf(int n
, char *zBuf
, const char *zFormat
, ...){
1280 if( n
<=0 ) return zBuf
;
1281 #ifdef SQLITE_ENABLE_API_ARMOR
1282 if( zBuf
==0 || zFormat
==0 ) {
1283 (void)SQLITE_MISUSE_BKPT
;
1284 if( zBuf
) zBuf
[0] = 0;
1288 sqlite3StrAccumInit(&acc
, 0, zBuf
, n
, 0);
1289 va_start(ap
,zFormat
);
1290 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1292 zBuf
[acc
.nChar
] = 0;
1297 ** This is the routine that actually formats the sqlite3_log() message.
1298 ** We house it in a separate routine from sqlite3_log() to avoid using
1299 ** stack space on small-stack systems when logging is disabled.
1301 ** sqlite3_log() must render into a static buffer. It cannot dynamically
1302 ** allocate memory because it might be called while the memory allocator
1305 ** sqlite3_str_vappendf() might ask for *temporary* memory allocations for
1306 ** certain format characters (%q) or for very large precisions or widths.
1307 ** Care must be taken that any sqlite3_log() calls that occur while the
1308 ** memory mutex is held do not use these mechanisms.
1310 static void renderLogMsg(int iErrCode
, const char *zFormat
, va_list ap
){
1311 StrAccum acc
; /* String accumulator */
1312 char zMsg
[SQLITE_PRINT_BUF_SIZE
*3]; /* Complete log message */
1314 sqlite3StrAccumInit(&acc
, 0, zMsg
, sizeof(zMsg
), 0);
1315 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1316 sqlite3GlobalConfig
.xLog(sqlite3GlobalConfig
.pLogArg
, iErrCode
,
1317 sqlite3StrAccumFinish(&acc
));
1321 ** Format and write a message to the log if logging is enabled.
1323 void sqlite3_log(int iErrCode
, const char *zFormat
, ...){
1324 va_list ap
; /* Vararg list */
1325 if( sqlite3GlobalConfig
.xLog
){
1326 va_start(ap
, zFormat
);
1327 renderLogMsg(iErrCode
, zFormat
, ap
);
1332 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
1334 ** A version of printf() that understands %lld. Used for debugging.
1335 ** The printf() built into some versions of windows does not understand %lld
1336 ** and segfaults if you give it a long long int.
1338 void sqlite3DebugPrintf(const char *zFormat
, ...){
1341 char zBuf
[SQLITE_PRINT_BUF_SIZE
*10];
1342 sqlite3StrAccumInit(&acc
, 0, zBuf
, sizeof(zBuf
), 0);
1343 va_start(ap
,zFormat
);
1344 sqlite3_str_vappendf(&acc
, zFormat
, ap
);
1346 sqlite3StrAccumFinish(&acc
);
1347 #ifdef SQLITE_OS_TRACE_PROC
1349 extern void SQLITE_OS_TRACE_PROC(const char *zBuf
, int nBuf
);
1350 SQLITE_OS_TRACE_PROC(zBuf
, sizeof(zBuf
));
1353 fprintf(stdout
,"%s", zBuf
);
1361 ** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument
1362 ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
1364 void sqlite3_str_appendf(StrAccum
*p
, const char *zFormat
, ...){
1366 va_start(ap
,zFormat
);
1367 sqlite3_str_vappendf(p
, zFormat
, ap
);
1372 /*****************************************************************************
1373 ** Reference counted string/blob storage
1374 *****************************************************************************/
1377 ** Increase the reference count of the string by one.
1379 ** The input parameter is returned.
1381 char *sqlite3RCStrRef(char *z
){
1382 RCStr
*p
= (RCStr
*)z
;
1390 ** Decrease the reference count by one. Free the string when the
1391 ** reference count reaches zero.
1393 void sqlite3RCStrUnref(void *z
){
1394 RCStr
*p
= (RCStr
*)z
;
1397 assert( p
->nRCRef
>0 );
1406 ** Create a new string that is capable of holding N bytes of text, not counting
1407 ** the zero byte at the end. The string is uninitialized.
1409 ** The reference count is initially 1. Call sqlite3RCStrUnref() to free the
1410 ** newly allocated string.
1412 ** This routine returns 0 on an OOM.
1414 char *sqlite3RCStrNew(u64 N
){
1415 RCStr
*p
= sqlite3_malloc64( N
+ sizeof(*p
) + 1 );
1416 if( p
==0 ) return 0;
1418 return (char*)&p
[1];
1422 ** Change the size of the string so that it is able to hold N bytes.
1423 ** The string might be reallocated, so return the new allocation.
1425 char *sqlite3RCStrResize(char *z
, u64 N
){
1426 RCStr
*p
= (RCStr
*)z
;
1430 assert( p
->nRCRef
==1 );
1431 pNew
= sqlite3_realloc64(p
, N
+sizeof(RCStr
)+1);
1436 return (char*)&pNew
[1];