/*** The "printf" code that follows dates from the 1980's.  It is in** the public domain.  The original comments are included here for** completeness.  They are very out-of-date but might be useful as** an historical reference.  Most of the "enhancements" have been backed** out so that the functionality is now the same as standard printf().******************************************************************************** The following modules is an enhanced replacement for the "printf" subroutines** found in the standard C library.  The following enhancements are** supported:****      +  Additional functions.  The standard set of "printf" functions**         includes printf, fprintf, sprintf, vprintf, vfprintf, and**         vsprintf.  This module adds the following:****           *  snprintf -- Works like sprintf, but has an extra argument**                          which is the size of the buffer written to.****           *  mprintf --  Similar to sprintf.  Writes output to memory**                          obtained from malloc.****           *  xprintf --  Calls a function to dispose of output.****           *  nprintf --  No output, but returns the number of characters**                          that would have been output by printf.****           *  A v- version (ex: vsnprintf) of every function is also**              supplied.****      +  A few extensions to the formatting notation are supported:****           *  The "=" flag (similar to "-") causes the output to be**              be centered in the appropriately sized field.****           *  The %b field outputs an integer in binary notation.****           *  The %c field now accepts a precision.  The character output**              is repeated by the number of times the precision specifies.****           *  The %' field works like %c, but takes as its character the**              next character of the format string, instead of the next**              argument.  For example,  printf("%.78'-")  prints 78 minus**              signs, the same as  printf("%.78c",'-').****      +  When compiled using GCC on a SPARC, this version of printf is**         faster than the library printf for SUN OS 4.1.****      +  All functions are fully reentrant.***/#include "sqliteInt.h"/*** Conversion types fall into various categories as defined by the** following enumeration.*/#define etRADIX       1 /* Integer types.  %d, %x, %o, and so forth */#define etFLOAT       2 /* Floating point.  %f */#define etEXP         3 /* Exponentional notation. %e and %E */#define etGENERIC     4 /* Floating or exponential, depending on exponent. %g */#define etSIZE        5 /* Return number of characters processed so far. %n */#define etSTRING      6 /* Strings. %s */#define etDYNSTRING   7 /* Dynamically allocated strings. %z */#define etPERCENT     8 /* Percent symbol. %% */#define etCHARX       9 /* Characters. %c *//* The rest are extensions, not normally found in printf() */#define etCHARLIT    10 /* Literal characters.  %' */#define etSQLESCAPE  11 /* Strings with '\'' doubled.  %q */#define etSQLESCAPE2 12 /* Strings with '\'' doubled and enclosed in '',                          NULL pointers replaced by SQL NULL.  %Q */#define etTOKEN      13 /* a pointer to a Token structure */#define etSRCLIST    14 /* a pointer to a SrcList */#define etPOINTER    15 /* The %p conversion *//*** An "etByte" is an 8-bit unsigned value.*/typedef unsigned char etByte;/*** Each builtin conversion character (ex: the 'd' in "%d") is described** by an instance of the following structure*/typedef struct et_info {   /* Information about each format field */  char fmttype;            /* The format field code letter */  etByte base;             /* The base for radix conversion */  etByte flags;            /* One or more of FLAG_ constants below */  etByte type;             /* Conversion paradigm */  etByte charset;          /* Offset into aDigits[] of the digits string */  etByte prefix;           /* Offset into aPrefix[] of the prefix string */} et_info;/*** Allowed values for et_info.flags*/#define FLAG_SIGNED  1     /* True if the value to convert is signed */#define FLAG_INTERN  2     /* True if for internal use only */#define FLAG_STRING  4     /* Allow infinity precision *//*** The following table is searched linearly, so it is good to put the** most frequently used conversion types first.*/static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";static const char aPrefix[] = "-x0\000X0";static const et_info fmtinfo[] = {  {  'd', 10, 1, etRADIX,      0,  0 },  {  's',  0, 4, etSTRING,     0,  0 },  {  'g',  0, 1, etGENERIC,    30, 0 },  {  'z',  0, 6, etDYNSTRING,  0,  0 },  {  'q',  0, 4, etSQLESCAPE,  0,  0 },  {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },  {  'c',  0, 0, etCHARX,      0,  0 },  {  'o',  8, 0, etRADIX,      0,  2 },  {  'u', 10, 0, etRADIX,      0,  0 },  {  'x', 16, 0, etRADIX,      16, 1 },  {  'X', 16, 0, etRADIX,      0,  4 },#ifndef SQLITE_OMIT_FLOATING_POINT  {  'f',  0, 1, etFLOAT,      0,  0 },  {  'e',  0, 1, etEXP,        30, 0 },  {  'E',  0, 1, etEXP,        14, 0 },  {  'G',  0, 1, etGENERIC,    14, 0 },#endif  {  'i', 10, 1, etRADIX,      0,  0 },  {  'n',  0, 0, etSIZE,       0,  0 },  {  '%',  0, 0, etPERCENT,    0,  0 },  {  'p', 16, 0, etPOINTER,    0,  1 },  {  'T',  0, 2, etTOKEN,      0,  0 },  {  'S',  0, 2, etSRCLIST,    0,  0 },};#define etNINFO  (sizeof(fmtinfo)/sizeof(fmtinfo[0]))/*** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point** conversions will work.*/#ifndef SQLITE_OMIT_FLOATING_POINT/*** "*val" is a double such that 0.1 <= *val < 10.0** Return the ascii code for the leading digit of *val, then** multiply "*val" by 10.0 to renormalize.**** Example:**     input:     *val = 3.14159**     output:    *val = 1.4159    function return = '3'**** The counter *cnt is incremented each time.  After counter exceeds** 16 (the number of significant digits in a 64-bit float) '0' is** always returned.*/static int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){  int digit;  LONGDOUBLE_TYPE d;  if( (*cnt)++ >= 16 ) return '0';  digit = (int)*val;  d = digit;  digit += '0';  *val = (*val - d)*10.0;  return digit;}#endif /* SQLITE_OMIT_FLOATING_POINT *//*** On machines with a small stack size, you can redefine the** SQLITE_PRINT_BUF_SIZE to be less than 350.  But beware - for** smaller values some %f conversions may go into an infinite loop.*/#ifndef SQLITE_PRINT_BUF_SIZE# define SQLITE_PRINT_BUF_SIZE 350#endif#define etBUFSIZE SQLITE_PRINT_BUF_SIZE  /* Size of the output buffer *//*** The root program.  All variations call this core.**** INPUTS:**   func   This is a pointer to a function taking three arguments**            1. A pointer to anything.  Same as the "arg" parameter.**            2. A pointer to the list of characters to be output**               (Note, this list is NOT null terminated.)**            3. An integer number of characters to be output.**               (Note: This number might be zero.)****   arg    This is the pointer to anything which will be passed as the**          first argument to "func".  Use it for whatever you like.****   fmt    This is the format string, as in the usual print.****   ap     This is a pointer to a list of arguments.  Same as in**          vfprint.**** OUTPUTS:**          The return value is the total number of characters sent to**          the function "func".  Returns -1 on a error.**** Note that the order in which automatic variables are declared below** seems to make a big difference in determining how fast this beast** will run.*/static int vxprintf(  void (*func)(void*,const char*,int),     /* Consumer of text */  void *arg,                         /* First argument to the consumer */  int useExtended,                   /* Allow extended %-conversions */  const char *fmt,                   /* Format string */  va_list ap                         /* arguments */){  int c;                     /* Next character in the format string */  char *bufpt;               /* Pointer to the conversion buffer */  int precision;             /* Precision of the current field */  int length;                /* Length of the field */  int idx;                   /* A general purpose loop counter */  int count;                 /* Total number of characters output */  int width;                 /* Width of the current field */  etByte flag_leftjustify;   /* True if "-" flag is present */  etByte flag_plussign;      /* True if "+" flag is present */  etByte flag_blanksign;     /* True if " " flag is present */  etByte flag_alternateform; /* True if "#" flag is present */  etByte flag_altform2;      /* True if "!" flag is present */  etByte flag_zeropad;       /* True if field width constant starts with zero */  etByte flag_long;          /* True if "l" flag is present */  etByte flag_longlong;      /* True if the "ll" flag is present */  etByte done;               /* Loop termination flag */  sqlite_uint64 longvalue;   /* Value for integer types */  LONGDOUBLE_TYPE realvalue; /* Value for real types */  const et_info *infop;      /* Pointer to the appropriate info structure */  char buf[etBUFSIZE];       /* Conversion buffer */  char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */  etByte errorflag = 0;      /* True if an error is encountered */  etByte xtype;              /* Conversion paradigm */  char *zExtra;              /* Extra memory used for etTCLESCAPE conversions */  static const char spaces[] =   "                                                                         ";#define etSPACESIZE (sizeof(spaces)-1)#ifndef SQLITE_OMIT_FLOATING_POINT  int  exp, e2;              /* exponent of real numbers */  double rounder;            /* Used for rounding floating point values */  etByte flag_dp;            /* True if decimal point should be shown */  etByte flag_rtz;           /* True if trailing zeros should be removed */  etByte flag_exp;           /* True to force display of the exponent */  int nsd;                   /* Number of significant digits returned */#endif  func(arg,"",0);  count = length = 0;  bufpt = 0;  for(; (c=(*fmt))!=0; ++fmt){    if( c!='%' ){      int amt;      bufpt = (char *)fmt;      amt = 1;      while( (c=(*++fmt))!='%' && c!=0 ) amt++;      (*func)(arg,bufpt,amt);      count += amt;      if( c==0 ) break;    }    if( (c=(*++fmt))==0 ){      errorflag = 1;      (*func)(arg,"%",1);      count++;      break;    }    /* Find out what flags are present */    flag_leftjustify = flag_plussign = flag_blanksign =      flag_alternateform = flag_altform2 = flag_zeropad = 0;    done = 0;    do{      switch( c ){        case '-':   flag_leftjustify = 1;     break;        case '+':   flag_plussign = 1;        break;        case ' ':   flag_blanksign = 1;       break;        case '#':   flag_alternateform = 1;   break;        case '!':   flag_altform2 = 1;        break;        case '0':   flag_zeropad = 1;         break;        default:    done = 1;                 break;      }    }while( !done && (c=(*++fmt))!=0 );    /* Get the field width */    width = 0;    if( c=='*' ){      width = va_arg(ap,int);      if( width<0 ){        flag_leftjustify = 1;        width = -width;      }      c = *++fmt;    }else{      while( c>='0' && c<='9' ){        width = width*10 + c - '0';        c = *++fmt;      }    }    if( width > etBUFSIZE-10 ){      width = etBUFSIZE-10;    }    /* Get the precision */    if( c=='.' ){      precision = 0;      c = *++fmt;      if( c=='*' ){        precision = va_arg(ap,int);        if( precision<0 ) precision = -precision;        c = *++fmt;      }else{        while( c>='0' && c<='9' ){          precision = precision*10 + c - '0';          c = *++fmt;        }      }    }else{      precision = -1;    }    /* Get the conversion type modifier */    if( c=='l' ){      flag_long = 1;      c = *++fmt;      if( c=='l' ){        flag_longlong = 1;        c = *++fmt;      }else{        flag_longlong = 0;      }    }else{      flag_long = flag_longlong = 0;    }    /* Fetch the info entry for the field */    infop = 0;    for(idx=0; idx<etNINFO; idx++){      if( c==fmtinfo[idx].fmttype ){        infop = &fmtinfo[idx];        if( useExtended || (infop->flags & FLAG_INTERN)==0 ){          xtype = infop->type;        }else{          return -1;        }        break;      }    }    zExtra = 0;    if( infop==0 ){      return -1;    }    /* Limit the precision to prevent overflowing buf[] during conversion */    if( precision>etBUFSIZE-40 && (infop->flags & FLAG_STRING)==0 ){      precision = etBUFSIZE-40;    }    /*    ** At this point, variables are initialized as follows:    **    **   flag_alternateform          TRUE if a '#' is present.    **   flag_altform2               TRUE if a '!' is present.    **   flag_plussign               TRUE if a '+' is present.    **   flag_leftjustify            TRUE if a '-' is present or if the    **                               field width was negative.    **   flag_zeropad                TRUE if the width began with 0.    **   flag_long                   TRUE if the letter 'l' (ell) prefixed    **                               the conversion character.    **   flag_longlong               TRUE if the letter 'll' (ell ell) prefixed    **                               the conversion character.    **   flag_blanksign              TRUE if a ' ' is present.    **   width                       The specified field width.  This is    **                               always non-negative.  Zero is the default.    **   precision                   The specified precision.  The default    **                               is -1.    **   xtype                       The class of the conversion.    **   infop                       Pointer to the appropriate info struct.    */    switch( xtype ){      case etPOINTER:        flag_longlong = sizeof(char*)==sizeof(i64);        flag_long = sizeof(char*)==sizeof(long int);        /* Fall through into the next case */      case etRADIX:        if( infop->flags & FLAG_SIGNED ){          i64 v;          if( flag_longlong )   v = va_arg(ap,i64);          else if( flag_long )  v = va_arg(ap,long int);          else                  v = va_arg(ap,int);          if( v<0 ){            longvalue = -v;            prefix = '-';          }else{            longvalue = v;            if( flag_plussign )        prefix = '+';            else if( flag_blanksign )  prefix = ' ';            else                       prefix = 0;          }        }else{          if( flag_longlong )   longvalue = va_arg(ap,u64);          else if( flag_long )  longvalue = va_arg(ap,unsigned long int);          else                  longvalue = va_arg(ap,unsigned int);          prefix = 0;        }        if( longvalue==0 ) flag_alternateform = 0;        if( flag_zeropad && precision<width-(prefix!=0) ){          precision = width-(prefix!=0);        }        bufpt = &buf[etBUFSIZE-1];        {          register const char *cset;      /* Use registers for speed */          register int base;          cset = &aDigits[infop->charset];          base = infop->base;          do{                                           /* Convert to ascii */            *(--bufpt) = cset[longvalue%base];            longvalue = longvalue/base;          }while( longvalue>0 );        }        length = &buf[etBUFSIZE-1]-bufpt;        for(idx=precision-length; idx>0; idx--){          *(--bufpt) = '0';                             /* Zero pad */        }        if( prefix ) *(--bufpt) = prefix;               /* Add sign */        if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */          const char *pre;          char x;          pre = &aPrefix[infop->prefix];          if( *bufpt!=pre[0] ){            for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;          }        }        length = &buf[etBUFSIZE-1]-bufpt;        break;      case etFLOAT:      case etEXP:      case etGENERIC: