Annotation of embedaddon/sqlite3/src/printf.c, revision 1.1.1.1
1.1 misho 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: ** This file contains code for a set of "printf"-like routines. These
11: ** routines format strings much like the printf() from the standard C
12: ** library, though the implementation here has enhancements to support
13: ** SQLlite.
14: */
15: #include "sqliteInt.h"
16:
17: /*
18: ** Conversion types fall into various categories as defined by the
19: ** following enumeration.
20: */
21: #define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */
22: #define etFLOAT 2 /* Floating point. %f */
23: #define etEXP 3 /* Exponentional notation. %e and %E */
24: #define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */
25: #define etSIZE 5 /* Return number of characters processed so far. %n */
26: #define etSTRING 6 /* Strings. %s */
27: #define etDYNSTRING 7 /* Dynamically allocated strings. %z */
28: #define etPERCENT 8 /* Percent symbol. %% */
29: #define etCHARX 9 /* Characters. %c */
30: /* The rest are extensions, not normally found in printf() */
31: #define etSQLESCAPE 10 /* Strings with '\'' doubled. %q */
32: #define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '',
33: NULL pointers replaced by SQL NULL. %Q */
34: #define etTOKEN 12 /* a pointer to a Token structure */
35: #define etSRCLIST 13 /* a pointer to a SrcList */
36: #define etPOINTER 14 /* The %p conversion */
37: #define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */
38: #define etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
39:
40: #define etINVALID 0 /* Any unrecognized conversion type */
41:
42:
43: /*
44: ** An "etByte" is an 8-bit unsigned value.
45: */
46: typedef unsigned char etByte;
47:
48: /*
49: ** Each builtin conversion character (ex: the 'd' in "%d") is described
50: ** by an instance of the following structure
51: */
52: typedef struct et_info { /* Information about each format field */
53: char fmttype; /* The format field code letter */
54: etByte base; /* The base for radix conversion */
55: etByte flags; /* One or more of FLAG_ constants below */
56: etByte type; /* Conversion paradigm */
57: etByte charset; /* Offset into aDigits[] of the digits string */
58: etByte prefix; /* Offset into aPrefix[] of the prefix string */
59: } et_info;
60:
61: /*
62: ** Allowed values for et_info.flags
63: */
64: #define FLAG_SIGNED 1 /* True if the value to convert is signed */
65: #define FLAG_INTERN 2 /* True if for internal use only */
66: #define FLAG_STRING 4 /* Allow infinity precision */
67:
68:
69: /*
70: ** The following table is searched linearly, so it is good to put the
71: ** most frequently used conversion types first.
72: */
73: static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
74: static const char aPrefix[] = "-x0\000X0";
75: static const et_info fmtinfo[] = {
76: { 'd', 10, 1, etRADIX, 0, 0 },
77: { 's', 0, 4, etSTRING, 0, 0 },
78: { 'g', 0, 1, etGENERIC, 30, 0 },
79: { 'z', 0, 4, etDYNSTRING, 0, 0 },
80: { 'q', 0, 4, etSQLESCAPE, 0, 0 },
81: { 'Q', 0, 4, etSQLESCAPE2, 0, 0 },
82: { 'w', 0, 4, etSQLESCAPE3, 0, 0 },
83: { 'c', 0, 0, etCHARX, 0, 0 },
84: { 'o', 8, 0, etRADIX, 0, 2 },
85: { 'u', 10, 0, etRADIX, 0, 0 },
86: { 'x', 16, 0, etRADIX, 16, 1 },
87: { 'X', 16, 0, etRADIX, 0, 4 },
88: #ifndef SQLITE_OMIT_FLOATING_POINT
89: { 'f', 0, 1, etFLOAT, 0, 0 },
90: { 'e', 0, 1, etEXP, 30, 0 },
91: { 'E', 0, 1, etEXP, 14, 0 },
92: { 'G', 0, 1, etGENERIC, 14, 0 },
93: #endif
94: { 'i', 10, 1, etRADIX, 0, 0 },
95: { 'n', 0, 0, etSIZE, 0, 0 },
96: { '%', 0, 0, etPERCENT, 0, 0 },
97: { 'p', 16, 0, etPOINTER, 0, 1 },
98:
99: /* All the rest have the FLAG_INTERN bit set and are thus for internal
100: ** use only */
101: { 'T', 0, 2, etTOKEN, 0, 0 },
102: { 'S', 0, 2, etSRCLIST, 0, 0 },
103: { 'r', 10, 3, etORDINAL, 0, 0 },
104: };
105:
106: /*
107: ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
108: ** conversions will work.
109: */
110: #ifndef SQLITE_OMIT_FLOATING_POINT
111: /*
112: ** "*val" is a double such that 0.1 <= *val < 10.0
113: ** Return the ascii code for the leading digit of *val, then
114: ** multiply "*val" by 10.0 to renormalize.
115: **
116: ** Example:
117: ** input: *val = 3.14159
118: ** output: *val = 1.4159 function return = '3'
119: **
120: ** The counter *cnt is incremented each time. After counter exceeds
121: ** 16 (the number of significant digits in a 64-bit float) '0' is
122: ** always returned.
123: */
124: static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
125: int digit;
126: LONGDOUBLE_TYPE d;
127: if( (*cnt)++ >= 16 ) return '0';
128: digit = (int)*val;
129: d = digit;
130: digit += '0';
131: *val = (*val - d)*10.0;
132: return (char)digit;
133: }
134: #endif /* SQLITE_OMIT_FLOATING_POINT */
135:
136: /*
137: ** Append N space characters to the given string buffer.
138: */
139: void sqlite3AppendSpace(StrAccum *pAccum, int N){
140: static const char zSpaces[] = " ";
141: while( N>=(int)sizeof(zSpaces)-1 ){
142: sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
143: N -= sizeof(zSpaces)-1;
144: }
145: if( N>0 ){
146: sqlite3StrAccumAppend(pAccum, zSpaces, N);
147: }
148: }
149:
150: /*
151: ** On machines with a small stack size, you can redefine the
152: ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
153: */
154: #ifndef SQLITE_PRINT_BUF_SIZE
155: # define SQLITE_PRINT_BUF_SIZE 70
156: #endif
157: #define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */
158:
159: /*
160: ** Render a string given by "fmt" into the StrAccum object.
161: */
162: void sqlite3VXPrintf(
163: StrAccum *pAccum, /* Accumulate results here */
164: int useExtended, /* Allow extended %-conversions */
165: const char *fmt, /* Format string */
166: va_list ap /* arguments */
167: ){
168: int c; /* Next character in the format string */
169: char *bufpt; /* Pointer to the conversion buffer */
170: int precision; /* Precision of the current field */
171: int length; /* Length of the field */
172: int idx; /* A general purpose loop counter */
173: int width; /* Width of the current field */
174: etByte flag_leftjustify; /* True if "-" flag is present */
175: etByte flag_plussign; /* True if "+" flag is present */
176: etByte flag_blanksign; /* True if " " flag is present */
177: etByte flag_alternateform; /* True if "#" flag is present */
178: etByte flag_altform2; /* True if "!" flag is present */
179: etByte flag_zeropad; /* True if field width constant starts with zero */
180: etByte flag_long; /* True if "l" flag is present */
181: etByte flag_longlong; /* True if the "ll" flag is present */
182: etByte done; /* Loop termination flag */
183: etByte xtype = 0; /* Conversion paradigm */
184: char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
185: sqlite_uint64 longvalue; /* Value for integer types */
186: LONGDOUBLE_TYPE realvalue; /* Value for real types */
187: const et_info *infop; /* Pointer to the appropriate info structure */
188: char *zOut; /* Rendering buffer */
189: int nOut; /* Size of the rendering buffer */
190: char *zExtra; /* Malloced memory used by some conversion */
191: #ifndef SQLITE_OMIT_FLOATING_POINT
192: int exp, e2; /* exponent of real numbers */
193: int nsd; /* Number of significant digits returned */
194: double rounder; /* Used for rounding floating point values */
195: etByte flag_dp; /* True if decimal point should be shown */
196: etByte flag_rtz; /* True if trailing zeros should be removed */
197: #endif
198: char buf[etBUFSIZE]; /* Conversion buffer */
199:
200: bufpt = 0;
201: for(; (c=(*fmt))!=0; ++fmt){
202: if( c!='%' ){
203: int amt;
204: bufpt = (char *)fmt;
205: amt = 1;
206: while( (c=(*++fmt))!='%' && c!=0 ) amt++;
207: sqlite3StrAccumAppend(pAccum, bufpt, amt);
208: if( c==0 ) break;
209: }
210: if( (c=(*++fmt))==0 ){
211: sqlite3StrAccumAppend(pAccum, "%", 1);
212: break;
213: }
214: /* Find out what flags are present */
215: flag_leftjustify = flag_plussign = flag_blanksign =
216: flag_alternateform = flag_altform2 = flag_zeropad = 0;
217: done = 0;
218: do{
219: switch( c ){
220: case '-': flag_leftjustify = 1; break;
221: case '+': flag_plussign = 1; break;
222: case ' ': flag_blanksign = 1; break;
223: case '#': flag_alternateform = 1; break;
224: case '!': flag_altform2 = 1; break;
225: case '0': flag_zeropad = 1; break;
226: default: done = 1; break;
227: }
228: }while( !done && (c=(*++fmt))!=0 );
229: /* Get the field width */
230: width = 0;
231: if( c=='*' ){
232: width = va_arg(ap,int);
233: if( width<0 ){
234: flag_leftjustify = 1;
235: width = -width;
236: }
237: c = *++fmt;
238: }else{
239: while( c>='0' && c<='9' ){
240: width = width*10 + c - '0';
241: c = *++fmt;
242: }
243: }
244: /* Get the precision */
245: if( c=='.' ){
246: precision = 0;
247: c = *++fmt;
248: if( c=='*' ){
249: precision = va_arg(ap,int);
250: if( precision<0 ) precision = -precision;
251: c = *++fmt;
252: }else{
253: while( c>='0' && c<='9' ){
254: precision = precision*10 + c - '0';
255: c = *++fmt;
256: }
257: }
258: }else{
259: precision = -1;
260: }
261: /* Get the conversion type modifier */
262: if( c=='l' ){
263: flag_long = 1;
264: c = *++fmt;
265: if( c=='l' ){
266: flag_longlong = 1;
267: c = *++fmt;
268: }else{
269: flag_longlong = 0;
270: }
271: }else{
272: flag_long = flag_longlong = 0;
273: }
274: /* Fetch the info entry for the field */
275: infop = &fmtinfo[0];
276: xtype = etINVALID;
277: for(idx=0; idx<ArraySize(fmtinfo); idx++){
278: if( c==fmtinfo[idx].fmttype ){
279: infop = &fmtinfo[idx];
280: if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
281: xtype = infop->type;
282: }else{
283: return;
284: }
285: break;
286: }
287: }
288: zExtra = 0;
289:
290: /*
291: ** At this point, variables are initialized as follows:
292: **
293: ** flag_alternateform TRUE if a '#' is present.
294: ** flag_altform2 TRUE if a '!' is present.
295: ** flag_plussign TRUE if a '+' is present.
296: ** flag_leftjustify TRUE if a '-' is present or if the
297: ** field width was negative.
298: ** flag_zeropad TRUE if the width began with 0.
299: ** flag_long TRUE if the letter 'l' (ell) prefixed
300: ** the conversion character.
301: ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed
302: ** the conversion character.
303: ** flag_blanksign TRUE if a ' ' is present.
304: ** width The specified field width. This is
305: ** always non-negative. Zero is the default.
306: ** precision The specified precision. The default
307: ** is -1.
308: ** xtype The class of the conversion.
309: ** infop Pointer to the appropriate info struct.
310: */
311: switch( xtype ){
312: case etPOINTER:
313: flag_longlong = sizeof(char*)==sizeof(i64);
314: flag_long = sizeof(char*)==sizeof(long int);
315: /* Fall through into the next case */
316: case etORDINAL:
317: case etRADIX:
318: if( infop->flags & FLAG_SIGNED ){
319: i64 v;
320: if( flag_longlong ){
321: v = va_arg(ap,i64);
322: }else if( flag_long ){
323: v = va_arg(ap,long int);
324: }else{
325: v = va_arg(ap,int);
326: }
327: if( v<0 ){
328: if( v==SMALLEST_INT64 ){
329: longvalue = ((u64)1)<<63;
330: }else{
331: longvalue = -v;
332: }
333: prefix = '-';
334: }else{
335: longvalue = v;
336: if( flag_plussign ) prefix = '+';
337: else if( flag_blanksign ) prefix = ' ';
338: else prefix = 0;
339: }
340: }else{
341: if( flag_longlong ){
342: longvalue = va_arg(ap,u64);
343: }else if( flag_long ){
344: longvalue = va_arg(ap,unsigned long int);
345: }else{
346: longvalue = va_arg(ap,unsigned int);
347: }
348: prefix = 0;
349: }
350: if( longvalue==0 ) flag_alternateform = 0;
351: if( flag_zeropad && precision<width-(prefix!=0) ){
352: precision = width-(prefix!=0);
353: }
354: if( precision<etBUFSIZE-10 ){
355: nOut = etBUFSIZE;
356: zOut = buf;
357: }else{
358: nOut = precision + 10;
359: zOut = zExtra = sqlite3Malloc( nOut );
360: if( zOut==0 ){
361: pAccum->mallocFailed = 1;
362: return;
363: }
364: }
365: bufpt = &zOut[nOut-1];
366: if( xtype==etORDINAL ){
367: static const char zOrd[] = "thstndrd";
368: int x = (int)(longvalue % 10);
369: if( x>=4 || (longvalue/10)%10==1 ){
370: x = 0;
371: }
372: *(--bufpt) = zOrd[x*2+1];
373: *(--bufpt) = zOrd[x*2];
374: }
375: {
376: register const char *cset; /* Use registers for speed */
377: register int base;
378: cset = &aDigits[infop->charset];
379: base = infop->base;
380: do{ /* Convert to ascii */
381: *(--bufpt) = cset[longvalue%base];
382: longvalue = longvalue/base;
383: }while( longvalue>0 );
384: }
385: length = (int)(&zOut[nOut-1]-bufpt);
386: for(idx=precision-length; idx>0; idx--){
387: *(--bufpt) = '0'; /* Zero pad */
388: }
389: if( prefix ) *(--bufpt) = prefix; /* Add sign */
390: if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
391: const char *pre;
392: char x;
393: pre = &aPrefix[infop->prefix];
394: for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
395: }
396: length = (int)(&zOut[nOut-1]-bufpt);
397: break;
398: case etFLOAT:
399: case etEXP:
400: case etGENERIC:
401: realvalue = va_arg(ap,double);
402: #ifdef SQLITE_OMIT_FLOATING_POINT
403: length = 0;
404: #else
405: if( precision<0 ) precision = 6; /* Set default precision */
406: if( realvalue<0.0 ){
407: realvalue = -realvalue;
408: prefix = '-';
409: }else{
410: if( flag_plussign ) prefix = '+';
411: else if( flag_blanksign ) prefix = ' ';
412: else prefix = 0;
413: }
414: if( xtype==etGENERIC && precision>0 ) precision--;
415: #if 0
416: /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */
417: for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
418: #else
419: /* It makes more sense to use 0.5 */
420: for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
421: #endif
422: if( xtype==etFLOAT ) realvalue += rounder;
423: /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
424: exp = 0;
425: if( sqlite3IsNaN((double)realvalue) ){
426: bufpt = "NaN";
427: length = 3;
428: break;
429: }
430: if( realvalue>0.0 ){
431: while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }
432: while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
433: while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
434: while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
435: while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
436: if( exp>350 ){
437: if( prefix=='-' ){
438: bufpt = "-Inf";
439: }else if( prefix=='+' ){
440: bufpt = "+Inf";
441: }else{
442: bufpt = "Inf";
443: }
444: length = sqlite3Strlen30(bufpt);
445: break;
446: }
447: }
448: bufpt = buf;
449: /*
450: ** If the field type is etGENERIC, then convert to either etEXP
451: ** or etFLOAT, as appropriate.
452: */
453: if( xtype!=etFLOAT ){
454: realvalue += rounder;
455: if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
456: }
457: if( xtype==etGENERIC ){
458: flag_rtz = !flag_alternateform;
459: if( exp<-4 || exp>precision ){
460: xtype = etEXP;
461: }else{
462: precision = precision - exp;
463: xtype = etFLOAT;
464: }
465: }else{
466: flag_rtz = 0;
467: }
468: if( xtype==etEXP ){
469: e2 = 0;
470: }else{
471: e2 = exp;
472: }
473: if( e2+precision+width > etBUFSIZE - 15 ){
474: bufpt = zExtra = sqlite3Malloc( e2+precision+width+15 );
475: if( bufpt==0 ){
476: pAccum->mallocFailed = 1;
477: return;
478: }
479: }
480: zOut = bufpt;
481: nsd = 0;
482: flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
483: /* The sign in front of the number */
484: if( prefix ){
485: *(bufpt++) = prefix;
486: }
487: /* Digits prior to the decimal point */
488: if( e2<0 ){
489: *(bufpt++) = '0';
490: }else{
491: for(; e2>=0; e2--){
492: *(bufpt++) = et_getdigit(&realvalue,&nsd);
493: }
494: }
495: /* The decimal point */
496: if( flag_dp ){
497: *(bufpt++) = '.';
498: }
499: /* "0" digits after the decimal point but before the first
500: ** significant digit of the number */
501: for(e2++; e2<0; precision--, e2++){
502: assert( precision>0 );
503: *(bufpt++) = '0';
504: }
505: /* Significant digits after the decimal point */
506: while( (precision--)>0 ){
507: *(bufpt++) = et_getdigit(&realvalue,&nsd);
508: }
509: /* Remove trailing zeros and the "." if no digits follow the "." */
510: if( flag_rtz && flag_dp ){
511: while( bufpt[-1]=='0' ) *(--bufpt) = 0;
512: assert( bufpt>zOut );
513: if( bufpt[-1]=='.' ){
514: if( flag_altform2 ){
515: *(bufpt++) = '0';
516: }else{
517: *(--bufpt) = 0;
518: }
519: }
520: }
521: /* Add the "eNNN" suffix */
522: if( xtype==etEXP ){
523: *(bufpt++) = aDigits[infop->charset];
524: if( exp<0 ){
525: *(bufpt++) = '-'; exp = -exp;
526: }else{
527: *(bufpt++) = '+';
528: }
529: if( exp>=100 ){
530: *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */
531: exp %= 100;
532: }
533: *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */
534: *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */
535: }
536: *bufpt = 0;
537:
538: /* The converted number is in buf[] and zero terminated. Output it.
539: ** Note that the number is in the usual order, not reversed as with
540: ** integer conversions. */
541: length = (int)(bufpt-zOut);
542: bufpt = zOut;
543:
544: /* Special case: Add leading zeros if the flag_zeropad flag is
545: ** set and we are not left justified */
546: if( flag_zeropad && !flag_leftjustify && length < width){
547: int i;
548: int nPad = width - length;
549: for(i=width; i>=nPad; i--){
550: bufpt[i] = bufpt[i-nPad];
551: }
552: i = prefix!=0;
553: while( nPad-- ) bufpt[i++] = '0';
554: length = width;
555: }
556: #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
557: break;
558: case etSIZE:
559: *(va_arg(ap,int*)) = pAccum->nChar;
560: length = width = 0;
561: break;
562: case etPERCENT:
563: buf[0] = '%';
564: bufpt = buf;
565: length = 1;
566: break;
567: case etCHARX:
568: c = va_arg(ap,int);
569: buf[0] = (char)c;
570: if( precision>=0 ){
571: for(idx=1; idx<precision; idx++) buf[idx] = (char)c;
572: length = precision;
573: }else{
574: length =1;
575: }
576: bufpt = buf;
577: break;
578: case etSTRING:
579: case etDYNSTRING:
580: bufpt = va_arg(ap,char*);
581: if( bufpt==0 ){
582: bufpt = "";
583: }else if( xtype==etDYNSTRING ){
584: zExtra = bufpt;
585: }
586: if( precision>=0 ){
587: for(length=0; length<precision && bufpt[length]; length++){}
588: }else{
589: length = sqlite3Strlen30(bufpt);
590: }
591: break;
592: case etSQLESCAPE:
593: case etSQLESCAPE2:
594: case etSQLESCAPE3: {
595: int i, j, k, n, isnull;
596: int needQuote;
597: char ch;
598: char q = ((xtype==etSQLESCAPE3)?'"':'\''); /* Quote character */
599: char *escarg = va_arg(ap,char*);
600: isnull = escarg==0;
601: if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
602: k = precision;
603: for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
604: if( ch==q ) n++;
605: }
606: needQuote = !isnull && xtype==etSQLESCAPE2;
607: n += i + 1 + needQuote*2;
608: if( n>etBUFSIZE ){
609: bufpt = zExtra = sqlite3Malloc( n );
610: if( bufpt==0 ){
611: pAccum->mallocFailed = 1;
612: return;
613: }
614: }else{
615: bufpt = buf;
616: }
617: j = 0;
618: if( needQuote ) bufpt[j++] = q;
619: k = i;
620: for(i=0; i<k; i++){
621: bufpt[j++] = ch = escarg[i];
622: if( ch==q ) bufpt[j++] = ch;
623: }
624: if( needQuote ) bufpt[j++] = q;
625: bufpt[j] = 0;
626: length = j;
627: /* The precision in %q and %Q means how many input characters to
628: ** consume, not the length of the output...
629: ** if( precision>=0 && precision<length ) length = precision; */
630: break;
631: }
632: case etTOKEN: {
633: Token *pToken = va_arg(ap, Token*);
634: if( pToken ){
635: sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
636: }
637: length = width = 0;
638: break;
639: }
640: case etSRCLIST: {
641: SrcList *pSrc = va_arg(ap, SrcList*);
642: int k = va_arg(ap, int);
643: struct SrcList_item *pItem = &pSrc->a[k];
644: assert( k>=0 && k<pSrc->nSrc );
645: if( pItem->zDatabase ){
646: sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);
647: sqlite3StrAccumAppend(pAccum, ".", 1);
648: }
649: sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
650: length = width = 0;
651: break;
652: }
653: default: {
654: assert( xtype==etINVALID );
655: return;
656: }
657: }/* End switch over the format type */
658: /*
659: ** The text of the conversion is pointed to by "bufpt" and is
660: ** "length" characters long. The field width is "width". Do
661: ** the output.
662: */
663: if( !flag_leftjustify ){
664: register int nspace;
665: nspace = width-length;
666: if( nspace>0 ){
667: sqlite3AppendSpace(pAccum, nspace);
668: }
669: }
670: if( length>0 ){
671: sqlite3StrAccumAppend(pAccum, bufpt, length);
672: }
673: if( flag_leftjustify ){
674: register int nspace;
675: nspace = width-length;
676: if( nspace>0 ){
677: sqlite3AppendSpace(pAccum, nspace);
678: }
679: }
680: sqlite3_free(zExtra);
681: }/* End for loop over the format string */
682: } /* End of function */
683:
684: /*
685: ** Append N bytes of text from z to the StrAccum object.
686: */
687: void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
688: assert( z!=0 || N==0 );
689: if( p->tooBig | p->mallocFailed ){
690: testcase(p->tooBig);
691: testcase(p->mallocFailed);
692: return;
693: }
694: assert( p->zText!=0 || p->nChar==0 );
695: if( N<0 ){
696: N = sqlite3Strlen30(z);
697: }
698: if( N==0 || NEVER(z==0) ){
699: return;
700: }
701: if( p->nChar+N >= p->nAlloc ){
702: char *zNew;
703: if( !p->useMalloc ){
704: p->tooBig = 1;
705: N = p->nAlloc - p->nChar - 1;
706: if( N<=0 ){
707: return;
708: }
709: }else{
710: char *zOld = (p->zText==p->zBase ? 0 : p->zText);
711: i64 szNew = p->nChar;
712: szNew += N + 1;
713: if( szNew > p->mxAlloc ){
714: sqlite3StrAccumReset(p);
715: p->tooBig = 1;
716: return;
717: }else{
718: p->nAlloc = (int)szNew;
719: }
720: if( p->useMalloc==1 ){
721: zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
722: }else{
723: zNew = sqlite3_realloc(zOld, p->nAlloc);
724: }
725: if( zNew ){
726: if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
727: p->zText = zNew;
728: }else{
729: p->mallocFailed = 1;
730: sqlite3StrAccumReset(p);
731: return;
732: }
733: }
734: }
735: assert( p->zText );
736: memcpy(&p->zText[p->nChar], z, N);
737: p->nChar += N;
738: }
739:
740: /*
741: ** Finish off a string by making sure it is zero-terminated.
742: ** Return a pointer to the resulting string. Return a NULL
743: ** pointer if any kind of error was encountered.
744: */
745: char *sqlite3StrAccumFinish(StrAccum *p){
746: if( p->zText ){
747: p->zText[p->nChar] = 0;
748: if( p->useMalloc && p->zText==p->zBase ){
749: if( p->useMalloc==1 ){
750: p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
751: }else{
752: p->zText = sqlite3_malloc(p->nChar+1);
753: }
754: if( p->zText ){
755: memcpy(p->zText, p->zBase, p->nChar+1);
756: }else{
757: p->mallocFailed = 1;
758: }
759: }
760: }
761: return p->zText;
762: }
763:
764: /*
765: ** Reset an StrAccum string. Reclaim all malloced memory.
766: */
767: void sqlite3StrAccumReset(StrAccum *p){
768: if( p->zText!=p->zBase ){
769: if( p->useMalloc==1 ){
770: sqlite3DbFree(p->db, p->zText);
771: }else{
772: sqlite3_free(p->zText);
773: }
774: }
775: p->zText = 0;
776: }
777:
778: /*
779: ** Initialize a string accumulator
780: */
781: void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
782: p->zText = p->zBase = zBase;
783: p->db = 0;
784: p->nChar = 0;
785: p->nAlloc = n;
786: p->mxAlloc = mx;
787: p->useMalloc = 1;
788: p->tooBig = 0;
789: p->mallocFailed = 0;
790: }
791:
792: /*
793: ** Print into memory obtained from sqliteMalloc(). Use the internal
794: ** %-conversion extensions.
795: */
796: char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
797: char *z;
798: char zBase[SQLITE_PRINT_BUF_SIZE];
799: StrAccum acc;
800: assert( db!=0 );
801: sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
802: db->aLimit[SQLITE_LIMIT_LENGTH]);
803: acc.db = db;
804: sqlite3VXPrintf(&acc, 1, zFormat, ap);
805: z = sqlite3StrAccumFinish(&acc);
806: if( acc.mallocFailed ){
807: db->mallocFailed = 1;
808: }
809: return z;
810: }
811:
812: /*
813: ** Print into memory obtained from sqliteMalloc(). Use the internal
814: ** %-conversion extensions.
815: */
816: char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
817: va_list ap;
818: char *z;
819: va_start(ap, zFormat);
820: z = sqlite3VMPrintf(db, zFormat, ap);
821: va_end(ap);
822: return z;
823: }
824:
825: /*
826: ** Like sqlite3MPrintf(), but call sqlite3DbFree() on zStr after formatting
827: ** the string and before returnning. This routine is intended to be used
828: ** to modify an existing string. For example:
829: **
830: ** x = sqlite3MPrintf(db, x, "prefix %s suffix", x);
831: **
832: */
833: char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zFormat, ...){
834: va_list ap;
835: char *z;
836: va_start(ap, zFormat);
837: z = sqlite3VMPrintf(db, zFormat, ap);
838: va_end(ap);
839: sqlite3DbFree(db, zStr);
840: return z;
841: }
842:
843: /*
844: ** Print into memory obtained from sqlite3_malloc(). Omit the internal
845: ** %-conversion extensions.
846: */
847: char *sqlite3_vmprintf(const char *zFormat, va_list ap){
848: char *z;
849: char zBase[SQLITE_PRINT_BUF_SIZE];
850: StrAccum acc;
851: #ifndef SQLITE_OMIT_AUTOINIT
852: if( sqlite3_initialize() ) return 0;
853: #endif
854: sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
855: acc.useMalloc = 2;
856: sqlite3VXPrintf(&acc, 0, zFormat, ap);
857: z = sqlite3StrAccumFinish(&acc);
858: return z;
859: }
860:
861: /*
862: ** Print into memory obtained from sqlite3_malloc()(). Omit the internal
863: ** %-conversion extensions.
864: */
865: char *sqlite3_mprintf(const char *zFormat, ...){
866: va_list ap;
867: char *z;
868: #ifndef SQLITE_OMIT_AUTOINIT
869: if( sqlite3_initialize() ) return 0;
870: #endif
871: va_start(ap, zFormat);
872: z = sqlite3_vmprintf(zFormat, ap);
873: va_end(ap);
874: return z;
875: }
876:
877: /*
878: ** sqlite3_snprintf() works like snprintf() except that it ignores the
879: ** current locale settings. This is important for SQLite because we
880: ** are not able to use a "," as the decimal point in place of "." as
881: ** specified by some locales.
882: **
883: ** Oops: The first two arguments of sqlite3_snprintf() are backwards
884: ** from the snprintf() standard. Unfortunately, it is too late to change
885: ** this without breaking compatibility, so we just have to live with the
886: ** mistake.
887: **
888: ** sqlite3_vsnprintf() is the varargs version.
889: */
890: char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
891: StrAccum acc;
892: if( n<=0 ) return zBuf;
893: sqlite3StrAccumInit(&acc, zBuf, n, 0);
894: acc.useMalloc = 0;
895: sqlite3VXPrintf(&acc, 0, zFormat, ap);
896: return sqlite3StrAccumFinish(&acc);
897: }
898: char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
899: char *z;
900: va_list ap;
901: va_start(ap,zFormat);
902: z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
903: va_end(ap);
904: return z;
905: }
906:
907: /*
908: ** This is the routine that actually formats the sqlite3_log() message.
909: ** We house it in a separate routine from sqlite3_log() to avoid using
910: ** stack space on small-stack systems when logging is disabled.
911: **
912: ** sqlite3_log() must render into a static buffer. It cannot dynamically
913: ** allocate memory because it might be called while the memory allocator
914: ** mutex is held.
915: */
916: static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
917: StrAccum acc; /* String accumulator */
918: char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */
919:
920: sqlite3StrAccumInit(&acc, zMsg, sizeof(zMsg), 0);
921: acc.useMalloc = 0;
922: sqlite3VXPrintf(&acc, 0, zFormat, ap);
923: sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
924: sqlite3StrAccumFinish(&acc));
925: }
926:
927: /*
928: ** Format and write a message to the log if logging is enabled.
929: */
930: void sqlite3_log(int iErrCode, const char *zFormat, ...){
931: va_list ap; /* Vararg list */
932: if( sqlite3GlobalConfig.xLog ){
933: va_start(ap, zFormat);
934: renderLogMsg(iErrCode, zFormat, ap);
935: va_end(ap);
936: }
937: }
938:
939: #if defined(SQLITE_DEBUG)
940: /*
941: ** A version of printf() that understands %lld. Used for debugging.
942: ** The printf() built into some versions of windows does not understand %lld
943: ** and segfaults if you give it a long long int.
944: */
945: void sqlite3DebugPrintf(const char *zFormat, ...){
946: va_list ap;
947: StrAccum acc;
948: char zBuf[500];
949: sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);
950: acc.useMalloc = 0;
951: va_start(ap,zFormat);
952: sqlite3VXPrintf(&acc, 0, zFormat, ap);
953: va_end(ap);
954: sqlite3StrAccumFinish(&acc);
955: fprintf(stdout,"%s", zBuf);
956: fflush(stdout);
957: }
958: #endif
959:
960: #ifndef SQLITE_OMIT_TRACE
961: /*
962: ** variable-argument wrapper around sqlite3VXPrintf().
963: */
964: void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
965: va_list ap;
966: va_start(ap,zFormat);
967: sqlite3VXPrintf(p, 1, zFormat, ap);
968: va_end(ap);
969: }
970: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to printf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src