mirror of
https://github.com/sqlite/sqlite.git
synced 2025-08-10 01:02:56 +03:00
9296c18a50
hex literals. Casting and coercing string literals into numeric values does not understand hexadecimal integers. This preserves backwards compatibility. Also: Throw an error on any hex literal that is too big to fit into 64 bits. FossilOrigin-Name: 6c6f0de59bf96b79c8ace8c9bfe48c7a6a306a50
1367 lines
35 KiB
C
1367 lines
35 KiB
C
/*
|
|
** 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 unsigned dummy = 0;
|
|
dummy += (unsigned)x;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Give a callback to the test harness that can be used to simulate faults
|
|
** in places where it is difficult or expensive to do so purely by means
|
|
** of inputs.
|
|
**
|
|
** The intent of the integer argument is to let the fault simulator know
|
|
** which of multiple sqlite3FaultSim() calls has been hit.
|
|
**
|
|
** Return whatever integer value the test callback returns, or return
|
|
** SQLITE_OK if no test callback is installed.
|
|
*/
|
|
#ifndef SQLITE_OMIT_BUILTIN_TEST
|
|
int sqlite3FaultSim(int iTest){
|
|
int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback;
|
|
return xCallback ? xCallback(iTest) : SQLITE_OK;
|
|
}
|
|
#endif
|
|
|
|
#ifndef SQLITE_OMIT_FLOATING_POINT
|
|
/*
|
|
** 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;
|
|
}
|
|
#endif /* SQLITE_OMIT_FLOATING_POINT */
|
|
|
|
/*
|
|
** 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, ...){
|
|
assert( db!=0 );
|
|
db->errCode = err_code;
|
|
if( zFormat && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
|
|
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 if( db->pErr ){
|
|
sqlite3ValueSetNull(db->pErr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** 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, ...){
|
|
char *zMsg;
|
|
va_list ap;
|
|
sqlite3 *db = pParse->db;
|
|
va_start(ap, zFormat);
|
|
zMsg = sqlite3VMPrintf(db, zFormat, ap);
|
|
va_end(ap);
|
|
if( db->suppressErr ){
|
|
sqlite3DbFree(db, zMsg);
|
|
}else{
|
|
pParse->nErr++;
|
|
sqlite3DbFree(db, pParse->zErrMsg);
|
|
pParse->zErrMsg = zMsg;
|
|
pParse->rc = SQLITE_ERROR;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** 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;; i++){
|
|
assert( z[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.
|
|
**
|
|
** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
|
|
** sqlite3_strnicmp() APIs allow applications and extensions to compare
|
|
** the contents of two buffers containing UTF-8 strings in a
|
|
** case-independent fashion, using the same definition of "case
|
|
** independence" that SQLite uses internally when comparing identifiers.
|
|
*/
|
|
int sqlite3_stricmp(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];
|
|
}
|
|
|
|
/*
|
|
** The string z[] is an text representation of a real number.
|
|
** Convert this string to a double and write it into *pResult.
|
|
**
|
|
** The string z[] is length bytes in length (bytes, not characters) and
|
|
** uses the encoding enc. The string is not necessarily zero-terminated.
|
|
**
|
|
** Return TRUE if the result is a valid real number (or integer) and FALSE
|
|
** if the string is empty or contains extraneous text. Valid numbers
|
|
** are in one of these formats:
|
|
**
|
|
** [+-]digits[E[+-]digits]
|
|
** [+-]digits.[digits][E[+-]digits]
|
|
** [+-].digits[E[+-]digits]
|
|
**
|
|
** Leading and trailing whitespace is ignored for the purpose of determining
|
|
** validity.
|
|
**
|
|
** If some prefix of the input string is a valid number, this routine
|
|
** returns FALSE but it still converts the prefix and writes the result
|
|
** into *pResult.
|
|
*/
|
|
int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
|
|
#ifndef SQLITE_OMIT_FLOATING_POINT
|
|
int incr;
|
|
const char *zEnd = z + length;
|
|
/* 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 */
|
|
int eValid = 1; /* True exponent is either not used or is well-formed */
|
|
double result;
|
|
int nDigits = 0;
|
|
int nonNum = 0;
|
|
|
|
assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
|
|
*pResult = 0.0; /* Default return value, in case of an error */
|
|
|
|
if( enc==SQLITE_UTF8 ){
|
|
incr = 1;
|
|
}else{
|
|
int i;
|
|
incr = 2;
|
|
assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
|
|
for(i=3-enc; i<length && z[i]==0; i+=2){}
|
|
nonNum = i<length;
|
|
zEnd = z+i+enc-3;
|
|
z += (enc&1);
|
|
}
|
|
|
|
/* skip leading spaces */
|
|
while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
|
|
if( z>=zEnd ) return 0;
|
|
|
|
/* get sign of significand */
|
|
if( *z=='-' ){
|
|
sign = -1;
|
|
z+=incr;
|
|
}else if( *z=='+' ){
|
|
z+=incr;
|
|
}
|
|
|
|
/* skip leading zeroes */
|
|
while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;
|
|
|
|
/* copy max significant digits to significand */
|
|
while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
|
|
s = s*10 + (*z - '0');
|
|
z+=incr, nDigits++;
|
|
}
|
|
|
|
/* skip non-significant significand digits
|
|
** (increase exponent by d to shift decimal left) */
|
|
while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
|
|
if( z>=zEnd ) goto do_atof_calc;
|
|
|
|
/* if decimal point is present */
|
|
if( *z=='.' ){
|
|
z+=incr;
|
|
/* copy digits from after decimal to significand
|
|
** (decrease exponent by d to shift decimal right) */
|
|
while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
|
|
s = s*10 + (*z - '0');
|
|
z+=incr, nDigits++, d--;
|
|
}
|
|
/* skip non-significant digits */
|
|
while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++;
|
|
}
|
|
if( z>=zEnd ) goto do_atof_calc;
|
|
|
|
/* if exponent is present */
|
|
if( *z=='e' || *z=='E' ){
|
|
z+=incr;
|
|
eValid = 0;
|
|
if( z>=zEnd ) goto do_atof_calc;
|
|
/* get sign of exponent */
|
|
if( *z=='-' ){
|
|
esign = -1;
|
|
z+=incr;
|
|
}else if( *z=='+' ){
|
|
z+=incr;
|
|
}
|
|
/* copy digits to exponent */
|
|
while( z<zEnd && sqlite3Isdigit(*z) ){
|
|
e = e<10000 ? (e*10 + (*z - '0')) : 10000;
|
|
z+=incr;
|
|
eValid = 1;
|
|
}
|
|
}
|
|
|
|
/* skip trailing spaces */
|
|
if( nDigits && eValid ){
|
|
while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
|
|
}
|
|
|
|
do_atof_calc:
|
|
/* 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 ){
|
|
LONGDOUBLE_TYPE 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 if( e>=342 ){
|
|
if( esign<0 ){
|
|
result = 0.0*s;
|
|
}else{
|
|
result = 1e308*1e308*s; /* Infinity */
|
|
}
|
|
}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 true if number and no extra non-whitespace chracters after */
|
|
return z>=zEnd && nDigits>0 && eValid && nonNum==0;
|
|
#else
|
|
return !sqlite3Atoi64(z, pResult, length, enc);
|
|
#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.
|
|
** Note that zNum must contain exactly 19 characters.
|
|
**
|
|
** 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", 1)
|
|
**
|
|
** will return -8.
|
|
*/
|
|
static int compare2pow63(const char *zNum, int incr){
|
|
int c = 0;
|
|
int i;
|
|
/* 012345678901234567 */
|
|
const char *pow63 = "922337203685477580";
|
|
for(i=0; c==0 && i<18; i++){
|
|
c = (zNum[i*incr]-pow63[i])*10;
|
|
}
|
|
if( c==0 ){
|
|
c = zNum[18*incr] - '8';
|
|
testcase( c==(-1) );
|
|
testcase( c==0 );
|
|
testcase( c==(+1) );
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/*
|
|
** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
|
|
** routine does *not* accept hexadecimal notation.
|
|
**
|
|
** If the zNum value is representable as a 64-bit twos-complement
|
|
** integer, then write that value into *pNum and return 0.
|
|
**
|
|
** If zNum is exactly 9223372036854775808, return 2. This special
|
|
** case is broken out because while 9223372036854775808 cannot be a
|
|
** signed 64-bit integer, its negative -9223372036854775808 can be.
|
|
**
|
|
** If zNum is too big for a 64-bit integer and is not
|
|
** 9223372036854775808 or if zNum contains any non-numeric text,
|
|
** then return 1.
|
|
**
|
|
** length is the number of bytes in the string (bytes, not characters).
|
|
** The string is not necessarily zero-terminated. The encoding is
|
|
** given by enc.
|
|
*/
|
|
int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
|
|
int incr;
|
|
u64 u = 0;
|
|
int neg = 0; /* assume positive */
|
|
int i;
|
|
int c = 0;
|
|
int nonNum = 0;
|
|
const char *zStart;
|
|
const char *zEnd = zNum + length;
|
|
assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
|
|
if( enc==SQLITE_UTF8 ){
|
|
incr = 1;
|
|
}else{
|
|
incr = 2;
|
|
assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
|
|
for(i=3-enc; i<length && zNum[i]==0; i+=2){}
|
|
nonNum = i<length;
|
|
zEnd = zNum+i+enc-3;
|
|
zNum += (enc&1);
|
|
}
|
|
while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
|
|
if( zNum<zEnd ){
|
|
if( *zNum=='-' ){
|
|
neg = 1;
|
|
zNum+=incr;
|
|
}else if( *zNum=='+' ){
|
|
zNum+=incr;
|
|
}
|
|
}
|
|
zStart = zNum;
|
|
while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
|
|
for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
|
|
u = u*10 + c - '0';
|
|
}
|
|
if( u>LARGEST_INT64 ){
|
|
*pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
|
|
}else if( neg ){
|
|
*pNum = -(i64)u;
|
|
}else{
|
|
*pNum = (i64)u;
|
|
}
|
|
testcase( i==18 );
|
|
testcase( i==19 );
|
|
testcase( i==20 );
|
|
if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr || nonNum ){
|
|
/* zNum is empty or contains non-numeric text or is longer
|
|
** than 19 digits (thus guaranteeing that it is too large) */
|
|
return 1;
|
|
}else if( i<19*incr ){
|
|
/* Less than 19 digits, so we know that it fits in 64 bits */
|
|
assert( u<=LARGEST_INT64 );
|
|
return 0;
|
|
}else{
|
|
/* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
|
|
c = compare2pow63(zNum, incr);
|
|
if( c<0 ){
|
|
/* zNum is less than 9223372036854775808 so it fits */
|
|
assert( u<=LARGEST_INT64 );
|
|
return 0;
|
|
}else if( c>0 ){
|
|
/* zNum is greater than 9223372036854775808 so it overflows */
|
|
return 1;
|
|
}else{
|
|
/* zNum is exactly 9223372036854775808. Fits if negative. The
|
|
** special case 2 overflow if positive */
|
|
assert( u-1==LARGEST_INT64 );
|
|
return neg ? 0 : 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
|
|
** into a 64-bit signed integer. This routine accepts hexadecimal literals,
|
|
** whereas sqlite3Atoi64() does not.
|
|
**
|
|
** Returns:
|
|
**
|
|
** 0 Successful transformation. Fits in a 64-bit signed integer.
|
|
** 1 Integer too large for a 64-bit signed integer or is malformed
|
|
** 2 Special case of 9223372036854775808
|
|
*/
|
|
int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
|
|
#ifndef SQLITE_OMIT_HEX_INTEGER
|
|
if( z[0]=='0'
|
|
&& (z[1]=='x' || z[1]=='X')
|
|
&& sqlite3Isxdigit(z[2])
|
|
){
|
|
u64 u = 0;
|
|
int i, k;
|
|
for(i=2; z[i]=='0'; i++){}
|
|
for(k=i; sqlite3Isxdigit(z[k]); k++){
|
|
u = u*16 + sqlite3HexToInt(z[k]);
|
|
}
|
|
memcpy(pOut, &u, 8);
|
|
return (z[k]==0 && k-i<=16) ? 0 : 1;
|
|
}else
|
|
#endif /* SQLITE_OMIT_HEX_INTEGER */
|
|
{
|
|
return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If zNum represents an integer that will fit in 32-bits, then set
|
|
** *pValue to that integer and return true. Otherwise return false.
|
|
**
|
|
** This routine accepts both decimal and hexadecimal notation for integers.
|
|
**
|
|
** 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++;
|
|
}
|
|
#ifndef SQLITE_OMIT_HEX_INTEGER
|
|
else if( zNum[0]=='0'
|
|
&& (zNum[1]=='x' || zNum[1]=='X')
|
|
&& sqlite3Isxdigit(zNum[2])
|
|
){
|
|
u32 u = 0;
|
|
zNum += 2;
|
|
while( zNum[0]=='0' ) zNum++;
|
|
for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
|
|
u = u*16 + sqlite3HexToInt(zNum[i]);
|
|
}
|
|
if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
|
|
memcpy(pValue, &u, 4);
|
|
return 1;
|
|
}else{
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
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
|
|
*/
|
|
testcase( i==10 );
|
|
if( i>10 ){
|
|
return 0;
|
|
}
|
|
testcase( v-neg==2147483647 );
|
|
if( v-neg>2147483647 ){
|
|
return 0;
|
|
}
|
|
if( neg ){
|
|
v = -v;
|
|
}
|
|
*pValue = (int)v;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
** Return a 32-bit integer value extracted from a string. If the
|
|
** string is not an integer, just return 0.
|
|
*/
|
|
int sqlite3Atoi(const char *z){
|
|
int x = 0;
|
|
if( z ) sqlite3GetInt32(z, &x);
|
|
return x;
|
|
}
|
|
|
|
/*
|
|
** 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);
|
|
}
|
|
|
|
/*
|
|
** Bitmasks used by sqlite3GetVarint(). These precomputed constants
|
|
** are defined here rather than simply putting the constant expressions
|
|
** inline in order to work around bugs in the RVT compiler.
|
|
**
|
|
** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
|
|
**
|
|
** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
|
|
*/
|
|
#define SLOT_2_0 0x001fc07f
|
|
#define SLOT_4_2_0 0xf01fc07f
|
|
|
|
|
|
/*
|
|
** 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;
|
|
}
|
|
|
|
/* Verify that constants are precomputed correctly */
|
|
assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
|
|
assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
|
|
|
|
p++;
|
|
a = a<<14;
|
|
a |= *p;
|
|
/* a: p0<<14 | p2 (unmasked) */
|
|
if (!(a&0x80))
|
|
{
|
|
a &= SLOT_2_0;
|
|
b &= 0x7f;
|
|
b = b<<7;
|
|
a |= b;
|
|
*v = a;
|
|
return 3;
|
|
}
|
|
|
|
/* CSE1 from below */
|
|
a &= SLOT_2_0;
|
|
p++;
|
|
b = b<<14;
|
|
b |= *p;
|
|
/* b: p1<<14 | p3 (unmasked) */
|
|
if (!(b&0x80))
|
|
{
|
|
b &= SLOT_2_0;
|
|
/* 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 &= SLOT_2_0;
|
|
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 &= SLOT_2_0;
|
|
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 &= SLOT_4_2_0;
|
|
b &= SLOT_2_0;
|
|
b = b<<7;
|
|
a |= b;
|
|
s = s>>11;
|
|
*v = ((u64)s)<<32 | a;
|
|
return 7;
|
|
}
|
|
|
|
/* CSE2 from below */
|
|
a &= SLOT_2_0;
|
|
p++;
|
|
b = b<<14;
|
|
b |= *p;
|
|
/* b: p3<<28 | p5<<14 | p7 (unmasked) */
|
|
if (!(b&0x80))
|
|
{
|
|
b &= SLOT_4_2_0;
|
|
/* 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 &= SLOT_2_0;
|
|
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))
|
|
{
|
|
/* Values between 268435456 and 34359738367 */
|
|
a &= SLOT_4_2_0;
|
|
b &= SLOT_4_2_0;
|
|
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){
|
|
testcase( p[0]&0x80 );
|
|
return ((unsigned)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;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** Translate a single byte of Hex into an integer.
|
|
** This routine only works if h really is a valid hexadecimal
|
|
** character: 0..9a..fA..F
|
|
*/
|
|
u8 sqlite3HexToInt(int h){
|
|
assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
|
|
#ifdef SQLITE_ASCII
|
|
h += 9*(1&(h>>6));
|
|
#endif
|
|
#ifdef SQLITE_EBCDIC
|
|
h += 9*(1&~(h>>4));
|
|
#endif
|
|
return (u8)(h & 0xf);
|
|
}
|
|
|
|
#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] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
|
|
}
|
|
zBlob[i/2] = 0;
|
|
}
|
|
return zBlob;
|
|
}
|
|
#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
|
|
|
|
/*
|
|
** Log an error that is an API call on a connection pointer that should
|
|
** not have been used. The "type" of connection pointer is given as the
|
|
** argument. The zType is a word like "NULL" or "closed" or "invalid".
|
|
*/
|
|
static void logBadConnection(const char *zType){
|
|
sqlite3_log(SQLITE_MISUSE,
|
|
"API call with %s database connection pointer",
|
|
zType
|
|
);
|
|
}
|
|
|
|
/*
|
|
** 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 ){
|
|
logBadConnection("NULL");
|
|
return 0;
|
|
}
|
|
magic = db->magic;
|
|
if( magic!=SQLITE_MAGIC_OPEN ){
|
|
if( sqlite3SafetyCheckSickOrOk(db) ){
|
|
testcase( sqlite3GlobalConfig.xLog!=0 );
|
|
logBadConnection("unopened");
|
|
}
|
|
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 ){
|
|
testcase( sqlite3GlobalConfig.xLog!=0 );
|
|
logBadConnection("invalid");
|
|
return 0;
|
|
}else{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Attempt to add, substract, or multiply the 64-bit signed value iB against
|
|
** the other 64-bit signed integer at *pA and store the result in *pA.
|
|
** Return 0 on success. Or if the operation would have resulted in an
|
|
** overflow, leave *pA unchanged and return 1.
|
|
*/
|
|
int sqlite3AddInt64(i64 *pA, i64 iB){
|
|
i64 iA = *pA;
|
|
testcase( iA==0 ); testcase( iA==1 );
|
|
testcase( iB==-1 ); testcase( iB==0 );
|
|
if( iB>=0 ){
|
|
testcase( iA>0 && LARGEST_INT64 - iA == iB );
|
|
testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
|
|
if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
|
|
}else{
|
|
testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
|
|
testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
|
|
if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
|
|
}
|
|
*pA += iB;
|
|
return 0;
|
|
}
|
|
int sqlite3SubInt64(i64 *pA, i64 iB){
|
|
testcase( iB==SMALLEST_INT64+1 );
|
|
if( iB==SMALLEST_INT64 ){
|
|
testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
|
|
if( (*pA)>=0 ) return 1;
|
|
*pA -= iB;
|
|
return 0;
|
|
}else{
|
|
return sqlite3AddInt64(pA, -iB);
|
|
}
|
|
}
|
|
#define TWOPOWER32 (((i64)1)<<32)
|
|
#define TWOPOWER31 (((i64)1)<<31)
|
|
int sqlite3MulInt64(i64 *pA, i64 iB){
|
|
i64 iA = *pA;
|
|
i64 iA1, iA0, iB1, iB0, r;
|
|
|
|
iA1 = iA/TWOPOWER32;
|
|
iA0 = iA % TWOPOWER32;
|
|
iB1 = iB/TWOPOWER32;
|
|
iB0 = iB % TWOPOWER32;
|
|
if( iA1==0 ){
|
|
if( iB1==0 ){
|
|
*pA *= iB;
|
|
return 0;
|
|
}
|
|
r = iA0*iB1;
|
|
}else if( iB1==0 ){
|
|
r = iA1*iB0;
|
|
}else{
|
|
/* If both iA1 and iB1 are non-zero, overflow will result */
|
|
return 1;
|
|
}
|
|
testcase( r==(-TWOPOWER31)-1 );
|
|
testcase( r==(-TWOPOWER31) );
|
|
testcase( r==TWOPOWER31 );
|
|
testcase( r==TWOPOWER31-1 );
|
|
if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1;
|
|
r *= TWOPOWER32;
|
|
if( sqlite3AddInt64(&r, iA0*iB0) ) return 1;
|
|
*pA = r;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** Compute the absolute value of a 32-bit signed integer, of possible. Or
|
|
** if the integer has a value of -2147483648, return +2147483647
|
|
*/
|
|
int sqlite3AbsInt32(int x){
|
|
if( x>=0 ) return x;
|
|
if( x==(int)0x80000000 ) return 0x7fffffff;
|
|
return -x;
|
|
}
|
|
|
|
#ifdef SQLITE_ENABLE_8_3_NAMES
|
|
/*
|
|
** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
|
|
** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
|
|
** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
|
|
** three characters, then shorten the suffix on z[] to be the last three
|
|
** characters of the original suffix.
|
|
**
|
|
** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
|
|
** do the suffix shortening regardless of URI parameter.
|
|
**
|
|
** Examples:
|
|
**
|
|
** test.db-journal => test.nal
|
|
** test.db-wal => test.wal
|
|
** test.db-shm => test.shm
|
|
** test.db-mj7f3319fa => test.9fa
|
|
*/
|
|
void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
|
|
#if SQLITE_ENABLE_8_3_NAMES<2
|
|
if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
|
|
#endif
|
|
{
|
|
int i, sz;
|
|
sz = sqlite3Strlen30(z);
|
|
for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
|
|
if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** Find (an approximate) sum of two LogEst values. This computation is
|
|
** not a simple "+" operator because LogEst is stored as a logarithmic
|
|
** value.
|
|
**
|
|
*/
|
|
LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
|
|
static const unsigned char x[] = {
|
|
10, 10, /* 0,1 */
|
|
9, 9, /* 2,3 */
|
|
8, 8, /* 4,5 */
|
|
7, 7, 7, /* 6,7,8 */
|
|
6, 6, 6, /* 9,10,11 */
|
|
5, 5, 5, /* 12-14 */
|
|
4, 4, 4, 4, /* 15-18 */
|
|
3, 3, 3, 3, 3, 3, /* 19-24 */
|
|
2, 2, 2, 2, 2, 2, 2, /* 25-31 */
|
|
};
|
|
if( a>=b ){
|
|
if( a>b+49 ) return a;
|
|
if( a>b+31 ) return a+1;
|
|
return a+x[a-b];
|
|
}else{
|
|
if( b>a+49 ) return b;
|
|
if( b>a+31 ) return b+1;
|
|
return b+x[b-a];
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Convert an integer into a LogEst. In other words, compute an
|
|
** approximation for 10*log2(x).
|
|
*/
|
|
LogEst sqlite3LogEst(u64 x){
|
|
static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
|
|
LogEst y = 40;
|
|
if( x<8 ){
|
|
if( x<2 ) return 0;
|
|
while( x<8 ){ y -= 10; x <<= 1; }
|
|
}else{
|
|
while( x>255 ){ y += 40; x >>= 4; }
|
|
while( x>15 ){ y += 10; x >>= 1; }
|
|
}
|
|
return a[x&7] + y - 10;
|
|
}
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
/*
|
|
** Convert a double into a LogEst
|
|
** In other words, compute an approximation for 10*log2(x).
|
|
*/
|
|
LogEst sqlite3LogEstFromDouble(double x){
|
|
u64 a;
|
|
LogEst e;
|
|
assert( sizeof(x)==8 && sizeof(a)==8 );
|
|
if( x<=1 ) return 0;
|
|
if( x<=2000000000 ) return sqlite3LogEst((u64)x);
|
|
memcpy(&a, &x, 8);
|
|
e = (a>>52) - 1022;
|
|
return e*10;
|
|
}
|
|
#endif /* SQLITE_OMIT_VIRTUALTABLE */
|
|
|
|
/*
|
|
** Convert a LogEst into an integer.
|
|
*/
|
|
u64 sqlite3LogEstToInt(LogEst x){
|
|
u64 n;
|
|
if( x<10 ) return 1;
|
|
n = x%10;
|
|
x /= 10;
|
|
if( n>=5 ) n -= 2;
|
|
else if( n>=1 ) n -= 1;
|
|
if( x>=3 ){
|
|
return x>60 ? (u64)LARGEST_INT64 : (n+8)<<(x-3);
|
|
}
|
|
return (n+8)>>(3-x);
|
|
}
|