/*

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

  /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,

  ** then the encoding of the value may not have changed.

  */

  rc = sqlite3VdbeMemTranslate(pMem, desiredEnc);

  assert(rc==SQLITE_OK    || rc==SQLITE_NOMEM);

  assert(rc==SQLITE_OK    || pMem->enc!=desiredEnc);

  assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);

  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 = (char*)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 = (u8*)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 = (char*)z;

  pMem->flags &= ~(MEM_Ephem|MEM_Static);

  assert(0==(1&(int)pMem->z));

  return SQLITE_OK;

}

/*

** Make sure the given Mem is \u0000 terminated.

*/

int sqlite3VdbeMemNulTerminate(Mem *pMem){

  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;

    if( pMem->xDel ){

      pMem->xDel(pMem->z);

    }else{

      sqliteFree(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;

  char *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_Int ){

    sqlite3_snprintf(NBFS, z, "%lld", pMem->i);

  }else{

    assert( fg & MEM_Real );

    sqlite3_snprintf(NBFS, z, "%!.15g", pMem->r);

  }

  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.

**

** Return SQLITE_ERROR if the finalizer reports an error.  SQLITE_OK

** otherwise.

*/

int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){

  int rc = SQLITE_OK;

  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;

    ctx.isError = 0;

    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;

    }

    if( ctx.isError ){

      rc = SQLITE_ERROR;

    }

  }

  return rc;

}

/*

** 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 0;

    }

    assert( pMem->z );

    sqlite3atoi64(pMem->z, &value);

    return value;

  }else{

    return 0;

  }

}

/*

** 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 0.0;

    }

    assert( pMem->z );

    sqlite3AtoF(pMem->z, &val);

    return val;

  }else{

    return 0.0;

  }

}

/*

** The MEM structure is already a MEM_Real.  Try to also make it a

** MEM_Int if we can.

*/

void sqlite3VdbeIntegerAffinity(Mem *pMem){

  assert( pMem->flags & MEM_Real );

  pMem->i = pMem->r;

  if( ((double)pMem->i)==pMem->r ){

    pMem->flags |= MEM_Int;

  }

}

/*

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

}

/*

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

}

/*

** Convert pMem so that it has types MEM_Real or MEM_Int or both.

** Invalidate any prior representations.

*/

int sqlite3VdbeMemNumerify(Mem *pMem){

  sqlite3VdbeMemRealify(pMem);

  sqlite3VdbeIntegerAffinity(pMem);

  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;

  }

  pMem->z = (char *)z;

  if( xDel==SQLITE_STATIC ){

    pMem->flags = MEM_Static;

  }else if( xDel==SQLITE_TRANSIENT ){

    pMem->flags = MEM_Ephem;

  }else{

    pMem->flags = MEM_Dyn;

    pMem->xDel = xDel;

  }

  pMem->enc = enc;

  pMem->type = enc==0 ? SQLITE_BLOB : SQLITE_TEXT;

  pMem->n = n;

  assert( enc==0 || enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE 

      || enc==SQLITE_UTF16BE );

  switch( enc ){

    case 0:

      pMem->flags |= MEM_Blob;

      pMem->enc = SQLITE_UTF8;

      break;

    case SQLITE_UTF8:

      pMem->flags |= MEM_Str;

      if( n<0 ){

        pMem->n = strlen(z);

        pMem->flags |= MEM_Term;

      }

      break;

#ifndef SQLITE_OMIT_UTF16

    case SQLITE_UTF16LE:

    case SQLITE_UTF16BE:

      pMem->flags |= MEM_Str;

      if( pMem->n<0 ){

        pMem->n = sqlite3utf16ByteLen(pMem->z,-1);

        pMem->flags |= MEM_Term;

      }

      if( sqlite3VdbeMemHandleBom(pMem) ){

        return SQLITE_NOMEM;

      }

#endif /* SQLITE_OMIT_UTF16 */

  }

  if( pMem->flags&MEM_Ephem ){

    return sqlite3VdbeMemMakeWriteable(pMem);

  }

  return SQLITE_OK;

}

/*

** Compare the values contained by the two memory cells, returning

** negative, zero or positive if pMem1 is less than, equal to, or greater

** than pMem2. Sorting order is NULL's first, followed by numbers (integers

** and reals) sorted numerically, followed by text ordered by the collating

** sequence pColl and finally blob's ordered by memcmp().

**

** Two NULL values are considered equal by this function.

*/

int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){

  int rc;

  int f1, f2;

  int combined_flags;

  /* Interchange pMem1 and pMem2 if the collating sequence specifies

  ** DESC order.

  */

  f1 = pMem1->flags;

  f2 = pMem2->flags;

  combined_flags = f1|f2;

  /* If one value is NULL, it is less than the other. If both values

  ** are NULL, return 0.

  */

  if( combined_flags&MEM_Null ){

    return (f2&MEM_Null) - (f1&MEM_Null);

  }

  /* If one value is a number and the other is not, the number is less.

  ** If both are numbers, compare as reals if one is a real, or as integers

  ** if both values are integers.