/*** 2004 May 26**** The author disclaims copyright to this source code.  In place of** a legal notice, here is a blessing:****    May you do good and not evil.**    May you find forgiveness for yourself and forgive others.**    May you share freely, never taking more than you give.******************************************************************************* This file contains code use to manipulate "Mem" structure.  A "Mem"** stores a single value in the VDBE.  Mem is an opaque structure visible** only within the VDBE.  Interface routines refer to a Mem using the** name sqlite_value*/#include "sqliteInt.h"#include "os.h"#include <ctype.h>#include "vdbeInt.h"/*** If pMem is an object with a valid string representation, this routine** ensures the internal encoding for the string representation is** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.**** If pMem is not a string object, or the encoding of the string** representation is already stored using the requested encoding, then this** routine is a no-op.**** SQLITE_OK is returned if the conversion is successful (or not required).** SQLITE_NOMEM may be returned if a malloc() fails during conversion** between formats.*/int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){  int rc;  if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){    return SQLITE_OK;  }#ifdef SQLITE_OMIT_UTF16  return SQLITE_ERROR;#else  rc = sqlite3VdbeMemTranslate(pMem, desiredEnc);  if( rc==SQLITE_NOMEM ){    sqlite3VdbeMemRelease(pMem);    pMem->flags = MEM_Null;    pMem->z = 0;  }  return rc;#endif}/*** Make the given Mem object MEM_Dyn.**** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.*/int sqlite3VdbeMemDynamicify(Mem *pMem){  int n = pMem->n;  u8 *z;  if( (pMem->flags & (MEM_Ephem|MEM_Static|MEM_Short))==0 ){    return SQLITE_OK;  }  assert( (pMem->flags & MEM_Dyn)==0 );  assert( pMem->flags & (MEM_Str|MEM_Blob) );  z = sqliteMallocRaw( n+2 );  if( z==0 ){    return SQLITE_NOMEM;  }  pMem->flags |= MEM_Dyn|MEM_Term;  pMem->xDel = 0;  memcpy(z, pMem->z, n );  z[n] = 0;  z[n+1] = 0;  pMem->z = z;  pMem->flags &= ~(MEM_Ephem|MEM_Static|MEM_Short);  return SQLITE_OK;}/*** Make the given Mem object either MEM_Short or MEM_Dyn so that bytes** of the Mem.z[] array can be modified.**** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.*/int sqlite3VdbeMemMakeWriteable(Mem *pMem){  int n;  u8 *z;  if( (pMem->flags & (MEM_Ephem|MEM_Static))==0 ){    return SQLITE_OK;  }  assert( (pMem->flags & MEM_Dyn)==0 );  assert( pMem->flags & (MEM_Str|MEM_Blob) );  if( (n = pMem->n)+2<sizeof(pMem->zShort) ){    z = pMem->zShort;    pMem->flags |= MEM_Short|MEM_Term;  }else{    z = sqliteMallocRaw( n+2 );    if( z==0 ){      return SQLITE_NOMEM;    }    pMem->flags |= MEM_Dyn|MEM_Term;    pMem->xDel = 0;  }  memcpy(z, pMem->z, n );  z[n] = 0;  z[n+1] = 0;  pMem->z = z;  pMem->flags &= ~(MEM_Ephem|MEM_Static);  return SQLITE_OK;}/*** Make sure the given Mem is \u0000 terminated.*/int sqlite3VdbeMemNulTerminate(Mem *pMem){  /* In SQLite, a string without a nul terminator occurs when a string  ** is loaded from disk (in this case the memory management is ephemeral),  ** or when it is supplied by the user as a bound variable or function  ** return value. Therefore, the memory management of the string must be  ** either ephemeral, static or controlled by a user-supplied destructor.  */  assert(                             !(pMem->flags&MEM_Str) ||                /* it's not a string, or      */    (pMem->flags&MEM_Term) ||                /* it's nul term. already, or */    (pMem->flags&(MEM_Ephem|MEM_Static)) ||  /* it's static or ephem, or   */    (pMem->flags&MEM_Dyn && pMem->xDel)      /* external management        */  );  if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){    return SQLITE_OK;   /* Nothing to do */  }  if( pMem->flags & (MEM_Static|MEM_Ephem) ){    return sqlite3VdbeMemMakeWriteable(pMem);  }else{    char *z = sqliteMalloc(pMem->n+2);    if( !z ) return SQLITE_NOMEM;    memcpy(z, pMem->z, pMem->n);    z[pMem->n] = 0;    z[pMem->n+1] = 0;    pMem->xDel(pMem->z);    pMem->xDel = 0;    pMem->z = z;  }  return SQLITE_OK;}/*** Add MEM_Str to the set of representations for the given Mem.  Numbers** are converted using sqlite3_snprintf().  Converting a BLOB to a string** is a no-op.**** Existing representations MEM_Int and MEM_Real are *not* invalidated.**** A MEM_Null value will never be passed to this function. This function is** used for converting values to text for returning to the user (i.e. via** sqlite3_value_text()), or for ensuring that values to be used as btree** keys are strings. In the former case a NULL pointer is returned the** user and the later is an internal programming error.*/int sqlite3VdbeMemStringify(Mem *pMem, int enc){  int rc = SQLITE_OK;  int fg = pMem->flags;  u8 *z = pMem->zShort;  assert( !(fg&(MEM_Str|MEM_Blob)) );  assert( fg&(MEM_Int|MEM_Real) );  /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8  ** string representation of the value. Then, if the required encoding  ** is UTF-16le or UTF-16be do a translation.  **   ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.  */  if( fg & MEM_Real ){    sqlite3_snprintf(NBFS, z, "%!.15g", pMem->r);  }else{    assert( fg & MEM_Int );    sqlite3_snprintf(NBFS, z, "%lld", pMem->i);  }  pMem->n = strlen(z);  pMem->z = z;  pMem->enc = SQLITE_UTF8;  pMem->flags |= MEM_Str | MEM_Short | MEM_Term;  sqlite3VdbeChangeEncoding(pMem, enc);  return rc;}/*** Memory cell pMem contains the context of an aggregate function.** This routine calls the finalize method for that function.  The** result of the aggregate is stored back into pMem.*/void sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){  if( pFunc && pFunc->xFinalize ){    sqlite3_context ctx;    assert( (pMem->flags & MEM_Null)!=0 || pFunc==*(FuncDef**)&pMem->i );    ctx.s.flags = MEM_Null;    ctx.s.z = pMem->zShort;    ctx.pMem = pMem;    ctx.pFunc = pFunc;    pFunc->xFinalize(&ctx);    if( pMem->z && pMem->z!=pMem->zShort ){      sqliteFree( pMem->z );    }    *pMem = ctx.s;    if( pMem->flags & MEM_Short ){      pMem->z = pMem->zShort;    }  }}/*** Release any memory held by the Mem. This may leave the Mem in an** inconsistent state, for example with (Mem.z==0) and** (Mem.type==SQLITE_TEXT).*/void sqlite3VdbeMemRelease(Mem *p){  if( p->flags & (MEM_Dyn|MEM_Agg) ){    if( p->xDel ){      if( p->flags & MEM_Agg ){        sqlite3VdbeMemFinalize(p, *(FuncDef**)&p->i);        assert( (p->flags & MEM_Agg)==0 );        sqlite3VdbeMemRelease(p);      }else{        p->xDel((void *)p->z);      }    }else{      sqliteFree(p->z);    }    p->z = 0;    p->xDel = 0;  }}/*** Return some kind of integer value which is the best we can do** at representing the value that *pMem describes as an integer.** If pMem is an integer, then the value is exact.  If pMem is** a floating-point then the value returned is the integer part.** If pMem is a string or blob, then we make an attempt to convert** it into a integer and return that.  If pMem is NULL, return 0.**** If pMem is a string, its encoding might be changed.*/i64 sqlite3VdbeIntValue(Mem *pMem){  int flags = pMem->flags;  if( flags & MEM_Int ){    return pMem->i;  }else if( flags & MEM_Real ){    return (i64)pMem->r;  }else if( flags & (MEM_Str|MEM_Blob) ){    i64 value;    if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)       || sqlite3VdbeMemNulTerminate(pMem) ){      return SQLITE_NOMEM;    }    assert( pMem->z );    sqlite3atoi64(pMem->z, &value);    return value;  }else{    return 0;  }}/*** Convert pMem to type integer.  Invalidate any prior representations.*/int sqlite3VdbeMemIntegerify(Mem *pMem){  pMem->i = sqlite3VdbeIntValue(pMem);  sqlite3VdbeMemRelease(pMem);  pMem->flags = MEM_Int;  return SQLITE_OK;}/*** Return the best representation of pMem that we can get into a** double.  If pMem is already a double or an integer, return its** value.  If it is a string or blob, try to convert it to a double.** If it is a NULL, return 0.0.*/double sqlite3VdbeRealValue(Mem *pMem){  if( pMem->flags & MEM_Real ){    return pMem->r;  }else if( pMem->flags & MEM_Int ){    return (double)pMem->i;  }else if( pMem->flags & (MEM_Str|MEM_Blob) ){    double val = 0.0;    if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)       || sqlite3VdbeMemNulTerminate(pMem) ){      return SQLITE_NOMEM;    }    assert( pMem->z );    sqlite3AtoF(pMem->z, &val);    return val;  }else{    return 0.0;  }}/*** Convert pMem so that it is of type MEM_Real.  Invalidate any** prior representations.*/int sqlite3VdbeMemRealify(Mem *pMem){  pMem->r = sqlite3VdbeRealValue(pMem);  sqlite3VdbeMemRelease(pMem);  pMem->flags = MEM_Real;  return SQLITE_OK;}/*** Delete any previous value and set the value stored in *pMem to NULL.*/void sqlite3VdbeMemSetNull(Mem *pMem){  sqlite3VdbeMemRelease(pMem);  pMem->flags = MEM_Null;  pMem->type = SQLITE_NULL;  pMem->n = 0;}/*** Delete any previous value and set the value stored in *pMem to val,** manifest type INTEGER.*/void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){  sqlite3VdbeMemRelease(pMem);  pMem->i = val;  pMem->flags = MEM_Int;  pMem->type = SQLITE_INTEGER;}/*** Delete any previous value and set the value stored in *pMem to val,** manifest type REAL.*/void sqlite3VdbeMemSetDouble(Mem *pMem, double val){  sqlite3VdbeMemRelease(pMem);  pMem->r = val;  pMem->flags = MEM_Real;  pMem->type = SQLITE_FLOAT;}/*** Make an shallow copy of pFrom into pTo.  Prior contents of** pTo are overwritten.  The pFrom->z field is not duplicated.  If** pFrom->z is used, then pTo->z points to the same thing as pFrom->z** and flags gets srcType (either MEM_Ephem or MEM_Static).*/void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){  memcpy(pTo, pFrom, sizeof(*pFrom)-sizeof(pFrom->zShort));  pTo->xDel = 0;  if( pTo->flags & (MEM_Str|MEM_Blob) ){    pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short|MEM_Ephem);    assert( srcType==MEM_Ephem || srcType==MEM_Static );    pTo->flags |= srcType;  }}/*** Make a full copy of pFrom into pTo.  Prior contents of pTo are** freed before the copy is made.*/int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){  int rc;  if( pTo->flags & MEM_Dyn ){    sqlite3VdbeMemRelease(pTo);  }  sqlite3VdbeMemShallowCopy(pTo, pFrom, MEM_Ephem);  if( pTo->flags & MEM_Ephem ){    rc = sqlite3VdbeMemMakeWriteable(pTo);  }else{    rc = SQLITE_OK;  }  return rc;}/*** Transfer the contents of pFrom to pTo. Any existing value in pTo is** freed. If pFrom contains ephemeral data, a copy is made.**** pFrom contains an SQL NULL when this routine returns.  SQLITE_NOMEM** might be returned if pFrom held ephemeral data and we were unable** to allocate enough space to make a copy.*/int sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){  int rc;  if( pTo->flags & MEM_Dyn ){    sqlite3VdbeMemRelease(pTo);  }  memcpy(pTo, pFrom, sizeof(Mem));  if( pFrom->flags & MEM_Short ){    pTo->z = pTo->zShort;  }  pFrom->flags = MEM_Null;  pFrom->xDel = 0;  if( pTo->flags & MEM_Ephem ){    rc = sqlite3VdbeMemMakeWriteable(pTo);  }else{    rc = SQLITE_OK;  }  return rc;}/*** Change the value of a Mem to be a string or a BLOB.*/int sqlite3VdbeMemSetStr(  Mem *pMem,          /* Memory cell to set to string value */  const char *z,      /* String pointer */  int n,              /* Bytes in string, or negative */  u8 enc,             /* Encoding of z.  0 for BLOBs */  void (*xDel)(void*) /* Destructor function */){  sqlite3VdbeMemRelease(pMem);  if( !z ){    pMem->flags = MEM_Null;    pMem->type = SQLITE_NULL;    return SQLITE_OK;  }