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