| OLD | NEW |
|---|
| (Empty) |
| 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 */ | |
| 18 #include "sqliteInt.h" | |
| 19 #include <stdarg.h> | |
| 20 #ifdef SQLITE_HAVE_ISNAN | |
| 21 # include <math.h> | |
| 22 #endif | |
| 23 | |
| 24 /* | |
| 25 ** Routine needed to support the testcase() macro. | |
| 26 */ | |
| 27 #ifdef SQLITE_COVERAGE_TEST | |
| 28 void sqlite3Coverage(int x){ | |
| 29 static unsigned dummy = 0; | |
| 30 dummy += (unsigned)x; | |
| 31 } | |
| 32 #endif | |
| 33 | |
| 34 /* | |
| 35 ** Give a callback to the test harness that can be used to simulate faults | |
| 36 ** in places where it is difficult or expensive to do so purely by means | |
| 37 ** of inputs. | |
| 38 ** | |
| 39 ** The intent of the integer argument is to let the fault simulator know | |
| 40 ** which of multiple sqlite3FaultSim() calls has been hit. | |
| 41 ** | |
| 42 ** Return whatever integer value the test callback returns, or return | |
| 43 ** SQLITE_OK if no test callback is installed. | |
| 44 */ | |
| 45 #ifndef SQLITE_OMIT_BUILTIN_TEST | |
| 46 int sqlite3FaultSim(int iTest){ | |
| 47 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback; | |
| 48 return xCallback ? xCallback(iTest) : SQLITE_OK; | |
| 49 } | |
| 50 #endif | |
| 51 | |
| 52 #ifndef SQLITE_OMIT_FLOATING_POINT | |
| 53 /* | |
| 54 ** Return true if the floating point value is Not a Number (NaN). | |
| 55 ** | |
| 56 ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN. | |
| 57 ** Otherwise, we have our own implementation that works on most systems. | |
| 58 */ | |
| 59 int sqlite3IsNaN(double x){ | |
| 60 int rc; /* The value return */ | |
| 61 #if !defined(SQLITE_HAVE_ISNAN) | |
| 62 /* | |
| 63 ** Systems that support the isnan() library function should probably | |
| 64 ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have | |
| 65 ** found that many systems do not have a working isnan() function so | |
| 66 ** this implementation is provided as an alternative. | |
| 67 ** | |
| 68 ** This NaN test sometimes fails if compiled on GCC with -ffast-math. | |
| 69 ** On the other hand, the use of -ffast-math comes with the following | |
| 70 ** warning: | |
| 71 ** | |
| 72 ** This option [-ffast-math] should never be turned on by any | |
| 73 ** -O option since it can result in incorrect output for programs | |
| 74 ** which depend on an exact implementation of IEEE or ISO | |
| 75 ** rules/specifications for math functions. | |
| 76 ** | |
| 77 ** Under MSVC, this NaN test may fail if compiled with a floating- | |
| 78 ** point precision mode other than /fp:precise. From the MSDN | |
| 79 ** documentation: | |
| 80 ** | |
| 81 ** The compiler [with /fp:precise] will properly handle comparisons | |
| 82 ** involving NaN. For example, x != x evaluates to true if x is NaN | |
| 83 ** ... | |
| 84 */ | |
| 85 #ifdef __FAST_MATH__ | |
| 86 # error SQLite will not work correctly with the -ffast-math option of GCC. | |
| 87 #endif | |
| 88 volatile double y = x; | |
| 89 volatile double z = y; | |
| 90 rc = (y!=z); | |
| 91 #else /* if defined(SQLITE_HAVE_ISNAN) */ | |
| 92 rc = isnan(x); | |
| 93 #endif /* SQLITE_HAVE_ISNAN */ | |
| 94 testcase( rc ); | |
| 95 return rc; | |
| 96 } | |
| 97 #endif /* SQLITE_OMIT_FLOATING_POINT */ | |
| 98 | |
| 99 /* | |
| 100 ** Compute a string length that is limited to what can be stored in | |
| 101 ** lower 30 bits of a 32-bit signed integer. | |
| 102 ** | |
| 103 ** The value returned will never be negative. Nor will it ever be greater | |
| 104 ** than the actual length of the string. For very long strings (greater | |
| 105 ** than 1GiB) the value returned might be less than the true string length. | |
| 106 */ | |
| 107 int sqlite3Strlen30(const char *z){ | |
| 108 const char *z2 = z; | |
| 109 if( z==0 ) return 0; | |
| 110 while( *z2 ){ z2++; } | |
| 111 return 0x3fffffff & (int)(z2 - z); | |
| 112 } | |
| 113 | |
| 114 /* | |
| 115 ** Set the current error code to err_code and clear any prior error message. | |
| 116 */ | |
| 117 void sqlite3Error(sqlite3 *db, int err_code){ | |
| 118 assert( db!=0 ); | |
| 119 db->errCode = err_code; | |
| 120 if( db->pErr ) sqlite3ValueSetNull(db->pErr); | |
| 121 } | |
| 122 | |
| 123 /* | |
| 124 ** Set the most recent error code and error string for the sqlite | |
| 125 ** handle "db". The error code is set to "err_code". | |
| 126 ** | |
| 127 ** If it is not NULL, string zFormat specifies the format of the | |
| 128 ** error string in the style of the printf functions: The following | |
| 129 ** format characters are allowed: | |
| 130 ** | |
| 131 ** %s Insert a string | |
| 132 ** %z A string that should be freed after use | |
| 133 ** %d Insert an integer | |
| 134 ** %T Insert a token | |
| 135 ** %S Insert the first element of a SrcList | |
| 136 ** | |
| 137 ** zFormat and any string tokens that follow it are assumed to be | |
| 138 ** encoded in UTF-8. | |
| 139 ** | |
| 140 ** To clear the most recent error for sqlite handle "db", sqlite3Error | |
| 141 ** should be called with err_code set to SQLITE_OK and zFormat set | |
| 142 ** to NULL. | |
| 143 */ | |
| 144 void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ | |
| 145 assert( db!=0 ); | |
| 146 db->errCode = err_code; | |
| 147 if( zFormat==0 ){ | |
| 148 sqlite3Error(db, err_code); | |
| 149 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ | |
| 150 char *z; | |
| 151 va_list ap; | |
| 152 va_start(ap, zFormat); | |
| 153 z = sqlite3VMPrintf(db, zFormat, ap); | |
| 154 va_end(ap); | |
| 155 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 /* | |
| 160 ** Add an error message to pParse->zErrMsg and increment pParse->nErr. | |
| 161 ** The following formatting characters are allowed: | |
| 162 ** | |
| 163 ** %s Insert a string | |
| 164 ** %z A string that should be freed after use | |
| 165 ** %d Insert an integer | |
| 166 ** %T Insert a token | |
| 167 ** %S Insert the first element of a SrcList | |
| 168 ** | |
| 169 ** This function should be used to report any error that occurs while | |
| 170 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The | |
| 171 ** last thing the sqlite3_prepare() function does is copy the error | |
| 172 ** stored by this function into the database handle using sqlite3Error(). | |
| 173 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used | |
| 174 ** during statement execution (sqlite3_step() etc.). | |
| 175 */ | |
| 176 void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ | |
| 177 char *zMsg; | |
| 178 va_list ap; | |
| 179 sqlite3 *db = pParse->db; | |
| 180 va_start(ap, zFormat); | |
| 181 zMsg = sqlite3VMPrintf(db, zFormat, ap); | |
| 182 va_end(ap); | |
| 183 if( db->suppressErr ){ | |
| 184 sqlite3DbFree(db, zMsg); | |
| 185 }else{ | |
| 186 pParse->nErr++; | |
| 187 sqlite3DbFree(db, pParse->zErrMsg); | |
| 188 pParse->zErrMsg = zMsg; | |
| 189 pParse->rc = SQLITE_ERROR; | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 /* | |
| 194 ** Convert an SQL-style quoted string into a normal string by removing | |
| 195 ** the quote characters. The conversion is done in-place. If the | |
| 196 ** input does not begin with a quote character, then this routine | |
| 197 ** is a no-op. | |
| 198 ** | |
| 199 ** The input string must be zero-terminated. A new zero-terminator | |
| 200 ** is added to the dequoted string. | |
| 201 ** | |
| 202 ** The return value is -1 if no dequoting occurs or the length of the | |
| 203 ** dequoted string, exclusive of the zero terminator, if dequoting does | |
| 204 ** occur. | |
| 205 ** | |
| 206 ** 2002-Feb-14: This routine is extended to remove MS-Access style | |
| 207 ** brackets from around identifiers. For example: "[a-b-c]" becomes | |
| 208 ** "a-b-c". | |
| 209 */ | |
| 210 int sqlite3Dequote(char *z){ | |
| 211 char quote; | |
| 212 int i, j; | |
| 213 if( z==0 ) return -1; | |
| 214 quote = z[0]; | |
| 215 switch( quote ){ | |
| 216 case '\'': break; | |
| 217 case '"': break; | |
| 218 case '`': break; /* For MySQL compatibility */ | |
| 219 case '[': quote = ']'; break; /* For MS SqlServer compatibility */ | |
| 220 default: return -1; | |
| 221 } | |
| 222 for(i=1, j=0;; i++){ | |
| 223 assert( z[i] ); | |
| 224 if( z[i]==quote ){ | |
| 225 if( z[i+1]==quote ){ | |
| 226 z[j++] = quote; | |
| 227 i++; | |
| 228 }else{ | |
| 229 break; | |
| 230 } | |
| 231 }else{ | |
| 232 z[j++] = z[i]; | |
| 233 } | |
| 234 } | |
| 235 z[j] = 0; | |
| 236 return j; | |
| 237 } | |
| 238 | |
| 239 /* Convenient short-hand */ | |
| 240 #define UpperToLower sqlite3UpperToLower | |
| 241 | |
| 242 /* | |
| 243 ** Some systems have stricmp(). Others have strcasecmp(). Because | |
| 244 ** there is no consistency, we will define our own. | |
| 245 ** | |
| 246 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and | |
| 247 ** sqlite3_strnicmp() APIs allow applications and extensions to compare | |
| 248 ** the contents of two buffers containing UTF-8 strings in a | |
| 249 ** case-independent fashion, using the same definition of "case | |
| 250 ** independence" that SQLite uses internally when comparing identifiers. | |
| 251 */ | |
| 252 int sqlite3_stricmp(const char *zLeft, const char *zRight){ | |
| 253 register unsigned char *a, *b; | |
| 254 a = (unsigned char *)zLeft; | |
| 255 b = (unsigned char *)zRight; | |
| 256 while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } | |
| 257 return UpperToLower[*a] - UpperToLower[*b]; | |
| 258 } | |
| 259 int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ | |
| 260 register unsigned char *a, *b; | |
| 261 a = (unsigned char *)zLeft; | |
| 262 b = (unsigned char *)zRight; | |
| 263 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } | |
| 264 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; | |
| 265 } | |
| 266 | |
| 267 /* | |
| 268 ** The string z[] is an text representation of a real number. | |
| 269 ** Convert this string to a double and write it into *pResult. | |
| 270 ** | |
| 271 ** The string z[] is length bytes in length (bytes, not characters) and | |
| 272 ** uses the encoding enc. The string is not necessarily zero-terminated. | |
| 273 ** | |
| 274 ** Return TRUE if the result is a valid real number (or integer) and FALSE | |
| 275 ** if the string is empty or contains extraneous text. Valid numbers | |
| 276 ** are in one of these formats: | |
| 277 ** | |
| 278 ** [+-]digits[E[+-]digits] | |
| 279 ** [+-]digits.[digits][E[+-]digits] | |
| 280 ** [+-].digits[E[+-]digits] | |
| 281 ** | |
| 282 ** Leading and trailing whitespace is ignored for the purpose of determining | |
| 283 ** validity. | |
| 284 ** | |
| 285 ** If some prefix of the input string is a valid number, this routine | |
| 286 ** returns FALSE but it still converts the prefix and writes the result | |
| 287 ** into *pResult. | |
| 288 */ | |
| 289 int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ | |
| 290 #ifndef SQLITE_OMIT_FLOATING_POINT | |
| 291 int incr; | |
| 292 const char *zEnd = z + length; | |
| 293 /* sign * significand * (10 ^ (esign * exponent)) */ | |
| 294 int sign = 1; /* sign of significand */ | |
| 295 i64 s = 0; /* significand */ | |
| 296 int d = 0; /* adjust exponent for shifting decimal point */ | |
| 297 int esign = 1; /* sign of exponent */ | |
| 298 int e = 0; /* exponent */ | |
| 299 int eValid = 1; /* True exponent is either not used or is well-formed */ | |
| 300 double result; | |
| 301 int nDigits = 0; | |
| 302 int nonNum = 0; | |
| 303 | |
| 304 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); | |
| 305 *pResult = 0.0; /* Default return value, in case of an error */ | |
| 306 | |
| 307 if( enc==SQLITE_UTF8 ){ | |
| 308 incr = 1; | |
| 309 }else{ | |
| 310 int i; | |
| 311 incr = 2; | |
| 312 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); | |
| 313 for(i=3-enc; i<length && z[i]==0; i+=2){} | |
| 314 nonNum = i<length; | |
| 315 zEnd = z+i+enc-3; | |
| 316 z += (enc&1); | |
| 317 } | |
| 318 | |
| 319 /* skip leading spaces */ | |
| 320 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; | |
| 321 if( z>=zEnd ) return 0; | |
| 322 | |
| 323 /* get sign of significand */ | |
| 324 if( *z=='-' ){ | |
| 325 sign = -1; | |
| 326 z+=incr; | |
| 327 }else if( *z=='+' ){ | |
| 328 z+=incr; | |
| 329 } | |
| 330 | |
| 331 /* skip leading zeroes */ | |
| 332 while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++; | |
| 333 | |
| 334 /* copy max significant digits to significand */ | |
| 335 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){ | |
| 336 s = s*10 + (*z - '0'); | |
| 337 z+=incr, nDigits++; | |
| 338 } | |
| 339 | |
| 340 /* skip non-significant significand digits | |
| 341 ** (increase exponent by d to shift decimal left) */ | |
| 342 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++; | |
| 343 if( z>=zEnd ) goto do_atof_calc; | |
| 344 | |
| 345 /* if decimal point is present */ | |
| 346 if( *z=='.' ){ | |
| 347 z+=incr; | |
| 348 /* copy digits from after decimal to significand | |
| 349 ** (decrease exponent by d to shift decimal right) */ | |
| 350 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){ | |
| 351 s = s*10 + (*z - '0'); | |
| 352 z+=incr, nDigits++, d--; | |
| 353 } | |
| 354 /* skip non-significant digits */ | |
| 355 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++; | |
| 356 } | |
| 357 if( z>=zEnd ) goto do_atof_calc; | |
| 358 | |
| 359 /* if exponent is present */ | |
| 360 if( *z=='e' || *z=='E' ){ | |
| 361 z+=incr; | |
| 362 eValid = 0; | |
| 363 if( z>=zEnd ) goto do_atof_calc; | |
| 364 /* get sign of exponent */ | |
| 365 if( *z=='-' ){ | |
| 366 esign = -1; | |
| 367 z+=incr; | |
| 368 }else if( *z=='+' ){ | |
| 369 z+=incr; | |
| 370 } | |
| 371 /* copy digits to exponent */ | |
| 372 while( z<zEnd && sqlite3Isdigit(*z) ){ | |
| 373 e = e<10000 ? (e*10 + (*z - '0')) : 10000; | |
| 374 z+=incr; | |
| 375 eValid = 1; | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 /* skip trailing spaces */ | |
| 380 if( nDigits && eValid ){ | |
| 381 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; | |
| 382 } | |
| 383 | |
| 384 do_atof_calc: | |
| 385 /* adjust exponent by d, and update sign */ | |
| 386 e = (e*esign) + d; | |
| 387 if( e<0 ) { | |
| 388 esign = -1; | |
| 389 e *= -1; | |
| 390 } else { | |
| 391 esign = 1; | |
| 392 } | |
| 393 | |
| 394 /* if 0 significand */ | |
| 395 if( !s ) { | |
| 396 /* In the IEEE 754 standard, zero is signed. | |
| 397 ** Add the sign if we've seen at least one digit */ | |
| 398 result = (sign<0 && nDigits) ? -(double)0 : (double)0; | |
| 399 } else { | |
| 400 /* attempt to reduce exponent */ | |
| 401 if( esign>0 ){ | |
| 402 while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10; | |
| 403 }else{ | |
| 404 while( !(s%10) && e>0 ) e--,s/=10; | |
| 405 } | |
| 406 | |
| 407 /* adjust the sign of significand */ | |
| 408 s = sign<0 ? -s : s; | |
| 409 | |
| 410 /* if exponent, scale significand as appropriate | |
| 411 ** and store in result. */ | |
| 412 if( e ){ | |
| 413 LONGDOUBLE_TYPE scale = 1.0; | |
| 414 /* attempt to handle extremely small/large numbers better */ | |
| 415 if( e>307 && e<342 ){ | |
| 416 while( e%308 ) { scale *= 1.0e+1; e -= 1; } | |
| 417 if( esign<0 ){ | |
| 418 result = s / scale; | |
| 419 result /= 1.0e+308; | |
| 420 }else{ | |
| 421 result = s * scale; | |
| 422 result *= 1.0e+308; | |
| 423 } | |
| 424 }else if( e>=342 ){ | |
| 425 if( esign<0 ){ | |
| 426 result = 0.0*s; | |
| 427 }else{ | |
| 428 result = 1e308*1e308*s; /* Infinity */ | |
| 429 } | |
| 430 }else{ | |
| 431 /* 1.0e+22 is the largest power of 10 than can be | |
| 432 ** represented exactly. */ | |
| 433 while( e%22 ) { scale *= 1.0e+1; e -= 1; } | |
| 434 while( e>0 ) { scale *= 1.0e+22; e -= 22; } | |
| 435 if( esign<0 ){ | |
| 436 result = s / scale; | |
| 437 }else{ | |
| 438 result = s * scale; | |
| 439 } | |
| 440 } | |
| 441 } else { | |
| 442 result = (double)s; | |
| 443 } | |
| 444 } | |
| 445 | |
| 446 /* store the result */ | |
| 447 *pResult = result; | |
| 448 | |
| 449 /* return true if number and no extra non-whitespace chracters after */ | |
| 450 return z>=zEnd && nDigits>0 && eValid && nonNum==0; | |
| 451 #else | |
| 452 return !sqlite3Atoi64(z, pResult, length, enc); | |
| 453 #endif /* SQLITE_OMIT_FLOATING_POINT */ | |
| 454 } | |
| 455 | |
| 456 /* | |
| 457 ** Compare the 19-character string zNum against the text representation | |
| 458 ** value 2^63: 9223372036854775808. Return negative, zero, or positive | |
| 459 ** if zNum is less than, equal to, or greater than the string. | |
| 460 ** Note that zNum must contain exactly 19 characters. | |
| 461 ** | |
| 462 ** Unlike memcmp() this routine is guaranteed to return the difference | |
| 463 ** in the values of the last digit if the only difference is in the | |
| 464 ** last digit. So, for example, | |
| 465 ** | |
| 466 ** compare2pow63("9223372036854775800", 1) | |
| 467 ** | |
| 468 ** will return -8. | |
| 469 */ | |
| 470 static int compare2pow63(const char *zNum, int incr){ | |
| 471 int c = 0; | |
| 472 int i; | |
| 473 /* 012345678901234567 */ | |
| 474 const char *pow63 = "922337203685477580"; | |
| 475 for(i=0; c==0 && i<18; i++){ | |
| 476 c = (zNum[i*incr]-pow63[i])*10; | |
| 477 } | |
| 478 if( c==0 ){ | |
| 479 c = zNum[18*incr] - '8'; | |
| 480 testcase( c==(-1) ); | |
| 481 testcase( c==0 ); | |
| 482 testcase( c==(+1) ); | |
| 483 } | |
| 484 return c; | |
| 485 } | |
| 486 | |
| 487 /* | |
| 488 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This | |
| 489 ** routine does *not* accept hexadecimal notation. | |
| 490 ** | |
| 491 ** If the zNum value is representable as a 64-bit twos-complement | |
| 492 ** integer, then write that value into *pNum and return 0. | |
| 493 ** | |
| 494 ** If zNum is exactly 9223372036854775808, return 2. This special | |
| 495 ** case is broken out because while 9223372036854775808 cannot be a | |
| 496 ** signed 64-bit integer, its negative -9223372036854775808 can be. | |
| 497 ** | |
| 498 ** If zNum is too big for a 64-bit integer and is not | |
| 499 ** 9223372036854775808 or if zNum contains any non-numeric text, | |
| 500 ** then return 1. | |
| 501 ** | |
| 502 ** length is the number of bytes in the string (bytes, not characters). | |
| 503 ** The string is not necessarily zero-terminated. The encoding is | |
| 504 ** given by enc. | |
| 505 */ | |
| 506 int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ | |
| 507 int incr; | |
| 508 u64 u = 0; | |
| 509 int neg = 0; /* assume positive */ | |
| 510 int i; | |
| 511 int c = 0; | |
| 512 int nonNum = 0; | |
| 513 const char *zStart; | |
| 514 const char *zEnd = zNum + length; | |
| 515 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); | |
| 516 if( enc==SQLITE_UTF8 ){ | |
| 517 incr = 1; | |
| 518 }else{ | |
| 519 incr = 2; | |
| 520 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); | |
| 521 for(i=3-enc; i<length && zNum[i]==0; i+=2){} | |
| 522 nonNum = i<length; | |
| 523 zEnd = zNum+i+enc-3; | |
| 524 zNum += (enc&1); | |
| 525 } | |
| 526 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr; | |
| 527 if( zNum<zEnd ){ | |
| 528 if( *zNum=='-' ){ | |
| 529 neg = 1; | |
| 530 zNum+=incr; | |
| 531 }else if( *zNum=='+' ){ | |
| 532 zNum+=incr; | |
| 533 } | |
| 534 } | |
| 535 zStart = zNum; | |
| 536 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */ | |
| 537 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){ | |
| 538 u = u*10 + c - '0'; | |
| 539 } | |
| 540 if( u>LARGEST_INT64 ){ | |
| 541 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; | |
| 542 }else if( neg ){ | |
| 543 *pNum = -(i64)u; | |
| 544 }else{ | |
| 545 *pNum = (i64)u; | |
| 546 } | |
| 547 testcase( i==18 ); | |
| 548 testcase( i==19 ); | |
| 549 testcase( i==20 ); | |
| 550 if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr || nonNum )
{ | |
| 551 /* zNum is empty or contains non-numeric text or is longer | |
| 552 ** than 19 digits (thus guaranteeing that it is too large) */ | |
| 553 return 1; | |
| 554 }else if( i<19*incr ){ | |
| 555 /* Less than 19 digits, so we know that it fits in 64 bits */ | |
| 556 assert( u<=LARGEST_INT64 ); | |
| 557 return 0; | |
| 558 }else{ | |
| 559 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */ | |
| 560 c = compare2pow63(zNum, incr); | |
| 561 if( c<0 ){ | |
| 562 /* zNum is less than 9223372036854775808 so it fits */ | |
| 563 assert( u<=LARGEST_INT64 ); | |
| 564 return 0; | |
| 565 }else if( c>0 ){ | |
| 566 /* zNum is greater than 9223372036854775808 so it overflows */ | |
| 567 return 1; | |
| 568 }else{ | |
| 569 /* zNum is exactly 9223372036854775808. Fits if negative. The | |
| 570 ** special case 2 overflow if positive */ | |
| 571 assert( u-1==LARGEST_INT64 ); | |
| 572 return neg ? 0 : 2; | |
| 573 } | |
| 574 } | |
| 575 } | |
| 576 | |
| 577 /* | |
| 578 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal, | |
| 579 ** into a 64-bit signed integer. This routine accepts hexadecimal literals, | |
| 580 ** whereas sqlite3Atoi64() does not. | |
| 581 ** | |
| 582 ** Returns: | |
| 583 ** | |
| 584 ** 0 Successful transformation. Fits in a 64-bit signed integer. | |
| 585 ** 1 Integer too large for a 64-bit signed integer or is malformed | |
| 586 ** 2 Special case of 9223372036854775808 | |
| 587 */ | |
| 588 int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ | |
| 589 #ifndef SQLITE_OMIT_HEX_INTEGER | |
| 590 if( z[0]=='0' | |
| 591 && (z[1]=='x' || z[1]=='X') | |
| 592 && sqlite3Isxdigit(z[2]) | |
| 593 ){ | |
| 594 u64 u = 0; | |
| 595 int i, k; | |
| 596 for(i=2; z[i]=='0'; i++){} | |
| 597 for(k=i; sqlite3Isxdigit(z[k]); k++){ | |
| 598 u = u*16 + sqlite3HexToInt(z[k]); | |
| 599 } | |
| 600 memcpy(pOut, &u, 8); | |
| 601 return (z[k]==0 && k-i<=16) ? 0 : 1; | |
| 602 }else | |
| 603 #endif /* SQLITE_OMIT_HEX_INTEGER */ | |
| 604 { | |
| 605 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); | |
| 606 } | |
| 607 } | |
| 608 | |
| 609 /* | |
| 610 ** If zNum represents an integer that will fit in 32-bits, then set | |
| 611 ** *pValue to that integer and return true. Otherwise return false. | |
| 612 ** | |
| 613 ** This routine accepts both decimal and hexadecimal notation for integers. | |
| 614 ** | |
| 615 ** Any non-numeric characters that following zNum are ignored. | |
| 616 ** This is different from sqlite3Atoi64() which requires the | |
| 617 ** input number to be zero-terminated. | |
| 618 */ | |
| 619 int sqlite3GetInt32(const char *zNum, int *pValue){ | |
| 620 sqlite_int64 v = 0; | |
| 621 int i, c; | |
| 622 int neg = 0; | |
| 623 if( zNum[0]=='-' ){ | |
| 624 neg = 1; | |
| 625 zNum++; | |
| 626 }else if( zNum[0]=='+' ){ | |
| 627 zNum++; | |
| 628 } | |
| 629 #ifndef SQLITE_OMIT_HEX_INTEGER | |
| 630 else if( zNum[0]=='0' | |
| 631 && (zNum[1]=='x' || zNum[1]=='X') | |
| 632 && sqlite3Isxdigit(zNum[2]) | |
| 633 ){ | |
| 634 u32 u = 0; | |
| 635 zNum += 2; | |
| 636 while( zNum[0]=='0' ) zNum++; | |
| 637 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){ | |
| 638 u = u*16 + sqlite3HexToInt(zNum[i]); | |
| 639 } | |
| 640 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ | |
| 641 memcpy(pValue, &u, 4); | |
| 642 return 1; | |
| 643 }else{ | |
| 644 return 0; | |
| 645 } | |
| 646 } | |
| 647 #endif | |
| 648 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ | |
| 649 v = v*10 + c; | |
| 650 } | |
| 651 | |
| 652 /* The longest decimal representation of a 32 bit integer is 10 digits: | |
| 653 ** | |
| 654 ** 1234567890 | |
| 655 ** 2^31 -> 2147483648 | |
| 656 */ | |
| 657 testcase( i==10 ); | |
| 658 if( i>10 ){ | |
| 659 return 0; | |
| 660 } | |
| 661 testcase( v-neg==2147483647 ); | |
| 662 if( v-neg>2147483647 ){ | |
| 663 return 0; | |
| 664 } | |
| 665 if( neg ){ | |
| 666 v = -v; | |
| 667 } | |
| 668 *pValue = (int)v; | |
| 669 return 1; | |
| 670 } | |
| 671 | |
| 672 /* | |
| 673 ** Return a 32-bit integer value extracted from a string. If the | |
| 674 ** string is not an integer, just return 0. | |
| 675 */ | |
| 676 int sqlite3Atoi(const char *z){ | |
| 677 int x = 0; | |
| 678 if( z ) sqlite3GetInt32(z, &x); | |
| 679 return x; | |
| 680 } | |
| 681 | |
| 682 /* | |
| 683 ** The variable-length integer encoding is as follows: | |
| 684 ** | |
| 685 ** KEY: | |
| 686 ** A = 0xxxxxxx 7 bits of data and one flag bit | |
| 687 ** B = 1xxxxxxx 7 bits of data and one flag bit | |
| 688 ** C = xxxxxxxx 8 bits of data | |
| 689 ** | |
| 690 ** 7 bits - A | |
| 691 ** 14 bits - BA | |
| 692 ** 21 bits - BBA | |
| 693 ** 28 bits - BBBA | |
| 694 ** 35 bits - BBBBA | |
| 695 ** 42 bits - BBBBBA | |
| 696 ** 49 bits - BBBBBBA | |
| 697 ** 56 bits - BBBBBBBA | |
| 698 ** 64 bits - BBBBBBBBC | |
| 699 */ | |
| 700 | |
| 701 /* | |
| 702 ** Write a 64-bit variable-length integer to memory starting at p[0]. | |
| 703 ** The length of data write will be between 1 and 9 bytes. The number | |
| 704 ** of bytes written is returned. | |
| 705 ** | |
| 706 ** A variable-length integer consists of the lower 7 bits of each byte | |
| 707 ** for all bytes that have the 8th bit set and one byte with the 8th | |
| 708 ** bit clear. Except, if we get to the 9th byte, it stores the full | |
| 709 ** 8 bits and is the last byte. | |
| 710 */ | |
| 711 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ | |
| 712 int i, j, n; | |
| 713 u8 buf[10]; | |
| 714 if( v & (((u64)0xff000000)<<32) ){ | |
| 715 p[8] = (u8)v; | |
| 716 v >>= 8; | |
| 717 for(i=7; i>=0; i--){ | |
| 718 p[i] = (u8)((v & 0x7f) | 0x80); | |
| 719 v >>= 7; | |
| 720 } | |
| 721 return 9; | |
| 722 } | |
| 723 n = 0; | |
| 724 do{ | |
| 725 buf[n++] = (u8)((v & 0x7f) | 0x80); | |
| 726 v >>= 7; | |
| 727 }while( v!=0 ); | |
| 728 buf[0] &= 0x7f; | |
| 729 assert( n<=9 ); | |
| 730 for(i=0, j=n-1; j>=0; j--, i++){ | |
| 731 p[i] = buf[j]; | |
| 732 } | |
| 733 return n; | |
| 734 } | |
| 735 int sqlite3PutVarint(unsigned char *p, u64 v){ | |
| 736 if( v<=0x7f ){ | |
| 737 p[0] = v&0x7f; | |
| 738 return 1; | |
| 739 } | |
| 740 if( v<=0x3fff ){ | |
| 741 p[0] = ((v>>7)&0x7f)|0x80; | |
| 742 p[1] = v&0x7f; | |
| 743 return 2; | |
| 744 } | |
| 745 return putVarint64(p,v); | |
| 746 } | |
| 747 | |
| 748 /* | |
| 749 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants | |
| 750 ** are defined here rather than simply putting the constant expressions | |
| 751 ** inline in order to work around bugs in the RVT compiler. | |
| 752 ** | |
| 753 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f | |
| 754 ** | |
| 755 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 | |
| 756 */ | |
| 757 #define SLOT_2_0 0x001fc07f | |
| 758 #define SLOT_4_2_0 0xf01fc07f | |
| 759 | |
| 760 | |
| 761 /* | |
| 762 ** Read a 64-bit variable-length integer from memory starting at p[0]. | |
| 763 ** Return the number of bytes read. The value is stored in *v. | |
| 764 */ | |
| 765 u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ | |
| 766 u32 a,b,s; | |
| 767 | |
| 768 a = *p; | |
| 769 /* a: p0 (unmasked) */ | |
| 770 if (!(a&0x80)) | |
| 771 { | |
| 772 *v = a; | |
| 773 return 1; | |
| 774 } | |
| 775 | |
| 776 p++; | |
| 777 b = *p; | |
| 778 /* b: p1 (unmasked) */ | |
| 779 if (!(b&0x80)) | |
| 780 { | |
| 781 a &= 0x7f; | |
| 782 a = a<<7; | |
| 783 a |= b; | |
| 784 *v = a; | |
| 785 return 2; | |
| 786 } | |
| 787 | |
| 788 /* Verify that constants are precomputed correctly */ | |
| 789 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); | |
| 790 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); | |
| 791 | |
| 792 p++; | |
| 793 a = a<<14; | |
| 794 a |= *p; | |
| 795 /* a: p0<<14 | p2 (unmasked) */ | |
| 796 if (!(a&0x80)) | |
| 797 { | |
| 798 a &= SLOT_2_0; | |
| 799 b &= 0x7f; | |
| 800 b = b<<7; | |
| 801 a |= b; | |
| 802 *v = a; | |
| 803 return 3; | |
| 804 } | |
| 805 | |
| 806 /* CSE1 from below */ | |
| 807 a &= SLOT_2_0; | |
| 808 p++; | |
| 809 b = b<<14; | |
| 810 b |= *p; | |
| 811 /* b: p1<<14 | p3 (unmasked) */ | |
| 812 if (!(b&0x80)) | |
| 813 { | |
| 814 b &= SLOT_2_0; | |
| 815 /* moved CSE1 up */ | |
| 816 /* a &= (0x7f<<14)|(0x7f); */ | |
| 817 a = a<<7; | |
| 818 a |= b; | |
| 819 *v = a; | |
| 820 return 4; | |
| 821 } | |
| 822 | |
| 823 /* a: p0<<14 | p2 (masked) */ | |
| 824 /* b: p1<<14 | p3 (unmasked) */ | |
| 825 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ | |
| 826 /* moved CSE1 up */ | |
| 827 /* a &= (0x7f<<14)|(0x7f); */ | |
| 828 b &= SLOT_2_0; | |
| 829 s = a; | |
| 830 /* s: p0<<14 | p2 (masked) */ | |
| 831 | |
| 832 p++; | |
| 833 a = a<<14; | |
| 834 a |= *p; | |
| 835 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ | |
| 836 if (!(a&0x80)) | |
| 837 { | |
| 838 /* we can skip these cause they were (effectively) done above in calc'ing s
*/ | |
| 839 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ | |
| 840 /* b &= (0x7f<<14)|(0x7f); */ | |
| 841 b = b<<7; | |
| 842 a |= b; | |
| 843 s = s>>18; | |
| 844 *v = ((u64)s)<<32 | a; | |
| 845 return 5; | |
| 846 } | |
| 847 | |
| 848 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ | |
| 849 s = s<<7; | |
| 850 s |= b; | |
| 851 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ | |
| 852 | |
| 853 p++; | |
| 854 b = b<<14; | |
| 855 b |= *p; | |
| 856 /* b: p1<<28 | p3<<14 | p5 (unmasked) */ | |
| 857 if (!(b&0x80)) | |
| 858 { | |
| 859 /* we can skip this cause it was (effectively) done above in calc'ing s */ | |
| 860 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ | |
| 861 a &= SLOT_2_0; | |
| 862 a = a<<7; | |
| 863 a |= b; | |
| 864 s = s>>18; | |
| 865 *v = ((u64)s)<<32 | a; | |
| 866 return 6; | |
| 867 } | |
| 868 | |
| 869 p++; | |
| 870 a = a<<14; | |
| 871 a |= *p; | |
| 872 /* a: p2<<28 | p4<<14 | p6 (unmasked) */ | |
| 873 if (!(a&0x80)) | |
| 874 { | |
| 875 a &= SLOT_4_2_0; | |
| 876 b &= SLOT_2_0; | |
| 877 b = b<<7; | |
| 878 a |= b; | |
| 879 s = s>>11; | |
| 880 *v = ((u64)s)<<32 | a; | |
| 881 return 7; | |
| 882 } | |
| 883 | |
| 884 /* CSE2 from below */ | |
| 885 a &= SLOT_2_0; | |
| 886 p++; | |
| 887 b = b<<14; | |
| 888 b |= *p; | |
| 889 /* b: p3<<28 | p5<<14 | p7 (unmasked) */ | |
| 890 if (!(b&0x80)) | |
| 891 { | |
| 892 b &= SLOT_4_2_0; | |
| 893 /* moved CSE2 up */ | |
| 894 /* a &= (0x7f<<14)|(0x7f); */ | |
| 895 a = a<<7; | |
| 896 a |= b; | |
| 897 s = s>>4; | |
| 898 *v = ((u64)s)<<32 | a; | |
| 899 return 8; | |
| 900 } | |
| 901 | |
| 902 p++; | |
| 903 a = a<<15; | |
| 904 a |= *p; | |
| 905 /* a: p4<<29 | p6<<15 | p8 (unmasked) */ | |
| 906 | |
| 907 /* moved CSE2 up */ | |
| 908 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ | |
| 909 b &= SLOT_2_0; | |
| 910 b = b<<8; | |
| 911 a |= b; | |
| 912 | |
| 913 s = s<<4; | |
| 914 b = p[-4]; | |
| 915 b &= 0x7f; | |
| 916 b = b>>3; | |
| 917 s |= b; | |
| 918 | |
| 919 *v = ((u64)s)<<32 | a; | |
| 920 | |
| 921 return 9; | |
| 922 } | |
| 923 | |
| 924 /* | |
| 925 ** Read a 32-bit variable-length integer from memory starting at p[0]. | |
| 926 ** Return the number of bytes read. The value is stored in *v. | |
| 927 ** | |
| 928 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned | |
| 929 ** integer, then set *v to 0xffffffff. | |
| 930 ** | |
| 931 ** A MACRO version, getVarint32, is provided which inlines the | |
| 932 ** single-byte case. All code should use the MACRO version as | |
| 933 ** this function assumes the single-byte case has already been handled. | |
| 934 */ | |
| 935 u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ | |
| 936 u32 a,b; | |
| 937 | |
| 938 /* The 1-byte case. Overwhelmingly the most common. Handled inline | |
| 939 ** by the getVarin32() macro */ | |
| 940 a = *p; | |
| 941 /* a: p0 (unmasked) */ | |
| 942 #ifndef getVarint32 | |
| 943 if (!(a&0x80)) | |
| 944 { | |
| 945 /* Values between 0 and 127 */ | |
| 946 *v = a; | |
| 947 return 1; | |
| 948 } | |
| 949 #endif | |
| 950 | |
| 951 /* The 2-byte case */ | |
| 952 p++; | |
| 953 b = *p; | |
| 954 /* b: p1 (unmasked) */ | |
| 955 if (!(b&0x80)) | |
| 956 { | |
| 957 /* Values between 128 and 16383 */ | |
| 958 a &= 0x7f; | |
| 959 a = a<<7; | |
| 960 *v = a | b; | |
| 961 return 2; | |
| 962 } | |
| 963 | |
| 964 /* The 3-byte case */ | |
| 965 p++; | |
| 966 a = a<<14; | |
| 967 a |= *p; | |
| 968 /* a: p0<<14 | p2 (unmasked) */ | |
| 969 if (!(a&0x80)) | |
| 970 { | |
| 971 /* Values between 16384 and 2097151 */ | |
| 972 a &= (0x7f<<14)|(0x7f); | |
| 973 b &= 0x7f; | |
| 974 b = b<<7; | |
| 975 *v = a | b; | |
| 976 return 3; | |
| 977 } | |
| 978 | |
| 979 /* A 32-bit varint is used to store size information in btrees. | |
| 980 ** Objects are rarely larger than 2MiB limit of a 3-byte varint. | |
| 981 ** A 3-byte varint is sufficient, for example, to record the size | |
| 982 ** of a 1048569-byte BLOB or string. | |
| 983 ** | |
| 984 ** We only unroll the first 1-, 2-, and 3- byte cases. The very | |
| 985 ** rare larger cases can be handled by the slower 64-bit varint | |
| 986 ** routine. | |
| 987 */ | |
| 988 #if 1 | |
| 989 { | |
| 990 u64 v64; | |
| 991 u8 n; | |
| 992 | |
| 993 p -= 2; | |
| 994 n = sqlite3GetVarint(p, &v64); | |
| 995 assert( n>3 && n<=9 ); | |
| 996 if( (v64 & SQLITE_MAX_U32)!=v64 ){ | |
| 997 *v = 0xffffffff; | |
| 998 }else{ | |
| 999 *v = (u32)v64; | |
| 1000 } | |
| 1001 return n; | |
| 1002 } | |
| 1003 | |
| 1004 #else | |
| 1005 /* For following code (kept for historical record only) shows an | |
| 1006 ** unrolling for the 3- and 4-byte varint cases. This code is | |
| 1007 ** slightly faster, but it is also larger and much harder to test. | |
| 1008 */ | |
| 1009 p++; | |
| 1010 b = b<<14; | |
| 1011 b |= *p; | |
| 1012 /* b: p1<<14 | p3 (unmasked) */ | |
| 1013 if (!(b&0x80)) | |
| 1014 { | |
| 1015 /* Values between 2097152 and 268435455 */ | |
| 1016 b &= (0x7f<<14)|(0x7f); | |
| 1017 a &= (0x7f<<14)|(0x7f); | |
| 1018 a = a<<7; | |
| 1019 *v = a | b; | |
| 1020 return 4; | |
| 1021 } | |
| 1022 | |
| 1023 p++; | |
| 1024 a = a<<14; | |
| 1025 a |= *p; | |
| 1026 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ | |
| 1027 if (!(a&0x80)) | |
| 1028 { | |
| 1029 /* Values between 268435456 and 34359738367 */ | |
| 1030 a &= SLOT_4_2_0; | |
| 1031 b &= SLOT_4_2_0; | |
| 1032 b = b<<7; | |
| 1033 *v = a | b; | |
| 1034 return 5; | |
| 1035 } | |
| 1036 | |
| 1037 /* We can only reach this point when reading a corrupt database | |
| 1038 ** file. In that case we are not in any hurry. Use the (relatively | |
| 1039 ** slow) general-purpose sqlite3GetVarint() routine to extract the | |
| 1040 ** value. */ | |
| 1041 { | |
| 1042 u64 v64; | |
| 1043 u8 n; | |
| 1044 | |
| 1045 p -= 4; | |
| 1046 n = sqlite3GetVarint(p, &v64); | |
| 1047 assert( n>5 && n<=9 ); | |
| 1048 *v = (u32)v64; | |
| 1049 return n; | |
| 1050 } | |
| 1051 #endif | |
| 1052 } | |
| 1053 | |
| 1054 /* | |
| 1055 ** Return the number of bytes that will be needed to store the given | |
| 1056 ** 64-bit integer. | |
| 1057 */ | |
| 1058 int sqlite3VarintLen(u64 v){ | |
| 1059 int i = 0; | |
| 1060 do{ | |
| 1061 i++; | |
| 1062 v >>= 7; | |
| 1063 }while( v!=0 && ALWAYS(i<9) ); | |
| 1064 return i; | |
| 1065 } | |
| 1066 | |
| 1067 | |
| 1068 /* | |
| 1069 ** Read or write a four-byte big-endian integer value. | |
| 1070 */ | |
| 1071 u32 sqlite3Get4byte(const u8 *p){ | |
| 1072 testcase( p[0]&0x80 ); | |
| 1073 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; | |
| 1074 } | |
| 1075 void sqlite3Put4byte(unsigned char *p, u32 v){ | |
| 1076 p[0] = (u8)(v>>24); | |
| 1077 p[1] = (u8)(v>>16); | |
| 1078 p[2] = (u8)(v>>8); | |
| 1079 p[3] = (u8)v; | |
| 1080 } | |
| 1081 | |
| 1082 | |
| 1083 | |
| 1084 /* | |
| 1085 ** Translate a single byte of Hex into an integer. | |
| 1086 ** This routine only works if h really is a valid hexadecimal | |
| 1087 ** character: 0..9a..fA..F | |
| 1088 */ | |
| 1089 u8 sqlite3HexToInt(int h){ | |
| 1090 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); | |
| 1091 #ifdef SQLITE_ASCII | |
| 1092 h += 9*(1&(h>>6)); | |
| 1093 #endif | |
| 1094 #ifdef SQLITE_EBCDIC | |
| 1095 h += 9*(1&~(h>>4)); | |
| 1096 #endif | |
| 1097 return (u8)(h & 0xf); | |
| 1098 } | |
| 1099 | |
| 1100 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) | |
| 1101 /* | |
| 1102 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary | |
| 1103 ** value. Return a pointer to its binary value. Space to hold the | |
| 1104 ** binary value has been obtained from malloc and must be freed by | |
| 1105 ** the calling routine. | |
| 1106 */ | |
| 1107 void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ | |
| 1108 char *zBlob; | |
| 1109 int i; | |
| 1110 | |
| 1111 zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1); | |
| 1112 n--; | |
| 1113 if( zBlob ){ | |
| 1114 for(i=0; i<n; i+=2){ | |
| 1115 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]); | |
| 1116 } | |
| 1117 zBlob[i/2] = 0; | |
| 1118 } | |
| 1119 return zBlob; | |
| 1120 } | |
| 1121 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */ | |
| 1122 | |
| 1123 /* | |
| 1124 ** Log an error that is an API call on a connection pointer that should | |
| 1125 ** not have been used. The "type" of connection pointer is given as the | |
| 1126 ** argument. The zType is a word like "NULL" or "closed" or "invalid". | |
| 1127 */ | |
| 1128 static void logBadConnection(const char *zType){ | |
| 1129 sqlite3_log(SQLITE_MISUSE, | |
| 1130 "API call with %s database connection pointer", | |
| 1131 zType | |
| 1132 ); | |
| 1133 } | |
| 1134 | |
| 1135 /* | |
| 1136 ** Check to make sure we have a valid db pointer. This test is not | |
| 1137 ** foolproof but it does provide some measure of protection against | |
| 1138 ** misuse of the interface such as passing in db pointers that are | |
| 1139 ** NULL or which have been previously closed. If this routine returns | |
| 1140 ** 1 it means that the db pointer is valid and 0 if it should not be | |
| 1141 ** dereferenced for any reason. The calling function should invoke | |
| 1142 ** SQLITE_MISUSE immediately. | |
| 1143 ** | |
| 1144 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for | |
| 1145 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to | |
| 1146 ** open properly and is not fit for general use but which can be | |
| 1147 ** used as an argument to sqlite3_errmsg() or sqlite3_close(). | |
| 1148 */ | |
| 1149 int sqlite3SafetyCheckOk(sqlite3 *db){ | |
| 1150 u32 magic; | |
| 1151 if( db==0 ){ | |
| 1152 logBadConnection("NULL"); | |
| 1153 return 0; | |
| 1154 } | |
| 1155 magic = db->magic; | |
| 1156 if( magic!=SQLITE_MAGIC_OPEN ){ | |
| 1157 if( sqlite3SafetyCheckSickOrOk(db) ){ | |
| 1158 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 1159 logBadConnection("unopened"); | |
| 1160 } | |
| 1161 return 0; | |
| 1162 }else{ | |
| 1163 return 1; | |
| 1164 } | |
| 1165 } | |
| 1166 int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ | |
| 1167 u32 magic; | |
| 1168 magic = db->magic; | |
| 1169 if( magic!=SQLITE_MAGIC_SICK && | |
| 1170 magic!=SQLITE_MAGIC_OPEN && | |
| 1171 magic!=SQLITE_MAGIC_BUSY ){ | |
| 1172 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 1173 logBadConnection("invalid"); | |
| 1174 return 0; | |
| 1175 }else{ | |
| 1176 return 1; | |
| 1177 } | |
| 1178 } | |
| 1179 | |
| 1180 /* | |
| 1181 ** Attempt to add, substract, or multiply the 64-bit signed value iB against | |
| 1182 ** the other 64-bit signed integer at *pA and store the result in *pA. | |
| 1183 ** Return 0 on success. Or if the operation would have resulted in an | |
| 1184 ** overflow, leave *pA unchanged and return 1. | |
| 1185 */ | |
| 1186 int sqlite3AddInt64(i64 *pA, i64 iB){ | |
| 1187 i64 iA = *pA; | |
| 1188 testcase( iA==0 ); testcase( iA==1 ); | |
| 1189 testcase( iB==-1 ); testcase( iB==0 ); | |
| 1190 if( iB>=0 ){ | |
| 1191 testcase( iA>0 && LARGEST_INT64 - iA == iB ); | |
| 1192 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); | |
| 1193 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; | |
| 1194 }else{ | |
| 1195 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); | |
| 1196 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); | |
| 1197 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; | |
| 1198 } | |
| 1199 *pA += iB; | |
| 1200 return 0; | |
| 1201 } | |
| 1202 int sqlite3SubInt64(i64 *pA, i64 iB){ | |
| 1203 testcase( iB==SMALLEST_INT64+1 ); | |
| 1204 if( iB==SMALLEST_INT64 ){ | |
| 1205 testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); | |
| 1206 if( (*pA)>=0 ) return 1; | |
| 1207 *pA -= iB; | |
| 1208 return 0; | |
| 1209 }else{ | |
| 1210 return sqlite3AddInt64(pA, -iB); | |
| 1211 } | |
| 1212 } | |
| 1213 #define TWOPOWER32 (((i64)1)<<32) | |
| 1214 #define TWOPOWER31 (((i64)1)<<31) | |
| 1215 int sqlite3MulInt64(i64 *pA, i64 iB){ | |
| 1216 i64 iA = *pA; | |
| 1217 i64 iA1, iA0, iB1, iB0, r; | |
| 1218 | |
| 1219 iA1 = iA/TWOPOWER32; | |
| 1220 iA0 = iA % TWOPOWER32; | |
| 1221 iB1 = iB/TWOPOWER32; | |
| 1222 iB0 = iB % TWOPOWER32; | |
| 1223 if( iA1==0 ){ | |
| 1224 if( iB1==0 ){ | |
| 1225 *pA *= iB; | |
| 1226 return 0; | |
| 1227 } | |
| 1228 r = iA0*iB1; | |
| 1229 }else if( iB1==0 ){ | |
| 1230 r = iA1*iB0; | |
| 1231 }else{ | |
| 1232 /* If both iA1 and iB1 are non-zero, overflow will result */ | |
| 1233 return 1; | |
| 1234 } | |
| 1235 testcase( r==(-TWOPOWER31)-1 ); | |
| 1236 testcase( r==(-TWOPOWER31) ); | |
| 1237 testcase( r==TWOPOWER31 ); | |
| 1238 testcase( r==TWOPOWER31-1 ); | |
| 1239 if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1; | |
| 1240 r *= TWOPOWER32; | |
| 1241 if( sqlite3AddInt64(&r, iA0*iB0) ) return 1; | |
| 1242 *pA = r; | |
| 1243 return 0; | |
| 1244 } | |
| 1245 | |
| 1246 /* | |
| 1247 ** Compute the absolute value of a 32-bit signed integer, of possible. Or | |
| 1248 ** if the integer has a value of -2147483648, return +2147483647 | |
| 1249 */ | |
| 1250 int sqlite3AbsInt32(int x){ | |
| 1251 if( x>=0 ) return x; | |
| 1252 if( x==(int)0x80000000 ) return 0x7fffffff; | |
| 1253 return -x; | |
| 1254 } | |
| 1255 | |
| 1256 #ifdef SQLITE_ENABLE_8_3_NAMES | |
| 1257 /* | |
| 1258 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database | |
| 1259 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and | |
| 1260 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than | |
| 1261 ** three characters, then shorten the suffix on z[] to be the last three | |
| 1262 ** characters of the original suffix. | |
| 1263 ** | |
| 1264 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always | |
| 1265 ** do the suffix shortening regardless of URI parameter. | |
| 1266 ** | |
| 1267 ** Examples: | |
| 1268 ** | |
| 1269 ** test.db-journal => test.nal | |
| 1270 ** test.db-wal => test.wal | |
| 1271 ** test.db-shm => test.shm | |
| 1272 ** test.db-mj7f3319fa => test.9fa | |
| 1273 */ | |
| 1274 void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ | |
| 1275 #if SQLITE_ENABLE_8_3_NAMES<2 | |
| 1276 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) | |
| 1277 #endif | |
| 1278 { | |
| 1279 int i, sz; | |
| 1280 sz = sqlite3Strlen30(z); | |
| 1281 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} | |
| 1282 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); | |
| 1283 } | |
| 1284 } | |
| 1285 #endif | |
| 1286 | |
| 1287 /* | |
| 1288 ** Find (an approximate) sum of two LogEst values. This computation is | |
| 1289 ** not a simple "+" operator because LogEst is stored as a logarithmic | |
| 1290 ** value. | |
| 1291 ** | |
| 1292 */ | |
| 1293 LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ | |
| 1294 static const unsigned char x[] = { | |
| 1295 10, 10, /* 0,1 */ | |
| 1296 9, 9, /* 2,3 */ | |
| 1297 8, 8, /* 4,5 */ | |
| 1298 7, 7, 7, /* 6,7,8 */ | |
| 1299 6, 6, 6, /* 9,10,11 */ | |
| 1300 5, 5, 5, /* 12-14 */ | |
| 1301 4, 4, 4, 4, /* 15-18 */ | |
| 1302 3, 3, 3, 3, 3, 3, /* 19-24 */ | |
| 1303 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ | |
| 1304 }; | |
| 1305 if( a>=b ){ | |
| 1306 if( a>b+49 ) return a; | |
| 1307 if( a>b+31 ) return a+1; | |
| 1308 return a+x[a-b]; | |
| 1309 }else{ | |
| 1310 if( b>a+49 ) return b; | |
| 1311 if( b>a+31 ) return b+1; | |
| 1312 return b+x[b-a]; | |
| 1313 } | |
| 1314 } | |
| 1315 | |
| 1316 /* | |
| 1317 ** Convert an integer into a LogEst. In other words, compute an | |
| 1318 ** approximation for 10*log2(x). | |
| 1319 */ | |
| 1320 LogEst sqlite3LogEst(u64 x){ | |
| 1321 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; | |
| 1322 LogEst y = 40; | |
| 1323 if( x<8 ){ | |
| 1324 if( x<2 ) return 0; | |
| 1325 while( x<8 ){ y -= 10; x <<= 1; } | |
| 1326 }else{ | |
| 1327 while( x>255 ){ y += 40; x >>= 4; } | |
| 1328 while( x>15 ){ y += 10; x >>= 1; } | |
| 1329 } | |
| 1330 return a[x&7] + y - 10; | |
| 1331 } | |
| 1332 | |
| 1333 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 1334 /* | |
| 1335 ** Convert a double into a LogEst | |
| 1336 ** In other words, compute an approximation for 10*log2(x). | |
| 1337 */ | |
| 1338 LogEst sqlite3LogEstFromDouble(double x){ | |
| 1339 u64 a; | |
| 1340 LogEst e; | |
| 1341 assert( sizeof(x)==8 && sizeof(a)==8 ); | |
| 1342 if( x<=1 ) return 0; | |
| 1343 if( x<=2000000000 ) return sqlite3LogEst((u64)x); | |
| 1344 memcpy(&a, &x, 8); | |
| 1345 e = (a>>52) - 1022; | |
| 1346 return e*10; | |
| 1347 } | |
| 1348 #endif /* SQLITE_OMIT_VIRTUALTABLE */ | |
| 1349 | |
| 1350 /* | |
| 1351 ** Convert a LogEst into an integer. | |
| 1352 */ | |
| 1353 u64 sqlite3LogEstToInt(LogEst x){ | |
| 1354 u64 n; | |
| 1355 if( x<10 ) return 1; | |
| 1356 n = x%10; | |
| 1357 x /= 10; | |
| 1358 if( n>=5 ) n -= 2; | |
| 1359 else if( n>=1 ) n -= 1; | |
| 1360 if( x>=3 ){ | |
| 1361 return x>60 ? (u64)LARGEST_INT64 : (n+8)<<(x-3); | |
| 1362 } | |
| 1363 return (n+8)>>(3-x); | |
| 1364 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
