SQLite

    if( negFlag ) i = -i;
    sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
  }else{
    int c;
    i64 value;
    const char *z = pExpr->u.zToken;
    assert( z!=0 );
    c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
    if( c==0 || (c==2 && negFlag) ){
      char *zV;
      if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
      zV = dup8bytes(v, (char*)&value);
      sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
    }else{
#ifdef SQLITE_OMIT_FLOATING_POINT
      sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
#else



      codeReal(v, z, negFlag, iMem);

#endif
    }
  }
}

/*
** Clear a cache entry.

sqlite3_int64 sqlite3_uri_int64(
  const char *zFilename,    /* Filename as passed to xOpen */
  const char *zParam,       /* URI parameter sought */
  sqlite3_int64 bDflt       /* return if parameter is missing */
){
  const char *z = sqlite3_uri_parameter(zFilename, zParam);
  sqlite3_int64 v;
  if( z && sqlite3Atoi64(z, &v, sqlite3Strlen30(z), SQLITE_UTF8)==SQLITE_OK ){
    bDflt = v;
  }
  return bDflt;
}

/*
** Return the Btree pointer identified by zDbName.  Return NULL if not found.

  **
  ** Get or set the size limit on rollback journal files.
  */
  case PragTyp_JOURNAL_SIZE_LIMIT: {
    Pager *pPager = sqlite3BtreePager(pDb->pBt);
    i64 iLimit = -2;
    if( zRight ){
      sqlite3Atoi64(zRight, &iLimit, sqlite3Strlen30(zRight), SQLITE_UTF8);
      if( iLimit<-1 ) iLimit = -1;
    }
    iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
    returnSingleInt(pParse, "journal_size_limit", iLimit);
    break;
  }

  */
  case PragTyp_MMAP_SIZE: {
    sqlite3_int64 sz;
#if SQLITE_MAX_MMAP_SIZE>0
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    if( zRight ){
      int ii;
      sqlite3Atoi64(zRight, &sz, sqlite3Strlen30(zRight), SQLITE_UTF8);
      if( sz<0 ) sz = sqlite3GlobalConfig.szMmap;
      if( pId2->n==0 ) db->szMmap = sz;
      for(ii=db->nDb-1; ii>=0; ii--){
        if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
          sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
        }
      }

  **   PRAGMA soft_heap_limit = N
  **
  ** Call sqlite3_soft_heap_limit64(N).  Return the result.  If N is omitted,
  ** use -1.
  */
  case PragTyp_SOFT_HEAP_LIMIT: {
    sqlite3_int64 N;
    if( zRight && sqlite3Atoi64(zRight, &N, 1000000, SQLITE_UTF8)==SQLITE_OK ){
      sqlite3_soft_heap_limit64(N);
    }
    returnSingleInt(pParse, "soft_heap_limit",  sqlite3_soft_heap_limit64(-1));
    break;
  }

#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)

const char *sqlite3IndexAffinityStr(Vdbe *, Index *);
void sqlite3TableAffinity(Vdbe*, Table*, int);
char sqlite3CompareAffinity(Expr *pExpr, char aff2);
int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
char sqlite3ExprAffinity(Expr *pExpr);
int sqlite3Atoi64(const char*, i64*, int, u8);

void sqlite3Error(sqlite3*, int, const char*,...);
void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
u8 sqlite3HexToInt(int h);

int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);

#if defined(SQLITE_TEST) 
const char *sqlite3ErrName(int);
#endif

const char *sqlite3ErrStr(int);

  register unsigned char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
}

/*
** Translate a single byte of Hex into an integer.
** This routine only works if h really is a valid hexadecimal
** character:  0..9a..fA..F
*/
u8 sqlite3HexToInt(int h){
  assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
#ifdef SQLITE_ASCII
  h += 9*(1&(h>>6));
#endif
#ifdef SQLITE_EBCDIC
  h += 9*(1&~(h>>4));
#endif
  return (u8)(h & 0xf);
}

/*
** The string z[] is an text representation of a real number.
** Convert this string to a double and write it into *pResult.
**
** The string z[] is length bytes in length (bytes, not characters) and
** uses the encoding enc.  The string is not necessarily zero-terminated.
**

  /* get sign of significand */
  if( *z=='-' ){
    sign = -1;
    z+=incr;
  }else if( *z=='+' ){
    z+=incr;
  }
#ifndef SQLITE_OMIT_HEX_INTEGER
  else if( *z=='0'
        && &z[incr*2]<zEnd
        && (z[incr]=='x' || z[incr]=='X')
        && sqlite3Isxdigit(z[incr*2])
  ){
    result = 0.0;
    for(z += incr*2; z<zEnd && sqlite3Isxdigit(z[0]); z += incr){
      result = result*16.0 + sqlite3HexToInt(z[0]);
    }
    *pResult = result;
    return z>=zEnd && nonNum==0;
  }
#endif

  /* skip leading zeroes */
  while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;

  /* copy max significant digits to significand */
  while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
    s = s*10 + (*z - '0');

    testcase( c==0 );
    testcase( c==(+1) );
  }
  return c;
}

/*
** Convert zNum to a 64-bit signed integer.

**
** If the zNum value is representable as a 64-bit twos-complement 
** integer, then write that value into *pNum and return 0.
**
** If zNum is exactly 9223372036854775808, return 2.  This special
** case is broken out because while 9223372036854775808 cannot be a 
** signed 64-bit integer, its negative -9223372036854775808 can be.

  if( zNum<zEnd ){
    if( *zNum=='-' ){
      neg = 1;
      zNum+=incr;
    }else if( *zNum=='+' ){
      zNum+=incr;
    }
#ifndef SQLITE_OMIT_HEX_INTEGER
    else if( *zNum=='0'
          &&  &zNum[incr*2]<zEnd
          && (zNum[incr]=='x' || zNum[incr]=='X')
          && sqlite3Isxdigit(zNum[incr*2])
    ){
      zNum += incr*2;
      while( zNum<zEnd && zNum[0]=='0' ) zNum += incr;
      for(i=0; &zNum[i]<zEnd && sqlite3Isxdigit(zNum[i]); i+=incr){
        u = u*16 + sqlite3HexToInt(zNum[i]);
      }
      memcpy(pNum, &u, 8);
      return &zNum[i]<zEnd || i>16*incr || nonNum;
    }
#endif
  }
  zStart = zNum;
  while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
  for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
    u = u*10 + c - '0';
  }
  if( u>LARGEST_INT64 ){

      /* zNum is exactly 9223372036854775808.  Fits if negative.  The
      ** special case 2 overflow if positive */
      assert( u-1==LARGEST_INT64 );
      return neg ? 0 : 2;
    }
  }
}

/*
































** If zNum represents an integer that will fit in 32-bits, then set
** *pValue to that integer and return true.  Otherwise return false.


**
** Any non-numeric characters that following zNum are ignored.
** This is different from sqlite3Atoi64() which requires the
** input number to be zero-terminated.
*/
int sqlite3GetInt32(const char *zNum, int *pValue){
  sqlite_int64 v = 0;

void sqlite3Put4byte(unsigned char *p, u32 v){
  p[0] = (u8)(v>>24);
  p[1] = (u8)(v>>16);
  p[2] = (u8)(v>>8);
  p[3] = (u8)v;
}



















#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
/*
** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
** value.  Return a pointer to its binary value.  Space to hold the
** binary value has been obtained from malloc and must be freed by
** the calling routine.
*/

hexlit1 215 0x00d 13
hexlit1 216 0x00D 13
hexlit1 217 0x00e 14
hexlit1 218 0x00E 14 
hexlit1 219 0x00f 15
hexlit1 220 0x00F 15



proc hexlit2 {tnum hex ans} {




  do_execsql_test hexlit-$tnum "SELECT printf('%7e',CAST('$hex' AS real))" $ans


}


hexlit2 300 0x1 1.000000e+00
hexlit2 301 0x10 1.600000e+01
hexlit2 302 0x100 2.560000e+02
hexlit2 303 0x1000 4.096000e+03
hexlit2 304 0x10000 6.553600e+04
hexlit2 305 0x100000 1.048576e+06
hexlit2 306 0x1000000 1.677722e+07
hexlit2 307 0x10000000 2.684355e+08
hexlit2 308 0x100000000 4.294967e+09
hexlit2 309 0x1000000000 6.871948e+10
hexlit2 310 0x10000000000 1.099512e+12
hexlit2 311 0x100000000000 1.759219e+13
hexlit2 312 0x1000000000000 2.814750e+14
hexlit2 313 0x10000000000000 4.503600e+15
hexlit2 314 0x100000000000000 7.205759e+16
hexlit2 315 0x1000000000000000 1.152922e+18
hexlit2 316 0x10000000000000000 1.844674e+19
hexlit2 317 0x100000000000000000 2.951479e+20
hexlit2 318 0x1000000000000000000 4.722366e+21
hexlit2 319 0x10000000000000000000 7.555786e+22
hexlit2 320 0x100000000000000000000 1.208926e+24
hexlit2 321 0x1000000000000000000000 1.934281e+25
hexlit2 322 0x10000000000000000000000 3.094850e+26
hexlit2 323 0x100000000000000000000000 4.951760e+27
hexlit2 324 0x1000000000000000000000000 7.922816e+28
hexlit2 325 0x10000000000000000000000000 1.267651e+30
hexlit2 326 0x100000000000000000000000000 2.028241e+31
hexlit2 327 0x1000000000000000000000000000 3.245186e+32
hexlit2 328 0x10000000000000000000000000000 5.192297e+33
hexlit2 329 0x100000000000000000000000000000 8.307675e+34

hexlit2 400 0x07fffffffffffffff 9.223372e+18
hexlit2 401 0x08000000000000000 9.223372e+18
hexlit2 402 0x0ffffffffffffffff 1.844674e+19
hexlit2 403 0x10000000000000000 1.844674e+19

finish_test