source: trunk/src/3rdparty/sqlite/printf.c

Last change on this file was 205, checked in by rudi, 14 years ago

Added SQLite 2.8.17 sources. This allows to build at least one of the sql drivers / plugins.
File size: 30.3 KB
RevLine 
[205]1/*
2** The "printf" code that follows dates from the 1980's. It is in
3** the public domain. The original comments are included here for
4** completeness. They are very out-of-date but might be useful as
5** an historical reference. Most of the "enhancements" have been backed
6** out so that the functionality is now the same as standard printf().
7**
8**************************************************************************
9**
10** The following modules is an enhanced replacement for the "printf" subroutines
11** found in the standard C library. The following enhancements are
12** supported:
13**
14** + Additional functions. The standard set of "printf" functions
15** includes printf, fprintf, sprintf, vprintf, vfprintf, and
16** vsprintf. This module adds the following:
17**
18** * snprintf -- Works like sprintf, but has an extra argument
19** which is the size of the buffer written to.
20**
21** * mprintf -- Similar to sprintf. Writes output to memory
22** obtained from malloc.
23**
24** * xprintf -- Calls a function to dispose of output.
25**
26** * nprintf -- No output, but returns the number of characters
27** that would have been output by printf.
28**
29** * A v- version (ex: vsnprintf) of every function is also
30** supplied.
31**
32** + A few extensions to the formatting notation are supported:
33**
34** * The "=" flag (similar to "-") causes the output to be
35** be centered in the appropriately sized field.
36**
37** * The %b field outputs an integer in binary notation.
38**
39** * The %c field now accepts a precision. The character output
40** is repeated by the number of times the precision specifies.
41**
42** * The %' field works like %c, but takes as its character the
43** next character of the format string, instead of the next
44** argument. For example, printf("%.78'-") prints 78 minus
45** signs, the same as printf("%.78c",'-').
46**
47** + When compiled using GCC on a SPARC, this version of printf is
48** faster than the library printf for SUN OS 4.1.
49**
50** + All functions are fully reentrant.
51**
52*/
53#include "sqliteInt.h"
54
55/*
56** Conversion types fall into various categories as defined by the
57** following enumeration.
58*/
59#define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */
60#define etFLOAT 2 /* Floating point. %f */
61#define etEXP 3 /* Exponentional notation. %e and %E */
62#define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */
63#define etSIZE 5 /* Return number of characters processed so far. %n */
64#define etSTRING 6 /* Strings. %s */
65#define etDYNSTRING 7 /* Dynamically allocated strings. %z */
66#define etPERCENT 8 /* Percent symbol. %% */
67#define etCHARX 9 /* Characters. %c */
68#define etERROR 10 /* Used to indicate no such conversion type */
69/* The rest are extensions, not normally found in printf() */
70#define etCHARLIT 11 /* Literal characters. %' */
71#define etSQLESCAPE 12 /* Strings with '\'' doubled. %q */
72#define etSQLESCAPE2 13 /* Strings with '\'' doubled and enclosed in '',
73 NULL pointers replaced by SQL NULL. %Q */
74#define etTOKEN 14 /* a pointer to a Token structure */
75#define etSRCLIST 15 /* a pointer to a SrcList */
76
77
78/*
79** An "etByte" is an 8-bit unsigned value.
80*/
81typedef unsigned char etByte;
82
83/*
84** Each builtin conversion character (ex: the 'd' in "%d") is described
85** by an instance of the following structure
86*/
87typedef struct et_info { /* Information about each format field */
88 char fmttype; /* The format field code letter */
89 etByte base; /* The base for radix conversion */
90 etByte flags; /* One or more of FLAG_ constants below */
91 etByte type; /* Conversion paradigm */
92 char *charset; /* The character set for conversion */
93 char *prefix; /* Prefix on non-zero values in alt format */
94} et_info;
95
96/*
97** Allowed values for et_info.flags
98*/
99#define FLAG_SIGNED 1 /* True if the value to convert is signed */
100#define FLAG_INTERN 2 /* True if for internal use only */
101
102
103/*
104** The following table is searched linearly, so it is good to put the
105** most frequently used conversion types first.
106*/
107static et_info fmtinfo[] = {
108 { 'd', 10, 1, etRADIX, "0123456789", 0 },
109 { 's', 0, 0, etSTRING, 0, 0 },
110 { 'z', 0, 2, etDYNSTRING, 0, 0 },
111 { 'q', 0, 0, etSQLESCAPE, 0, 0 },
112 { 'Q', 0, 0, etSQLESCAPE2, 0, 0 },
113 { 'c', 0, 0, etCHARX, 0, 0 },
114 { 'o', 8, 0, etRADIX, "01234567", "0" },
115 { 'u', 10, 0, etRADIX, "0123456789", 0 },
116 { 'x', 16, 0, etRADIX, "0123456789abcdef", "x0" },
117 { 'X', 16, 0, etRADIX, "0123456789ABCDEF", "X0" },
118 { 'f', 0, 1, etFLOAT, 0, 0 },
119 { 'e', 0, 1, etEXP, "e", 0 },
120 { 'E', 0, 1, etEXP, "E", 0 },
121 { 'g', 0, 1, etGENERIC, "e", 0 },
122 { 'G', 0, 1, etGENERIC, "E", 0 },
123 { 'i', 10, 1, etRADIX, "0123456789", 0 },
124 { 'n', 0, 0, etSIZE, 0, 0 },
125 { '%', 0, 0, etPERCENT, 0, 0 },
126 { 'p', 10, 0, etRADIX, "0123456789", 0 },
127 { 'T', 0, 2, etTOKEN, 0, 0 },
128 { 'S', 0, 2, etSRCLIST, 0, 0 },
129};
130#define etNINFO (sizeof(fmtinfo)/sizeof(fmtinfo[0]))
131
132/*
133** If NOFLOATINGPOINT is defined, then none of the floating point
134** conversions will work.
135*/
136#ifndef etNOFLOATINGPOINT
137/*
138** "*val" is a double such that 0.1 <= *val < 10.0
139** Return the ascii code for the leading digit of *val, then
140** multiply "*val" by 10.0 to renormalize.
141**
142** Example:
143** input: *val = 3.14159
144** output: *val = 1.4159 function return = '3'
145**
146** The counter *cnt is incremented each time. After counter exceeds
147** 16 (the number of significant digits in a 64-bit float) '0' is
148** always returned.
149*/
150static int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
151 int digit;
152 LONGDOUBLE_TYPE d;
153 if( (*cnt)++ >= 16 ) return '0';
154 digit = (int)*val;
155 d = digit;
156 digit += '0';
157 *val = (*val - d)*10.0;
158 return digit;
159}
160#endif
161
162#define etBUFSIZE 1000 /* Size of the output buffer */
163
164/*
165** The root program. All variations call this core.
166**
167** INPUTS:
168** func This is a pointer to a function taking three arguments
169** 1. A pointer to anything. Same as the "arg" parameter.
170** 2. A pointer to the list of characters to be output
171** (Note, this list is NOT null terminated.)
172** 3. An integer number of characters to be output.
173** (Note: This number might be zero.)
174**
175** arg This is the pointer to anything which will be passed as the
176** first argument to "func". Use it for whatever you like.
177**
178** fmt This is the format string, as in the usual print.
179**
180** ap This is a pointer to a list of arguments. Same as in
181** vfprint.
182**
183** OUTPUTS:
184** The return value is the total number of characters sent to
185** the function "func". Returns -1 on a error.
186**
187** Note that the order in which automatic variables are declared below
188** seems to make a big difference in determining how fast this beast
189** will run.
190*/
191static int vxprintf(
192 void (*func)(void*,const char*,int), /* Consumer of text */
193 void *arg, /* First argument to the consumer */
194 int useExtended, /* Allow extended %-conversions */
195 const char *fmt, /* Format string */
196 va_list ap /* arguments */
197){
198 int c; /* Next character in the format string */
199 char *bufpt; /* Pointer to the conversion buffer */
200 int precision; /* Precision of the current field */
201 int length; /* Length of the field */
202 int idx; /* A general purpose loop counter */
203 int count; /* Total number of characters output */
204 int width; /* Width of the current field */
205 etByte flag_leftjustify; /* True if "-" flag is present */
206 etByte flag_plussign; /* True if "+" flag is present */
207 etByte flag_blanksign; /* True if " " flag is present */
208 etByte flag_alternateform; /* True if "#" flag is present */
209 etByte flag_zeropad; /* True if field width constant starts with zero */
210 etByte flag_long; /* True if "l" flag is present */
211 unsigned long longvalue; /* Value for integer types */
212 LONGDOUBLE_TYPE realvalue; /* Value for real types */
213 et_info *infop; /* Pointer to the appropriate info structure */
214 char buf[etBUFSIZE]; /* Conversion buffer */
215 char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
216 etByte errorflag = 0; /* True if an error is encountered */
217 etByte xtype; /* Conversion paradigm */
218 char *zExtra; /* Extra memory used for etTCLESCAPE conversions */
219 static char spaces[] = " ";
220#define etSPACESIZE (sizeof(spaces)-1)
221#ifndef etNOFLOATINGPOINT
222 int exp; /* exponent of real numbers */
223 double rounder; /* Used for rounding floating point values */
224 etByte flag_dp; /* True if decimal point should be shown */
225 etByte flag_rtz; /* True if trailing zeros should be removed */
226 etByte flag_exp; /* True to force display of the exponent */
227 int nsd; /* Number of significant digits returned */
228#endif
229
230 func(arg,"",0);
231 count = length = 0;
232 bufpt = 0;
233 for(; (c=(*fmt))!=0; ++fmt){
234 if( c!='%' ){
235 int amt;
236 bufpt = (char *)fmt;
237 amt = 1;
238 while( (c=(*++fmt))!='%' && c!=0 ) amt++;
239 (*func)(arg,bufpt,amt);
240 count += amt;
241 if( c==0 ) break;
242 }
243 if( (c=(*++fmt))==0 ){
244 errorflag = 1;
245 (*func)(arg,"%",1);
246 count++;
247 break;
248 }
249 /* Find out what flags are present */
250 flag_leftjustify = flag_plussign = flag_blanksign =
251 flag_alternateform = flag_zeropad = 0;
252 do{
253 switch( c ){
254 case '-': flag_leftjustify = 1; c = 0; break;
255 case '+': flag_plussign = 1; c = 0; break;
256 case ' ': flag_blanksign = 1; c = 0; break;
257 case '#': flag_alternateform = 1; c = 0; break;
258 case '0': flag_zeropad = 1; c = 0; break;
259 default: break;
260 }
261 }while( c==0 && (c=(*++fmt))!=0 );
262 /* Get the field width */
263 width = 0;
264 if( c=='*' ){
265 width = va_arg(ap,int);
266 if( width<0 ){
267 flag_leftjustify = 1;
268 width = -width;
269 }
270 c = *++fmt;
271 }else{
272 while( c>='0' && c<='9' ){
273 width = width*10 + c - '0';
274 c = *++fmt;
275 }
276 }
277 if( width > etBUFSIZE-10 ){
278 width = etBUFSIZE-10;
279 }
280 /* Get the precision */
281 if( c=='.' ){
282 precision = 0;
283 c = *++fmt;
284 if( c=='*' ){
285 precision = va_arg(ap,int);
286 if( precision<0 ) precision = -precision;
287 c = *++fmt;
288 }else{
289 while( c>='0' && c<='9' ){
290 precision = precision*10 + c - '0';
291 c = *++fmt;
292 }
293 }
294 /* Limit the precision to prevent overflowing buf[] during conversion */
295 if( precision>etBUFSIZE-40 ) precision = etBUFSIZE-40;
296 }else{
297 precision = -1;
298 }
299 /* Get the conversion type modifier */
300 if( c=='l' ){
301 flag_long = 1;
302 c = *++fmt;
303 }else{
304 flag_long = 0;
305 }
306 /* Fetch the info entry for the field */
307 infop = 0;
308 xtype = etERROR;
309 for(idx=0; idx<etNINFO; idx++){
310 if( c==fmtinfo[idx].fmttype ){
311 infop = &fmtinfo[idx];
312 if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
313 xtype = infop->type;
314 }
315 break;
316 }
317 }
318 zExtra = 0;
319
320 /*
321 ** At this point, variables are initialized as follows:
322 **
323 ** flag_alternateform TRUE if a '#' is present.
324 ** flag_plussign TRUE if a '+' is present.
325 ** flag_leftjustify TRUE if a '-' is present or if the
326 ** field width was negative.
327 ** flag_zeropad TRUE if the width began with 0.
328 ** flag_long TRUE if the letter 'l' (ell) prefixed
329 ** the conversion character.
330 ** flag_blanksign TRUE if a ' ' is present.
331 ** width The specified field width. This is
332 ** always non-negative. Zero is the default.
333 ** precision The specified precision. The default
334 ** is -1.
335 ** xtype The class of the conversion.
336 ** infop Pointer to the appropriate info struct.
337 */
338 switch( xtype ){
339 case etRADIX:
340 if( flag_long ) longvalue = va_arg(ap,long);
341 else longvalue = va_arg(ap,int);
342#if 1
343 /* For the format %#x, the value zero is printed "0" not "0x0".
344 ** I think this is stupid. */
345 if( longvalue==0 ) flag_alternateform = 0;
346#else
347 /* More sensible: turn off the prefix for octal (to prevent "00"),
348 ** but leave the prefix for hex. */
349 if( longvalue==0 && infop->base==8 ) flag_alternateform = 0;
350#endif
351 if( infop->flags & FLAG_SIGNED ){
352 if( *(long*)&longvalue<0 ){
353 longvalue = -*(long*)&longvalue;
354 prefix = '-';
355 }else if( flag_plussign ) prefix = '+';
356 else if( flag_blanksign ) prefix = ' ';
357 else prefix = 0;
358 }else prefix = 0;
359 if( flag_zeropad && precision<width-(prefix!=0) ){
360 precision = width-(prefix!=0);
361 }
362 bufpt = &buf[etBUFSIZE-1];
363 {
364 register char *cset; /* Use registers for speed */
365 register int base;
366 cset = infop->charset;
367 base = infop->base;
368 do{ /* Convert to ascii */
369 *(--bufpt) = cset[longvalue%base];
370 longvalue = longvalue/base;
371 }while( longvalue>0 );
372 }
373 length = &buf[etBUFSIZE-1]-bufpt;
374 for(idx=precision-length; idx>0; idx--){
375 *(--bufpt) = '0'; /* Zero pad */
376 }
377 if( prefix ) *(--bufpt) = prefix; /* Add sign */
378 if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
379 char *pre, x;
380 pre = infop->prefix;
381 if( *bufpt!=pre[0] ){
382 for(pre=infop->prefix; (x=(*pre))!=0; pre++) *(--bufpt) = x;
383 }
384 }
385 length = &buf[etBUFSIZE-1]-bufpt;
386 break;
387 case etFLOAT:
388 case etEXP:
389 case etGENERIC:
390 realvalue = va_arg(ap,double);
391#ifndef etNOFLOATINGPOINT
392 if( precision<0 ) precision = 6; /* Set default precision */
393 if( precision>etBUFSIZE-10 ) precision = etBUFSIZE-10;
394 if( realvalue<0.0 ){
395 realvalue = -realvalue;
396 prefix = '-';
397 }else{
398 if( flag_plussign ) prefix = '+';
399 else if( flag_blanksign ) prefix = ' ';
400 else prefix = 0;
401 }
402 if( infop->type==etGENERIC && precision>0 ) precision--;
403 rounder = 0.0;
404#if 0
405 /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */
406 for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
407#else
408 /* It makes more sense to use 0.5 */
409 for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1);
410#endif
411 if( infop->type==etFLOAT ) realvalue += rounder;
412 /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
413 exp = 0;
414 if( realvalue>0.0 ){
415 while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
416 while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
417 while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; }
418 while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; }
419 if( exp>350 || exp<-350 ){
420 bufpt = "NaN";
421 length = 3;
422 break;
423 }
424 }
425 bufpt = buf;
426 /*
427 ** If the field type is etGENERIC, then convert to either etEXP
428 ** or etFLOAT, as appropriate.
429 */
430 flag_exp = xtype==etEXP;
431 if( xtype!=etFLOAT ){
432 realvalue += rounder;
433 if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
434 }
435 if( xtype==etGENERIC ){
436 flag_rtz = !flag_alternateform;
437 if( exp<-4 || exp>precision ){
438 xtype = etEXP;
439 }else{
440 precision = precision - exp;
441 xtype = etFLOAT;
442 }
443 }else{
444 flag_rtz = 0;
445 }
446 /*
447 ** The "exp+precision" test causes output to be of type etEXP if
448 ** the precision is too large to fit in buf[].
449 */
450 nsd = 0;
451 if( xtype==etFLOAT && exp+precision<etBUFSIZE-30 ){
452 flag_dp = (precision>0 || flag_alternateform);
453 if( prefix ) *(bufpt++) = prefix; /* Sign */
454 if( exp<0 ) *(bufpt++) = '0'; /* Digits before "." */
455 else for(; exp>=0; exp--) *(bufpt++) = et_getdigit(&realvalue,&nsd);
456 if( flag_dp ) *(bufpt++) = '.'; /* The decimal point */
457 for(exp++; exp<0 && precision>0; precision--, exp++){
458 *(bufpt++) = '0';
459 }
460 while( (precision--)>0 ) *(bufpt++) = et_getdigit(&realvalue,&nsd);
461 *(bufpt--) = 0; /* Null terminate */
462 if( flag_rtz && flag_dp ){ /* Remove trailing zeros and "." */
463 while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0;
464 if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0;
465 }
466 bufpt++; /* point to next free slot */
467 }else{ /* etEXP or etGENERIC */
468 flag_dp = (precision>0 || flag_alternateform);
469 if( prefix ) *(bufpt++) = prefix; /* Sign */
470 *(bufpt++) = et_getdigit(&realvalue,&nsd); /* First digit */
471 if( flag_dp ) *(bufpt++) = '.'; /* Decimal point */
472 while( (precision--)>0 ) *(bufpt++) = et_getdigit(&realvalue,&nsd);
473 bufpt--; /* point to last digit */
474 if( flag_rtz && flag_dp ){ /* Remove tail zeros */
475 while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0;
476 if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0;
477 }
478 bufpt++; /* point to next free slot */
479 if( exp || flag_exp ){
480 *(bufpt++) = infop->charset[0];
481 if( exp<0 ){ *(bufpt++) = '-'; exp = -exp; } /* sign of exp */
482 else { *(bufpt++) = '+'; }
483 if( exp>=100 ){
484 *(bufpt++) = (exp/100)+'0'; /* 100's digit */
485 exp %= 100;
486 }
487 *(bufpt++) = exp/10+'0'; /* 10's digit */
488 *(bufpt++) = exp%10+'0'; /* 1's digit */
489 }
490 }
491 /* The converted number is in buf[] and zero terminated. Output it.
492 ** Note that the number is in the usual order, not reversed as with
493 ** integer conversions. */
494 length = bufpt-buf;
495 bufpt = buf;
496
497 /* Special case: Add leading zeros if the flag_zeropad flag is
498 ** set and we are not left justified */
499 if( flag_zeropad && !flag_leftjustify && length < width){
500 int i;
501 int nPad = width - length;
502 for(i=width; i>=nPad; i--){
503 bufpt[i] = bufpt[i-nPad];
504 }
505 i = prefix!=0;
506 while( nPad-- ) bufpt[i++] = '0';
507 length = width;
508 }
509#endif
510 break;
511 case etSIZE:
512 *(va_arg(ap,int*)) = count;
513 length = width = 0;
514 break;
515 case etPERCENT:
516 buf[0] = '%';
517 bufpt = buf;
518 length = 1;
519 break;
520 case etCHARLIT:
521 case etCHARX:
522 c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt);
523 if( precision>=0 ){
524 for(idx=1; idx<precision; idx++) buf[idx] = c;
525 length = precision;
526 }else{
527 length =1;
528 }
529 bufpt = buf;
530 break;
531 case etSTRING:
532 case etDYNSTRING:
533 bufpt = va_arg(ap,char*);
534 if( bufpt==0 ){
535 bufpt = "";
536 }else if( xtype==etDYNSTRING ){
537 zExtra = bufpt;
538 }
539 length = strlen(bufpt);
540 if( precision>=0 && precision<length ) length = precision;
541 break;
542 case etSQLESCAPE:
543 case etSQLESCAPE2:
544 {
545 int i, j, n, c, isnull;
546 char *arg = va_arg(ap,char*);
547 isnull = arg==0;
548 if( isnull ) arg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
549 for(i=n=0; (c=arg[i])!=0; i++){
550 if( c=='\'' ) n++;
551 }
552 n += i + 1 + ((!isnull && xtype==etSQLESCAPE2) ? 2 : 0);
553 if( n>etBUFSIZE ){
554 bufpt = zExtra = sqliteMalloc( n );
555 if( bufpt==0 ) return -1;
556 }else{
557 bufpt = buf;
558 }
559 j = 0;
560 if( !isnull && xtype==etSQLESCAPE2 ) bufpt[j++] = '\'';
561 for(i=0; (c=arg[i])!=0; i++){
562 bufpt[j++] = c;
563 if( c=='\'' ) bufpt[j++] = c;
564 }
565 if( !isnull && xtype==etSQLESCAPE2 ) bufpt[j++] = '\'';
566 bufpt[j] = 0;
567 length = j;
568 if( precision>=0 && precision<length ) length = precision;
569 }
570 break;
571 case etTOKEN: {
572 Token *pToken = va_arg(ap, Token*);
573 (*func)(arg, pToken->z, pToken->n);
574 length = width = 0;
575 break;
576 }
577 case etSRCLIST: {
578 SrcList *pSrc = va_arg(ap, SrcList*);
579 int k = va_arg(ap, int);
580 struct SrcList_item *pItem = &pSrc->a[k];
581 assert( k>=0 && k<pSrc->nSrc );
582 if( pItem->zDatabase && pItem->zDatabase[0] ){
583 (*func)(arg, pItem->zDatabase, strlen(pItem->zDatabase));
584 (*func)(arg, ".", 1);
585 }
586 (*func)(arg, pItem->zName, strlen(pItem->zName));
587 length = width = 0;
588 break;
589 }
590 case etERROR:
591 buf[0] = '%';
592 buf[1] = c;
593 errorflag = 0;
594 idx = 1+(c!=0);
595 (*func)(arg,"%",idx);
596 count += idx;
597 if( c==0 ) fmt--;
598 break;
599 }/* End switch over the format type */
600 /*
601 ** The text of the conversion is pointed to by "bufpt" and is
602 ** "length" characters long. The field width is "width". Do
603 ** the output.
604 */
605 if( !flag_leftjustify ){
606 register int nspace;
607 nspace = width-length;
608 if( nspace>0 ){
609 count += nspace;
610 while( nspace>=etSPACESIZE ){
611 (*func)(arg,spaces,etSPACESIZE);
612 nspace -= etSPACESIZE;
613 }
614 if( nspace>0 ) (*func)(arg,spaces,nspace);
615 }
616 }
617 if( length>0 ){
618 (*func)(arg,bufpt,length);
619 count += length;
620 }
621 if( flag_leftjustify ){
622 register int nspace;
623 nspace = width-length;
624 if( nspace>0 ){
625 count += nspace;
626 while( nspace>=etSPACESIZE ){
627 (*func)(arg,spaces,etSPACESIZE);
628 nspace -= etSPACESIZE;
629 }
630 if( nspace>0 ) (*func)(arg,spaces,nspace);
631 }
632 }
633 if( zExtra ){
634 sqliteFree(zExtra);
635 }
636 }/* End for loop over the format string */
637 return errorflag ? -1 : count;
638} /* End of function */
639
640
641/* This structure is used to store state information about the
642** write to memory that is currently in progress.
643*/
644struct sgMprintf {
645 char *zBase; /* A base allocation */
646 char *zText; /* The string collected so far */
647 int nChar; /* Length of the string so far */
648 int nTotal; /* Output size if unconstrained */
649 int nAlloc; /* Amount of space allocated in zText */
650 void *(*xRealloc)(void*,int); /* Function used to realloc memory */
651};
652
653/*
654** This function implements the callback from vxprintf.
655**
656** This routine add nNewChar characters of text in zNewText to
657** the sgMprintf structure pointed to by "arg".
658*/
659static void mout(void *arg, const char *zNewText, int nNewChar){
660 struct sgMprintf *pM = (struct sgMprintf*)arg;
661 pM->nTotal += nNewChar;
662 if( pM->nChar + nNewChar + 1 > pM->nAlloc ){
663 if( pM->xRealloc==0 ){
664 nNewChar = pM->nAlloc - pM->nChar - 1;
665 }else{
666 pM->nAlloc = pM->nChar + nNewChar*2 + 1;
667 if( pM->zText==pM->zBase ){
668 pM->zText = pM->xRealloc(0, pM->nAlloc);
669 if( pM->zText && pM->nChar ){
670 memcpy(pM->zText, pM->zBase, pM->nChar);
671 }
672 }else{
673 pM->zText = pM->xRealloc(pM->zText, pM->nAlloc);
674 }
675 }
676 }
677 if( pM->zText ){
678 if( nNewChar>0 ){
679 memcpy(&pM->zText[pM->nChar], zNewText, nNewChar);
680 pM->nChar += nNewChar;
681 }
682 pM->zText[pM->nChar] = 0;
683 }
684}
685
686/*
687** This routine is a wrapper around xprintf() that invokes mout() as
688** the consumer.
689*/
690static char *base_vprintf(
691 void *(*xRealloc)(void*,int), /* Routine to realloc memory. May be NULL */
692 int useInternal, /* Use internal %-conversions if true */
693 char *zInitBuf, /* Initially write here, before mallocing */
694 int nInitBuf, /* Size of zInitBuf[] */
695 const char *zFormat, /* format string */
696 va_list ap /* arguments */
697){
698 struct sgMprintf sM;
699 sM.zBase = sM.zText = zInitBuf;
700 sM.nChar = sM.nTotal = 0;
701 sM.nAlloc = nInitBuf;
702 sM.xRealloc = xRealloc;
703 vxprintf(mout, &sM, useInternal, zFormat, ap);
704 if( xRealloc ){
705 if( sM.zText==sM.zBase ){
706 sM.zText = xRealloc(0, sM.nChar+1);
707 memcpy(sM.zText, sM.zBase, sM.nChar+1);
708 }else if( sM.nAlloc>sM.nChar+10 ){
709 sM.zText = xRealloc(sM.zText, sM.nChar+1);
710 }
711 }
712 return sM.zText;
713}
714
715/*
716** Realloc that is a real function, not a macro.
717*/
718static void *printf_realloc(void *old, int size){
719 return sqliteRealloc(old,size);
720}
721
722/*
723** Print into memory obtained from sqliteMalloc(). Use the internal
724** %-conversion extensions.
725*/
726char *sqliteVMPrintf(const char *zFormat, va_list ap){
727 char zBase[1000];
728 return base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap);
729}
730
731/*
732** Print into memory obtained from sqliteMalloc(). Use the internal
733** %-conversion extensions.
734*/
735char *sqliteMPrintf(const char *zFormat, ...){
736 va_list ap;
737 char *z;
738 char zBase[1000];
739 va_start(ap, zFormat);
740 z = base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap);
741 va_end(ap);
742 return z;
743}
744
745/*
746** Print into memory obtained from malloc(). Do not use the internal
747** %-conversion extensions. This routine is for use by external users.
748*/
749char *sqlite_mprintf(const char *zFormat, ...){
750 va_list ap;
751 char *z;
752 char zBuf[200];
753
754 va_start(ap,zFormat);
755 z = base_vprintf((void*(*)(void*,int))realloc, 0,
756 zBuf, sizeof(zBuf), zFormat, ap);
757 va_end(ap);
758 return z;
759}
760
761/* This is the varargs version of sqlite_mprintf.
762*/
763char *sqlite_vmprintf(const char *zFormat, va_list ap){
764 char zBuf[200];
765 return base_vprintf((void*(*)(void*,int))realloc, 0,
766 zBuf, sizeof(zBuf), zFormat, ap);
767}
768
769/*
770** sqlite_snprintf() works like snprintf() except that it ignores the
771** current locale settings. This is important for SQLite because we
772** are not able to use a "," as the decimal point in place of "." as
773** specified by some locales.
774*/
775char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){
776 char *z;
777 va_list ap;
778
779 va_start(ap,zFormat);
780 z = base_vprintf(0, 0, zBuf, n, zFormat, ap);
781 va_end(ap);
782 return z;
783}
784
785/*
786** The following four routines implement the varargs versions of the
787** sqlite_exec() and sqlite_get_table() interfaces. See the sqlite.h
788** header files for a more detailed description of how these interfaces
789** work.
790**
791** These routines are all just simple wrappers.
792*/
793int sqlite_exec_printf(
794 sqlite *db, /* An open database */
795 const char *sqlFormat, /* printf-style format string for the SQL */
796 sqlite_callback xCallback, /* Callback function */
797 void *pArg, /* 1st argument to callback function */
798 char **errmsg, /* Error msg written here */
799 ... /* Arguments to the format string. */
800){
801 va_list ap;
802 int rc;
803
804 va_start(ap, errmsg);
805 rc = sqlite_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap);
806 va_end(ap);
807 return rc;
808}
809int sqlite_exec_vprintf(
810 sqlite *db, /* An open database */
811 const char *sqlFormat, /* printf-style format string for the SQL */
812 sqlite_callback xCallback, /* Callback function */
813 void *pArg, /* 1st argument to callback function */
814 char **errmsg, /* Error msg written here */
815 va_list ap /* Arguments to the format string. */
816){
817 char *zSql;
818 int rc;
819
820 zSql = sqlite_vmprintf(sqlFormat, ap);
821 rc = sqlite_exec(db, zSql, xCallback, pArg, errmsg);
822 free(zSql);
823 return rc;
824}
825int sqlite_get_table_printf(
826 sqlite *db, /* An open database */
827 const char *sqlFormat, /* printf-style format string for the SQL */
828 char ***resultp, /* Result written to a char *[] that this points to */
829 int *nrow, /* Number of result rows written here */
830 int *ncol, /* Number of result columns written here */
831 char **errmsg, /* Error msg written here */
832 ... /* Arguments to the format string */
833){
834 va_list ap;
835 int rc;
836
837 va_start(ap, errmsg);
838 rc = sqlite_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap);
839 va_end(ap);
840 return rc;
841}
842int sqlite_get_table_vprintf(
843 sqlite *db, /* An open database */
844 const char *sqlFormat, /* printf-style format string for the SQL */
845 char ***resultp, /* Result written to a char *[] that this points to */
846 int *nrow, /* Number of result rows written here */
847 int *ncolumn, /* Number of result columns written here */
848 char **errmsg, /* Error msg written here */
849 va_list ap /* Arguments to the format string */
850){
851 char *zSql;
852 int rc;
853
854 zSql = sqlite_vmprintf(sqlFormat, ap);
855 rc = sqlite_get_table(db, zSql, resultp, nrow, ncolumn, errmsg);
856 free(zSql);
857 return rc;
858}
Note: See TracBrowser for help on using the repository browser.