SQLite util.c somehow had CRLF.

This is making it impossible to test a change to it on the trybots.

BUG=none
TEST=none

Review URL: http://codereview.chromium.org/7034042

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85932 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 1094 insertions, 1094 deletions

diff --git a/third_party/sqlite/src/src/util.c b/third_party/sqlite/src/src/util.c
index d12bcd5..81e42b4 100644
--- a/third_party/sqlite/src/src/util.c
+++ b/third_party/sqlite/src/src/util.c
@@ -1,1094 +1,1094 @@
-/*

-** 2001 September 15

-**

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

-**

-*************************************************************************

-** Utility functions used throughout sqlite.

-**

-** This file contains functions for allocating memory, comparing

-** strings, and stuff like that.

-**

-*/

-#include "sqliteInt.h"

-#include <stdarg.h>

-#ifdef SQLITE_HAVE_ISNAN

-# include <math.h>

-#endif

-

-/*

-** Routine needed to support the testcase() macro.

-*/

-#ifdef SQLITE_COVERAGE_TEST

-void sqlite3Coverage(int x){

-  static int dummy = 0;

-  dummy += x;

-}

-#endif

-

-/*

-** Return true if the floating point value is Not a Number (NaN).

-**

-** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.

-** Otherwise, we have our own implementation that works on most systems.

-*/

-int sqlite3IsNaN(double x){

-  int rc;   /* The value return */

-#if !defined(SQLITE_HAVE_ISNAN)

-  /*

-  ** Systems that support the isnan() library function should probably

-  ** make use of it by compiling with -DSQLITE_HAVE_ISNAN.  But we have

-  ** found that many systems do not have a working isnan() function so

-  ** this implementation is provided as an alternative.

-  **

-  ** This NaN test sometimes fails if compiled on GCC with -ffast-math.

-  ** On the other hand, the use of -ffast-math comes with the following

-  ** warning:

-  **

-  **      This option [-ffast-math] should never be turned on by any

-  **      -O option since it can result in incorrect output for programs

-  **      which depend on an exact implementation of IEEE or ISO 

-  **      rules/specifications for math functions.

-  **

-  ** Under MSVC, this NaN test may fail if compiled with a floating-

-  ** point precision mode other than /fp:precise.  From the MSDN 

-  ** documentation:

-  **

-  **      The compiler [with /fp:precise] will properly handle comparisons 

-  **      involving NaN. For example, x != x evaluates to true if x is NaN 

-  **      ...

-  */

-#ifdef __FAST_MATH__

-# error SQLite will not work correctly with the -ffast-math option of GCC.

-#endif

-  volatile double y = x;

-  volatile double z = y;

-  rc = (y!=z);

-#else  /* if defined(SQLITE_HAVE_ISNAN) */

-  rc = isnan(x);

-#endif /* SQLITE_HAVE_ISNAN */

-  testcase( rc );

-  return rc;

-}

-

-/*

-** Compute a string length that is limited to what can be stored in

-** lower 30 bits of a 32-bit signed integer.

-**

-** The value returned will never be negative.  Nor will it ever be greater

-** than the actual length of the string.  For very long strings (greater

-** than 1GiB) the value returned might be less than the true string length.

-*/

-int sqlite3Strlen30(const char *z){

-  const char *z2 = z;

-  if( z==0 ) return 0;

-  while( *z2 ){ z2++; }

-  return 0x3fffffff & (int)(z2 - z);

-}

-

-/*

-** Set the most recent error code and error string for the sqlite

-** handle "db". The error code is set to "err_code".

-**

-** If it is not NULL, string zFormat specifies the format of the

-** error string in the style of the printf functions: The following

-** format characters are allowed:

-**

-**      %s      Insert a string

-**      %z      A string that should be freed after use

-**      %d      Insert an integer

-**      %T      Insert a token

-**      %S      Insert the first element of a SrcList

-**

-** zFormat and any string tokens that follow it are assumed to be

-** encoded in UTF-8.

-**

-** To clear the most recent error for sqlite handle "db", sqlite3Error

-** should be called with err_code set to SQLITE_OK and zFormat set

-** to NULL.

-*/

-void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){

-  if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){

-    db->errCode = err_code;

-    if( zFormat ){

-      char *z;

-      va_list ap;

-      va_start(ap, zFormat);

-      z = sqlite3VMPrintf(db, zFormat, ap);

-      va_end(ap);

-      sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);

-    }else{

-      sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);

-    }

-  }

-}

-

-/*

-** Add an error message to pParse->zErrMsg and increment pParse->nErr.

-** The following formatting characters are allowed:

-**

-**      %s      Insert a string

-**      %z      A string that should be freed after use

-**      %d      Insert an integer

-**      %T      Insert a token

-**      %S      Insert the first element of a SrcList

-**

-** This function should be used to report any error that occurs whilst

-** compiling an SQL statement (i.e. within sqlite3_prepare()). The

-** last thing the sqlite3_prepare() function does is copy the error

-** stored by this function into the database handle using sqlite3Error().

-** Function sqlite3Error() should be used during statement execution

-** (sqlite3_step() etc.).

-*/

-void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){

-  va_list ap;

-  sqlite3 *db = pParse->db;

-  pParse->nErr++;

-  sqlite3DbFree(db, pParse->zErrMsg);

-  va_start(ap, zFormat);

-  pParse->zErrMsg = sqlite3VMPrintf(db, zFormat, ap);

-  va_end(ap);

-  pParse->rc = SQLITE_ERROR;

-}

-

-/*

-** Clear the error message in pParse, if any

-*/

-void sqlite3ErrorClear(Parse *pParse){

-  sqlite3DbFree(pParse->db, pParse->zErrMsg);

-  pParse->zErrMsg = 0;

-  pParse->nErr = 0;

-}

-

-/*

-** Convert an SQL-style quoted string into a normal string by removing

-** the quote characters.  The conversion is done in-place.  If the

-** input does not begin with a quote character, then this routine

-** is a no-op.

-**

-** The input string must be zero-terminated.  A new zero-terminator

-** is added to the dequoted string.

-**

-** The return value is -1 if no dequoting occurs or the length of the

-** dequoted string, exclusive of the zero terminator, if dequoting does

-** occur.

-**

-** 2002-Feb-14: This routine is extended to remove MS-Access style

-** brackets from around identifers.  For example:  "[a-b-c]" becomes

-** "a-b-c".

-*/

-int sqlite3Dequote(char *z){

-  char quote;

-  int i, j;

-  if( z==0 ) return -1;

-  quote = z[0];

-  switch( quote ){

-    case '\'':  break;

-    case '"':   break;

-    case '`':   break;                /* For MySQL compatibility */

-    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */

-    default:    return -1;

-  }

-  for(i=1, j=0; ALWAYS(z[i]); i++){

-    if( z[i]==quote ){

-      if( z[i+1]==quote ){

-        z[j++] = quote;

-        i++;

-      }else{

-        break;

-      }

-    }else{

-      z[j++] = z[i];

-    }

-  }

-  z[j] = 0;

-  return j;

-}

-

-/* Convenient short-hand */

-#define UpperToLower sqlite3UpperToLower

-

-/*

-** Some systems have stricmp().  Others have strcasecmp().  Because

-** there is no consistency, we will define our own.

-*/

-int sqlite3StrICmp(const char *zLeft, const char *zRight){

-  register unsigned char *a, *b;

-  a = (unsigned char *)zLeft;

-  b = (unsigned char *)zRight;

-  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }

-  return UpperToLower[*a] - UpperToLower[*b];

-}

-int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){

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

-}

-

-/*

-** Return TRUE if z is a pure numeric string.  Return FALSE and leave

-** *realnum unchanged if the string contains any character which is not

-** part of a number.

-**

-** If the string is pure numeric, set *realnum to TRUE if the string

-** contains the '.' character or an "E+000" style exponentiation suffix.

-** Otherwise set *realnum to FALSE.  Note that just becaue *realnum is

-** false does not mean that the number can be successfully converted into

-** an integer - it might be too big.

-**

-** An empty string is considered non-numeric.

-*/

-int sqlite3IsNumber(const char *z, int *realnum, u8 enc){

-  int incr = (enc==SQLITE_UTF8?1:2);

-  if( enc==SQLITE_UTF16BE ) z++;

-  if( *z=='-' || *z=='+' ) z += incr;

-  if( !sqlite3Isdigit(*z) ){

-    return 0;

-  }

-  z += incr;

-  *realnum = 0;

-  while( sqlite3Isdigit(*z) ){ z += incr; }

-  if( *z=='.' ){

-    z += incr;

-    if( !sqlite3Isdigit(*z) ) return 0;

-    while( sqlite3Isdigit(*z) ){ z += incr; }

-    *realnum = 1;

-  }

-  if( *z=='e' || *z=='E' ){

-    z += incr;

-    if( *z=='+' || *z=='-' ) z += incr;

-    if( !sqlite3Isdigit(*z) ) return 0;

-    while( sqlite3Isdigit(*z) ){ z += incr; }

-    *realnum = 1;

-  }

-  return *z==0;

-}

-

-/*

-** The string z[] is an ASCII representation of a real number.

-** Convert this string to a double.

-**

-** This routine assumes that z[] really is a valid number.  If it

-** is not, the result is undefined.

-**

-** This routine is used instead of the library atof() function because

-** the library atof() might want to use "," as the decimal point instead

-** of "." depending on how locale is set.  But that would cause problems

-** for SQL.  So this routine always uses "." regardless of locale.

-*/

-int sqlite3AtoF(const char *z, double *pResult){

-#ifndef SQLITE_OMIT_FLOATING_POINT

-  const char *zBegin = z;

-  /* sign * significand * (10 ^ (esign * exponent)) */

-  int sign = 1;   /* sign of significand */

-  i64 s = 0;      /* significand */

-  int d = 0;      /* adjust exponent for shifting decimal point */

-  int esign = 1;  /* sign of exponent */

-  int e = 0;      /* exponent */

-  double result;

-  int nDigits = 0;

-

-  /* skip leading spaces */

-  while( sqlite3Isspace(*z) ) z++;

-  /* get sign of significand */

-  if( *z=='-' ){

-    sign = -1;

-    z++;

-  }else if( *z=='+' ){

-    z++;

-  }

-  /* skip leading zeroes */

-  while( z[0]=='0' ) z++, nDigits++;

-

-  /* copy max significant digits to significand */

-  while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){

-    s = s*10 + (*z - '0');

-    z++, nDigits++;

-  }

-  /* skip non-significant significand digits

-  ** (increase exponent by d to shift decimal left) */

-  while( sqlite3Isdigit(*z) ) z++, nDigits++, d++;

-

-  /* if decimal point is present */

-  if( *z=='.' ){

-    z++;

-    /* copy digits from after decimal to significand

-    ** (decrease exponent by d to shift decimal right) */

-    while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){

-      s = s*10 + (*z - '0');

-      z++, nDigits++, d--;

-    }

-    /* skip non-significant digits */

-    while( sqlite3Isdigit(*z) ) z++, nDigits++;

-  }

-

-  /* if exponent is present */

-  if( *z=='e' || *z=='E' ){

-    z++;

-    /* get sign of exponent */

-    if( *z=='-' ){

-      esign = -1;

-      z++;

-    }else if( *z=='+' ){

-      z++;

-    }

-    /* copy digits to exponent */

-    while( sqlite3Isdigit(*z) ){

-      e = e*10 + (*z - '0');

-      z++;

-    }

-  }

-

-  /* adjust exponent by d, and update sign */

-  e = (e*esign) + d;

-  if( e<0 ) {

-    esign = -1;

-    e *= -1;

-  } else {

-    esign = 1;

-  }

-

-  /* if 0 significand */

-  if( !s ) {

-    /* In the IEEE 754 standard, zero is signed.

-    ** Add the sign if we've seen at least one digit */

-    result = (sign<0 && nDigits) ? -(double)0 : (double)0;

-  } else {

-    /* attempt to reduce exponent */

-    if( esign>0 ){

-      while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;

-    }else{

-      while( !(s%10) && e>0 ) e--,s/=10;

-    }

-

-    /* adjust the sign of significand */

-    s = sign<0 ? -s : s;

-

-    /* if exponent, scale significand as appropriate

-    ** and store in result. */

-    if( e ){

-      double scale = 1.0;

-      /* attempt to handle extremely small/large numbers better */

-      if( e>307 && e<342 ){

-        while( e%308 ) { scale *= 1.0e+1; e -= 1; }

-        if( esign<0 ){

-          result = s / scale;

-          result /= 1.0e+308;

-        }else{

-          result = s * scale;

-          result *= 1.0e+308;

-        }

-      }else{

-        /* 1.0e+22 is the largest power of 10 than can be 

-        ** represented exactly. */

-        while( e%22 ) { scale *= 1.0e+1; e -= 1; }

-        while( e>0 ) { scale *= 1.0e+22; e -= 22; }

-        if( esign<0 ){

-          result = s / scale;

-        }else{

-          result = s * scale;

-        }

-      }

-    } else {

-      result = (double)s;

-    }

-  }

-

-  /* store the result */

-  *pResult = result;

-

-  /* return number of characters used */

-  return (int)(z - zBegin);

-#else

-  return sqlite3Atoi64(z, pResult);

-#endif /* SQLITE_OMIT_FLOATING_POINT */

-}

-

-/*

-** Compare the 19-character string zNum against the text representation

-** value 2^63:  9223372036854775808.  Return negative, zero, or positive

-** if zNum is less than, equal to, or greater than the string.

-**

-** Unlike memcmp() this routine is guaranteed to return the difference

-** in the values of the last digit if the only difference is in the

-** last digit.  So, for example,

-**

-**      compare2pow63("9223372036854775800")

-**

-** will return -8.

-*/

-static int compare2pow63(const char *zNum){

-  int c;

-  c = memcmp(zNum,"922337203685477580",18)*10;

-  if( c==0 ){

-    c = zNum[18] - '8';

-  }

-  return c;

-}

-

-

-/*

-** Return TRUE if zNum is a 64-bit signed integer and write

-** the value of the integer into *pNum.  If zNum is not an integer

-** or is an integer that is too large to be expressed with 64 bits,

-** then return false.

-**

-** When this routine was originally written it dealt with only

-** 32-bit numbers.  At that time, it was much faster than the

-** atoi() library routine in RedHat 7.2.

-*/

-int sqlite3Atoi64(const char *zNum, i64 *pNum){

-  i64 v = 0;

-  int neg;

-  int i, c;

-  const char *zStart;

-  while( sqlite3Isspace(*zNum) ) zNum++;

-  if( *zNum=='-' ){

-    neg = 1;

-    zNum++;

-  }else if( *zNum=='+' ){

-    neg = 0;

-    zNum++;

-  }else{

-    neg = 0;

-  }

-  zStart = zNum;

-  while( zNum[0]=='0' ){ zNum++; } /* Skip over leading zeros. Ticket #2454 */

-  for(i=0; (c=zNum[i])>='0' && c<='9'; i++){

-    v = v*10 + c - '0';

-  }

-  *pNum = neg ? -v : v;

-  if( c!=0 || (i==0 && zStart==zNum) || i>19 ){

-    /* zNum is empty or contains non-numeric text or is longer

-    ** than 19 digits (thus guaranting that it is too large) */

-    return 0;

-  }else if( i<19 ){

-    /* Less than 19 digits, so we know that it fits in 64 bits */

-    return 1;

-  }else{

-    /* 19-digit numbers must be no larger than 9223372036854775807 if positive

-    ** or 9223372036854775808 if negative.  Note that 9223372036854665808

-    ** is 2^63. */

-    return compare2pow63(zNum)<neg;

-  }

-}

-

-/*

-** The string zNum represents an unsigned integer.  The zNum string

-** consists of one or more digit characters and is terminated by

-** a zero character.  Any stray characters in zNum result in undefined

-** behavior.

-**

-** If the unsigned integer that zNum represents will fit in a

-** 64-bit signed integer, return TRUE.  Otherwise return FALSE.

-**

-** If the negFlag parameter is true, that means that zNum really represents

-** a negative number.  (The leading "-" is omitted from zNum.)  This

-** parameter is needed to determine a boundary case.  A string

-** of "9223373036854775808" returns false if negFlag is false or true

-** if negFlag is true.

-**

-** Leading zeros are ignored.

-*/

-int sqlite3FitsIn64Bits(const char *zNum, int negFlag){

-  int i;

-  int neg = 0;

-

-  assert( zNum[0]>='0' && zNum[0]<='9' ); /* zNum is an unsigned number */

-

-  if( negFlag ) neg = 1-neg;

-  while( *zNum=='0' ){

-    zNum++;   /* Skip leading zeros.  Ticket #2454 */

-  }

-  for(i=0; zNum[i]; i++){ assert( zNum[i]>='0' && zNum[i]<='9' ); }

-  if( i<19 ){

-    /* Guaranteed to fit if less than 19 digits */

-    return 1;

-  }else if( i>19 ){

-    /* Guaranteed to be too big if greater than 19 digits */

-    return 0;

-  }else{

-    /* Compare against 2^63. */

-    return compare2pow63(zNum)<neg;

-  }

-}

-

-/*

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

-  int i, c;

-  int neg = 0;

-  if( zNum[0]=='-' ){

-    neg = 1;

-    zNum++;

-  }else if( zNum[0]=='+' ){

-    zNum++;

-  }

-  while( zNum[0]=='0' ) zNum++;

-  for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){

-    v = v*10 + c;

-  }

-

-  /* The longest decimal representation of a 32 bit integer is 10 digits:

-  **

-  **             1234567890

-  **     2^31 -> 2147483648

-  */

-  if( i>10 ){

-    return 0;

-  }

-  if( v-neg>2147483647 ){

-    return 0;

-  }

-  if( neg ){

-    v = -v;

-  }

-  *pValue = (int)v;

-  return 1;

-}

-

-/*

-** The variable-length integer encoding is as follows:

-**

-** KEY:

-**         A = 0xxxxxxx    7 bits of data and one flag bit

-**         B = 1xxxxxxx    7 bits of data and one flag bit

-**         C = xxxxxxxx    8 bits of data

-**

-**  7 bits - A

-** 14 bits - BA

-** 21 bits - BBA

-** 28 bits - BBBA

-** 35 bits - BBBBA

-** 42 bits - BBBBBA

-** 49 bits - BBBBBBA

-** 56 bits - BBBBBBBA

-** 64 bits - BBBBBBBBC

-*/

-

-/*

-** Write a 64-bit variable-length integer to memory starting at p[0].

-** The length of data write will be between 1 and 9 bytes.  The number

-** of bytes written is returned.

-**

-** A variable-length integer consists of the lower 7 bits of each byte

-** for all bytes that have the 8th bit set and one byte with the 8th

-** bit clear.  Except, if we get to the 9th byte, it stores the full

-** 8 bits and is the last byte.

-*/

-int sqlite3PutVarint(unsigned char *p, u64 v){

-  int i, j, n;

-  u8 buf[10];

-  if( v & (((u64)0xff000000)<<32) ){

-    p[8] = (u8)v;

-    v >>= 8;

-    for(i=7; i>=0; i--){

-      p[i] = (u8)((v & 0x7f) | 0x80);

-      v >>= 7;

-    }

-    return 9;

-  }    

-  n = 0;

-  do{

-    buf[n++] = (u8)((v & 0x7f) | 0x80);

-    v >>= 7;

-  }while( v!=0 );

-  buf[0] &= 0x7f;

-  assert( n<=9 );

-  for(i=0, j=n-1; j>=0; j--, i++){

-    p[i] = buf[j];

-  }

-  return n;

-}

-

-/*

-** This routine is a faster version of sqlite3PutVarint() that only

-** works for 32-bit positive integers and which is optimized for

-** the common case of small integers.  A MACRO version, putVarint32,

-** is provided which inlines the single-byte case.  All code should use

-** the MACRO version as this function assumes the single-byte case has

-** already been handled.

-*/

-int sqlite3PutVarint32(unsigned char *p, u32 v){

-#ifndef putVarint32

-  if( (v & ~0x7f)==0 ){

-    p[0] = v;

-    return 1;

-  }

-#endif

-  if( (v & ~0x3fff)==0 ){

-    p[0] = (u8)((v>>7) | 0x80);

-    p[1] = (u8)(v & 0x7f);

-    return 2;

-  }

-  return sqlite3PutVarint(p, v);

-}

-

-/*

-** Read a 64-bit variable-length integer from memory starting at p[0].

-** Return the number of bytes read.  The value is stored in *v.

-*/

-u8 sqlite3GetVarint(const unsigned char *p, u64 *v){

-  u32 a,b,s;

-

-  a = *p;

-  /* a: p0 (unmasked) */

-  if (!(a&0x80))

-  {

-    *v = a;

-    return 1;

-  }

-

-  p++;

-  b = *p;

-  /* b: p1 (unmasked) */

-  if (!(b&0x80))

-  {

-    a &= 0x7f;

-    a = a<<7;

-    a |= b;

-    *v = a;

-    return 2;

-  }

-

-  p++;

-  a = a<<14;

-  a |= *p;

-  /* a: p0<<14 | p2 (unmasked) */

-  if (!(a&0x80))

-  {

-    a &= (0x7f<<14)|(0x7f);

-    b &= 0x7f;

-    b = b<<7;

-    a |= b;

-    *v = a;

-    return 3;

-  }

-

-  /* CSE1 from below */

-  a &= (0x7f<<14)|(0x7f);

-  p++;

-  b = b<<14;

-  b |= *p;

-  /* b: p1<<14 | p3 (unmasked) */

-  if (!(b&0x80))

-  {

-    b &= (0x7f<<14)|(0x7f);

-    /* moved CSE1 up */

-    /* a &= (0x7f<<14)|(0x7f); */

-    a = a<<7;

-    a |= b;

-    *v = a;

-    return 4;

-  }

-

-  /* a: p0<<14 | p2 (masked) */

-  /* b: p1<<14 | p3 (unmasked) */

-  /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */

-  /* moved CSE1 up */

-  /* a &= (0x7f<<14)|(0x7f); */

-  b &= (0x7f<<14)|(0x7f);

-  s = a;

-  /* s: p0<<14 | p2 (masked) */

-

-  p++;

-  a = a<<14;

-  a |= *p;

-  /* a: p0<<28 | p2<<14 | p4 (unmasked) */

-  if (!(a&0x80))

-  {

-    /* we can skip these cause they were (effectively) done above in calc'ing s */

-    /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */

-    /* b &= (0x7f<<14)|(0x7f); */

-    b = b<<7;

-    a |= b;

-    s = s>>18;

-    *v = ((u64)s)<<32 | a;

-    return 5;

-  }

-

-  /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */

-  s = s<<7;

-  s |= b;

-  /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */

-

-  p++;

-  b = b<<14;

-  b |= *p;

-  /* b: p1<<28 | p3<<14 | p5 (unmasked) */

-  if (!(b&0x80))

-  {

-    /* we can skip this cause it was (effectively) done above in calc'ing s */

-    /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */

-    a &= (0x7f<<14)|(0x7f);

-    a = a<<7;

-    a |= b;

-    s = s>>18;

-    *v = ((u64)s)<<32 | a;

-    return 6;

-  }

-

-  p++;

-  a = a<<14;

-  a |= *p;

-  /* a: p2<<28 | p4<<14 | p6 (unmasked) */

-  if (!(a&0x80))

-  {

-    a &= (0x1f<<28)|(0x7f<<14)|(0x7f);

-    b &= (0x7f<<14)|(0x7f);

-    b = b<<7;

-    a |= b;

-    s = s>>11;

-    *v = ((u64)s)<<32 | a;

-    return 7;

-  }

-

-  /* CSE2 from below */

-  a &= (0x7f<<14)|(0x7f);

-  p++;

-  b = b<<14;

-  b |= *p;

-  /* b: p3<<28 | p5<<14 | p7 (unmasked) */

-  if (!(b&0x80))

-  {

-    b &= (0x1f<<28)|(0x7f<<14)|(0x7f);

-    /* moved CSE2 up */

-    /* a &= (0x7f<<14)|(0x7f); */

-    a = a<<7;

-    a |= b;

-    s = s>>4;

-    *v = ((u64)s)<<32 | a;

-    return 8;

-  }

-

-  p++;

-  a = a<<15;

-  a |= *p;

-  /* a: p4<<29 | p6<<15 | p8 (unmasked) */

-

-  /* moved CSE2 up */

-  /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */

-  b &= (0x7f<<14)|(0x7f);

-  b = b<<8;

-  a |= b;

-

-  s = s<<4;

-  b = p[-4];

-  b &= 0x7f;

-  b = b>>3;

-  s |= b;

-

-  *v = ((u64)s)<<32 | a;

-

-  return 9;

-}

-

-/*

-** Read a 32-bit variable-length integer from memory starting at p[0].

-** Return the number of bytes read.  The value is stored in *v.

-**

-** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned

-** integer, then set *v to 0xffffffff.

-**

-** A MACRO version, getVarint32, is provided which inlines the 

-** single-byte case.  All code should use the MACRO version as 

-** this function assumes the single-byte case has already been handled.

-*/

-u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){

-  u32 a,b;

-

-  /* The 1-byte case.  Overwhelmingly the most common.  Handled inline

-  ** by the getVarin32() macro */

-  a = *p;

-  /* a: p0 (unmasked) */

-#ifndef getVarint32

-  if (!(a&0x80))

-  {

-    /* Values between 0 and 127 */

-    *v = a;

-    return 1;

-  }

-#endif

-

-  /* The 2-byte case */

-  p++;

-  b = *p;

-  /* b: p1 (unmasked) */

-  if (!(b&0x80))

-  {

-    /* Values between 128 and 16383 */

-    a &= 0x7f;

-    a = a<<7;

-    *v = a | b;

-    return 2;

-  }

-

-  /* The 3-byte case */

-  p++;

-  a = a<<14;

-  a |= *p;

-  /* a: p0<<14 | p2 (unmasked) */

-  if (!(a&0x80))

-  {

-    /* Values between 16384 and 2097151 */

-    a &= (0x7f<<14)|(0x7f);

-    b &= 0x7f;

-    b = b<<7;

-    *v = a | b;

-    return 3;

-  }

-

-  /* A 32-bit varint is used to store size information in btrees.

-  ** Objects are rarely larger than 2MiB limit of a 3-byte varint.

-  ** A 3-byte varint is sufficient, for example, to record the size

-  ** of a 1048569-byte BLOB or string.

-  **

-  ** We only unroll the first 1-, 2-, and 3- byte cases.  The very

-  ** rare larger cases can be handled by the slower 64-bit varint

-  ** routine.

-  */

-#if 1

-  {

-    u64 v64;

-    u8 n;

-

-    p -= 2;

-    n = sqlite3GetVarint(p, &v64);

-    assert( n>3 && n<=9 );

-    if( (v64 & SQLITE_MAX_U32)!=v64 ){

-      *v = 0xffffffff;

-    }else{

-      *v = (u32)v64;

-    }

-    return n;

-  }

-

-#else

-  /* For following code (kept for historical record only) shows an

-  ** unrolling for the 3- and 4-byte varint cases.  This code is

-  ** slightly faster, but it is also larger and much harder to test.

-  */

-  p++;

-  b = b<<14;

-  b |= *p;

-  /* b: p1<<14 | p3 (unmasked) */

-  if (!(b&0x80))

-  {

-    /* Values between 2097152 and 268435455 */

-    b &= (0x7f<<14)|(0x7f);

-    a &= (0x7f<<14)|(0x7f);

-    a = a<<7;

-    *v = a | b;

-    return 4;

-  }

-

-  p++;

-  a = a<<14;

-  a |= *p;

-  /* a: p0<<28 | p2<<14 | p4 (unmasked) */

-  if (!(a&0x80))

-  {

-    /* Walues  between 268435456 and 34359738367 */

-    a &= (0x1f<<28)|(0x7f<<14)|(0x7f);

-    b &= (0x1f<<28)|(0x7f<<14)|(0x7f);

-    b = b<<7;

-    *v = a | b;

-    return 5;

-  }

-

-  /* We can only reach this point when reading a corrupt database

-  ** file.  In that case we are not in any hurry.  Use the (relatively

-  ** slow) general-purpose sqlite3GetVarint() routine to extract the

-  ** value. */

-  {

-    u64 v64;

-    u8 n;

-

-    p -= 4;

-    n = sqlite3GetVarint(p, &v64);

-    assert( n>5 && n<=9 );

-    *v = (u32)v64;

-    return n;

-  }

-#endif

-}

-

-/*

-** Return the number of bytes that will be needed to store the given

-** 64-bit integer.

-*/

-int sqlite3VarintLen(u64 v){

-  int i = 0;

-  do{

-    i++;

-    v >>= 7;

-  }while( v!=0 && ALWAYS(i<9) );

-  return i;

-}

-

-

-/*

-** Read or write a four-byte big-endian integer value.

-*/

-u32 sqlite3Get4byte(const u8 *p){

-  return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];

-}

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

-/*

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

-*/

-static u8 hexToInt(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);

-}

-#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */

-

-#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.

-*/

-void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){

-  char *zBlob;

-  int i;

-

-  zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);

-  n--;

-  if( zBlob ){

-    for(i=0; i<n; i+=2){

-      zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);

-    }

-    zBlob[i/2] = 0;

-  }

-  return zBlob;

-}

-#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */

-

-

-/*

-** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.

-** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN

-** when this routine is called.

-**

-** This routine is called when entering an SQLite API.  The SQLITE_MAGIC_OPEN

-** value indicates that the database connection passed into the API is

-** open and is not being used by another thread.  By changing the value

-** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.

-** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN

-** when the API exits. 

-**

-** This routine is a attempt to detect if two threads use the

-** same sqlite* pointer at the same time.  There is a race 

-** condition so it is possible that the error is not detected.

-** But usually the problem will be seen.  The result will be an

-** error which can be used to debug the application that is

-** using SQLite incorrectly.

-**

-** Ticket #202:  If db->magic is not a valid open value, take care not

-** to modify the db structure at all.  It could be that db is a stale

-** pointer.  In other words, it could be that there has been a prior

-** call to sqlite3_close(db) and db has been deallocated.  And we do

-** not want to write into deallocated memory.

-*/

-#ifdef SQLITE_DEBUG

-int sqlite3SafetyOn(sqlite3 *db){

-  if( db->magic==SQLITE_MAGIC_OPEN ){

-    db->magic = SQLITE_MAGIC_BUSY;

-    assert( sqlite3_mutex_held(db->mutex) );

-    return 0;

-  }else if( db->magic==SQLITE_MAGIC_BUSY ){

-    db->magic = SQLITE_MAGIC_ERROR;

-    db->u1.isInterrupted = 1;

-  }

-  return 1;

-}

-#endif

-

-/*

-** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.

-** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY

-** when this routine is called.

-*/

-#ifdef SQLITE_DEBUG

-int sqlite3SafetyOff(sqlite3 *db){

-  if( db->magic==SQLITE_MAGIC_BUSY ){

-    db->magic = SQLITE_MAGIC_OPEN;

-    assert( sqlite3_mutex_held(db->mutex) );

-    return 0;

-  }else{

-    db->magic = SQLITE_MAGIC_ERROR;

-    db->u1.isInterrupted = 1;

-    return 1;

-  }

-}

-#endif

-

-/*

-** Check to make sure we have a valid db pointer.  This test is not

-** foolproof but it does provide some measure of protection against

-** misuse of the interface such as passing in db pointers that are

-** NULL or which have been previously closed.  If this routine returns

-** 1 it means that the db pointer is valid and 0 if it should not be

-** dereferenced for any reason.  The calling function should invoke

-** SQLITE_MISUSE immediately.

-**

-** sqlite3SafetyCheckOk() requires that the db pointer be valid for

-** use.  sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to

-** open properly and is not fit for general use but which can be

-** used as an argument to sqlite3_errmsg() or sqlite3_close().

-*/

-int sqlite3SafetyCheckOk(sqlite3 *db){

-  u32 magic;

-  if( db==0 ) return 0;

-  magic = db->magic;

-  if( magic!=SQLITE_MAGIC_OPEN 

-#ifdef SQLITE_DEBUG

-     && magic!=SQLITE_MAGIC_BUSY

-#endif

-  ){

-    return 0;

-  }else{

-    return 1;

-  }

-}

-int sqlite3SafetyCheckSickOrOk(sqlite3 *db){

-  u32 magic;

-  magic = db->magic;

-  if( magic!=SQLITE_MAGIC_SICK &&

-      magic!=SQLITE_MAGIC_OPEN &&

-      magic!=SQLITE_MAGIC_BUSY ) return 0;

-  return 1;

-}

+/*
+** 2001 September 15
+**
+** 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.
+**
+*************************************************************************
+** Utility functions used throughout sqlite.
+**
+** This file contains functions for allocating memory, comparing
+** strings, and stuff like that.
+**
+*/
+#include "sqliteInt.h"
+#include <stdarg.h>
+#ifdef SQLITE_HAVE_ISNAN
+# include <math.h>
+#endif
+
+/*
+** Routine needed to support the testcase() macro.
+*/
+#ifdef SQLITE_COVERAGE_TEST
+void sqlite3Coverage(int x){
+  static int dummy = 0;
+  dummy += x;
+}
+#endif
+
+/*
+** Return true if the floating point value is Not a Number (NaN).
+**
+** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
+** Otherwise, we have our own implementation that works on most systems.
+*/
+int sqlite3IsNaN(double x){
+  int rc;   /* The value return */
+#if !defined(SQLITE_HAVE_ISNAN)
+  /*
+  ** Systems that support the isnan() library function should probably
+  ** make use of it by compiling with -DSQLITE_HAVE_ISNAN.  But we have
+  ** found that many systems do not have a working isnan() function so
+  ** this implementation is provided as an alternative.
+  **
+  ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
+  ** On the other hand, the use of -ffast-math comes with the following
+  ** warning:
+  **
+  **      This option [-ffast-math] should never be turned on by any
+  **      -O option since it can result in incorrect output for programs
+  **      which depend on an exact implementation of IEEE or ISO 
+  **      rules/specifications for math functions.
+  **
+  ** Under MSVC, this NaN test may fail if compiled with a floating-
+  ** point precision mode other than /fp:precise.  From the MSDN 
+  ** documentation:
+  **
+  **      The compiler [with /fp:precise] will properly handle comparisons 
+  **      involving NaN. For example, x != x evaluates to true if x is NaN 
+  **      ...
+  */
+#ifdef __FAST_MATH__
+# error SQLite will not work correctly with the -ffast-math option of GCC.
+#endif
+  volatile double y = x;
+  volatile double z = y;
+  rc = (y!=z);
+#else  /* if defined(SQLITE_HAVE_ISNAN) */
+  rc = isnan(x);
+#endif /* SQLITE_HAVE_ISNAN */
+  testcase( rc );
+  return rc;
+}
+
+/*
+** Compute a string length that is limited to what can be stored in
+** lower 30 bits of a 32-bit signed integer.
+**
+** The value returned will never be negative.  Nor will it ever be greater
+** than the actual length of the string.  For very long strings (greater
+** than 1GiB) the value returned might be less than the true string length.
+*/
+int sqlite3Strlen30(const char *z){
+  const char *z2 = z;
+  if( z==0 ) return 0;
+  while( *z2 ){ z2++; }
+  return 0x3fffffff & (int)(z2 - z);
+}
+
+/*
+** Set the most recent error code and error string for the sqlite
+** handle "db". The error code is set to "err_code".
+**
+** If it is not NULL, string zFormat specifies the format of the
+** error string in the style of the printf functions: The following
+** format characters are allowed:
+**
+**      %s      Insert a string
+**      %z      A string that should be freed after use
+**      %d      Insert an integer
+**      %T      Insert a token
+**      %S      Insert the first element of a SrcList
+**
+** zFormat and any string tokens that follow it are assumed to be
+** encoded in UTF-8.
+**
+** To clear the most recent error for sqlite handle "db", sqlite3Error
+** should be called with err_code set to SQLITE_OK and zFormat set
+** to NULL.
+*/
+void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
+  if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
+    db->errCode = err_code;
+    if( zFormat ){
+      char *z;
+      va_list ap;
+      va_start(ap, zFormat);
+      z = sqlite3VMPrintf(db, zFormat, ap);
+      va_end(ap);
+      sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
+    }else{
+      sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
+    }
+  }
+}
+
+/*
+** Add an error message to pParse->zErrMsg and increment pParse->nErr.
+** The following formatting characters are allowed:
+**
+**      %s      Insert a string
+**      %z      A string that should be freed after use
+**      %d      Insert an integer
+**      %T      Insert a token
+**      %S      Insert the first element of a SrcList
+**
+** This function should be used to report any error that occurs whilst
+** compiling an SQL statement (i.e. within sqlite3_prepare()). The
+** last thing the sqlite3_prepare() function does is copy the error
+** stored by this function into the database handle using sqlite3Error().
+** Function sqlite3Error() should be used during statement execution
+** (sqlite3_step() etc.).
+*/
+void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
+  va_list ap;
+  sqlite3 *db = pParse->db;
+  pParse->nErr++;
+  sqlite3DbFree(db, pParse->zErrMsg);
+  va_start(ap, zFormat);
+  pParse->zErrMsg = sqlite3VMPrintf(db, zFormat, ap);
+  va_end(ap);
+  pParse->rc = SQLITE_ERROR;
+}
+
+/*
+** Clear the error message in pParse, if any
+*/
+void sqlite3ErrorClear(Parse *pParse){
+  sqlite3DbFree(pParse->db, pParse->zErrMsg);
+  pParse->zErrMsg = 0;
+  pParse->nErr = 0;
+}
+
+/*
+** Convert an SQL-style quoted string into a normal string by removing
+** the quote characters.  The conversion is done in-place.  If the
+** input does not begin with a quote character, then this routine
+** is a no-op.
+**
+** The input string must be zero-terminated.  A new zero-terminator
+** is added to the dequoted string.
+**
+** The return value is -1 if no dequoting occurs or the length of the
+** dequoted string, exclusive of the zero terminator, if dequoting does
+** occur.
+**
+** 2002-Feb-14: This routine is extended to remove MS-Access style
+** brackets from around identifers.  For example:  "[a-b-c]" becomes
+** "a-b-c".
+*/
+int sqlite3Dequote(char *z){
+  char quote;
+  int i, j;
+  if( z==0 ) return -1;
+  quote = z[0];
+  switch( quote ){
+    case '\'':  break;
+    case '"':   break;
+    case '`':   break;                /* For MySQL compatibility */
+    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
+    default:    return -1;
+  }
+  for(i=1, j=0; ALWAYS(z[i]); i++){
+    if( z[i]==quote ){
+      if( z[i+1]==quote ){
+        z[j++] = quote;
+        i++;
+      }else{
+        break;
+      }
+    }else{
+      z[j++] = z[i];
+    }
+  }
+  z[j] = 0;
+  return j;
+}
+
+/* Convenient short-hand */
+#define UpperToLower sqlite3UpperToLower
+
+/*
+** Some systems have stricmp().  Others have strcasecmp().  Because
+** there is no consistency, we will define our own.
+*/
+int sqlite3StrICmp(const char *zLeft, const char *zRight){
+  register unsigned char *a, *b;
+  a = (unsigned char *)zLeft;
+  b = (unsigned char *)zRight;
+  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
+  return UpperToLower[*a] - UpperToLower[*b];
+}
+int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
+  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];
+}
+
+/*
+** Return TRUE if z is a pure numeric string.  Return FALSE and leave
+** *realnum unchanged if the string contains any character which is not
+** part of a number.
+**
+** If the string is pure numeric, set *realnum to TRUE if the string
+** contains the '.' character or an "E+000" style exponentiation suffix.
+** Otherwise set *realnum to FALSE.  Note that just becaue *realnum is
+** false does not mean that the number can be successfully converted into
+** an integer - it might be too big.
+**
+** An empty string is considered non-numeric.
+*/
+int sqlite3IsNumber(const char *z, int *realnum, u8 enc){
+  int incr = (enc==SQLITE_UTF8?1:2);
+  if( enc==SQLITE_UTF16BE ) z++;
+  if( *z=='-' || *z=='+' ) z += incr;
+  if( !sqlite3Isdigit(*z) ){
+    return 0;
+  }
+  z += incr;
+  *realnum = 0;
+  while( sqlite3Isdigit(*z) ){ z += incr; }
+  if( *z=='.' ){
+    z += incr;
+    if( !sqlite3Isdigit(*z) ) return 0;
+    while( sqlite3Isdigit(*z) ){ z += incr; }
+    *realnum = 1;
+  }
+  if( *z=='e' || *z=='E' ){
+    z += incr;
+    if( *z=='+' || *z=='-' ) z += incr;
+    if( !sqlite3Isdigit(*z) ) return 0;
+    while( sqlite3Isdigit(*z) ){ z += incr; }
+    *realnum = 1;
+  }
+  return *z==0;
+}
+
+/*
+** The string z[] is an ASCII representation of a real number.
+** Convert this string to a double.
+**
+** This routine assumes that z[] really is a valid number.  If it
+** is not, the result is undefined.
+**
+** This routine is used instead of the library atof() function because
+** the library atof() might want to use "," as the decimal point instead
+** of "." depending on how locale is set.  But that would cause problems
+** for SQL.  So this routine always uses "." regardless of locale.
+*/
+int sqlite3AtoF(const char *z, double *pResult){
+#ifndef SQLITE_OMIT_FLOATING_POINT
+  const char *zBegin = z;
+  /* sign * significand * (10 ^ (esign * exponent)) */
+  int sign = 1;   /* sign of significand */
+  i64 s = 0;      /* significand */
+  int d = 0;      /* adjust exponent for shifting decimal point */
+  int esign = 1;  /* sign of exponent */
+  int e = 0;      /* exponent */
+  double result;
+  int nDigits = 0;
+
+  /* skip leading spaces */
+  while( sqlite3Isspace(*z) ) z++;
+  /* get sign of significand */
+  if( *z=='-' ){
+    sign = -1;
+    z++;
+  }else if( *z=='+' ){
+    z++;
+  }
+  /* skip leading zeroes */
+  while( z[0]=='0' ) z++, nDigits++;
+
+  /* copy max significant digits to significand */
+  while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
+    s = s*10 + (*z - '0');
+    z++, nDigits++;
+  }
+  /* skip non-significant significand digits
+  ** (increase exponent by d to shift decimal left) */
+  while( sqlite3Isdigit(*z) ) z++, nDigits++, d++;
+
+  /* if decimal point is present */
+  if( *z=='.' ){
+    z++;
+    /* copy digits from after decimal to significand
+    ** (decrease exponent by d to shift decimal right) */
+    while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
+      s = s*10 + (*z - '0');
+      z++, nDigits++, d--;
+    }
+    /* skip non-significant digits */
+    while( sqlite3Isdigit(*z) ) z++, nDigits++;
+  }
+
+  /* if exponent is present */
+  if( *z=='e' || *z=='E' ){
+    z++;
+    /* get sign of exponent */
+    if( *z=='-' ){
+      esign = -1;
+      z++;
+    }else if( *z=='+' ){
+      z++;
+    }
+    /* copy digits to exponent */
+    while( sqlite3Isdigit(*z) ){
+      e = e*10 + (*z - '0');
+      z++;
+    }
+  }
+
+  /* adjust exponent by d, and update sign */
+  e = (e*esign) + d;
+  if( e<0 ) {
+    esign = -1;
+    e *= -1;
+  } else {
+    esign = 1;
+  }
+
+  /* if 0 significand */
+  if( !s ) {
+    /* In the IEEE 754 standard, zero is signed.
+    ** Add the sign if we've seen at least one digit */
+    result = (sign<0 && nDigits) ? -(double)0 : (double)0;
+  } else {
+    /* attempt to reduce exponent */
+    if( esign>0 ){
+      while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
+    }else{
+      while( !(s%10) && e>0 ) e--,s/=10;
+    }
+
+    /* adjust the sign of significand */
+    s = sign<0 ? -s : s;
+
+    /* if exponent, scale significand as appropriate
+    ** and store in result. */
+    if( e ){
+      double scale = 1.0;
+      /* attempt to handle extremely small/large numbers better */
+      if( e>307 && e<342 ){
+        while( e%308 ) { scale *= 1.0e+1; e -= 1; }
+        if( esign<0 ){
+          result = s / scale;
+          result /= 1.0e+308;
+        }else{
+          result = s * scale;
+          result *= 1.0e+308;
+        }
+      }else{
+        /* 1.0e+22 is the largest power of 10 than can be 
+        ** represented exactly. */
+        while( e%22 ) { scale *= 1.0e+1; e -= 1; }
+        while( e>0 ) { scale *= 1.0e+22; e -= 22; }
+        if( esign<0 ){
+          result = s / scale;
+        }else{
+          result = s * scale;
+        }
+      }
+    } else {
+      result = (double)s;
+    }
+  }
+
+  /* store the result */
+  *pResult = result;
+
+  /* return number of characters used */
+  return (int)(z - zBegin);
+#else
+  return sqlite3Atoi64(z, pResult);
+#endif /* SQLITE_OMIT_FLOATING_POINT */
+}
+
+/*
+** Compare the 19-character string zNum against the text representation
+** value 2^63:  9223372036854775808.  Return negative, zero, or positive
+** if zNum is less than, equal to, or greater than the string.
+**
+** Unlike memcmp() this routine is guaranteed to return the difference
+** in the values of the last digit if the only difference is in the
+** last digit.  So, for example,
+**
+**      compare2pow63("9223372036854775800")
+**
+** will return -8.
+*/
+static int compare2pow63(const char *zNum){
+  int c;
+  c = memcmp(zNum,"922337203685477580",18)*10;
+  if( c==0 ){
+    c = zNum[18] - '8';
+  }
+  return c;
+}
+
+
+/*
+** Return TRUE if zNum is a 64-bit signed integer and write
+** the value of the integer into *pNum.  If zNum is not an integer
+** or is an integer that is too large to be expressed with 64 bits,
+** then return false.
+**
+** When this routine was originally written it dealt with only
+** 32-bit numbers.  At that time, it was much faster than the
+** atoi() library routine in RedHat 7.2.
+*/
+int sqlite3Atoi64(const char *zNum, i64 *pNum){
+  i64 v = 0;
+  int neg;
+  int i, c;
+  const char *zStart;
+  while( sqlite3Isspace(*zNum) ) zNum++;
+  if( *zNum=='-' ){
+    neg = 1;
+    zNum++;
+  }else if( *zNum=='+' ){
+    neg = 0;
+    zNum++;
+  }else{
+    neg = 0;
+  }
+  zStart = zNum;
+  while( zNum[0]=='0' ){ zNum++; } /* Skip over leading zeros. Ticket #2454 */
+  for(i=0; (c=zNum[i])>='0' && c<='9'; i++){
+    v = v*10 + c - '0';
+  }
+  *pNum = neg ? -v : v;
+  if( c!=0 || (i==0 && zStart==zNum) || i>19 ){
+    /* zNum is empty or contains non-numeric text or is longer
+    ** than 19 digits (thus guaranting that it is too large) */
+    return 0;
+  }else if( i<19 ){
+    /* Less than 19 digits, so we know that it fits in 64 bits */
+    return 1;
+  }else{
+    /* 19-digit numbers must be no larger than 9223372036854775807 if positive
+    ** or 9223372036854775808 if negative.  Note that 9223372036854665808
+    ** is 2^63. */
+    return compare2pow63(zNum)<neg;
+  }
+}
+
+/*
+** The string zNum represents an unsigned integer.  The zNum string
+** consists of one or more digit characters and is terminated by
+** a zero character.  Any stray characters in zNum result in undefined
+** behavior.
+**
+** If the unsigned integer that zNum represents will fit in a
+** 64-bit signed integer, return TRUE.  Otherwise return FALSE.
+**
+** If the negFlag parameter is true, that means that zNum really represents
+** a negative number.  (The leading "-" is omitted from zNum.)  This
+** parameter is needed to determine a boundary case.  A string
+** of "9223373036854775808" returns false if negFlag is false or true
+** if negFlag is true.
+**
+** Leading zeros are ignored.
+*/
+int sqlite3FitsIn64Bits(const char *zNum, int negFlag){
+  int i;
+  int neg = 0;
+
+  assert( zNum[0]>='0' && zNum[0]<='9' ); /* zNum is an unsigned number */
+
+  if( negFlag ) neg = 1-neg;
+  while( *zNum=='0' ){
+    zNum++;   /* Skip leading zeros.  Ticket #2454 */
+  }
+  for(i=0; zNum[i]; i++){ assert( zNum[i]>='0' && zNum[i]<='9' ); }
+  if( i<19 ){
+    /* Guaranteed to fit if less than 19 digits */
+    return 1;
+  }else if( i>19 ){
+    /* Guaranteed to be too big if greater than 19 digits */
+    return 0;
+  }else{
+    /* Compare against 2^63. */
+    return compare2pow63(zNum)<neg;
+  }
+}
+
+/*
+** 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;
+  int i, c;
+  int neg = 0;
+  if( zNum[0]=='-' ){
+    neg = 1;
+    zNum++;
+  }else if( zNum[0]=='+' ){
+    zNum++;
+  }
+  while( zNum[0]=='0' ) zNum++;
+  for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
+    v = v*10 + c;
+  }
+
+  /* The longest decimal representation of a 32 bit integer is 10 digits:
+  **
+  **             1234567890
+  **     2^31 -> 2147483648
+  */
+  if( i>10 ){
+    return 0;
+  }
+  if( v-neg>2147483647 ){
+    return 0;
+  }
+  if( neg ){
+    v = -v;
+  }
+  *pValue = (int)v;
+  return 1;
+}
+
+/*
+** The variable-length integer encoding is as follows:
+**
+** KEY:
+**         A = 0xxxxxxx    7 bits of data and one flag bit
+**         B = 1xxxxxxx    7 bits of data and one flag bit
+**         C = xxxxxxxx    8 bits of data
+**
+**  7 bits - A
+** 14 bits - BA
+** 21 bits - BBA
+** 28 bits - BBBA
+** 35 bits - BBBBA
+** 42 bits - BBBBBA
+** 49 bits - BBBBBBA
+** 56 bits - BBBBBBBA
+** 64 bits - BBBBBBBBC
+*/
+
+/*
+** Write a 64-bit variable-length integer to memory starting at p[0].
+** The length of data write will be between 1 and 9 bytes.  The number
+** of bytes written is returned.
+**
+** A variable-length integer consists of the lower 7 bits of each byte
+** for all bytes that have the 8th bit set and one byte with the 8th
+** bit clear.  Except, if we get to the 9th byte, it stores the full
+** 8 bits and is the last byte.
+*/
+int sqlite3PutVarint(unsigned char *p, u64 v){
+  int i, j, n;
+  u8 buf[10];
+  if( v & (((u64)0xff000000)<<32) ){
+    p[8] = (u8)v;
+    v >>= 8;
+    for(i=7; i>=0; i--){
+      p[i] = (u8)((v & 0x7f) | 0x80);
+      v >>= 7;
+    }
+    return 9;
+  }    
+  n = 0;
+  do{
+    buf[n++] = (u8)((v & 0x7f) | 0x80);
+    v >>= 7;
+  }while( v!=0 );
+  buf[0] &= 0x7f;
+  assert( n<=9 );
+  for(i=0, j=n-1; j>=0; j--, i++){
+    p[i] = buf[j];
+  }
+  return n;
+}
+
+/*
+** This routine is a faster version of sqlite3PutVarint() that only
+** works for 32-bit positive integers and which is optimized for
+** the common case of small integers.  A MACRO version, putVarint32,
+** is provided which inlines the single-byte case.  All code should use
+** the MACRO version as this function assumes the single-byte case has
+** already been handled.
+*/
+int sqlite3PutVarint32(unsigned char *p, u32 v){
+#ifndef putVarint32
+  if( (v & ~0x7f)==0 ){
+    p[0] = v;
+    return 1;
+  }
+#endif
+  if( (v & ~0x3fff)==0 ){
+    p[0] = (u8)((v>>7) | 0x80);
+    p[1] = (u8)(v & 0x7f);
+    return 2;
+  }
+  return sqlite3PutVarint(p, v);
+}
+
+/*
+** Read a 64-bit variable-length integer from memory starting at p[0].
+** Return the number of bytes read.  The value is stored in *v.
+*/
+u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
+  u32 a,b,s;
+
+  a = *p;
+  /* a: p0 (unmasked) */
+  if (!(a&0x80))
+  {
+    *v = a;
+    return 1;
+  }
+
+  p++;
+  b = *p;
+  /* b: p1 (unmasked) */
+  if (!(b&0x80))
+  {
+    a &= 0x7f;
+    a = a<<7;
+    a |= b;
+    *v = a;
+    return 2;
+  }
+
+  p++;
+  a = a<<14;
+  a |= *p;
+  /* a: p0<<14 | p2 (unmasked) */
+  if (!(a&0x80))
+  {
+    a &= (0x7f<<14)|(0x7f);
+    b &= 0x7f;
+    b = b<<7;
+    a |= b;
+    *v = a;
+    return 3;
+  }
+
+  /* CSE1 from below */
+  a &= (0x7f<<14)|(0x7f);
+  p++;
+  b = b<<14;
+  b |= *p;
+  /* b: p1<<14 | p3 (unmasked) */
+  if (!(b&0x80))
+  {
+    b &= (0x7f<<14)|(0x7f);
+    /* moved CSE1 up */
+    /* a &= (0x7f<<14)|(0x7f); */
+    a = a<<7;
+    a |= b;
+    *v = a;
+    return 4;
+  }
+
+  /* a: p0<<14 | p2 (masked) */
+  /* b: p1<<14 | p3 (unmasked) */
+  /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
+  /* moved CSE1 up */
+  /* a &= (0x7f<<14)|(0x7f); */
+  b &= (0x7f<<14)|(0x7f);
+  s = a;
+  /* s: p0<<14 | p2 (masked) */
+
+  p++;
+  a = a<<14;
+  a |= *p;
+  /* a: p0<<28 | p2<<14 | p4 (unmasked) */
+  if (!(a&0x80))
+  {
+    /* we can skip these cause they were (effectively) done above in calc'ing s */
+    /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
+    /* b &= (0x7f<<14)|(0x7f); */
+    b = b<<7;
+    a |= b;
+    s = s>>18;
+    *v = ((u64)s)<<32 | a;
+    return 5;
+  }
+
+  /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
+  s = s<<7;
+  s |= b;
+  /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
+
+  p++;
+  b = b<<14;
+  b |= *p;
+  /* b: p1<<28 | p3<<14 | p5 (unmasked) */
+  if (!(b&0x80))
+  {
+    /* we can skip this cause it was (effectively) done above in calc'ing s */
+    /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
+    a &= (0x7f<<14)|(0x7f);
+    a = a<<7;
+    a |= b;
+    s = s>>18;
+    *v = ((u64)s)<<32 | a;
+    return 6;
+  }
+
+  p++;
+  a = a<<14;
+  a |= *p;
+  /* a: p2<<28 | p4<<14 | p6 (unmasked) */
+  if (!(a&0x80))
+  {
+    a &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+    b &= (0x7f<<14)|(0x7f);
+    b = b<<7;
+    a |= b;
+    s = s>>11;
+    *v = ((u64)s)<<32 | a;
+    return 7;
+  }
+
+  /* CSE2 from below */
+  a &= (0x7f<<14)|(0x7f);
+  p++;
+  b = b<<14;
+  b |= *p;
+  /* b: p3<<28 | p5<<14 | p7 (unmasked) */
+  if (!(b&0x80))
+  {
+    b &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+    /* moved CSE2 up */
+    /* a &= (0x7f<<14)|(0x7f); */
+    a = a<<7;
+    a |= b;
+    s = s>>4;
+    *v = ((u64)s)<<32 | a;
+    return 8;
+  }
+
+  p++;
+  a = a<<15;
+  a |= *p;
+  /* a: p4<<29 | p6<<15 | p8 (unmasked) */
+
+  /* moved CSE2 up */
+  /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
+  b &= (0x7f<<14)|(0x7f);
+  b = b<<8;
+  a |= b;
+
+  s = s<<4;
+  b = p[-4];
+  b &= 0x7f;
+  b = b>>3;
+  s |= b;
+
+  *v = ((u64)s)<<32 | a;
+
+  return 9;
+}
+
+/*
+** Read a 32-bit variable-length integer from memory starting at p[0].
+** Return the number of bytes read.  The value is stored in *v.
+**
+** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
+** integer, then set *v to 0xffffffff.
+**
+** A MACRO version, getVarint32, is provided which inlines the 
+** single-byte case.  All code should use the MACRO version as 
+** this function assumes the single-byte case has already been handled.
+*/
+u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
+  u32 a,b;
+
+  /* The 1-byte case.  Overwhelmingly the most common.  Handled inline
+  ** by the getVarin32() macro */
+  a = *p;
+  /* a: p0 (unmasked) */
+#ifndef getVarint32
+  if (!(a&0x80))
+  {
+    /* Values between 0 and 127 */
+    *v = a;
+    return 1;
+  }
+#endif
+
+  /* The 2-byte case */
+  p++;
+  b = *p;
+  /* b: p1 (unmasked) */
+  if (!(b&0x80))
+  {
+    /* Values between 128 and 16383 */
+    a &= 0x7f;
+    a = a<<7;
+    *v = a | b;
+    return 2;
+  }
+
+  /* The 3-byte case */
+  p++;
+  a = a<<14;
+  a |= *p;
+  /* a: p0<<14 | p2 (unmasked) */
+  if (!(a&0x80))
+  {
+    /* Values between 16384 and 2097151 */
+    a &= (0x7f<<14)|(0x7f);
+    b &= 0x7f;
+    b = b<<7;
+    *v = a | b;
+    return 3;
+  }
+
+  /* A 32-bit varint is used to store size information in btrees.
+  ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
+  ** A 3-byte varint is sufficient, for example, to record the size
+  ** of a 1048569-byte BLOB or string.
+  **
+  ** We only unroll the first 1-, 2-, and 3- byte cases.  The very
+  ** rare larger cases can be handled by the slower 64-bit varint
+  ** routine.
+  */
+#if 1
+  {
+    u64 v64;
+    u8 n;
+
+    p -= 2;
+    n = sqlite3GetVarint(p, &v64);
+    assert( n>3 && n<=9 );
+    if( (v64 & SQLITE_MAX_U32)!=v64 ){
+      *v = 0xffffffff;
+    }else{
+      *v = (u32)v64;
+    }
+    return n;
+  }
+
+#else
+  /* For following code (kept for historical record only) shows an
+  ** unrolling for the 3- and 4-byte varint cases.  This code is
+  ** slightly faster, but it is also larger and much harder to test.
+  */
+  p++;
+  b = b<<14;
+  b |= *p;
+  /* b: p1<<14 | p3 (unmasked) */
+  if (!(b&0x80))
+  {
+    /* Values between 2097152 and 268435455 */
+    b &= (0x7f<<14)|(0x7f);
+    a &= (0x7f<<14)|(0x7f);
+    a = a<<7;
+    *v = a | b;
+    return 4;
+  }
+
+  p++;
+  a = a<<14;
+  a |= *p;
+  /* a: p0<<28 | p2<<14 | p4 (unmasked) */
+  if (!(a&0x80))
+  {
+    /* Walues  between 268435456 and 34359738367 */
+    a &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+    b &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+    b = b<<7;
+    *v = a | b;
+    return 5;
+  }
+
+  /* We can only reach this point when reading a corrupt database
+  ** file.  In that case we are not in any hurry.  Use the (relatively
+  ** slow) general-purpose sqlite3GetVarint() routine to extract the
+  ** value. */
+  {
+    u64 v64;
+    u8 n;
+
+    p -= 4;
+    n = sqlite3GetVarint(p, &v64);
+    assert( n>5 && n<=9 );
+    *v = (u32)v64;
+    return n;
+  }
+#endif
+}
+
+/*
+** Return the number of bytes that will be needed to store the given
+** 64-bit integer.
+*/
+int sqlite3VarintLen(u64 v){
+  int i = 0;
+  do{
+    i++;
+    v >>= 7;
+  }while( v!=0 && ALWAYS(i<9) );
+  return i;
+}
+
+
+/*
+** Read or write a four-byte big-endian integer value.
+*/
+u32 sqlite3Get4byte(const u8 *p){
+  return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+}
+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)
+/*
+** 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
+*/
+static u8 hexToInt(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);
+}
+#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
+
+#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.
+*/
+void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
+  char *zBlob;
+  int i;
+
+  zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
+  n--;
+  if( zBlob ){
+    for(i=0; i<n; i+=2){
+      zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);
+    }
+    zBlob[i/2] = 0;
+  }
+  return zBlob;
+}
+#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
+
+
+/*
+** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.
+** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN
+** when this routine is called.
+**
+** This routine is called when entering an SQLite API.  The SQLITE_MAGIC_OPEN
+** value indicates that the database connection passed into the API is
+** open and is not being used by another thread.  By changing the value
+** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.
+** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN
+** when the API exits. 
+**
+** This routine is a attempt to detect if two threads use the
+** same sqlite* pointer at the same time.  There is a race 
+** condition so it is possible that the error is not detected.
+** But usually the problem will be seen.  The result will be an
+** error which can be used to debug the application that is
+** using SQLite incorrectly.
+**
+** Ticket #202:  If db->magic is not a valid open value, take care not
+** to modify the db structure at all.  It could be that db is a stale
+** pointer.  In other words, it could be that there has been a prior
+** call to sqlite3_close(db) and db has been deallocated.  And we do
+** not want to write into deallocated memory.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3SafetyOn(sqlite3 *db){
+  if( db->magic==SQLITE_MAGIC_OPEN ){
+    db->magic = SQLITE_MAGIC_BUSY;
+    assert( sqlite3_mutex_held(db->mutex) );
+    return 0;
+  }else if( db->magic==SQLITE_MAGIC_BUSY ){
+    db->magic = SQLITE_MAGIC_ERROR;
+    db->u1.isInterrupted = 1;
+  }
+  return 1;
+}
+#endif
+
+/*
+** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.
+** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
+** when this routine is called.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3SafetyOff(sqlite3 *db){
+  if( db->magic==SQLITE_MAGIC_BUSY ){
+    db->magic = SQLITE_MAGIC_OPEN;
+    assert( sqlite3_mutex_held(db->mutex) );
+    return 0;
+  }else{
+    db->magic = SQLITE_MAGIC_ERROR;
+    db->u1.isInterrupted = 1;
+    return 1;
+  }
+}
+#endif
+
+/*
+** Check to make sure we have a valid db pointer.  This test is not
+** foolproof but it does provide some measure of protection against
+** misuse of the interface such as passing in db pointers that are
+** NULL or which have been previously closed.  If this routine returns
+** 1 it means that the db pointer is valid and 0 if it should not be
+** dereferenced for any reason.  The calling function should invoke
+** SQLITE_MISUSE immediately.
+**
+** sqlite3SafetyCheckOk() requires that the db pointer be valid for
+** use.  sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
+** open properly and is not fit for general use but which can be
+** used as an argument to sqlite3_errmsg() or sqlite3_close().
+*/
+int sqlite3SafetyCheckOk(sqlite3 *db){
+  u32 magic;
+  if( db==0 ) return 0;
+  magic = db->magic;
+  if( magic!=SQLITE_MAGIC_OPEN 
+#ifdef SQLITE_DEBUG
+     && magic!=SQLITE_MAGIC_BUSY
+#endif
+  ){
+    return 0;
+  }else{
+    return 1;
+  }
+}
+int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
+  u32 magic;
+  magic = db->magic;
+  if( magic!=SQLITE_MAGIC_SICK &&
+      magic!=SQLITE_MAGIC_OPEN &&
+      magic!=SQLITE_MAGIC_BUSY ) return 0;
+  return 1;
+}