1 | /* |
2 | ** The "printf" code that follows dates from the 1980's. It is in |
3 | ** the public domain. |
4 | ** |
5 | ************************************************************************** |
6 | ** |
7 | ** This file contains code for a set of "printf"-like routines. These |
8 | ** routines format strings much like the printf() from the standard C |
9 | ** library, though the implementation here has enhancements to support |
10 | ** SQLite. |
11 | */ |
12 | #include "sqliteInt.h" |
13 | |
14 | /* |
15 | ** Conversion types fall into various categories as defined by the |
16 | ** following enumeration. |
17 | */ |
18 | #define etRADIX 0 /* non-decimal integer types. %x %o */ |
19 | #define etFLOAT 1 /* Floating point. %f */ |
20 | #define etEXP 2 /* Exponentional notation. %e and %E */ |
21 | #define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */ |
22 | #define etSIZE 4 /* Return number of characters processed so far. %n */ |
23 | #define etSTRING 5 /* Strings. %s */ |
24 | #define etDYNSTRING 6 /* Dynamically allocated strings. %z */ |
25 | #define etPERCENT 7 /* Percent symbol. %% */ |
26 | #define etCHARX 8 /* Characters. %c */ |
27 | /* The rest are extensions, not normally found in printf() */ |
28 | #define etSQLESCAPE 9 /* Strings with '\'' doubled. %q */ |
29 | #define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '', |
30 | NULL pointers replaced by SQL NULL. %Q */ |
31 | #define etTOKEN 11 /* a pointer to a Token structure */ |
32 | #define 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 */ |
37 | |
38 | #define etINVALID 17 /* Any unrecognized conversion type */ |
39 | |
40 | |
41 | /* |
42 | ** An "etByte" is an 8-bit unsigned value. |
43 | */ |
44 | typedef unsigned char etByte; |
45 | |
46 | /* |
47 | ** Each builtin conversion character (ex: the 'd' in "%d") is described |
48 | ** by an instance of the following structure |
49 | */ |
50 | typedef struct et_info { /* Information about each format field */ |
51 | char fmttype; /* The format field code letter */ |
52 | etByte base; /* The base for radix conversion */ |
53 | etByte flags; /* One or more of FLAG_ constants below */ |
54 | etByte type; /* Conversion paradigm */ |
55 | etByte charset; /* Offset into aDigits[] of the digits string */ |
56 | etByte prefix; /* Offset into aPrefix[] of the prefix string */ |
57 | } et_info; |
58 | |
59 | /* |
60 | ** Allowed values for et_info.flags |
61 | */ |
62 | #define FLAG_SIGNED 1 /* True if the value to convert is signed */ |
63 | #define FLAG_STRING 4 /* Allow infinite precision */ |
64 | |
65 | |
66 | /* |
67 | ** The following table is searched linearly, so it is good to put the |
68 | ** most frequently used conversion types first. |
69 | */ |
70 | static const char aDigits[] = "0123456789ABCDEF0123456789abcdef" ; |
71 | static const char aPrefix[] = "-x0\000X0" ; |
72 | static const et_info fmtinfo[] = { |
73 | { 'd', 10, 1, etDECIMAL, 0, 0 }, |
74 | { 's', 0, 4, etSTRING, 0, 0 }, |
75 | { 'g', 0, 1, etGENERIC, 30, 0 }, |
76 | { 'z', 0, 4, etDYNSTRING, 0, 0 }, |
77 | { 'q', 0, 4, etSQLESCAPE, 0, 0 }, |
78 | { 'Q', 0, 4, etSQLESCAPE2, 0, 0 }, |
79 | { 'w', 0, 4, etSQLESCAPE3, 0, 0 }, |
80 | { 'c', 0, 0, etCHARX, 0, 0 }, |
81 | { 'o', 8, 0, etRADIX, 0, 2 }, |
82 | { 'u', 10, 0, etDECIMAL, 0, 0 }, |
83 | { 'x', 16, 0, etRADIX, 16, 1 }, |
84 | { 'X', 16, 0, etRADIX, 0, 4 }, |
85 | #ifndef SQLITE_OMIT_FLOATING_POINT |
86 | { 'f', 0, 1, etFLOAT, 0, 0 }, |
87 | { 'e', 0, 1, etEXP, 30, 0 }, |
88 | { 'E', 0, 1, etEXP, 14, 0 }, |
89 | { 'G', 0, 1, etGENERIC, 14, 0 }, |
90 | #endif |
91 | { 'i', 10, 1, etDECIMAL, 0, 0 }, |
92 | { 'n', 0, 0, etSIZE, 0, 0 }, |
93 | { '%', 0, 0, etPERCENT, 0, 0 }, |
94 | { 'p', 16, 0, etPOINTER, 0, 1 }, |
95 | |
96 | /* All the rest are undocumented and are for internal use only */ |
97 | { 'T', 0, 0, etTOKEN, 0, 0 }, |
98 | { 'S', 0, 0, etSRCITEM, 0, 0 }, |
99 | { 'r', 10, 1, etORDINAL, 0, 0 }, |
100 | }; |
101 | |
102 | /* Notes: |
103 | ** |
104 | ** %S Takes a pointer to SrcItem. Shows name or database.name |
105 | ** %!S Like %S but prefer the zName over the zAlias |
106 | */ |
107 | |
108 | /* Floating point constants used for rounding */ |
109 | static const double arRound[] = { |
110 | 5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05, |
111 | 5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10, |
112 | }; |
113 | |
114 | /* |
115 | ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point |
116 | ** conversions will work. |
117 | */ |
118 | #ifndef SQLITE_OMIT_FLOATING_POINT |
119 | /* |
120 | ** "*val" is a double such that 0.1 <= *val < 10.0 |
121 | ** Return the ascii code for the leading digit of *val, then |
122 | ** multiply "*val" by 10.0 to renormalize. |
123 | ** |
124 | ** Example: |
125 | ** input: *val = 3.14159 |
126 | ** output: *val = 1.4159 function return = '3' |
127 | ** |
128 | ** The counter *cnt is incremented each time. After counter exceeds |
129 | ** 16 (the number of significant digits in a 64-bit float) '0' is |
130 | ** always returned. |
131 | */ |
132 | static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ |
133 | int digit; |
134 | LONGDOUBLE_TYPE d; |
135 | if( (*cnt)<=0 ) return '0'; |
136 | (*cnt)--; |
137 | digit = (int)*val; |
138 | d = digit; |
139 | digit += '0'; |
140 | *val = (*val - d)*10.0; |
141 | return (char)digit; |
142 | } |
143 | #endif /* SQLITE_OMIT_FLOATING_POINT */ |
144 | |
145 | /* |
146 | ** Set the StrAccum object to an error mode. |
147 | */ |
148 | void sqlite3StrAccumSetError(StrAccum *p, u8 eError){ |
149 | assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG ); |
150 | p->accError = eError; |
151 | if( p->mxAlloc ) sqlite3_str_reset(p); |
152 | if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError); |
153 | } |
154 | |
155 | /* |
156 | ** Extra argument values from a PrintfArguments object |
157 | */ |
158 | static sqlite3_int64 getIntArg(PrintfArguments *p){ |
159 | if( p->nArg<=p->nUsed ) return 0; |
160 | return sqlite3_value_int64(p->apArg[p->nUsed++]); |
161 | } |
162 | static double getDoubleArg(PrintfArguments *p){ |
163 | if( p->nArg<=p->nUsed ) return 0.0; |
164 | return sqlite3_value_double(p->apArg[p->nUsed++]); |
165 | } |
166 | static char *getTextArg(PrintfArguments *p){ |
167 | if( p->nArg<=p->nUsed ) return 0; |
168 | return (char*)sqlite3_value_text(p->apArg[p->nUsed++]); |
169 | } |
170 | |
171 | /* |
172 | ** Allocate memory for a temporary buffer needed for printf rendering. |
173 | ** |
174 | ** If the requested size of the temp buffer is larger than the size |
175 | ** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error. |
176 | ** Do the size check before the memory allocation to prevent rogue |
177 | ** SQL from requesting large allocations using the precision or width |
178 | ** field of the printf() function. |
179 | */ |
180 | static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){ |
181 | char *z; |
182 | if( pAccum->accError ) return 0; |
183 | if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){ |
184 | sqlite3StrAccumSetError(pAccum, SQLITE_TOOBIG); |
185 | return 0; |
186 | } |
187 | z = sqlite3DbMallocRaw(pAccum->db, n); |
188 | if( z==0 ){ |
189 | sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM); |
190 | } |
191 | return z; |
192 | } |
193 | |
194 | /* |
195 | ** On machines with a small stack size, you can redefine the |
196 | ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired. |
197 | */ |
198 | #ifndef SQLITE_PRINT_BUF_SIZE |
199 | # define SQLITE_PRINT_BUF_SIZE 70 |
200 | #endif |
201 | #define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */ |
202 | |
203 | /* |
204 | ** Hard limit on the precision of floating-point conversions. |
205 | */ |
206 | #ifndef SQLITE_PRINTF_PRECISION_LIMIT |
207 | # define SQLITE_FP_PRECISION_LIMIT 100000000 |
208 | #endif |
209 | |
210 | /* |
211 | ** Render a string given by "fmt" into the StrAccum object. |
212 | */ |
213 | void sqlite3_str_vappendf( |
214 | sqlite3_str *pAccum, /* Accumulate results here */ |
215 | const char *fmt, /* Format string */ |
216 | va_list ap /* arguments */ |
217 | ){ |
218 | int c; /* Next character in the format string */ |
219 | char *bufpt; /* Pointer to the conversion buffer */ |
220 | int precision; /* Precision of the current field */ |
221 | int length; /* Length of the field */ |
222 | int idx; /* A general purpose loop counter */ |
223 | int width; /* Width of the current field */ |
224 | etByte flag_leftjustify; /* True if "-" flag is present */ |
225 | etByte flag_prefix; /* '+' or ' ' or 0 for prefix */ |
226 | etByte flag_alternateform; /* True if "#" flag is present */ |
227 | etByte flag_altform2; /* True if "!" flag is present */ |
228 | etByte flag_zeropad; /* True if field width constant starts with zero */ |
229 | etByte flag_long; /* 1 for the "l" flag, 2 for "ll", 0 by default */ |
230 | etByte done; /* Loop termination flag */ |
231 | etByte cThousand; /* Thousands separator for %d and %u */ |
232 | etByte xtype = etINVALID; /* Conversion paradigm */ |
233 | u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */ |
234 | char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ |
235 | sqlite_uint64 longvalue; /* Value for integer types */ |
236 | LONGDOUBLE_TYPE realvalue; /* Value for real types */ |
237 | const et_info *infop; /* Pointer to the appropriate info structure */ |
238 | char *zOut; /* Rendering buffer */ |
239 | int nOut; /* Size of the rendering buffer */ |
240 | char * = 0; /* Malloced memory used by some conversion */ |
241 | #ifndef SQLITE_OMIT_FLOATING_POINT |
242 | int exp, e2; /* exponent of real numbers */ |
243 | int nsd; /* Number of significant digits returned */ |
244 | double rounder; /* Used for rounding floating point values */ |
245 | etByte flag_dp; /* True if decimal point should be shown */ |
246 | etByte flag_rtz; /* True if trailing zeros should be removed */ |
247 | #endif |
248 | PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */ |
249 | char buf[etBUFSIZE]; /* Conversion buffer */ |
250 | |
251 | /* pAccum never starts out with an empty buffer that was obtained from |
252 | ** malloc(). This precondition is required by the mprintf("%z...") |
253 | ** optimization. */ |
254 | assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); |
255 | |
256 | bufpt = 0; |
257 | if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){ |
258 | pArgList = va_arg(ap, PrintfArguments*); |
259 | bArgList = 1; |
260 | }else{ |
261 | bArgList = 0; |
262 | } |
263 | for(; (c=(*fmt))!=0; ++fmt){ |
264 | if( c!='%' ){ |
265 | bufpt = (char *)fmt; |
266 | #if HAVE_STRCHRNUL |
267 | fmt = strchrnul(fmt, '%'); |
268 | #else |
269 | do{ fmt++; }while( *fmt && *fmt != '%' ); |
270 | #endif |
271 | sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt)); |
272 | if( *fmt==0 ) break; |
273 | } |
274 | if( (c=(*++fmt))==0 ){ |
275 | sqlite3_str_append(pAccum, "%" , 1); |
276 | break; |
277 | } |
278 | /* Find out what flags are present */ |
279 | flag_leftjustify = flag_prefix = cThousand = |
280 | flag_alternateform = flag_altform2 = flag_zeropad = 0; |
281 | done = 0; |
282 | width = 0; |
283 | flag_long = 0; |
284 | precision = -1; |
285 | do{ |
286 | switch( c ){ |
287 | case '-': flag_leftjustify = 1; break; |
288 | case '+': flag_prefix = '+'; break; |
289 | case ' ': flag_prefix = ' '; break; |
290 | case '#': flag_alternateform = 1; break; |
291 | case '!': flag_altform2 = 1; break; |
292 | case '0': flag_zeropad = 1; break; |
293 | case ',': cThousand = ','; break; |
294 | default: done = 1; break; |
295 | case 'l': { |
296 | flag_long = 1; |
297 | c = *++fmt; |
298 | if( c=='l' ){ |
299 | c = *++fmt; |
300 | flag_long = 2; |
301 | } |
302 | done = 1; |
303 | break; |
304 | } |
305 | case '1': case '2': case '3': case '4': case '5': |
306 | case '6': case '7': case '8': case '9': { |
307 | unsigned wx = c - '0'; |
308 | while( (c = *++fmt)>='0' && c<='9' ){ |
309 | wx = wx*10 + c - '0'; |
310 | } |
311 | testcase( wx>0x7fffffff ); |
312 | width = wx & 0x7fffffff; |
313 | #ifdef SQLITE_PRINTF_PRECISION_LIMIT |
314 | if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ |
315 | width = SQLITE_PRINTF_PRECISION_LIMIT; |
316 | } |
317 | #endif |
318 | if( c!='.' && c!='l' ){ |
319 | done = 1; |
320 | }else{ |
321 | fmt--; |
322 | } |
323 | break; |
324 | } |
325 | case '*': { |
326 | if( bArgList ){ |
327 | width = (int)getIntArg(pArgList); |
328 | }else{ |
329 | width = va_arg(ap,int); |
330 | } |
331 | if( width<0 ){ |
332 | flag_leftjustify = 1; |
333 | width = width >= -2147483647 ? -width : 0; |
334 | } |
335 | #ifdef SQLITE_PRINTF_PRECISION_LIMIT |
336 | if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ |
337 | width = SQLITE_PRINTF_PRECISION_LIMIT; |
338 | } |
339 | #endif |
340 | if( (c = fmt[1])!='.' && c!='l' ){ |
341 | c = *++fmt; |
342 | done = 1; |
343 | } |
344 | break; |
345 | } |
346 | case '.': { |
347 | c = *++fmt; |
348 | if( c=='*' ){ |
349 | if( bArgList ){ |
350 | precision = (int)getIntArg(pArgList); |
351 | }else{ |
352 | precision = va_arg(ap,int); |
353 | } |
354 | if( precision<0 ){ |
355 | precision = precision >= -2147483647 ? -precision : -1; |
356 | } |
357 | c = *++fmt; |
358 | }else{ |
359 | unsigned px = 0; |
360 | while( c>='0' && c<='9' ){ |
361 | px = px*10 + c - '0'; |
362 | c = *++fmt; |
363 | } |
364 | testcase( px>0x7fffffff ); |
365 | precision = px & 0x7fffffff; |
366 | } |
367 | #ifdef SQLITE_PRINTF_PRECISION_LIMIT |
368 | if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){ |
369 | precision = SQLITE_PRINTF_PRECISION_LIMIT; |
370 | } |
371 | #endif |
372 | if( c=='l' ){ |
373 | --fmt; |
374 | }else{ |
375 | done = 1; |
376 | } |
377 | break; |
378 | } |
379 | } |
380 | }while( !done && (c=(*++fmt))!=0 ); |
381 | |
382 | /* Fetch the info entry for the field */ |
383 | infop = &fmtinfo[0]; |
384 | xtype = etINVALID; |
385 | for(idx=0; idx<ArraySize(fmtinfo); idx++){ |
386 | if( c==fmtinfo[idx].fmttype ){ |
387 | infop = &fmtinfo[idx]; |
388 | xtype = infop->type; |
389 | break; |
390 | } |
391 | } |
392 | |
393 | /* |
394 | ** At this point, variables are initialized as follows: |
395 | ** |
396 | ** flag_alternateform TRUE if a '#' is present. |
397 | ** flag_altform2 TRUE if a '!' is present. |
398 | ** flag_prefix '+' or ' ' or zero |
399 | ** flag_leftjustify TRUE if a '-' is present or if the |
400 | ** field width was negative. |
401 | ** flag_zeropad TRUE if the width began with 0. |
402 | ** flag_long 1 for "l", 2 for "ll" |
403 | ** width The specified field width. This is |
404 | ** always non-negative. Zero is the default. |
405 | ** precision The specified precision. The default |
406 | ** is -1. |
407 | ** xtype The class of the conversion. |
408 | ** infop Pointer to the appropriate info struct. |
409 | */ |
410 | assert( width>=0 ); |
411 | assert( precision>=(-1) ); |
412 | switch( xtype ){ |
413 | case etPOINTER: |
414 | flag_long = sizeof(char*)==sizeof(i64) ? 2 : |
415 | sizeof(char*)==sizeof(long int) ? 1 : 0; |
416 | /* no break */ deliberate_fall_through |
417 | case etORDINAL: |
418 | case etRADIX: |
419 | cThousand = 0; |
420 | /* no break */ deliberate_fall_through |
421 | case etDECIMAL: |
422 | if( infop->flags & FLAG_SIGNED ){ |
423 | i64 v; |
424 | if( bArgList ){ |
425 | v = getIntArg(pArgList); |
426 | }else if( flag_long ){ |
427 | if( flag_long==2 ){ |
428 | v = va_arg(ap,i64) ; |
429 | }else{ |
430 | v = va_arg(ap,long int); |
431 | } |
432 | }else{ |
433 | v = va_arg(ap,int); |
434 | } |
435 | if( v<0 ){ |
436 | testcase( v==SMALLEST_INT64 ); |
437 | testcase( v==(-1) ); |
438 | longvalue = ~v; |
439 | longvalue++; |
440 | prefix = '-'; |
441 | }else{ |
442 | longvalue = v; |
443 | prefix = flag_prefix; |
444 | } |
445 | }else{ |
446 | if( bArgList ){ |
447 | longvalue = (u64)getIntArg(pArgList); |
448 | }else if( flag_long ){ |
449 | if( flag_long==2 ){ |
450 | longvalue = va_arg(ap,u64); |
451 | }else{ |
452 | longvalue = va_arg(ap,unsigned long int); |
453 | } |
454 | }else{ |
455 | longvalue = va_arg(ap,unsigned int); |
456 | } |
457 | prefix = 0; |
458 | } |
459 | if( longvalue==0 ) flag_alternateform = 0; |
460 | if( flag_zeropad && precision<width-(prefix!=0) ){ |
461 | precision = width-(prefix!=0); |
462 | } |
463 | if( precision<etBUFSIZE-10-etBUFSIZE/3 ){ |
464 | nOut = etBUFSIZE; |
465 | zOut = buf; |
466 | }else{ |
467 | u64 n; |
468 | n = (u64)precision + 10; |
469 | if( cThousand ) n += precision/3; |
470 | zOut = zExtra = printfTempBuf(pAccum, n); |
471 | if( zOut==0 ) return; |
472 | nOut = (int)n; |
473 | } |
474 | bufpt = &zOut[nOut-1]; |
475 | if( xtype==etORDINAL ){ |
476 | static const char zOrd[] = "thstndrd" ; |
477 | int x = (int)(longvalue % 10); |
478 | if( x>=4 || (longvalue/10)%10==1 ){ |
479 | x = 0; |
480 | } |
481 | *(--bufpt) = zOrd[x*2+1]; |
482 | *(--bufpt) = zOrd[x*2]; |
483 | } |
484 | { |
485 | const char *cset = &aDigits[infop->charset]; |
486 | u8 base = infop->base; |
487 | do{ /* Convert to ascii */ |
488 | *(--bufpt) = cset[longvalue%base]; |
489 | longvalue = longvalue/base; |
490 | }while( longvalue>0 ); |
491 | } |
492 | length = (int)(&zOut[nOut-1]-bufpt); |
493 | while( precision>length ){ |
494 | *(--bufpt) = '0'; /* Zero pad */ |
495 | length++; |
496 | } |
497 | if( cThousand ){ |
498 | int nn = (length - 1)/3; /* Number of "," to insert */ |
499 | int ix = (length - 1)%3 + 1; |
500 | bufpt -= nn; |
501 | for(idx=0; nn>0; idx++){ |
502 | bufpt[idx] = bufpt[idx+nn]; |
503 | ix--; |
504 | if( ix==0 ){ |
505 | bufpt[++idx] = cThousand; |
506 | nn--; |
507 | ix = 3; |
508 | } |
509 | } |
510 | } |
511 | if( prefix ) *(--bufpt) = prefix; /* Add sign */ |
512 | if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ |
513 | const char *pre; |
514 | char x; |
515 | pre = &aPrefix[infop->prefix]; |
516 | for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; |
517 | } |
518 | length = (int)(&zOut[nOut-1]-bufpt); |
519 | break; |
520 | case etFLOAT: |
521 | case etEXP: |
522 | case etGENERIC: |
523 | if( bArgList ){ |
524 | realvalue = getDoubleArg(pArgList); |
525 | }else{ |
526 | realvalue = va_arg(ap,double); |
527 | } |
528 | #ifdef SQLITE_OMIT_FLOATING_POINT |
529 | length = 0; |
530 | #else |
531 | if( precision<0 ) precision = 6; /* Set default precision */ |
532 | #ifdef SQLITE_FP_PRECISION_LIMIT |
533 | if( precision>SQLITE_FP_PRECISION_LIMIT ){ |
534 | precision = SQLITE_FP_PRECISION_LIMIT; |
535 | } |
536 | #endif |
537 | if( realvalue<0.0 ){ |
538 | realvalue = -realvalue; |
539 | prefix = '-'; |
540 | }else{ |
541 | prefix = flag_prefix; |
542 | } |
543 | if( xtype==etGENERIC && precision>0 ) precision--; |
544 | testcase( precision>0xfff ); |
545 | idx = precision & 0xfff; |
546 | rounder = arRound[idx%10]; |
547 | while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; } |
548 | if( xtype==etFLOAT ){ |
549 | double rx = (double)realvalue; |
550 | sqlite3_uint64 u; |
551 | int ex; |
552 | memcpy(&u, &rx, sizeof(u)); |
553 | ex = -1023 + (int)((u>>52)&0x7ff); |
554 | if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16; |
555 | realvalue += rounder; |
556 | } |
557 | /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ |
558 | exp = 0; |
559 | if( sqlite3IsNaN((double)realvalue) ){ |
560 | bufpt = "NaN" ; |
561 | length = 3; |
562 | break; |
563 | } |
564 | if( realvalue>0.0 ){ |
565 | LONGDOUBLE_TYPE scale = 1.0; |
566 | while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;} |
567 | while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; } |
568 | while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; } |
569 | realvalue /= scale; |
570 | while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; } |
571 | while( realvalue<1.0 ){ realvalue *= 10.0; exp--; } |
572 | if( exp>350 ){ |
573 | bufpt = buf; |
574 | buf[0] = prefix; |
575 | memcpy(buf+(prefix!=0),"Inf" ,4); |
576 | length = 3+(prefix!=0); |
577 | break; |
578 | } |
579 | } |
580 | bufpt = buf; |
581 | /* |
582 | ** If the field type is etGENERIC, then convert to either etEXP |
583 | ** or etFLOAT, as appropriate. |
584 | */ |
585 | if( xtype!=etFLOAT ){ |
586 | realvalue += rounder; |
587 | if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; } |
588 | } |
589 | if( xtype==etGENERIC ){ |
590 | flag_rtz = !flag_alternateform; |
591 | if( exp<-4 || exp>precision ){ |
592 | xtype = etEXP; |
593 | }else{ |
594 | precision = precision - exp; |
595 | xtype = etFLOAT; |
596 | } |
597 | }else{ |
598 | flag_rtz = flag_altform2; |
599 | } |
600 | if( xtype==etEXP ){ |
601 | e2 = 0; |
602 | }else{ |
603 | e2 = exp; |
604 | } |
605 | { |
606 | i64 szBufNeeded; /* Size of a temporary buffer needed */ |
607 | szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15; |
608 | if( szBufNeeded > etBUFSIZE ){ |
609 | bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded); |
610 | if( bufpt==0 ) return; |
611 | } |
612 | } |
613 | zOut = bufpt; |
614 | nsd = 16 + flag_altform2*10; |
615 | flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2; |
616 | /* The sign in front of the number */ |
617 | if( prefix ){ |
618 | *(bufpt++) = prefix; |
619 | } |
620 | /* Digits prior to the decimal point */ |
621 | if( e2<0 ){ |
622 | *(bufpt++) = '0'; |
623 | }else{ |
624 | for(; e2>=0; e2--){ |
625 | *(bufpt++) = et_getdigit(&realvalue,&nsd); |
626 | } |
627 | } |
628 | /* The decimal point */ |
629 | if( flag_dp ){ |
630 | *(bufpt++) = '.'; |
631 | } |
632 | /* "0" digits after the decimal point but before the first |
633 | ** significant digit of the number */ |
634 | for(e2++; e2<0; precision--, e2++){ |
635 | assert( precision>0 ); |
636 | *(bufpt++) = '0'; |
637 | } |
638 | /* Significant digits after the decimal point */ |
639 | while( (precision--)>0 ){ |
640 | *(bufpt++) = et_getdigit(&realvalue,&nsd); |
641 | } |
642 | /* Remove trailing zeros and the "." if no digits follow the "." */ |
643 | if( flag_rtz && flag_dp ){ |
644 | while( bufpt[-1]=='0' ) *(--bufpt) = 0; |
645 | assert( bufpt>zOut ); |
646 | if( bufpt[-1]=='.' ){ |
647 | if( flag_altform2 ){ |
648 | *(bufpt++) = '0'; |
649 | }else{ |
650 | *(--bufpt) = 0; |
651 | } |
652 | } |
653 | } |
654 | /* Add the "eNNN" suffix */ |
655 | if( xtype==etEXP ){ |
656 | *(bufpt++) = aDigits[infop->charset]; |
657 | if( exp<0 ){ |
658 | *(bufpt++) = '-'; exp = -exp; |
659 | }else{ |
660 | *(bufpt++) = '+'; |
661 | } |
662 | if( exp>=100 ){ |
663 | *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */ |
664 | exp %= 100; |
665 | } |
666 | *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */ |
667 | *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */ |
668 | } |
669 | *bufpt = 0; |
670 | |
671 | /* The converted number is in buf[] and zero terminated. Output it. |
672 | ** Note that the number is in the usual order, not reversed as with |
673 | ** integer conversions. */ |
674 | length = (int)(bufpt-zOut); |
675 | bufpt = zOut; |
676 | |
677 | /* Special case: Add leading zeros if the flag_zeropad flag is |
678 | ** set and we are not left justified */ |
679 | if( flag_zeropad && !flag_leftjustify && length < width){ |
680 | int i; |
681 | int nPad = width - length; |
682 | for(i=width; i>=nPad; i--){ |
683 | bufpt[i] = bufpt[i-nPad]; |
684 | } |
685 | i = prefix!=0; |
686 | while( nPad-- ) bufpt[i++] = '0'; |
687 | length = width; |
688 | } |
689 | #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */ |
690 | break; |
691 | case etSIZE: |
692 | if( !bArgList ){ |
693 | *(va_arg(ap,int*)) = pAccum->nChar; |
694 | } |
695 | length = width = 0; |
696 | break; |
697 | case etPERCENT: |
698 | buf[0] = '%'; |
699 | bufpt = buf; |
700 | length = 1; |
701 | break; |
702 | case etCHARX: |
703 | if( bArgList ){ |
704 | bufpt = getTextArg(pArgList); |
705 | length = 1; |
706 | if( bufpt ){ |
707 | buf[0] = c = *(bufpt++); |
708 | if( (c&0xc0)==0xc0 ){ |
709 | while( length<4 && (bufpt[0]&0xc0)==0x80 ){ |
710 | buf[length++] = *(bufpt++); |
711 | } |
712 | } |
713 | }else{ |
714 | buf[0] = 0; |
715 | } |
716 | }else{ |
717 | unsigned int ch = va_arg(ap,unsigned int); |
718 | if( ch<0x00080 ){ |
719 | buf[0] = ch & 0xff; |
720 | length = 1; |
721 | }else if( ch<0x00800 ){ |
722 | buf[0] = 0xc0 + (u8)((ch>>6)&0x1f); |
723 | buf[1] = 0x80 + (u8)(ch & 0x3f); |
724 | length = 2; |
725 | }else if( ch<0x10000 ){ |
726 | buf[0] = 0xe0 + (u8)((ch>>12)&0x0f); |
727 | buf[1] = 0x80 + (u8)((ch>>6) & 0x3f); |
728 | buf[2] = 0x80 + (u8)(ch & 0x3f); |
729 | length = 3; |
730 | }else{ |
731 | buf[0] = 0xf0 + (u8)((ch>>18) & 0x07); |
732 | buf[1] = 0x80 + (u8)((ch>>12) & 0x3f); |
733 | buf[2] = 0x80 + (u8)((ch>>6) & 0x3f); |
734 | buf[3] = 0x80 + (u8)(ch & 0x3f); |
735 | length = 4; |
736 | } |
737 | } |
738 | if( precision>1 ){ |
739 | width -= precision-1; |
740 | if( width>1 && !flag_leftjustify ){ |
741 | sqlite3_str_appendchar(pAccum, width-1, ' '); |
742 | width = 0; |
743 | } |
744 | while( precision-- > 1 ){ |
745 | sqlite3_str_append(pAccum, buf, length); |
746 | } |
747 | } |
748 | bufpt = buf; |
749 | flag_altform2 = 1; |
750 | goto adjust_width_for_utf8; |
751 | case etSTRING: |
752 | case etDYNSTRING: |
753 | if( bArgList ){ |
754 | bufpt = getTextArg(pArgList); |
755 | xtype = etSTRING; |
756 | }else{ |
757 | bufpt = va_arg(ap,char*); |
758 | } |
759 | if( bufpt==0 ){ |
760 | bufpt = "" ; |
761 | }else if( xtype==etDYNSTRING ){ |
762 | if( pAccum->nChar==0 |
763 | && pAccum->mxAlloc |
764 | && width==0 |
765 | && precision<0 |
766 | && pAccum->accError==0 |
767 | ){ |
768 | /* Special optimization for sqlite3_mprintf("%z..."): |
769 | ** Extend an existing memory allocation rather than creating |
770 | ** a new one. */ |
771 | assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); |
772 | pAccum->zText = bufpt; |
773 | pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt); |
774 | pAccum->nChar = 0x7fffffff & (int)strlen(bufpt); |
775 | pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED; |
776 | length = 0; |
777 | break; |
778 | } |
779 | zExtra = bufpt; |
780 | } |
781 | if( precision>=0 ){ |
782 | if( flag_altform2 ){ |
783 | /* Set length to the number of bytes needed in order to display |
784 | ** precision characters */ |
785 | unsigned char *z = (unsigned char*)bufpt; |
786 | while( precision-- > 0 && z[0] ){ |
787 | SQLITE_SKIP_UTF8(z); |
788 | } |
789 | length = (int)(z - (unsigned char*)bufpt); |
790 | }else{ |
791 | for(length=0; length<precision && bufpt[length]; length++){} |
792 | } |
793 | }else{ |
794 | length = 0x7fffffff & (int)strlen(bufpt); |
795 | } |
796 | adjust_width_for_utf8: |
797 | if( flag_altform2 && width>0 ){ |
798 | /* Adjust width to account for extra bytes in UTF-8 characters */ |
799 | int ii = length - 1; |
800 | while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++; |
801 | } |
802 | break; |
803 | case etSQLESCAPE: /* %q: Escape ' characters */ |
804 | case etSQLESCAPE2: /* %Q: Escape ' and enclose in '...' */ |
805 | case etSQLESCAPE3: { /* %w: Escape " characters */ |
806 | i64 i, j, k, n; |
807 | int needQuote, isnull; |
808 | char ch; |
809 | char q = ((xtype==etSQLESCAPE3)?'"':'\''); /* Quote character */ |
810 | char *escarg; |
811 | |
812 | if( bArgList ){ |
813 | escarg = getTextArg(pArgList); |
814 | }else{ |
815 | escarg = va_arg(ap,char*); |
816 | } |
817 | isnull = escarg==0; |
818 | if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)" ); |
819 | /* For %q, %Q, and %w, the precision is the number of bytes (or |
820 | ** characters if the ! flags is present) to use from the input. |
821 | ** Because of the extra quoting characters inserted, the number |
822 | ** of output characters may be larger than the precision. |
823 | */ |
824 | k = precision; |
825 | for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){ |
826 | if( ch==q ) n++; |
827 | if( flag_altform2 && (ch&0xc0)==0xc0 ){ |
828 | while( (escarg[i+1]&0xc0)==0x80 ){ i++; } |
829 | } |
830 | } |
831 | needQuote = !isnull && xtype==etSQLESCAPE2; |
832 | n += i + 3; |
833 | if( n>etBUFSIZE ){ |
834 | bufpt = zExtra = printfTempBuf(pAccum, n); |
835 | if( bufpt==0 ) return; |
836 | }else{ |
837 | bufpt = buf; |
838 | } |
839 | j = 0; |
840 | if( needQuote ) bufpt[j++] = q; |
841 | k = i; |
842 | for(i=0; i<k; i++){ |
843 | bufpt[j++] = ch = escarg[i]; |
844 | if( ch==q ) bufpt[j++] = ch; |
845 | } |
846 | if( needQuote ) bufpt[j++] = q; |
847 | bufpt[j] = 0; |
848 | length = j; |
849 | goto adjust_width_for_utf8; |
850 | } |
851 | case etTOKEN: { |
852 | if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; |
853 | if( flag_alternateform ){ |
854 | /* %#T means an Expr pointer that uses Expr.u.zToken */ |
855 | Expr *pExpr = va_arg(ap,Expr*); |
856 | if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){ |
857 | sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken); |
858 | sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr); |
859 | } |
860 | }else{ |
861 | /* %T means a Token pointer */ |
862 | Token *pToken = va_arg(ap, Token*); |
863 | assert( bArgList==0 ); |
864 | if( pToken && pToken->n ){ |
865 | sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n); |
866 | sqlite3RecordErrorByteOffset(pAccum->db, pToken->z); |
867 | } |
868 | } |
869 | length = width = 0; |
870 | break; |
871 | } |
872 | case etSRCITEM: { |
873 | SrcItem *pItem; |
874 | if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; |
875 | pItem = va_arg(ap, SrcItem*); |
876 | assert( bArgList==0 ); |
877 | if( pItem->zAlias && !flag_altform2 ){ |
878 | sqlite3_str_appendall(pAccum, pItem->zAlias); |
879 | }else if( pItem->zName ){ |
880 | if( pItem->zDatabase ){ |
881 | sqlite3_str_appendall(pAccum, pItem->zDatabase); |
882 | sqlite3_str_append(pAccum, "." , 1); |
883 | } |
884 | sqlite3_str_appendall(pAccum, pItem->zName); |
885 | }else if( pItem->zAlias ){ |
886 | sqlite3_str_appendall(pAccum, pItem->zAlias); |
887 | }else{ |
888 | Select *pSel = pItem->pSelect; |
889 | assert( pSel!=0 ); |
890 | if( pSel->selFlags & SF_NestedFrom ){ |
891 | sqlite3_str_appendf(pAccum, "(join-%u)" , pSel->selId); |
892 | }else{ |
893 | sqlite3_str_appendf(pAccum, "(subquery-%u)" , pSel->selId); |
894 | } |
895 | } |
896 | length = width = 0; |
897 | break; |
898 | } |
899 | default: { |
900 | assert( xtype==etINVALID ); |
901 | return; |
902 | } |
903 | }/* End switch over the format type */ |
904 | /* |
905 | ** The text of the conversion is pointed to by "bufpt" and is |
906 | ** "length" characters long. The field width is "width". Do |
907 | ** the output. Both length and width are in bytes, not characters, |
908 | ** at this point. If the "!" flag was present on string conversions |
909 | ** indicating that width and precision should be expressed in characters, |
910 | ** then the values have been translated prior to reaching this point. |
911 | */ |
912 | width -= length; |
913 | if( width>0 ){ |
914 | if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); |
915 | sqlite3_str_append(pAccum, bufpt, length); |
916 | if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); |
917 | }else{ |
918 | sqlite3_str_append(pAccum, bufpt, length); |
919 | } |
920 | |
921 | if( zExtra ){ |
922 | sqlite3DbFree(pAccum->db, zExtra); |
923 | zExtra = 0; |
924 | } |
925 | }/* End for loop over the format string */ |
926 | } /* End of function */ |
927 | |
928 | |
929 | /* |
930 | ** The z string points to the first character of a token that is |
931 | ** associated with an error. If db does not already have an error |
932 | ** byte offset recorded, try to compute the error byte offset for |
933 | ** z and set the error byte offset in db. |
934 | */ |
935 | void sqlite3RecordErrorByteOffset(sqlite3 *db, const char *z){ |
936 | const Parse *pParse; |
937 | const char *zText; |
938 | const char *zEnd; |
939 | assert( z!=0 ); |
940 | if( NEVER(db==0) ) return; |
941 | if( db->errByteOffset!=(-2) ) return; |
942 | pParse = db->pParse; |
943 | if( NEVER(pParse==0) ) return; |
944 | zText =pParse->zTail; |
945 | if( NEVER(zText==0) ) return; |
946 | zEnd = &zText[strlen(zText)]; |
947 | if( SQLITE_WITHIN(z,zText,zEnd) ){ |
948 | db->errByteOffset = (int)(z-zText); |
949 | } |
950 | } |
951 | |
952 | /* |
953 | ** If pExpr has a byte offset for the start of a token, record that as |
954 | ** as the error offset. |
955 | */ |
956 | void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){ |
957 | while( pExpr |
958 | && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0) |
959 | ){ |
960 | pExpr = pExpr->pLeft; |
961 | } |
962 | if( pExpr==0 ) return; |
963 | db->errByteOffset = pExpr->w.iOfst; |
964 | } |
965 | |
966 | /* |
967 | ** Enlarge the memory allocation on a StrAccum object so that it is |
968 | ** able to accept at least N more bytes of text. |
969 | ** |
970 | ** Return the number of bytes of text that StrAccum is able to accept |
971 | ** after the attempted enlargement. The value returned might be zero. |
972 | */ |
973 | int sqlite3StrAccumEnlarge(StrAccum *p, int N){ |
974 | char *zNew; |
975 | assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */ |
976 | if( p->accError ){ |
977 | testcase(p->accError==SQLITE_TOOBIG); |
978 | testcase(p->accError==SQLITE_NOMEM); |
979 | return 0; |
980 | } |
981 | if( p->mxAlloc==0 ){ |
982 | sqlite3StrAccumSetError(p, SQLITE_TOOBIG); |
983 | return p->nAlloc - p->nChar - 1; |
984 | }else{ |
985 | char *zOld = isMalloced(p) ? p->zText : 0; |
986 | i64 szNew = p->nChar; |
987 | szNew += (sqlite3_int64)N + 1; |
988 | if( szNew+p->nChar<=p->mxAlloc ){ |
989 | /* Force exponential buffer size growth as long as it does not overflow, |
990 | ** to avoid having to call this routine too often */ |
991 | szNew += p->nChar; |
992 | } |
993 | if( szNew > p->mxAlloc ){ |
994 | sqlite3_str_reset(p); |
995 | sqlite3StrAccumSetError(p, SQLITE_TOOBIG); |
996 | return 0; |
997 | }else{ |
998 | p->nAlloc = (int)szNew; |
999 | } |
1000 | if( p->db ){ |
1001 | zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc); |
1002 | }else{ |
1003 | zNew = sqlite3Realloc(zOld, p->nAlloc); |
1004 | } |
1005 | if( zNew ){ |
1006 | assert( p->zText!=0 || p->nChar==0 ); |
1007 | if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar); |
1008 | p->zText = zNew; |
1009 | p->nAlloc = sqlite3DbMallocSize(p->db, zNew); |
1010 | p->printfFlags |= SQLITE_PRINTF_MALLOCED; |
1011 | }else{ |
1012 | sqlite3_str_reset(p); |
1013 | sqlite3StrAccumSetError(p, SQLITE_NOMEM); |
1014 | return 0; |
1015 | } |
1016 | } |
1017 | return N; |
1018 | } |
1019 | |
1020 | /* |
1021 | ** Append N copies of character c to the given string buffer. |
1022 | */ |
1023 | void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){ |
1024 | testcase( p->nChar + (i64)N > 0x7fffffff ); |
1025 | if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){ |
1026 | return; |
1027 | } |
1028 | while( (N--)>0 ) p->zText[p->nChar++] = c; |
1029 | } |
1030 | |
1031 | /* |
1032 | ** The StrAccum "p" is not large enough to accept N new bytes of z[]. |
1033 | ** So enlarge if first, then do the append. |
1034 | ** |
1035 | ** This is a helper routine to sqlite3_str_append() that does special-case |
1036 | ** work (enlarging the buffer) using tail recursion, so that the |
1037 | ** sqlite3_str_append() routine can use fast calling semantics. |
1038 | */ |
1039 | static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){ |
1040 | N = sqlite3StrAccumEnlarge(p, N); |
1041 | if( N>0 ){ |
1042 | memcpy(&p->zText[p->nChar], z, N); |
1043 | p->nChar += N; |
1044 | } |
1045 | } |
1046 | |
1047 | /* |
1048 | ** Append N bytes of text from z to the StrAccum object. Increase the |
1049 | ** size of the memory allocation for StrAccum if necessary. |
1050 | */ |
1051 | void sqlite3_str_append(sqlite3_str *p, const char *z, int N){ |
1052 | assert( z!=0 || N==0 ); |
1053 | assert( p->zText!=0 || p->nChar==0 || p->accError ); |
1054 | assert( N>=0 ); |
1055 | assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 ); |
1056 | if( p->nChar+N >= p->nAlloc ){ |
1057 | enlargeAndAppend(p,z,N); |
1058 | }else if( N ){ |
1059 | assert( p->zText ); |
1060 | p->nChar += N; |
1061 | memcpy(&p->zText[p->nChar-N], z, N); |
1062 | } |
1063 | } |
1064 | |
1065 | /* |
1066 | ** Append the complete text of zero-terminated string z[] to the p string. |
1067 | */ |
1068 | void sqlite3_str_appendall(sqlite3_str *p, const char *z){ |
1069 | sqlite3_str_append(p, z, sqlite3Strlen30(z)); |
1070 | } |
1071 | |
1072 | |
1073 | /* |
1074 | ** Finish off a string by making sure it is zero-terminated. |
1075 | ** Return a pointer to the resulting string. Return a NULL |
1076 | ** pointer if any kind of error was encountered. |
1077 | */ |
1078 | static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){ |
1079 | char *zText; |
1080 | assert( p->mxAlloc>0 && !isMalloced(p) ); |
1081 | zText = sqlite3DbMallocRaw(p->db, p->nChar+1 ); |
1082 | if( zText ){ |
1083 | memcpy(zText, p->zText, p->nChar+1); |
1084 | p->printfFlags |= SQLITE_PRINTF_MALLOCED; |
1085 | }else{ |
1086 | sqlite3StrAccumSetError(p, SQLITE_NOMEM); |
1087 | } |
1088 | p->zText = zText; |
1089 | return zText; |
1090 | } |
1091 | char *sqlite3StrAccumFinish(StrAccum *p){ |
1092 | if( p->zText ){ |
1093 | p->zText[p->nChar] = 0; |
1094 | if( p->mxAlloc>0 && !isMalloced(p) ){ |
1095 | return strAccumFinishRealloc(p); |
1096 | } |
1097 | } |
1098 | return p->zText; |
1099 | } |
1100 | |
1101 | /* |
1102 | ** Use the content of the StrAccum passed as the second argument |
1103 | ** as the result of an SQL function. |
1104 | */ |
1105 | void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){ |
1106 | if( p->accError ){ |
1107 | sqlite3_result_error_code(pCtx, p->accError); |
1108 | sqlite3_str_reset(p); |
1109 | }else if( isMalloced(p) ){ |
1110 | sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC); |
1111 | }else{ |
1112 | sqlite3_result_text(pCtx, "" , 0, SQLITE_STATIC); |
1113 | sqlite3_str_reset(p); |
1114 | } |
1115 | } |
1116 | |
1117 | /* |
1118 | ** This singleton is an sqlite3_str object that is returned if |
1119 | ** sqlite3_malloc() fails to provide space for a real one. This |
1120 | ** sqlite3_str object accepts no new text and always returns |
1121 | ** an SQLITE_NOMEM error. |
1122 | */ |
1123 | static sqlite3_str sqlite3OomStr = { |
1124 | 0, 0, 0, 0, 0, SQLITE_NOMEM, 0 |
1125 | }; |
1126 | |
1127 | /* Finalize a string created using sqlite3_str_new(). |
1128 | */ |
1129 | char *sqlite3_str_finish(sqlite3_str *p){ |
1130 | char *z; |
1131 | if( p!=0 && p!=&sqlite3OomStr ){ |
1132 | z = sqlite3StrAccumFinish(p); |
1133 | sqlite3_free(p); |
1134 | }else{ |
1135 | z = 0; |
1136 | } |
1137 | return z; |
1138 | } |
1139 | |
1140 | /* Return any error code associated with p */ |
1141 | int sqlite3_str_errcode(sqlite3_str *p){ |
1142 | return p ? p->accError : SQLITE_NOMEM; |
1143 | } |
1144 | |
1145 | /* Return the current length of p in bytes */ |
1146 | int sqlite3_str_length(sqlite3_str *p){ |
1147 | return p ? p->nChar : 0; |
1148 | } |
1149 | |
1150 | /* Return the current value for p */ |
1151 | char *sqlite3_str_value(sqlite3_str *p){ |
1152 | if( p==0 || p->nChar==0 ) return 0; |
1153 | p->zText[p->nChar] = 0; |
1154 | return p->zText; |
1155 | } |
1156 | |
1157 | /* |
1158 | ** Reset an StrAccum string. Reclaim all malloced memory. |
1159 | */ |
1160 | void sqlite3_str_reset(StrAccum *p){ |
1161 | if( isMalloced(p) ){ |
1162 | sqlite3DbFree(p->db, p->zText); |
1163 | p->printfFlags &= ~SQLITE_PRINTF_MALLOCED; |
1164 | } |
1165 | p->nAlloc = 0; |
1166 | p->nChar = 0; |
1167 | p->zText = 0; |
1168 | } |
1169 | |
1170 | /* |
1171 | ** Initialize a string accumulator. |
1172 | ** |
1173 | ** p: The accumulator to be initialized. |
1174 | ** db: Pointer to a database connection. May be NULL. Lookaside |
1175 | ** memory is used if not NULL. db->mallocFailed is set appropriately |
1176 | ** when not NULL. |
1177 | ** zBase: An initial buffer. May be NULL in which case the initial buffer |
1178 | ** is malloced. |
1179 | ** n: Size of zBase in bytes. If total space requirements never exceed |
1180 | ** n then no memory allocations ever occur. |
1181 | ** mx: Maximum number of bytes to accumulate. If mx==0 then no memory |
1182 | ** allocations will ever occur. |
1183 | */ |
1184 | void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){ |
1185 | p->zText = zBase; |
1186 | p->db = db; |
1187 | p->nAlloc = n; |
1188 | p->mxAlloc = mx; |
1189 | p->nChar = 0; |
1190 | p->accError = 0; |
1191 | p->printfFlags = 0; |
1192 | } |
1193 | |
1194 | /* Allocate and initialize a new dynamic string object */ |
1195 | sqlite3_str *sqlite3_str_new(sqlite3 *db){ |
1196 | sqlite3_str *p = sqlite3_malloc64(sizeof(*p)); |
1197 | if( p ){ |
1198 | sqlite3StrAccumInit(p, 0, 0, 0, |
1199 | db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH); |
1200 | }else{ |
1201 | p = &sqlite3OomStr; |
1202 | } |
1203 | return p; |
1204 | } |
1205 | |
1206 | /* |
1207 | ** Print into memory obtained from sqliteMalloc(). Use the internal |
1208 | ** %-conversion extensions. |
1209 | */ |
1210 | char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){ |
1211 | char *z; |
1212 | char zBase[SQLITE_PRINT_BUF_SIZE]; |
1213 | StrAccum acc; |
1214 | assert( db!=0 ); |
1215 | sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase), |
1216 | db->aLimit[SQLITE_LIMIT_LENGTH]); |
1217 | acc.printfFlags = SQLITE_PRINTF_INTERNAL; |
1218 | sqlite3_str_vappendf(&acc, zFormat, ap); |
1219 | z = sqlite3StrAccumFinish(&acc); |
1220 | if( acc.accError==SQLITE_NOMEM ){ |
1221 | sqlite3OomFault(db); |
1222 | } |
1223 | return z; |
1224 | } |
1225 | |
1226 | /* |
1227 | ** Print into memory obtained from sqliteMalloc(). Use the internal |
1228 | ** %-conversion extensions. |
1229 | */ |
1230 | char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){ |
1231 | va_list ap; |
1232 | char *z; |
1233 | va_start(ap, zFormat); |
1234 | z = sqlite3VMPrintf(db, zFormat, ap); |
1235 | va_end(ap); |
1236 | return z; |
1237 | } |
1238 | |
1239 | /* |
1240 | ** Print into memory obtained from sqlite3_malloc(). Omit the internal |
1241 | ** %-conversion extensions. |
1242 | */ |
1243 | char *sqlite3_vmprintf(const char *zFormat, va_list ap){ |
1244 | char *z; |
1245 | char zBase[SQLITE_PRINT_BUF_SIZE]; |
1246 | StrAccum acc; |
1247 | |
1248 | #ifdef SQLITE_ENABLE_API_ARMOR |
1249 | if( zFormat==0 ){ |
1250 | (void)SQLITE_MISUSE_BKPT; |
1251 | return 0; |
1252 | } |
1253 | #endif |
1254 | #ifndef SQLITE_OMIT_AUTOINIT |
1255 | if( sqlite3_initialize() ) return 0; |
1256 | #endif |
1257 | sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH); |
1258 | sqlite3_str_vappendf(&acc, zFormat, ap); |
1259 | z = sqlite3StrAccumFinish(&acc); |
1260 | return z; |
1261 | } |
1262 | |
1263 | /* |
1264 | ** Print into memory obtained from sqlite3_malloc()(). Omit the internal |
1265 | ** %-conversion extensions. |
1266 | */ |
1267 | char *sqlite3_mprintf(const char *zFormat, ...){ |
1268 | va_list ap; |
1269 | char *z; |
1270 | #ifndef SQLITE_OMIT_AUTOINIT |
1271 | if( sqlite3_initialize() ) return 0; |
1272 | #endif |
1273 | va_start(ap, zFormat); |
1274 | z = sqlite3_vmprintf(zFormat, ap); |
1275 | va_end(ap); |
1276 | return z; |
1277 | } |
1278 | |
1279 | /* |
1280 | ** sqlite3_snprintf() works like snprintf() except that it ignores the |
1281 | ** current locale settings. This is important for SQLite because we |
1282 | ** are not able to use a "," as the decimal point in place of "." as |
1283 | ** specified by some locales. |
1284 | ** |
1285 | ** Oops: The first two arguments of sqlite3_snprintf() are backwards |
1286 | ** from the snprintf() standard. Unfortunately, it is too late to change |
1287 | ** this without breaking compatibility, so we just have to live with the |
1288 | ** mistake. |
1289 | ** |
1290 | ** sqlite3_vsnprintf() is the varargs version. |
1291 | */ |
1292 | char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){ |
1293 | StrAccum acc; |
1294 | if( n<=0 ) return zBuf; |
1295 | #ifdef SQLITE_ENABLE_API_ARMOR |
1296 | if( zBuf==0 || zFormat==0 ) { |
1297 | (void)SQLITE_MISUSE_BKPT; |
1298 | if( zBuf ) zBuf[0] = 0; |
1299 | return zBuf; |
1300 | } |
1301 | #endif |
1302 | sqlite3StrAccumInit(&acc, 0, zBuf, n, 0); |
1303 | sqlite3_str_vappendf(&acc, zFormat, ap); |
1304 | zBuf[acc.nChar] = 0; |
1305 | return zBuf; |
1306 | } |
1307 | char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ |
1308 | char *z; |
1309 | va_list ap; |
1310 | va_start(ap,zFormat); |
1311 | z = sqlite3_vsnprintf(n, zBuf, zFormat, ap); |
1312 | va_end(ap); |
1313 | return z; |
1314 | } |
1315 | |
1316 | /* |
1317 | ** This is the routine that actually formats the sqlite3_log() message. |
1318 | ** We house it in a separate routine from sqlite3_log() to avoid using |
1319 | ** stack space on small-stack systems when logging is disabled. |
1320 | ** |
1321 | ** sqlite3_log() must render into a static buffer. It cannot dynamically |
1322 | ** allocate memory because it might be called while the memory allocator |
1323 | ** mutex is held. |
1324 | ** |
1325 | ** sqlite3_str_vappendf() might ask for *temporary* memory allocations for |
1326 | ** certain format characters (%q) or for very large precisions or widths. |
1327 | ** Care must be taken that any sqlite3_log() calls that occur while the |
1328 | ** memory mutex is held do not use these mechanisms. |
1329 | */ |
1330 | static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){ |
1331 | StrAccum acc; /* String accumulator */ |
1332 | char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */ |
1333 | |
1334 | sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0); |
1335 | sqlite3_str_vappendf(&acc, zFormat, ap); |
1336 | sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode, |
1337 | sqlite3StrAccumFinish(&acc)); |
1338 | } |
1339 | |
1340 | /* |
1341 | ** Format and write a message to the log if logging is enabled. |
1342 | */ |
1343 | void sqlite3_log(int iErrCode, const char *zFormat, ...){ |
1344 | va_list ap; /* Vararg list */ |
1345 | if( sqlite3GlobalConfig.xLog ){ |
1346 | va_start(ap, zFormat); |
1347 | renderLogMsg(iErrCode, zFormat, ap); |
1348 | va_end(ap); |
1349 | } |
1350 | } |
1351 | |
1352 | #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) |
1353 | /* |
1354 | ** A version of printf() that understands %lld. Used for debugging. |
1355 | ** The printf() built into some versions of windows does not understand %lld |
1356 | ** and segfaults if you give it a long long int. |
1357 | */ |
1358 | void sqlite3DebugPrintf(const char *zFormat, ...){ |
1359 | va_list ap; |
1360 | StrAccum acc; |
1361 | char zBuf[SQLITE_PRINT_BUF_SIZE*10]; |
1362 | sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); |
1363 | va_start(ap,zFormat); |
1364 | sqlite3_str_vappendf(&acc, zFormat, ap); |
1365 | va_end(ap); |
1366 | sqlite3StrAccumFinish(&acc); |
1367 | #ifdef SQLITE_OS_TRACE_PROC |
1368 | { |
1369 | extern void SQLITE_OS_TRACE_PROC(const char *zBuf, int nBuf); |
1370 | SQLITE_OS_TRACE_PROC(zBuf, sizeof(zBuf)); |
1371 | } |
1372 | #else |
1373 | fprintf(stdout,"%s" , zBuf); |
1374 | fflush(stdout); |
1375 | #endif |
1376 | } |
1377 | #endif |
1378 | |
1379 | |
1380 | /* |
1381 | ** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument |
1382 | ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats. |
1383 | */ |
1384 | void sqlite3_str_appendf(StrAccum *p, const char *zFormat, ...){ |
1385 | va_list ap; |
1386 | va_start(ap,zFormat); |
1387 | sqlite3_str_vappendf(p, zFormat, ap); |
1388 | va_end(ap); |
1389 | } |
1390 | |