SQLite4  Check-in [e018823162]

  return x;
}

/*
** TODO: This is a placeholder implementation only.
*/
int sqlite4_num_to_int32(sqlite4_num num, int *piOut){
  i64 i;
  sqlite4_num_to_int64(num, &i);
  *piOut = i;
  return SQLITE4_OK;
}

int sqlite4_num_to_double(sqlite4_num num, double *pr){
  double rRet;
  int i;
  rRet = num.m;
  if( num.sign ) rRet = rRet*-1;
  for(i=0; i<num.e; i++){
    rRet = rRet * 10.0;
  }
  for(i=num.e; i<0; i++){
    rRet = rRet / 10.0;
  }
  *pr = rRet;
  return SQLITE4_OK;
}







int sqlite4_num_to_int64(sqlite4_num num, sqlite4_int64 *piOut){

  i64 iRet;
  int i;
  iRet = num.m;
  if( num.sign ) iRet = iRet*-1;

  for(i=0; i<num.e; i++){

    iRet = iRet * 10;
  }
  for(i=num.e; i<0; i++){

    iRet = iRet / 10;
  }

  *piOut = iRet;
  return SQLITE4_OK;
}


/*
** Convert an integer into text in the buffer supplied. The
** text is zero-terminated and right-justified in the buffer.
** A pointer to the first character of text is returned.

int sqlite4_num_isnan(sqlite4_num);
sqlite4_num sqlite4_num_round(sqlite4_num, int iDigit);
int sqlite4_num_compare(sqlite4_num, sqlite4_num);
sqlite4_num sqlite4_num_from_text(const char*, int n, unsigned flags, int*);
sqlite4_num sqlite4_num_from_int64(sqlite4_int64);
sqlite4_num sqlite4_num_from_double(double);
int sqlite4_num_to_int32(sqlite4_num, int*);
int sqlite4_num_to_int64(sqlite4_num, sqlite4_int64*);
int sqlite4_num_to_double(sqlite4_num, double *);
int sqlite4_num_to_text(sqlite4_num, char*, int);

/*
** CAPI4REF: Flags For Text-To-Numeric Conversion
*/
#define SQLITE4_PREFIX_ONLY         0x10

  pIn2 = &aMem[pOp->p2];
  applyNumericAffinity(pIn2);
  pOut = &aMem[pOp->p3];
  flags = pIn1->flags | pIn2->flags;
  if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;

  if( (pIn1->flags&MEM_Int) && (pIn2->flags&MEM_Int) ){
    sqlite4_num_to_int64(pIn1->u.num, &iA);
    sqlite4_num_to_int64(pIn2->u.num, &iB);

    switch( pOp->opcode ){
      case OP_Add:       if( sqlite4AddInt64(&iB,iA) ) goto fp_math;  break;
      case OP_Subtract:  if( sqlite4SubInt64(&iB,iA) ) goto fp_math;  break;
      case OP_Multiply:  if( sqlite4MulInt64(&iB,iA) ) goto fp_math;  break;
      case OP_Divide: {
        if( iA==0 ) goto arithmetic_result_is_null;

      case OP_Subtract: 
        pOut->u.num = sqlite4_num_sub(num2, num1); break;
      case OP_Multiply: 
        pOut->u.num = sqlite4_num_mul(num1, num2); break;
      case OP_Divide: 
        pOut->u.num = sqlite4_num_div(num2, num1); break;
      default: {
        sqlite4_num_to_int64(num1, &iA);
        sqlite4_num_to_int64(num2, &iB);
        if( iA==0 ) goto arithmetic_result_is_null;
        pOut->u.num = sqlite4_num_from_int64(iB % iA);
        break;
      }
    }

    if( sqlite4_num_isnan(pOut->u.num) ){

  Db *pDb;
  i64 v;

  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  pDb = &db->aDb[pOp->p1];
  pIn3 = &aMem[pOp->p3];
  sqlite4VdbeMemIntegerify(pIn3);
  sqlite4_num_to_int64(pIn3->u.num, &v);
  rc = sqlite4KVStorePutSchema(pDb->pKV, (u32)v);
  pDb->pSchema->schema_cookie = (int)v;
  db->flags |= SQLITE4_InternChanges;
  if( pOp->p1==1 ){
    /* Invalidate all prepared statements whenever the TEMP database
    ** schema is changed.  Ticket #1644 */
    sqlite4ExpirePreparedStatements(db);

#ifndef SQLITE_OMIT_AUTOINCREMENT
  if( pOp->p3 && rc==SQLITE4_OK ){
    pIn3 = sqlite4RegisterInRootFrame(p, pOp->p3);
    assert( memIsValid(pIn3) );
    REGISTER_TRACE(pOp->p3, pIn3);
    sqlite4VdbeMemIntegerify(pIn3);
    assert( (pIn3->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
    sqlite4_num_to_int64(pIn3->u.num, &i3);
    if( i3==MAX_ROWID ){
      rc = SQLITE4_FULL;
    }
    if( v<i3 ) v = i3;
  }
#endif
  pOut->flags = MEM_Int;

      }
    }else if( rc==SQLITE4_NOTFOUND ){
      rc = SQLITE4_OK;
    }
    sqlite4KVCursorClose(pCsr);
  }

  sqlite4_num_to_int64(pIn1->u.num, &i1);
  if( i1>=(i64)iMax ){
    i1++;
  }else{
    i1 = iMax+1;
  }
  pIn1->u.num = sqlite4_num_from_int64(i1);

  REGISTER_TRACE(pOp->p2, pData);

  if( pOp->opcode==OP_Insert ){
    pKey = &aMem[pOp->p3];
    assert( pKey->flags & MEM_Int );
    assert( memIsValid(pKey) );
    REGISTER_TRACE(pOp->p3, pKey);
    sqlite4_num_to_int64(pKey->u.num, &iKey);
  }else{
    /* assert( pOp->opcode==OP_InsertInt ); */
    iKey = pOp->p3;
  }

  if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
  if( pData->flags & MEM_Null ){

  Mem *pIn1;
  pIn1 = sqlite4RegisterInRootFrame(p, pOp->p1);
  assert( memIsValid(pIn1) );
  sqlite4VdbeMemIntegerify(pIn1);
  pIn2 = &aMem[pOp->p2];
  REGISTER_TRACE(pOp->p1, pIn1);
  sqlite4VdbeMemIntegerify(pIn2);
  sqlite4_num_to_int64(pIn1->u.num, &i1);
  sqlite4_num_to_int64(pIn2->u.num, &i2);
  if( i1<i2 ){
    pIn1->u.num = sqlite4_num_from_int64(i2);
  }
  REGISTER_TRACE(pOp->p1, pIn1);
  break;
}
#endif /* SQLITE4_OMIT_AUTOINCREMENT */

/* Opcode: IfPos P1 P2 * * *
**
** If the value of register P1 is 1 or greater, jump to P2.
**
** It is illegal to use this instruction on a register that does
** not contain an integer.  An assertion fault will result if you try.
*/
case OP_IfPos: {        /* jump, in1 */
  i64 i1;
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags&MEM_Int );
  sqlite4_num_to_int64(pIn1->u.num, &i1);
  if( i1>0 ){
     pc = pOp->p2 - 1;
  }
  break;
}

/* Opcode: IfNeg P1 P2 * * *
**
** If the value of register P1 is less than zero, jump to P2. 
**
** It is illegal to use this instruction on a register that does
** not contain an integer.  An assertion fault will result if you try.
*/
case OP_IfNeg: {        /* jump, in1 */
  i64 i1;
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags&MEM_Int );
  sqlite4_num_to_int64(pIn1->u.num, &i1);
  if( i1<0 ){
     pc = pOp->p2 - 1;
  }
  break;
}

/* Opcode: IfZero P1 P2 P3 * *
**
** The register P1 must contain an integer.  Add literal P3 to the
** value in register P1.  If the result is exactly 0, jump to P2. 
**
** It is illegal to use this instruction on a register that does
** not contain an integer.  An assertion fault will result if you try.
*/
case OP_IfZero: {        /* jump, in1 */
  i64 i1;
  pIn1 = &aMem[pOp->p1];
  assert( pIn1->flags&MEM_Int );
  sqlite4_num_to_int64(pIn1->u.num, &i1);
  i1 += pOp->p3;
  pIn1->u.num = sqlite4_num_from_int64(i1);
  if( i1==0 ){
     pc = pOp->p2 - 1;
  }
  break;
}

  cksum = 0;

  if( pOp->p5 ){
    sqlite4Fts5EntryCksum(db, pInfo, pKey, aArg, &cksum);
  }else{
    sqlite4Fts5RowCksum(db, pInfo, pKey, aArg, &cksum);
  }
  sqlite4_num_to_int64(pOut->u.num, &i1);
  pOut->u.num = sqlite4_num_from_int64(i1 ^ cksum);

  break;
}

/* Opcode: FtsOpen P1 P2 P3 P4 P5
**

){
  return bindText(pStmt, i, zData, nData, xDel, pDelArg, SQLITE4_UTF16NATIVE);
}
#endif /* SQLITE4_OMIT_UTF16 */
int sqlite4_bind_value(sqlite4_stmt *pStmt, int i, const sqlite4_value *pValue){
  int rc;
  switch( pValue->type ){
    case SQLITE4_INTEGER: {
      i64 i1;
      sqlite4_num_to_int64(pValue->u.num, &i1);
      rc = sqlite4_bind_int64(pStmt, i, i1);
      break;
    }
    case SQLITE4_FLOAT: {

      double r;



      sqlite4_num_to_double(pValue->u.num, &r);
      rc = sqlite4_bind_double(pStmt, i, r);
      break;
    }
    case SQLITE4_BLOB: {
      rc = sqlite4_bind_blob(pStmt, i, pValue->z, pValue->n,
                             SQLITE4_TRANSIENT, 0);
      break;
    }

  nOut = 9;
  for(i=0; i<nIn; i++){
    int flags = aIn[i].flags;
    if( flags & MEM_Null ){
      aOut[nOut++] = 0;
    }else if( flags & MEM_Int ){
      i64 i1;
      sqlite4_num_to_int64(aIn[i].u.num, &i1);
      n = significantBytes(i1);
      aOut[nOut++] = n+2;
      nPayload += n;
      aAux[i].n = n;
    }else if( flags & MEM_Real ){
      sqlite4_num *p = &aIn[i].u.num;
      int e;

  if( aOut==0 ){ rc = SQLITE4_NOMEM; goto vdbeEncodeData_error; }
  for(i=0; i<nIn; i++){
    int flags = aIn[i].flags;
    if( flags & MEM_Null ){
      /* No content */
    }else if( flags & MEM_Int ){
      sqlite4_int64 v;
      sqlite4_num_to_int64(aIn[i].u.num, &v);
      n = aAux[i].n;
      aOut[nOut+(--n)] = v & 0xff;
      while( n ){
        v >>= 8;
        aOut[nOut+(--n)] = v & 0xff;
      }
      nOut += aAux[i].n;

** If pMem is a string or blob, then we make an attempt to convert
** it into a integer and return that.  If pMem represents an
** an SQL-NULL value, return 0.
**
** If pMem represents a string value, its encoding might be changed.
*/
i64 sqlite4VdbeIntValue(Mem *pMem){
  int flags;
  assert( pMem->db==0 || sqlite4_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  flags = pMem->flags;
  if( flags & (MEM_Int|MEM_Real) ){
    i64 i1;
    sqlite4_num_to_int64(pMem->u.num, &i1);
    return i1;
  }else if( flags & (MEM_Str|MEM_Blob) ){
    i64 value = 0;
    assert( pMem->z || pMem->n==0 );
    testcase( pMem->z==0 );
    sqlite4Atoi64(pMem->z, &value, pMem->n, pMem->enc);
    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.

** Extract and return a numeric value from memory cell pMem. This call
** does not modify the contents or flags of *pMem in any way.
*/
sqlite4_num sqlite4VdbeNumValue(Mem *pMem){
  if( pMem->flags & (MEM_Real|MEM_Int) ){
    return pMem->u.num;
  }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
    int flags = SQLITE4_PREFIX_ONLY | pMem->enc;
    return sqlite4_num_from_text(pMem->z, pMem->n, flags, 0);
  }else{
    sqlite4_num zero = {0,0,0,0};
    return zero;
  }
}

/*
** The MEM structure is already a MEM_Real.  Try to also make it a
** MEM_Int if we can.
*/
void sqlite4VdbeIntegerAffinity(Mem *pMem){
  i64 i;
  double r;

  assert( pMem->flags & MEM_Real );
  assert( (pMem->flags & MEM_RowSet)==0 );
  assert( pMem->db==0 || sqlite4_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );

  sqlite4_num_to_int64(pMem->u.num, &i);
  sqlite4_num_to_double(pMem->u.num, &r);

  /* Only mark the value as an integer if
  **
  **    (1) the round-trip conversion real->int->real is a no-op, and
  **    (2) The integer is neither the largest nor the smallest
  **        possible integer (ticket #3922)
  **
  ** The second and third terms in the following conditional enforces
  ** the second condition under the assumption that addition overflow causes
  ** values to wrap around.  On x86 hardware, the third term is always
  ** true and could be omitted.  But we leave it in because other
  ** architectures might behave differently.
  */
  if( r==(double)i && i>SMALLEST_INT64 && ALWAYS(i<LARGEST_INT64) ){
    pMem->u.num = sqlite4_num_from_int64(i);
    MemSetTypeFlag(pMem, MEM_Int);
  }
}

/*
** Convert pMem to type integer.  Invalidate any prior representations.
*/
int sqlite4VdbeMemIntegerify(Mem *pMem){
  assert( pMem->db==0 || sqlite4_mutex_held(pMem->db->mutex) );
  assert( (pMem->flags & MEM_RowSet)==0 );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );

  if( (pMem->flags & MEM_Int)==0 ){
    sqlite4VdbeMemNumerify(pMem);
  }
  if( (pMem->flags & MEM_Int)==0 ){
    if( pMem->flags & MEM_Real ){
      i64 iVal;
      sqlite4_num_to_int64(pMem->u.num, &iVal);
      pMem->u.num = sqlite4_num_from_int64(iVal);
    }else{
      pMem->u.num = sqlite4_num_from_int64(0);
    }
  }

  MemSetTypeFlag(pMem, MEM_Int);
  return SQLITE4_OK;
}

/*
** Convert pMem so that it has types MEM_Real or MEM_Int or both.
** Invalidate any prior representations.
**

  }

  /* 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.
  */
  if( combined_flags&(MEM_Int|MEM_Real) ){
    if( !(f1&(MEM_Int|MEM_Real)) ){
      return 1;
    }
    if( !(f2&(MEM_Int|MEM_Real)) ){
      return -1;
    }
    if( (f1 & f2 & MEM_Int)==0 ){
      double r1, r2;
      sqlite4_num_to_double(pMem1->u.num, &r1);
      sqlite4_num_to_double(pMem2->u.num, &r2);
      if( r1<r2 ) return -1;
      if( r1>r2 ) return 1;
      return 0;
    }else{
      i64 i1, i2;
      sqlite4_num_to_int64(pMem1->u.num, &i1);
      sqlite4_num_to_int64(pMem2->u.num, &i2);
      assert( f1&MEM_Int );
      assert( f2&MEM_Int );
      if( i1<i2 ) return -1;
      if( i1>i2 ) return 1;
      return 0;
    }
  }

  /* If one value is a string and the other is a blob, the string is less.
  ** If both are strings, compare using the collating functions.
  */
  if( combined_flags&MEM_Str ){
    if( (f1 & MEM_Str)==0 ){