1 /*

     2 ** 2001 September 15

     3 **

     4 ** The author disclaims copyright to this source code.  In place of

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

     8 **    May you find forgiveness for yourself and forgive others.

     9 **    May you share freely, never taking more than you give.

    10 **

    11 *************************************************************************

    12 ** Utility functions used throughout sqlite.

    13 **

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

    15 ** strings, and stuff like that.

    16 **

    17 ** $Id: util.cpp 1282 2008-11-13 09:31:33Z LarsPson $

    18 */

    19 #include "sqliteInt.h"

    20 #include <stdarg.h>

    21 #include <ctype.h>

    22 

    23 

    24 /*

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

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

    27 **

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

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

    30 ** format characters are allowed:

    31 **

    32 **      %s      Insert a string

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

    34 **      %d      Insert an integer

    35 **      %T      Insert a token

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

    37 **

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

    39 ** encoded in UTF-8.

    40 **

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

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

    43 ** to NULL.

    44 */

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

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

    47     db->errCode = err_code;

    48     if( zFormat ){

    49       char *z;

    50       va_list ap;

    51       va_start(ap, zFormat);

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

    53       va_end(ap);

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

    55     }else{

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

    57     }

    58   }

    59 }

    60 

    61 /*

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

    63 ** The following formatting characters are allowed:

    64 **

    65 **      %s      Insert a string

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

    67 **      %d      Insert an integer

    68 **      %T      Insert a token

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

    70 **

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

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

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

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

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

    76 ** (sqlite3_step() etc.).

    77 */

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

    79   va_list ap;

    80   pParse->nErr++;

    81   sqlite3_free(pParse->zErrMsg);

    82   va_start(ap, zFormat);

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

    84   va_end(ap);

    85   if( pParse->rc==SQLITE_OK ){

    86     pParse->rc = SQLITE_ERROR;

    87   }

    88 }

    89 

    90 /*

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

    92 */

    93 void sqlite3ErrorClear(Parse *pParse){

    94   sqlite3_free(pParse->zErrMsg);

    95   pParse->zErrMsg = 0;

    96   pParse->nErr = 0;

    97 }

    98 

    99 /*

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

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

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

   103 ** is a no-op.

   104 **

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

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

   107 ** "a-b-c".

   108 */

   109 void sqlite3Dequote(char *z){

   110   int quote;

   111   int i, j;

   112   if( z==0 ) return;

   113   quote = z[0];

   114   switch( quote ){

   115     case '\'':  break;

   116     case '"':   break;

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

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

   119     default:    return;

   120   }

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

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

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

   124         z[j++] = quote;

   125         i++;

   126       }else{

   127         z[j++] = 0;

   128         break;

   129       }

   130     }else{

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

   132     }

   133   }

   134 }

   135 

   136 /* An array to map all upper-case characters into their corresponding

   137 ** lower-case character. 

   138 */

   139 const unsigned char sqlite3UpperToLower[] = {

   140 #ifdef SQLITE_ASCII

   141       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,

   142      18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,

   143      36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,

   144      54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,

   145     104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,

   146     122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,

   147     108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,

   148     126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,

   149     144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,

   150     162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,

   151     180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,

   152     198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,

   153     216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,

   154     234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,

   155     252,253,254,255

   156 #endif

   157 #ifdef SQLITE_EBCDIC

   158       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */

   159      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */

   160      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */

   161      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */

   162      64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */

   163      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */

   164      96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */

   165     112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */

   166     128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */

   167     144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */

   168     160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */

   169     176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */

   170     192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */

   171     208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */

   172     224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */

   173     239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */

   174 #endif

   175 };

   176 #define UpperToLower sqlite3UpperToLower

   177 

   178 /*

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

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

   181 */

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

   183   register unsigned char *a, *b;

   184   a = (unsigned char *)zLeft;

   185   b = (unsigned char *)zRight;

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

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

   188 }

   189 int sqlite3StrNICmp(const char *zLeft, const char *zRight, int N){

   190   register unsigned char *a, *b;

   191   a = (unsigned char *)zLeft;

   192   b = (unsigned char *)zRight;

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

   194   return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];

   195 }

   196 

   197 /*

   198 ** Return TRUE if z is a pure numeric string.  Return FALSE if the

   199 ** string contains any character which is not part of a number. If

   200 ** the string is numeric and contains the '.' character, set *realnum

   201 ** to TRUE (otherwise FALSE).

   202 **

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

   204 */

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

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

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

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

   209   if( !isdigit(*(u8*)z) ){

   210     return 0;

   211   }

   212   z += incr;

   213   if( realnum ) *realnum = 0;

   214   while( isdigit(*(u8*)z) ){ z += incr; }

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

   216     z += incr;

   217     if( !isdigit(*(u8*)z) ) return 0;

   218     while( isdigit(*(u8*)z) ){ z += incr; }

   219     if( realnum ) *realnum = 1;

   220   }

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

   222     z += incr;

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

   224     if( !isdigit(*(u8*)z) ) return 0;

   225     while( isdigit(*(u8*)z) ){ z += incr; }

   226     if( realnum ) *realnum = 1;

   227   }

   228   return *z==0;

   229 }

   230 

   231 /*

   232 ** The string z[] is an ascii representation of a real number.

   233 ** Convert this string to a double.

   234 **

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

   236 ** is not, the result is undefined.

   237 **

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

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

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

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

   242 */

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

   244 #ifndef SQLITE_OMIT_FLOATING_POINT

   245   int sign = 1;

   246   const char *zBegin = z;

   247   LONGDOUBLE_TYPE v1 = 0.0;

   248   while( isspace(*(u8*)z) ) z++;

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

   250     sign = -1;

   251     z++;

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

   253     z++;

   254   }

   255   while( isdigit(*(u8*)z) ){

   256     v1 = v1*10.0 + (*z - '0');

   257     z++;

   258   }

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

   260     LONGDOUBLE_TYPE divisor = 1.0;

   261     z++;

   262     while( isdigit(*(u8*)z) ){

   263       v1 = v1*10.0 + (*z - '0');

   264       divisor *= 10.0;

   265       z++;

   266     }

   267     v1 /= divisor;

   268   }

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

   270     int esign = 1;

   271     int eval = 0;

   272     LONGDOUBLE_TYPE scale = 1.0;

   273     z++;

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

   275       esign = -1;

   276       z++;

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

   278       z++;

   279     }

   280     while( isdigit(*(u8*)z) ){

   281       eval = eval*10 + *z - '0';

   282       z++;

   283     }

   284     while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; }

   285     while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; }

   286     while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; }

   287     while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; }

   288     if( esign<0 ){

   289       v1 /= scale;

   290     }else{

   291       v1 *= scale;

   292     }

   293   }

   294   *pResult = sign<0 ? -v1 : v1;

   295   return z - zBegin;

   296 #else

   297   return sqlite3Atoi64(z, pResult);

   298 #endif /* SQLITE_OMIT_FLOATING_POINT */

   299 }

   300 

   301 /*

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

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

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

   305 **

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

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

   308 ** last digit.  So, for example,

   309 **

   310 **      compare2pow63("9223372036854775800")

   311 **

   312 ** will return -8.

   313 */

   314 static int compare2pow63(const char *zNum){

   315   int c;

   316   c = memcmp(zNum,"922337203685477580",18);

   317   if( c==0 ){

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

   319   }

   320   return c;

   321 }

   322 

   323 

   324 /*

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

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

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

   328 ** then return false.

   329 **

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

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

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

   333 */

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

   335   i64 v = 0;

   336   int neg;

   337   int i, c;

   338   while( isspace(*(u8*)zNum) ) zNum++;

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

   340     neg = 1;

   341     zNum++;

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

   343     neg = 0;

   344     zNum++;

   345   }else{

   346     neg = 0;

   347   }

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

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

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

   351   }

   352   *pNum = neg ? -v : v;

   353   if( c!=0 || i==0 || i>19 ){

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

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

   356     return 0;

   357   }else if( i<19 ){

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

   359     return 1;

   360   }else{

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

   362     ** or 9223372036854775808 if negative.  Note that 9223372036854665808

   363     ** is 2^63. */

   364     return compare2pow63(zNum)<neg;

   365   }

   366 }

   367 

   368 /*

   369 ** The string zNum represents an integer.  There might be some other

   370 ** information following the integer too, but that part is ignored.

   371 ** If the integer that the prefix of zNum represents will fit in a

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

   373 **

   374 ** This routine returns FALSE for the string -9223372036854775808 even that

   375 ** that number will, in theory fit in a 64-bit integer.  Positive

   376 ** 9223373036854775808 will not fit in 64 bits.  So it seems safer to return

   377 ** false.

   378 */

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

   380   int i, c;

   381   int neg = 0;

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

   383     neg = 1;

   384     zNum++;

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

   386     zNum++;

   387   }

   388   if( negFlag ) neg = 1-neg;

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

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

   391   }

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

   393   if( i<19 ){

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

   395     return 1;

   396   }else if( i>19 ){

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

   398     return 0;

   399   }else{

   400     /* Compare against 2^63. */

   401     return compare2pow63(zNum)<neg;

   402   }

   403 }

   404 

   405 /*

   406 ** If zNum represents an integer that will fit in 32-bits, then set

   407 ** *pValue to that integer and return true.  Otherwise return false.

   408 **

   409 ** Any non-numeric characters that following zNum are ignored.

   410 ** This is different from sqlite3Atoi64() which requires the

   411 ** input number to be zero-terminated.

   412 */

   413 int sqlite3GetInt32(const char *zNum, int *pValue){

   414   sqlite_int64 v = 0;

   415   int i, c;

   416   int neg = 0;

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

   418     neg = 1;

   419     zNum++;

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

   421     zNum++;

   422   }

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

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

   425     v = v*10 + c;

   426   }

   427 

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

   429   **

   430   **             1234567890

   431   **     2^31 -> 2147483648

   432   */

   433   if( i>10 ){

   434     return 0;

   435   }

   436   if( v-neg>2147483647 ){

   437     return 0;

   438   }

   439   if( neg ){

   440     v = -v;

   441   }

   442   *pValue = (int)v;

   443   return 1;

   444 }

   445 

   446 /*

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

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

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

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

   451 ** TRUE it means that the db pointer is invalid and should not be

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

   453 ** SQLITE_MISUSE immediately.

   454 */

   455 int sqlite3SafetyCheck(sqlite3 *db){

   456   int magic;

   457   if( db==0 ) return 1;

   458   magic = db->magic;

   459   if( magic!=SQLITE_MAGIC_CLOSED &&

   460          magic!=SQLITE_MAGIC_OPEN &&

   461          magic!=SQLITE_MAGIC_BUSY ) return 1;

   462   return 0;

   463 }

   464 

   465 /*

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

   467 **

   468 ** KEY:

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

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

   471 **         C = xxxxxxxx    8 bits of data

   472 **

   473 **  7 bits - A

   474 ** 14 bits - BA

   475 ** 21 bits - BBA

   476 ** 28 bits - BBBA

   477 ** 35 bits - BBBBA

   478 ** 42 bits - BBBBBA

   479 ** 49 bits - BBBBBBA

   480 ** 56 bits - BBBBBBBA

   481 ** 64 bits - BBBBBBBBC

   482 */

   483 

   484 /*

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

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

   487 ** of bytes written is returned.

   488 **

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

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

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

   492 ** 8 bits and is the last byte.

   493 */

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

   495   int i, j, n;

   496   u8 buf[10];

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

   498     p[8] = v;

   499     v >>= 8;

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

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

   502       v >>= 7;

   503     }

   504     return 9;

   505   }    

   506   n = 0;

   507   do{

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

   509     v >>= 7;

   510   }while( v!=0 );

   511   buf[0] &= 0x7f;

   512   assert( n<=9 );

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

   514     p[i] = buf[j];

   515   }

   516   return n;

   517 }

   518 

   519 /*

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

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

   522 */

   523 int sqlite3GetVarint(const unsigned char *p, u64 *v){

   524   u32 x;

   525   u64 x64;

   526   int n;

   527   unsigned char c;

   528   if( ((c = p[0]) & 0x80)==0 ){

   529     *v = c;

   530     return 1;

   531   }

   532   x = c & 0x7f;

   533   if( ((c = p[1]) & 0x80)==0 ){

   534     *v = (x<<7) | c;

   535     return 2;

   536   }

   537   x = (x<<7) | (c&0x7f);

   538   if( ((c = p[2]) & 0x80)==0 ){

   539     *v = (x<<7) | c;

   540     return 3;

   541   }

   542   x = (x<<7) | (c&0x7f);

   543   if( ((c = p[3]) & 0x80)==0 ){

   544     *v = (x<<7) | c;

   545     return 4;

   546   }

   547   x64 = (x<<7) | (c&0x7f);

   548   n = 4;

   549   do{

   550     c = p[n++];

   551     if( n==9 ){

   552       x64 = (x64<<8) | c;

   553       break;

   554     }

   555     x64 = (x64<<7) | (c&0x7f);

   556   }while( (c & 0x80)!=0 );

   557   *v = x64;

   558   return n;

   559 }

   560 

   561 /*

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

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

   564 */

   565 int sqlite3GetVarint32(const unsigned char *p, u32 *v){

   566   u32 x;

   567   int n;

   568   unsigned char c;

   569   if( ((signed char*)p)[0]>=0 ){

   570     *v = p[0];

   571     return 1;

   572   }

   573   x = p[0] & 0x7f;

   574   if( ((signed char*)p)[1]>=0 ){

   575     *v = (x<<7) | p[1];

   576     return 2;

   577   }

   578   x = (x<<7) | (p[1] & 0x7f);

   579   n = 2;

   580   do{

   581     x = (x<<7) | ((c = p[n++])&0x7f);

   582   }while( (c & 0x80)!=0 && n<9 );

   583   *v = x;

   584   return n;

   585 }

   586 

   587 /*

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

   589 ** 64-bit integer.

   590 */

   591 int sqlite3VarintLen(u64 v){

   592   int i = 0;

   593   do{

   594     i++;

   595     v >>= 7;

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

   597   return i;

   598 }

   599 

   600 

   601 /*

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

   603 */

   604 u32 sqlite3Get4byte(const u8 *p){

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

   606 }

   607 void sqlite3Put4byte(unsigned char *p, u32 v){

   608   p[0] = v>>24;

   609   p[1] = v>>16;

   610   p[2] = v>>8;

   611   p[3] = v;

   612 }

   613 

   614 

   615 

   616 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) \

   617     || defined(SQLITE_TEST)

   618 /*

   619 ** Translate a single byte of Hex into an integer.

   620 */

   621 static int hexToInt(int h){

   622   if( h>='0' && h<='9' ){

   623     return h - '0';

   624   }else if( h>='a' && h<='f' ){

   625     return h - 'a' + 10;

   626   }else{

   627     assert( h>='A' && h<='F' );

   628     return h - 'A' + 10;

   629   }

   630 }

   631 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC || SQLITE_TEST */

   632 

   633 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)

   634 /*

   635 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary

   636 ** value.  Return a pointer to its binary value.  Space to hold the

   637 ** binary value has been obtained from malloc and must be freed by

   638 ** the calling routine.

   639 */

   640 void *sqlite3HexToBlob(sqlite3 *db, const char *z){

   641   char *zBlob;

   642   int i;

   643   int n = strlen(z);

   644   if( n%2 ) return 0;

   645 

   646   zBlob = (char *)sqlite3DbMallocRaw(db, n/2);

   647   if( zBlob ){

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

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

   650     }

   651   }

   652   return zBlob;

   653 }

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

   655 

   656 

   657 /*

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

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

   660 ** when this routine is called.

   661 **

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

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

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

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

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

   667 ** when the API exits. 

   668 **

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

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

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

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

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

   674 ** using SQLite incorrectly.

   675 **

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

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

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

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

   680 ** not want to write into deallocated memory.

   681 */

   682 int sqlite3SafetyOn(sqlite3 *db){

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

   684     db->magic = SQLITE_MAGIC_BUSY;

   685     return 0;

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

   687     db->magic = SQLITE_MAGIC_ERROR;

   688     db->u1.isInterrupted = 1;

   689   }

   690   return 1;

   691 }

   692 

   693 /*

   694 ** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.

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

   696 ** when this routine is called.

   697 */

   698 int sqlite3SafetyOff(sqlite3 *db){

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

   700     db->magic = SQLITE_MAGIC_OPEN;

   701     return 0;

   702   }else {

   703     db->magic = SQLITE_MAGIC_ERROR;

   704     db->u1.isInterrupted = 1;

   705     return 1;

   706   }

   707 }