/*+ −
** 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.+ −
**+ −
** $Id: util.cpp 1282 2008-11-13 09:31:33Z LarsPson $+ −
*/+ −
#include "sqliteInt.h"+ −
#include <stdarg.h>+ −
#include <ctype.h>+ −
+ − + − /*+ −
** 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, sqlite3_free);+ −
}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;+ −
pParse->nErr++;+ −
sqlite3_free(pParse->zErrMsg);+ −
va_start(ap, zFormat);+ −
pParse->zErrMsg = sqlite3VMPrintf(pParse->db, zFormat, ap);+ −
va_end(ap);+ −
if( pParse->rc==SQLITE_OK ){+ −
pParse->rc = SQLITE_ERROR;+ −
}+ −
}+ −
+ − /*+ −
** Clear the error message in pParse, if any+ −
*/+ −
void sqlite3ErrorClear(Parse *pParse){+ −
sqlite3_free(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.+ −
**+ −
** 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".+ −
*/+ −
void sqlite3Dequote(char *z){+ −
int quote;+ −
int i, j;+ −
if( z==0 ) return;+ −
quote = z[0];+ −
switch( quote ){+ −
case '\'': break;+ −
case '"': break;+ −
case '`': break; /* For MySQL compatibility */+ −
case '[': quote = ']'; break; /* For MS SqlServer compatibility */+ −
default: return;+ −
}+ −
for(i=1, j=0; z[i]; i++){+ −
if( z[i]==quote ){+ −
if( z[i+1]==quote ){+ −
z[j++] = quote;+ −
i++;+ −
}else{+ −
z[j++] = 0;+ −
break;+ −
}+ −
}else{+ −
z[j++] = z[i];+ −
}+ −
}+ −
}+ −
+ − /* An array to map all upper-case characters into their corresponding+ −
** lower-case character. + −
*/+ −
const unsigned char sqlite3UpperToLower[] = {+ −
#ifdef SQLITE_ASCII+ −
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,+ −
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,+ −
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,+ −
54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,+ −
104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,+ −
122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,+ −
108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,+ −
126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,+ −
144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,+ −
162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,+ −
180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,+ −
198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,+ −
216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,+ −
234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,+ −
252,253,254,255+ −
#endif+ −
#ifdef SQLITE_EBCDIC+ −
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */+ −
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */+ −
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */+ −
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */+ −
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */+ −
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */+ −
96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */+ −
112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */+ −
128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */+ −
144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */+ −
160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */+ −
176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */+ −
192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */+ −
208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */+ −
224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */+ −
239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */+ −
#endif+ −
};+ −
#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 sqlite3StrNICmp(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 if the+ −
** string contains any character which is not part of a number. If+ −
** the string is numeric and contains the '.' character, set *realnum+ −
** to TRUE (otherwise FALSE).+ −
**+ −
** 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( !isdigit(*(u8*)z) ){+ −
return 0;+ −
}+ −
z += incr;+ −
if( realnum ) *realnum = 0;+ −
while( isdigit(*(u8*)z) ){ z += incr; }+ −
if( *z=='.' ){+ −
z += incr;+ −
if( !isdigit(*(u8*)z) ) return 0;+ −
while( isdigit(*(u8*)z) ){ z += incr; }+ −
if( realnum ) *realnum = 1;+ −
}+ −
if( *z=='e' || *z=='E' ){+ −
z += incr;+ −
if( *z=='+' || *z=='-' ) z += incr;+ −
if( !isdigit(*(u8*)z) ) return 0;+ −
while( isdigit(*(u8*)z) ){ z += incr; }+ −
if( realnum ) *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+ −
int sign = 1;+ −
const char *zBegin = z;+ −
LONGDOUBLE_TYPE v1 = 0.0;+ −
while( isspace(*(u8*)z) ) z++;+ −
if( *z=='-' ){+ −
sign = -1;+ −
z++;+ −
}else if( *z=='+' ){+ −
z++;+ −
}+ −
while( isdigit(*(u8*)z) ){+ −
v1 = v1*10.0 + (*z - '0');+ −
z++;+ −
}+ −
if( *z=='.' ){+ −
LONGDOUBLE_TYPE divisor = 1.0;+ −
z++;+ −
while( isdigit(*(u8*)z) ){+ −
v1 = v1*10.0 + (*z - '0');+ −
divisor *= 10.0;+ −
z++;+ −
}+ −
v1 /= divisor;+ −
}+ −
if( *z=='e' || *z=='E' ){+ −
int esign = 1;+ −
int eval = 0;+ −
LONGDOUBLE_TYPE scale = 1.0;+ −
z++;+ −
if( *z=='-' ){+ −
esign = -1;+ −
z++;+ −
}else if( *z=='+' ){+ −
z++;+ −
}+ −
while( isdigit(*(u8*)z) ){+ −
eval = eval*10 + *z - '0';+ −
z++;+ −
}+ −
while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; }+ −
while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; }+ −
while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; }+ −
while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; }+ −
if( esign<0 ){+ −
v1 /= scale;+ −
}else{+ −
v1 *= scale;+ −
}+ −
}+ −
*pResult = sign<0 ? -v1 : v1;+ −
return 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);+ −
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;+ −
while( isspace(*(u8*)zNum) ) zNum++;+ −
if( *zNum=='-' ){+ −
neg = 1;+ −
zNum++;+ −
}else if( *zNum=='+' ){+ −
neg = 0;+ −
zNum++;+ −
}else{+ −
neg = 0;+ −
}+ −
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 || 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 integer. There might be some other+ −
** information following the integer too, but that part is ignored.+ −
** If the integer that the prefix of zNum represents will fit in a+ −
** 64-bit signed integer, return TRUE. Otherwise return FALSE.+ −
**+ −
** This routine returns FALSE for the string -9223372036854775808 even that+ −
** that number will, in theory fit in a 64-bit integer. Positive+ −
** 9223373036854775808 will not fit in 64 bits. So it seems safer to return+ −
** false.+ −
*/+ −
int sqlite3FitsIn64Bits(const char *zNum, int negFlag){+ −
int i, c;+ −
int neg = 0;+ −
if( *zNum=='-' ){+ −
neg = 1;+ −
zNum++;+ −
}else if( *zNum=='+' ){+ −
zNum++;+ −
}+ −
if( negFlag ) neg = 1-neg;+ −
while( *zNum=='0' ){+ −
zNum++; /* Skip leading zeros. Ticket #2454 */+ −
}+ −
for(i=0; (c=zNum[i])>='0' && c<='9'; i++){}+ −
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;+ −
}+ −
+ − /*+ −
** 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+ −
** TRUE it means that the db pointer is invalid and should not be+ −
** dereferenced for any reason. The calling function should invoke+ −
** SQLITE_MISUSE immediately.+ −
*/+ −
int sqlite3SafetyCheck(sqlite3 *db){+ −
int magic;+ −
if( db==0 ) return 1;+ −
magic = db->magic;+ −
if( magic!=SQLITE_MAGIC_CLOSED &&+ −
magic!=SQLITE_MAGIC_OPEN &&+ −
magic!=SQLITE_MAGIC_BUSY ) return 1;+ −
return 0;+ −
}+ −
+ − /*+ −
** 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] = v;+ −
v >>= 8;+ −
for(i=7; i>=0; i--){+ −
p[i] = (v & 0x7f) | 0x80;+ −
v >>= 7;+ −
}+ −
return 9;+ −
} + −
n = 0;+ −
do{+ −
buf[n++] = (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;+ −
}+ −
+ − /*+ −
** 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.+ −
*/+ −
int sqlite3GetVarint(const unsigned char *p, u64 *v){+ −
u32 x;+ −
u64 x64;+ −
int n;+ −
unsigned char c;+ −
if( ((c = p[0]) & 0x80)==0 ){+ −
*v = c;+ −
return 1;+ −
}+ −
x = c & 0x7f;+ −
if( ((c = p[1]) & 0x80)==0 ){+ −
*v = (x<<7) | c;+ −
return 2;+ −
}+ −
x = (x<<7) | (c&0x7f);+ −
if( ((c = p[2]) & 0x80)==0 ){+ −
*v = (x<<7) | c;+ −
return 3;+ −
}+ −
x = (x<<7) | (c&0x7f);+ −
if( ((c = p[3]) & 0x80)==0 ){+ −
*v = (x<<7) | c;+ −
return 4;+ −
}+ −
x64 = (x<<7) | (c&0x7f);+ −
n = 4;+ −
do{+ −
c = p[n++];+ −
if( n==9 ){+ −
x64 = (x64<<8) | c;+ −
break;+ −
}+ −
x64 = (x64<<7) | (c&0x7f);+ −
}while( (c & 0x80)!=0 );+ −
*v = x64;+ −
return n;+ −
}+ −
+ − /*+ −
** 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.+ −
*/+ −
int sqlite3GetVarint32(const unsigned char *p, u32 *v){+ −
u32 x;+ −
int n;+ −
unsigned char c;+ −
if( ((signed char*)p)[0]>=0 ){+ −
*v = p[0];+ −
return 1;+ −
}+ −
x = p[0] & 0x7f;+ −
if( ((signed char*)p)[1]>=0 ){+ −
*v = (x<<7) | p[1];+ −
return 2;+ −
}+ −
x = (x<<7) | (p[1] & 0x7f);+ −
n = 2;+ −
do{+ −
x = (x<<7) | ((c = p[n++])&0x7f);+ −
}while( (c & 0x80)!=0 && n<9 );+ −
*v = x;+ −
return n;+ −
}+ −
+ − /*+ −
** 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 && 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] = v>>24;+ −
p[1] = v>>16;+ −
p[2] = v>>8;+ −
p[3] = v;+ −
}+ −
+ − + − + − #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) \+ −
|| defined(SQLITE_TEST)+ −
/*+ −
** Translate a single byte of Hex into an integer.+ −
*/+ −
static int hexToInt(int h){+ −
if( h>='0' && h<='9' ){+ −
return h - '0';+ −
}else if( h>='a' && h<='f' ){+ −
return h - 'a' + 10;+ −
}else{+ −
assert( h>='A' && h<='F' );+ −
return h - 'A' + 10;+ −
}+ −
}+ −
#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC || SQLITE_TEST */+ −
+ − #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){+ −
char *zBlob;+ −
int i;+ −
int n = strlen(z);+ −
if( n%2 ) return 0;+ −
+ − zBlob = (char *)sqlite3DbMallocRaw(db, n/2);+ −
if( zBlob ){+ −
for(i=0; i<n; i+=2){+ −
zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);+ −
}+ −
}+ −
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.+ −
*/+ −
int sqlite3SafetyOn(sqlite3 *db){+ −
if( db->magic==SQLITE_MAGIC_OPEN ){+ −
db->magic = SQLITE_MAGIC_BUSY;+ −
return 0;+ −
}else if( db->magic==SQLITE_MAGIC_BUSY ){+ −
db->magic = SQLITE_MAGIC_ERROR;+ −
db->u1.isInterrupted = 1;+ −
}+ −
return 1;+ −
}+ −
+ − /*+ −
** 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.+ −
*/+ −
int sqlite3SafetyOff(sqlite3 *db){+ −
if( db->magic==SQLITE_MAGIC_BUSY ){+ −
db->magic = SQLITE_MAGIC_OPEN;+ −
return 0;+ −
}else {+ −
db->magic = SQLITE_MAGIC_ERROR;+ −
db->u1.isInterrupted = 1;+ −
return 1;+ −
}+ −
}+ −