/*

** 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().

**

** $Id: printf.c,v 1.93 2008/07/28 19:34:53 drh Exp $

**

**************************************************************************

**

** 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 etSQLESCAPE  10 /* Strings with '\'' doubled.  %q */

#define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '',

                          NULL pointers replaced by SQL NULL.  %Q */

#define etTOKEN      12 /* a pointer to a Token structure */

#define etSRCLIST    13 /* a pointer to a SrcList */

#define etPOINTER    14 /* The %p conversion */

#define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */

#define etORDINAL    16 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */

/*

** 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, 4, etDYNSTRING,  0,  0 },

  {  'q',  0, 4, etSQLESCAPE,  0,  0 },

  {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },

  {  'w',  0, 4, etSQLESCAPE3, 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 },

  {  'r', 10, 3, etORDINAL,    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 */

/*

** Append N space characters to the given string buffer.

*/

static void appendSpace(StrAccum *pAccum, int N){

  static const char zSpaces[] = "                             ";

  while( N>=sizeof(zSpaces)-1 ){

    sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);

    N -= sizeof(zSpaces)-1;

  }

  if( N>0 ){

    sqlite3StrAccumAppend(pAccum, zSpaces, N);

  }

}

/*

** 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.

*/

void sqlite3VXPrintf(

  StrAccum *pAccum,                  /* Accumulate results here */

  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 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 = 0;          /* Conversion paradigm */

  char *zExtra;              /* Extra memory used for etTCLESCAPE conversions */

#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

  length = 0;

  bufpt = 0;

  for(; (c=(*fmt))!=0; ++fmt){

    if( c!='%' ){

      int amt;

      bufpt = (char *)fmt;

      amt = 1;

      while( (c=(*++fmt))!='%' && c!=0 ) amt++;

      sqlite3StrAccumAppend(pAccum, bufpt, amt);

      if( c==0 ) break;

    }

    if( (c=(*++fmt))==0 ){

      errorflag = 1;

      sqlite3StrAccumAppend(pAccum, "%", 1);

      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;

        }

        break;

      }

    }

    zExtra = 0;

    if( infop==0 ){

      return;

    }

    /* 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 etORDINAL:

      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];

        if( xtype==etORDINAL ){

          static const char zOrd[] = "thstndrd";

          int x = longvalue % 10;

          if( x>=4 || (longvalue/10)%10==1 ){

            x = 0;

          }

          buf[etBUFSIZE-3] = zOrd[x*2];

          buf[etBUFSIZE-2] = zOrd[x*2+1];

          bufpt -= 2;

        }

        {

          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];

          for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;

        }

        length = &buf[etBUFSIZE-1]-bufpt;

        break;

      case etFLOAT:

      case etEXP:

      case etGENERIC:

        realvalue = va_arg(ap,double);

#ifndef SQLITE_OMIT_FLOATING_POINT

        if( precision<0 ) precision = 6;         /* Set default precision */

        if( precision>etBUFSIZE/2-10 ) precision = etBUFSIZE/2-10;

        if( realvalue<0.0 ){

          realvalue = -realvalue;

          prefix = '-';

        }else{

          if( flag_plussign )          prefix = '+';

          else if( flag_blanksign )    prefix = ' ';

          else                         prefix = 0;

        }

        if( xtype==etGENERIC && precision>0 ) precision--;

#if 0

        /* Rounding works like BSD when the constant 0.4999 is used.  Wierd! */

        for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);

#else

        /* It makes more sense to use 0.5 */

        for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}

#endif

        if( xtype==etFLOAT ) realvalue += rounder;

        /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */

        exp = 0;

        if( sqlite3IsNaN(realvalue) ){

          bufpt = "NaN";

          length = 3;

          break;

        }

        if( realvalue>0.0 ){

          while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }

          while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }

          while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }

          while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }

          while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }

          if( exp>350 ){

            if( prefix=='-' ){

              bufpt = "-Inf";

            }else if( prefix=='+' ){

              bufpt = "+Inf";

            }else{

              bufpt = "Inf";

            }

            length = strlen(bufpt);

            break;

          }

        }

        bufpt = buf;

        /*

        ** If the field type is etGENERIC, then convert to either etEXP

        ** or etFLOAT, as appropriate.

        */

        flag_exp = xtype==etEXP;

        if( xtype!=etFLOAT ){

          realvalue += rounder;

          if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }

        }

        if( xtype==etGENERIC ){

          flag_rtz = !flag_alternateform;

          if( exp<-4 || exp>precision ){

            xtype = etEXP;

          }else{

            precision = precision - exp;

            xtype = etFLOAT;

          }

        }else{

          flag_rtz = 0;

        }

        if( xtype==etEXP ){

          e2 = 0;

        }else{

          e2 = exp;

        }

        nsd = 0;

        flag_dp = (precision>0) | flag_alternateform | flag_altform2;

        /* The sign in front of the number */

        if( prefix ){

          *(bufpt++) = prefix;

        }

        /* Digits prior to the decimal point */

        if( e2<0 ){

          *(bufpt++) = '0';

        }else{

          for(; e2>=0; e2--){

            *(bufpt++) = et_getdigit(&realvalue,&nsd);

          }

        }

        /* The decimal point */

        if( flag_dp ){

          *(bufpt++) = '.';

        }

        /* "0" digits after the decimal point but before the first

        ** significant digit of the number */

        for(e2++; e2<0; precision--, e2++){

          assert( precision>0 );

          *(bufpt++) = '0';

        }

        /* Significant digits after the decimal point */

        while( (precision--)>0 ){

          *(bufpt++) = et_getdigit(&realvalue,&nsd);

        }

        /* Remove trailing zeros and the "." if no digits follow the "." */

        if( flag_rtz && flag_dp ){

          while( bufpt[-1]=='0' ) *(--bufpt) = 0;

          assert( bufpt>buf );

          if( bufpt[-1]=='.' ){

            if( flag_altform2 ){

              *(bufpt++) = '0';

            }else{

              *(--bufpt) = 0;

            }

          }

        }

        /* Add the "eNNN" suffix */

        if( flag_exp || xtype==etEXP ){

          *(bufpt++) = aDigits[infop->charset];

          if( exp<0 ){

            *(bufpt++) = '-'; exp = -exp;

          }else{

            *(bufpt++) = '+';

          }

          if( exp>=100 ){

            *(bufpt++) = (exp/100)+'0';                /* 100's digit */

            exp %= 100;

          }

          *(bufpt++) = exp/10+'0';                     /* 10's digit */

          *(bufpt++) = exp%10+'0';                     /* 1's digit */

        }

        *bufpt = 0;

        /* The converted number is in buf[] and zero terminated. Output it.

        ** Note that the number is in the usual order, not reversed as with

        ** integer conversions. */

        length = bufpt-buf;

        bufpt = buf;

        /* Special case:  Add leading zeros if the flag_zeropad flag is

        ** set and we are not left justified */

        if( flag_zeropad && !flag_leftjustify && length < width){

          int i;

          int nPad = width - length;

          for(i=width; i>=nPad; i--){

            bufpt[i] = bufpt[i-nPad];

          }

          i = prefix!=0;

          while( nPad-- ) bufpt[i++] = '0';

          length = width;

        }

#endif

        break;

      case etSIZE:

        *(va_arg(ap,int*)) = pAccum->nChar;

        length = width = 0;

        break;

      case etPERCENT:

        buf[0] = '%';

        bufpt = buf;

        length = 1;

        break;

      case etCHARX:

        c = buf[0] = va_arg(ap,int);

        if( precision>=0 ){

          for(idx=1; idx<precision; idx++) buf[idx] = c;

          length = precision;

        }else{

          length =1;

        }

        bufpt = buf;

        break;

      case etSTRING:

      case etDYNSTRING:

        bufpt = va_arg(ap,char*);

        if( bufpt==0 ){

          bufpt = "";

        }else if( xtype==etDYNSTRING ){

          zExtra = bufpt;

        }

        if( precision>=0 ){

          for(length=0; length<precision && bufpt[length]; length++){}

        }else{

          length = strlen(bufpt);

        }

        break;

      case etSQLESCAPE:

      case etSQLESCAPE2:

      case etSQLESCAPE3: {

        int i, j, n, ch, isnull;

        int needQuote;

        char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */

        char *escarg = va_arg(ap,char*);

        isnull = escarg==0;

        if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");

        for(i=n=0; (ch=escarg[i])!=0; i++){

          if( ch==q )  n++;

        }

        needQuote = !isnull && xtype==etSQLESCAPE2;

        n += i + 1 + needQuote*2;

        if( n>etBUFSIZE ){

          bufpt = zExtra = sqlite3Malloc( n );

          if( bufpt==0 ) return;

        }else{

          bufpt = buf;

        }

        j = 0;

        if( needQuote ) bufpt[j++] = q;

        for(i=0; (ch=escarg[i])!=0; i++){

          bufpt[j++] = ch;

          if( ch==q ) bufpt[j++] = ch;

        }

        if( needQuote ) bufpt[j++] = q;

        bufpt[j] = 0;

        length = j;

        /* The precision is ignored on %q and %Q */

        /* if( precision>=0 && precision<length ) length = precision; */

        break;

      }

      case etTOKEN: {

        Token *pToken = va_arg(ap, Token*);

        if( pToken ){

          sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);

        }

        length = width = 0;

        break;

      }

      case etSRCLIST: {

        SrcList *pSrc = va_arg(ap, SrcList*);

        int k = va_arg(ap, int);

        struct SrcList_item *pItem = &pSrc->a[k];

        assert( k>=0 && k<pSrc->nSrc );

        if( pItem->zDatabase ){

          sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);

          sqlite3StrAccumAppend(pAccum, ".", 1);

        }

        sqlite3StrAccumAppend(pAccum, pItem->zName, -1);

        length = width = 0;

        break;

      }

    }/* End switch over the format type */

    /*

    ** The text of the conversion is pointed to by "bufpt" and is

    ** "length" characters long.  The field width is "width".  Do

    ** the output.

    */

    if( !flag_leftjustify ){

      register int nspace;

      nspace = width-length;

      if( nspace>0 ){

        appendSpace(pAccum, nspace);

      }

    }

    if( length>0 ){

      sqlite3StrAccumAppend(pAccum, bufpt, length);

    }

    if( flag_leftjustify ){

      register int nspace;

      nspace = width-length;

      if( nspace>0 ){

        appendSpace(pAccum, nspace);

      }

    }

    if( zExtra ){

      sqlite3_free(zExtra);

    }

  }/* End for loop over the format string */

} /* End of function */

/*

** Append N bytes of text from z to the StrAccum object.

*/

void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){

  if( p->tooBig | p->mallocFailed ){

    return;

  }

  if( N<0 ){

    N = strlen(z);

  }

  if( N==0 ){

    return;

  }

  if( p->nChar+N >= p->nAlloc ){

    char *zNew;

    if( !p->useMalloc ){

      p->tooBig = 1;

      N = p->nAlloc - p->nChar - 1;

      if( N<=0 ){

        return;

      }

    }else{

      i64 szNew = p->nChar;

      szNew += N + 1;

      if( szNew > p->mxAlloc ){

        sqlite3StrAccumReset(p);

        p->tooBig = 1;

        return;

      }else{

        p->nAlloc = szNew;

      }

      zNew = sqlite3DbMallocRaw(p->db, p->nAlloc );

      if( zNew ){

        memcpy(zNew, p->zText, p->nChar);

        sqlite3StrAccumReset(p);

        p->zText = zNew;

      }else{

        p->mallocFailed = 1;

        sqlite3StrAccumReset(p);

        return;

      }

    }

  }

  memcpy(&p->zText[p->nChar], z, N);

  p->nChar += N;

}

/*

** Finish off a string by making sure it is zero-terminated.

** Return a pointer to the resulting string.  Return a NULL

** pointer if any kind of error was encountered.

*/

char *sqlite3StrAccumFinish(StrAccum *p){

  if( p->zText ){

    p->zText[p->nChar] = 0;

    if( p->useMalloc && p->zText==p->zBase ){

      p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );

      if( p->zText ){

        memcpy(p->zText, p->zBase, p->nChar+1);

      }else{

        p->mallocFailed = 1;

      }

    }

  }

  return p->zText;

}

/*

** Reset an StrAccum string.  Reclaim all malloced memory.

*/

void sqlite3StrAccumReset(StrAccum *p){

  if( p->zText!=p->zBase ){

    sqlite3DbFree(p->db, p->zText);

  }

  p->zText = 0;

}

/*

** Initialize a string accumulator

*/

void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){

  p->zText = p->zBase = zBase;

  p->db = 0;

  p->nChar = 0;

  p->nAlloc = n;

  p->mxAlloc = mx;

  p->useMalloc = 1;

  p->tooBig = 0;

  p->mallocFailed = 0;

}

/*

** Print into memory obtained from sqliteMalloc().  Use the internal

** %-conversion extensions.

*/

char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){

  char *z;

  char zBase[SQLITE_PRINT_BUF_SIZE];

  StrAccum acc;

  sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),

                      db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH);

  acc.db = db;

  sqlite3VXPrintf(&acc, 1, zFormat, ap);

  z = sqlite3StrAccumFinish(&acc);

  if( acc.mallocFailed && db ){

    db->mallocFailed = 1;

  }

  return z;

}

/*

** Print into memory obtained from sqliteMalloc().  Use the internal

** %-conversion extensions.

*/

char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){

  va_list ap;

  char *z;

  va_start(ap, zFormat);

  z = sqlite3VMPrintf(db, zFormat, ap);

  va_end(ap);

  return z;

}

/*

** Like sqlite3MPrintf(), but call sqlite3DbFree() on zStr after formatting

** the string and before returnning.  This routine is intended to be used

** to modify an existing string.  For example:

**

**       x = sqlite3MPrintf(db, x, "prefix %s suffix", x);

**

*/

char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zFormat, ...){

  va_list ap;

  char *z;

  va_start(ap, zFormat);

  z = sqlite3VMPrintf(db, zFormat, ap);

  va_end(ap);

  sqlite3DbFree(db, zStr);

  return z;

}

/*

** Print into memory obtained from sqlite3_malloc().  Omit the internal

** %-conversion extensions.

*/

char *sqlite3_vmprintf(const char *zFormat, va_list ap){

  char *z;

  char zBase[SQLITE_PRINT_BUF_SIZE];

  StrAccum acc;

#ifndef SQLITE_OMIT_AUTOINIT

  if( sqlite3_initialize() ) return 0;

#endif

  sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);

  sqlite3VXPrintf(&acc, 0, zFormat, ap);

  z = sqlite3StrAccumFinish(&acc);

  return z;

}

/*

** Print into memory obtained from sqlite3_malloc()().  Omit the internal

** %-conversion extensions.

*/

char *sqlite3_mprintf(const char *zFormat, ...){

  va_list ap;

  char *z;

#ifndef SQLITE_OMIT_AUTOINIT

  if( sqlite3_initialize() ) return 0;

#endif

  va_start(ap, zFormat);

  z = sqlite3_vmprintf(zFormat, ap);

  va_end(ap);

  return z;

}

/*

** sqlite3_snprintf() works like snprintf() except that it ignores the

** current locale settings.  This is important for SQLite because we

** are not able to use a "," as the decimal point in place of "." as

** specified by some locales.

*/

char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){

  char *z;

  va_list ap;

  StrAccum acc;

  if( n<=0 ){

    return zBuf;

  }

  sqlite3StrAccumInit(&acc, zBuf, n, 0);

  acc.useMalloc = 0;

  va_start(ap,zFormat);

  sqlite3VXPrintf(&acc, 0, zFormat, ap);

  va_end(ap);

  z = sqlite3StrAccumFinish(&acc);

  return z;

}

#if defined(SQLITE_DEBUG)

/*

** A version of printf() that understands %lld.  Used for debugging.

** The printf() built into some versions of windows does not understand %lld

** and segfaults if you give it a long long int.

*/

void sqlite3DebugPrintf(const char *zFormat, ...){

  va_list ap;

  StrAccum acc;

  char zBuf[500];

  sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);

  acc.useMalloc = 0;

  va_start(ap,zFormat);

  sqlite3VXPrintf(&acc, 0, zFormat, ap);

  va_end(ap);

  sqlite3StrAccumFinish(&acc);

  fprintf(stdout,"%s", zBuf);

  fflush(stdout);

}

#endif