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( 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 && exp>=-350 ){ realvalue *= 1e8; exp-=8; }          while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; }          if( exp>350 || exp<-350 ){            bufpt = "NaN";            length = 3;            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>0; precision--, e2++){          *(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 && exp) ){          *(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*)) = count;        length = width = 0;        break;      case etPERCENT:        buf[0] = '%';        bufpt = buf;        length = 1;        break;      case etCHARLIT:      case etCHARX:        c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt);        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;        }        length = strlen(bufpt);        if( precision>=0 && precision<length ) length = precision;        break;      case etSQLESCAPE:      case etSQLESCAPE2: {        int i, j, n, ch, isnull;        int needQuote;        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=='\'' )  n++;        }        needQuote = !isnull && xtype==etSQLESCAPE2;        n += i + 1 + needQuote*2;        if( n>etBUFSIZE ){          bufpt = zExtra = sqliteMalloc( n );          if( bufpt==0 ) return -1;        }else{          bufpt = buf;        }        j = 0;        if( needQuote ) bufpt[j++] = '\'';        for(i=0; (ch=escarg[i])!=0; i++){          bufpt[j++] = ch;          if( ch=='\'' ) bufpt[j++] = ch;        }        if( needQuote ) bufpt[j++] = '\'';        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 && pToken->z ){          (*func)(arg, (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 && pItem->zDatabase[0] ){          (*func)(arg, pItem->zDatabase, strlen(pItem->zDatabase));          (*func)(arg, ".", 1);        }        (*func)(arg, pItem->zName, strlen(pItem->zName));        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 ){        count += nspace;        while( nspace>=etSPACESIZE ){          (*func)(arg,spaces,etSPACESIZE);          nspace -= etSPACESIZE;        }        if( nspace>0 ) (*func)(arg,spaces,nspace);      }    }    if( length>0 ){      (*func)(arg,bufpt,length);      count += length;    }    if( flag_leftjustify ){      register int nspace;      nspace = width-length;      if( nspace>0 ){        count += nspace;        while( nspace>=etSPACESIZE ){          (*func)(arg,spaces,etSPACESIZE);          nspace -= etSPACESIZE;        }        if( nspace>0 ) (*func)(arg,spaces,nspace);      }    }    if( zExtra ){      sqliteFree(zExtra);    }  }/* End for loop over the format string */  return errorflag ? -1 : count;} /* End of function *//* This structure is used to store state information about the** write to memory that is currently in progress.*/struct sgMprintf {  char *zBase;     /* A base allocation */  char *zText;     /* The string collected so far */  int  nChar;      /* Length of the string so far */  int  nTotal;     /* Output size if unconstrained */  int  nAlloc;     /* Amount of space allocated in zText */  void *(*xRealloc)(void*,int);  /* Function used to realloc memory */};/* ** This function implements the callback from vxprintf. **** This routine add nNewChar characters of text in zNewText to** the sgMprintf structure pointed to by "arg".*/static void mout(void *arg, const char *zNewText, int nNewChar){  struct sgMprintf *pM = (struct sgMprintf*)arg;  pM->nTotal += nNewChar;  if( pM->nChar + nNewChar + 1 > pM->nAlloc ){    if( pM->xRealloc==0 ){      nNewChar =  pM->nAlloc - pM->nChar - 1;    }else{      pM->nAlloc = pM->nChar + nNewChar*2 + 1;      if( pM->zText==pM->zBase ){        pM->zText = pM->xRealloc(0, pM->nAlloc);        if( pM->zText && pM->nChar ){          memcpy(pM->zText, pM->zBase, pM->nChar);        }      }else{        char *zNew;        zNew = pM->xRealloc(pM->zText, pM->nAlloc);        if( zNew ){          pM->zText = zNew;        }      }    }  }  if( pM->zText ){    if( nNewChar>0 ){      memcpy(&pM->zText[pM->nChar], zNewText, nNewChar);      pM->nChar += nNewChar;    }    pM->zText[pM->nChar] = 0;  }}/*** This routine is a wrapper around xprintf() that invokes mout() as** the consumer.  */static char *base_vprintf(  void *(*xRealloc)(void*,int),   /* Routine to realloc memory. May be NULL */  int useInternal,                /* Use internal %-conversions if true */  char *zInitBuf,                 /* Initially write here, before mallocing */  int nInitBuf,                   /* Size of zInitBuf[] */  const char *zFormat,            /* format string */  va_list ap                      /* arguments */){  struct sgMprintf sM;  sM.zBase = sM.zText = zInitBuf;  sM.nChar = sM.nTotal = 0;  sM.nAlloc = nInitBuf;  sM.xRealloc = xRealloc;  vxprintf(mout, &sM, useInternal, zFormat, ap);  if( xRealloc ){    if( sM.zText==sM.zBase ){      sM.zText = xRealloc(0, sM.nChar+1);      if( sM.zText ){        memcpy(sM.zText, sM.zBase, sM.nChar+1);      }    }else if( sM.nAlloc>sM.nChar+10 ){      char *zNew = xRealloc(sM.zText, sM.nChar+1);      if( zNew ){        sM.zText = zNew;      }    }  }  return sM.zText;}/*** Realloc that is a real function, not a macro.*/static void *printf_realloc(void *old, int size){  return sqliteRealloc(old,size);}/*** Print into memory obtained from sqliteMalloc().  Use the internal** %-conversion extensions.*/char *sqlite3VMPrintf(const char *zFormat, va_list ap){  char zBase[SQLITE_PRINT_BUF_SIZE];  return base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap);}/*** Print into memory obtained from sqliteMalloc().  Use the internal** %-conversion extensions.*/char *sqlite3MPrintf(const char *zFormat, ...){  va_list ap;  char *z;  char zBase[SQLITE_PRINT_BUF_SIZE];  va_start(ap, zFormat);  z = base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap);  va_end(ap);  return z;}/*** Print into memory obtained from malloc().  Do not use the internal** %-conversion extensions.  This routine is for use by external users.*/char *sqlite3_mprintf(const char *zFormat, ...){  va_list ap;  char *z;  char zBuf[200];  va_start(ap,zFormat);  z = base_vprintf((void*(*)(void*,int))realloc, 0,                    zBuf, sizeof(zBuf), zFormat, ap);  va_end(ap);  return z;}/* This is the varargs version of sqlite3_mprintf.  */char *sqlite3_vmprintf(const char *zFormat, va_list ap){  char zBuf[200];  return base_vprintf((void*(*)(void*,int))realloc, 0,                      zBuf, sizeof(zBuf), zFormat, ap);}/*** 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;  va_start(ap,zFormat);  z = base_vprintf(0, 0, zBuf, n, zFormat, ap);  va_end(ap);  return z;}#if defined(SQLITE_TEST) || 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, ...){  extern int getpid(void);  va_list ap;  char zBuf[500];  va_start(ap, zFormat);  base_vprintf(0, 0, zBuf, sizeof(zBuf), zFormat, ap);  va_end(ap);  fprintf(stdout,"%d: %s", getpid(), zBuf);  fflush(stdout);}#endif