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 #if HAVE_ISNAN || 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_UNTESTABLE 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 !SQLITE_HAVE_ISNAN && !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 HAVE_ISNAN */ 92 rc = isnan(x); 93 #endif /* 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 if( z==0 ) return 0; 109 return 0x3fffffff & (int)strlen(z); 110 } 111 112 /* 113 ** Return the declared type of a column. Or return zDflt if the column 114 ** has no declared type. 115 ** 116 ** The column type is an extra string stored after the zero-terminator on 117 ** the column name if and only if the COLFLAG_HASTYPE flag is set. 118 */ 119 char *sqlite3ColumnType(Column *pCol, char *zDflt){ 120 if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt; 121 return pCol->zName + strlen(pCol->zName) + 1; 122 } 123 124 /* 125 ** Helper function for sqlite3Error() - called rarely. Broken out into 126 ** a separate routine to avoid unnecessary register saves on entry to 127 ** sqlite3Error(). 128 */ 129 static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){ 130 if( db->pErr ) sqlite3ValueSetNull(db->pErr); 131 sqlite3SystemError(db, err_code); 132 } 133 134 /* 135 ** Set the current error code to err_code and clear any prior error message. 136 ** Also set iSysErrno (by calling sqlite3System) if the err_code indicates 137 ** that would be appropriate. 138 */ 139 void sqlite3Error(sqlite3 *db, int err_code){ 140 assert( db!=0 ); 141 db->errCode = err_code; 142 if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code); 143 } 144 145 /* 146 ** Load the sqlite3.iSysErrno field if that is an appropriate thing 147 ** to do based on the SQLite error code in rc. 148 */ 149 void sqlite3SystemError(sqlite3 *db, int rc){ 150 if( rc==SQLITE_IOERR_NOMEM ) return; 151 rc &= 0xff; 152 if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){ 153 db->iSysErrno = sqlite3OsGetLastError(db->pVfs); 154 } 155 } 156 157 /* 158 ** Set the most recent error code and error string for the sqlite 159 ** handle "db". The error code is set to "err_code". 160 ** 161 ** If it is not NULL, string zFormat specifies the format of the 162 ** error string in the style of the printf functions: The following 163 ** format characters are allowed: 164 ** 165 ** %s Insert a string 166 ** %z A string that should be freed after use 167 ** %d Insert an integer 168 ** %T Insert a token 169 ** %S Insert the first element of a SrcList 170 ** 171 ** zFormat and any string tokens that follow it are assumed to be 172 ** encoded in UTF-8. 173 ** 174 ** To clear the most recent error for sqlite handle "db", sqlite3Error 175 ** should be called with err_code set to SQLITE_OK and zFormat set 176 ** to NULL. 177 */ 178 void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ 179 assert( db!=0 ); 180 db->errCode = err_code; 181 sqlite3SystemError(db, err_code); 182 if( zFormat==0 ){ 183 sqlite3Error(db, err_code); 184 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ 185 char *z; 186 va_list ap; 187 va_start(ap, zFormat); 188 z = sqlite3VMPrintf(db, zFormat, ap); 189 va_end(ap); 190 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); 191 } 192 } 193 194 /* 195 ** Add an error message to pParse->zErrMsg and increment pParse->nErr. 196 ** The following formatting characters are allowed: 197 ** 198 ** %s Insert a string 199 ** %z A string that should be freed after use 200 ** %d Insert an integer 201 ** %T Insert a token 202 ** %S Insert the first element of a SrcList 203 ** 204 ** This function should be used to report any error that occurs while 205 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The 206 ** last thing the sqlite3_prepare() function does is copy the error 207 ** stored by this function into the database handle using sqlite3Error(). 208 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used 209 ** during statement execution (sqlite3_step() etc.). 210 */ 211 void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ 212 char *zMsg; 213 va_list ap; 214 sqlite3 *db = pParse->db; 215 va_start(ap, zFormat); 216 zMsg = sqlite3VMPrintf(db, zFormat, ap); 217 va_end(ap); 218 if( db->suppressErr ){ 219 sqlite3DbFree(db, zMsg); 220 }else{ 221 pParse->nErr++; 222 sqlite3DbFree(db, pParse->zErrMsg); 223 pParse->zErrMsg = zMsg; 224 pParse->rc = SQLITE_ERROR; 225 } 226 } 227 228 /* 229 ** Convert an SQL-style quoted string into a normal string by removing 230 ** the quote characters. The conversion is done in-place. If the 231 ** input does not begin with a quote character, then this routine 232 ** is a no-op. 233 ** 234 ** The input string must be zero-terminated. A new zero-terminator 235 ** is added to the dequoted string. 236 ** 237 ** The return value is -1 if no dequoting occurs or the length of the 238 ** dequoted string, exclusive of the zero terminator, if dequoting does 239 ** occur. 240 ** 241 ** 2002-Feb-14: This routine is extended to remove MS-Access style 242 ** brackets from around identifiers. For example: "[a-b-c]" becomes 243 ** "a-b-c". 244 */ 245 void sqlite3Dequote(char *z){ 246 char quote; 247 int i, j; 248 if( z==0 ) return; 249 quote = z[0]; 250 if( !sqlite3Isquote(quote) ) return; 251 if( quote=='[' ) quote = ']'; 252 for(i=1, j=0;; i++){ 253 assert( z[i] ); 254 if( z[i]==quote ){ 255 if( z[i+1]==quote ){ 256 z[j++] = quote; 257 i++; 258 }else{ 259 break; 260 } 261 }else{ 262 z[j++] = z[i]; 263 } 264 } 265 z[j] = 0; 266 } 267 268 /* 269 ** Generate a Token object from a string 270 */ 271 void sqlite3TokenInit(Token *p, char *z){ 272 p->z = z; 273 p->n = sqlite3Strlen30(z); 274 } 275 276 /* Convenient short-hand */ 277 #define UpperToLower sqlite3UpperToLower 278 279 /* 280 ** Some systems have stricmp(). Others have strcasecmp(). Because 281 ** there is no consistency, we will define our own. 282 ** 283 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and 284 ** sqlite3_strnicmp() APIs allow applications and extensions to compare 285 ** the contents of two buffers containing UTF-8 strings in a 286 ** case-independent fashion, using the same definition of "case 287 ** independence" that SQLite uses internally when comparing identifiers. 288 */ 289 int sqlite3_stricmp(const char *zLeft, const char *zRight){ 290 if( zLeft==0 ){ 291 return zRight ? -1 : 0; 292 }else if( zRight==0 ){ 293 return 1; 294 } 295 return sqlite3StrICmp(zLeft, zRight); 296 } 297 int sqlite3StrICmp(const char *zLeft, const char *zRight){ 298 unsigned char *a, *b; 299 int c; 300 a = (unsigned char *)zLeft; 301 b = (unsigned char *)zRight; 302 for(;;){ 303 c = (int)UpperToLower[*a] - (int)UpperToLower[*b]; 304 if( c || *a==0 ) break; 305 a++; 306 b++; 307 } 308 return c; 309 } 310 int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ 311 register unsigned char *a, *b; 312 if( zLeft==0 ){ 313 return zRight ? -1 : 0; 314 }else if( zRight==0 ){ 315 return 1; 316 } 317 a = (unsigned char *)zLeft; 318 b = (unsigned char *)zRight; 319 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } 320 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; 321 } 322 323 /* 324 ** The string z[] is an text representation of a real number. 325 ** Convert this string to a double and write it into *pResult. 326 ** 327 ** The string z[] is length bytes in length (bytes, not characters) and 328 ** uses the encoding enc. The string is not necessarily zero-terminated. 329 ** 330 ** Return TRUE if the result is a valid real number (or integer) and FALSE 331 ** if the string is empty or contains extraneous text. Valid numbers 332 ** are in one of these formats: 333 ** 334 ** [+-]digits[E[+-]digits] 335 ** [+-]digits.[digits][E[+-]digits] 336 ** [+-].digits[E[+-]digits] 337 ** 338 ** Leading and trailing whitespace is ignored for the purpose of determining 339 ** validity. 340 ** 341 ** If some prefix of the input string is a valid number, this routine 342 ** returns FALSE but it still converts the prefix and writes the result 343 ** into *pResult. 344 */ 345 int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ 346 #ifndef SQLITE_OMIT_FLOATING_POINT 347 int incr; 348 const char *zEnd = z + length; 349 /* sign * significand * (10 ^ (esign * exponent)) */ 350 int sign = 1; /* sign of significand */ 351 i64 s = 0; /* significand */ 352 int d = 0; /* adjust exponent for shifting decimal point */ 353 int esign = 1; /* sign of exponent */ 354 int e = 0; /* exponent */ 355 int eValid = 1; /* True exponent is either not used or is well-formed */ 356 double result; 357 int nDigits = 0; 358 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */ 359 360 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); 361 *pResult = 0.0; /* Default return value, in case of an error */ 362 363 if( enc==SQLITE_UTF8 ){ 364 incr = 1; 365 }else{ 366 int i; 367 incr = 2; 368 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); 369 for(i=3-enc; i<length && z[i]==0; i+=2){} 370 nonNum = i<length; 371 zEnd = &z[i^1]; 372 z += (enc&1); 373 } 374 375 /* skip leading spaces */ 376 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; 377 if( z>=zEnd ) return 0; 378 379 /* get sign of significand */ 380 if( *z=='-' ){ 381 sign = -1; 382 z+=incr; 383 }else if( *z=='+' ){ 384 z+=incr; 385 } 386 387 /* copy max significant digits to significand */ 388 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){ 389 s = s*10 + (*z - '0'); 390 z+=incr, nDigits++; 391 } 392 393 /* skip non-significant significand digits 394 ** (increase exponent by d to shift decimal left) */ 395 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++; 396 if( z>=zEnd ) goto do_atof_calc; 397 398 /* if decimal point is present */ 399 if( *z=='.' ){ 400 z+=incr; 401 /* copy digits from after decimal to significand 402 ** (decrease exponent by d to shift decimal right) */ 403 while( z<zEnd && sqlite3Isdigit(*z) ){ 404 if( s<((LARGEST_INT64-9)/10) ){ 405 s = s*10 + (*z - '0'); 406 d--; 407 } 408 z+=incr, nDigits++; 409 } 410 } 411 if( z>=zEnd ) goto do_atof_calc; 412 413 /* if exponent is present */ 414 if( *z=='e' || *z=='E' ){ 415 z+=incr; 416 eValid = 0; 417 418 /* This branch is needed to avoid a (harmless) buffer overread. The 419 ** special comment alerts the mutation tester that the correct answer 420 ** is obtained even if the branch is omitted */ 421 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/ 422 423 /* get sign of exponent */ 424 if( *z=='-' ){ 425 esign = -1; 426 z+=incr; 427 }else if( *z=='+' ){ 428 z+=incr; 429 } 430 /* copy digits to exponent */ 431 while( z<zEnd && sqlite3Isdigit(*z) ){ 432 e = e<10000 ? (e*10 + (*z - '0')) : 10000; 433 z+=incr; 434 eValid = 1; 435 } 436 } 437 438 /* skip trailing spaces */ 439 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; 440 441 do_atof_calc: 442 /* adjust exponent by d, and update sign */ 443 e = (e*esign) + d; 444 if( e<0 ) { 445 esign = -1; 446 e *= -1; 447 } else { 448 esign = 1; 449 } 450 451 if( s==0 ) { 452 /* In the IEEE 754 standard, zero is signed. */ 453 result = sign<0 ? -(double)0 : (double)0; 454 } else { 455 /* Attempt to reduce exponent. 456 ** 457 ** Branches that are not required for the correct answer but which only 458 ** help to obtain the correct answer faster are marked with special 459 ** comments, as a hint to the mutation tester. 460 */ 461 while( e>0 ){ /*OPTIMIZATION-IF-TRUE*/ 462 if( esign>0 ){ 463 if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/ 464 s *= 10; 465 }else{ 466 if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/ 467 s /= 10; 468 } 469 e--; 470 } 471 472 /* adjust the sign of significand */ 473 s = sign<0 ? -s : s; 474 475 if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/ 476 result = (double)s; 477 }else{ 478 LONGDOUBLE_TYPE scale = 1.0; 479 /* attempt to handle extremely small/large numbers better */ 480 if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/ 481 if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/ 482 while( e%308 ) { scale *= 1.0e+1; e -= 1; } 483 if( esign<0 ){ 484 result = s / scale; 485 result /= 1.0e+308; 486 }else{ 487 result = s * scale; 488 result *= 1.0e+308; 489 } 490 }else{ assert( e>=342 ); 491 if( esign<0 ){ 492 result = 0.0*s; 493 }else{ 494 #ifdef INFINITY 495 result = INFINITY*s; 496 #else 497 result = 1e308*1e308*s; /* Infinity */ 498 #endif 499 } 500 } 501 }else{ 502 /* 1.0e+22 is the largest power of 10 than can be 503 ** represented exactly. */ 504 while( e%22 ) { scale *= 1.0e+1; e -= 1; } 505 while( e>0 ) { scale *= 1.0e+22; e -= 22; } 506 if( esign<0 ){ 507 result = s / scale; 508 }else{ 509 result = s * scale; 510 } 511 } 512 } 513 } 514 515 /* store the result */ 516 *pResult = result; 517 518 /* return true if number and no extra non-whitespace chracters after */ 519 return z==zEnd && nDigits>0 && eValid && nonNum==0; 520 #else 521 return !sqlite3Atoi64(z, pResult, length, enc); 522 #endif /* SQLITE_OMIT_FLOATING_POINT */ 523 } 524 525 /* 526 ** Compare the 19-character string zNum against the text representation 527 ** value 2^63: 9223372036854775808. Return negative, zero, or positive 528 ** if zNum is less than, equal to, or greater than the string. 529 ** Note that zNum must contain exactly 19 characters. 530 ** 531 ** Unlike memcmp() this routine is guaranteed to return the difference 532 ** in the values of the last digit if the only difference is in the 533 ** last digit. So, for example, 534 ** 535 ** compare2pow63("9223372036854775800", 1) 536 ** 537 ** will return -8. 538 */ 539 static int compare2pow63(const char *zNum, int incr){ 540 int c = 0; 541 int i; 542 /* 012345678901234567 */ 543 const char *pow63 = "922337203685477580"; 544 for(i=0; c==0 && i<18; i++){ 545 c = (zNum[i*incr]-pow63[i])*10; 546 } 547 if( c==0 ){ 548 c = zNum[18*incr] - '8'; 549 testcase( c==(-1) ); 550 testcase( c==0 ); 551 testcase( c==(+1) ); 552 } 553 return c; 554 } 555 556 /* 557 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This 558 ** routine does *not* accept hexadecimal notation. 559 ** 560 ** If the zNum value is representable as a 64-bit twos-complement 561 ** integer, then write that value into *pNum and return 0. 562 ** 563 ** If zNum is exactly 9223372036854775808, return 2. This special 564 ** case is broken out because while 9223372036854775808 cannot be a 565 ** signed 64-bit integer, its negative -9223372036854775808 can be. 566 ** 567 ** If zNum is too big for a 64-bit integer and is not 568 ** 9223372036854775808 or if zNum contains any non-numeric text, 569 ** then return 1. 570 ** 571 ** length is the number of bytes in the string (bytes, not characters). 572 ** The string is not necessarily zero-terminated. The encoding is 573 ** given by enc. 574 */ 575 int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ 576 int incr; 577 u64 u = 0; 578 int neg = 0; /* assume positive */ 579 int i; 580 int c = 0; 581 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */ 582 const char *zStart; 583 const char *zEnd = zNum + length; 584 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); 585 if( enc==SQLITE_UTF8 ){ 586 incr = 1; 587 }else{ 588 incr = 2; 589 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); 590 for(i=3-enc; i<length && zNum[i]==0; i+=2){} 591 nonNum = i<length; 592 zEnd = &zNum[i^1]; 593 zNum += (enc&1); 594 } 595 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr; 596 if( zNum<zEnd ){ 597 if( *zNum=='-' ){ 598 neg = 1; 599 zNum+=incr; 600 }else if( *zNum=='+' ){ 601 zNum+=incr; 602 } 603 } 604 zStart = zNum; 605 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */ 606 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){ 607 u = u*10 + c - '0'; 608 } 609 if( u>LARGEST_INT64 ){ 610 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; 611 }else if( neg ){ 612 *pNum = -(i64)u; 613 }else{ 614 *pNum = (i64)u; 615 } 616 testcase( i==18 ); 617 testcase( i==19 ); 618 testcase( i==20 ); 619 if( &zNum[i]<zEnd /* Extra bytes at the end */ 620 || (i==0 && zStart==zNum) /* No digits */ 621 || i>19*incr /* Too many digits */ 622 || nonNum /* UTF16 with high-order bytes non-zero */ 623 ){ 624 /* zNum is empty or contains non-numeric text or is longer 625 ** than 19 digits (thus guaranteeing that it is too large) */ 626 return 1; 627 }else if( i<19*incr ){ 628 /* Less than 19 digits, so we know that it fits in 64 bits */ 629 assert( u<=LARGEST_INT64 ); 630 return 0; 631 }else{ 632 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */ 633 c = compare2pow63(zNum, incr); 634 if( c<0 ){ 635 /* zNum is less than 9223372036854775808 so it fits */ 636 assert( u<=LARGEST_INT64 ); 637 return 0; 638 }else if( c>0 ){ 639 /* zNum is greater than 9223372036854775808 so it overflows */ 640 return 1; 641 }else{ 642 /* zNum is exactly 9223372036854775808. Fits if negative. The 643 ** special case 2 overflow if positive */ 644 assert( u-1==LARGEST_INT64 ); 645 return neg ? 0 : 2; 646 } 647 } 648 } 649 650 /* 651 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal, 652 ** into a 64-bit signed integer. This routine accepts hexadecimal literals, 653 ** whereas sqlite3Atoi64() does not. 654 ** 655 ** Returns: 656 ** 657 ** 0 Successful transformation. Fits in a 64-bit signed integer. 658 ** 1 Integer too large for a 64-bit signed integer or is malformed 659 ** 2 Special case of 9223372036854775808 660 */ 661 int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ 662 #ifndef SQLITE_OMIT_HEX_INTEGER 663 if( z[0]=='0' 664 && (z[1]=='x' || z[1]=='X') 665 ){ 666 u64 u = 0; 667 int i, k; 668 for(i=2; z[i]=='0'; i++){} 669 for(k=i; sqlite3Isxdigit(z[k]); k++){ 670 u = u*16 + sqlite3HexToInt(z[k]); 671 } 672 memcpy(pOut, &u, 8); 673 return (z[k]==0 && k-i<=16) ? 0 : 1; 674 }else 675 #endif /* SQLITE_OMIT_HEX_INTEGER */ 676 { 677 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); 678 } 679 } 680 681 /* 682 ** If zNum represents an integer that will fit in 32-bits, then set 683 ** *pValue to that integer and return true. Otherwise return false. 684 ** 685 ** This routine accepts both decimal and hexadecimal notation for integers. 686 ** 687 ** Any non-numeric characters that following zNum are ignored. 688 ** This is different from sqlite3Atoi64() which requires the 689 ** input number to be zero-terminated. 690 */ 691 int sqlite3GetInt32(const char *zNum, int *pValue){ 692 sqlite_int64 v = 0; 693 int i, c; 694 int neg = 0; 695 if( zNum[0]=='-' ){ 696 neg = 1; 697 zNum++; 698 }else if( zNum[0]=='+' ){ 699 zNum++; 700 } 701 #ifndef SQLITE_OMIT_HEX_INTEGER 702 else if( zNum[0]=='0' 703 && (zNum[1]=='x' || zNum[1]=='X') 704 && sqlite3Isxdigit(zNum[2]) 705 ){ 706 u32 u = 0; 707 zNum += 2; 708 while( zNum[0]=='0' ) zNum++; 709 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){ 710 u = u*16 + sqlite3HexToInt(zNum[i]); 711 } 712 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ 713 memcpy(pValue, &u, 4); 714 return 1; 715 }else{ 716 return 0; 717 } 718 } 719 #endif 720 if( !sqlite3Isdigit(zNum[0]) ) return 0; 721 while( zNum[0]=='0' ) zNum++; 722 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ 723 v = v*10 + c; 724 } 725 726 /* The longest decimal representation of a 32 bit integer is 10 digits: 727 ** 728 ** 1234567890 729 ** 2^31 -> 2147483648 730 */ 731 testcase( i==10 ); 732 if( i>10 ){ 733 return 0; 734 } 735 testcase( v-neg==2147483647 ); 736 if( v-neg>2147483647 ){ 737 return 0; 738 } 739 if( neg ){ 740 v = -v; 741 } 742 *pValue = (int)v; 743 return 1; 744 } 745 746 /* 747 ** Return a 32-bit integer value extracted from a string. If the 748 ** string is not an integer, just return 0. 749 */ 750 int sqlite3Atoi(const char *z){ 751 int x = 0; 752 if( z ) sqlite3GetInt32(z, &x); 753 return x; 754 } 755 756 /* 757 ** The variable-length integer encoding is as follows: 758 ** 759 ** KEY: 760 ** A = 0xxxxxxx 7 bits of data and one flag bit 761 ** B = 1xxxxxxx 7 bits of data and one flag bit 762 ** C = xxxxxxxx 8 bits of data 763 ** 764 ** 7 bits - A 765 ** 14 bits - BA 766 ** 21 bits - BBA 767 ** 28 bits - BBBA 768 ** 35 bits - BBBBA 769 ** 42 bits - BBBBBA 770 ** 49 bits - BBBBBBA 771 ** 56 bits - BBBBBBBA 772 ** 64 bits - BBBBBBBBC 773 */ 774 775 /* 776 ** Write a 64-bit variable-length integer to memory starting at p[0]. 777 ** The length of data write will be between 1 and 9 bytes. The number 778 ** of bytes written is returned. 779 ** 780 ** A variable-length integer consists of the lower 7 bits of each byte 781 ** for all bytes that have the 8th bit set and one byte with the 8th 782 ** bit clear. Except, if we get to the 9th byte, it stores the full 783 ** 8 bits and is the last byte. 784 */ 785 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ 786 int i, j, n; 787 u8 buf[10]; 788 if( v & (((u64)0xff000000)<<32) ){ 789 p[8] = (u8)v; 790 v >>= 8; 791 for(i=7; i>=0; i--){ 792 p[i] = (u8)((v & 0x7f) | 0x80); 793 v >>= 7; 794 } 795 return 9; 796 } 797 n = 0; 798 do{ 799 buf[n++] = (u8)((v & 0x7f) | 0x80); 800 v >>= 7; 801 }while( v!=0 ); 802 buf[0] &= 0x7f; 803 assert( n<=9 ); 804 for(i=0, j=n-1; j>=0; j--, i++){ 805 p[i] = buf[j]; 806 } 807 return n; 808 } 809 int sqlite3PutVarint(unsigned char *p, u64 v){ 810 if( v<=0x7f ){ 811 p[0] = v&0x7f; 812 return 1; 813 } 814 if( v<=0x3fff ){ 815 p[0] = ((v>>7)&0x7f)|0x80; 816 p[1] = v&0x7f; 817 return 2; 818 } 819 return putVarint64(p,v); 820 } 821 822 /* 823 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants 824 ** are defined here rather than simply putting the constant expressions 825 ** inline in order to work around bugs in the RVT compiler. 826 ** 827 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f 828 ** 829 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 830 */ 831 #define SLOT_2_0 0x001fc07f 832 #define SLOT_4_2_0 0xf01fc07f 833 834 835 /* 836 ** Read a 64-bit variable-length integer from memory starting at p[0]. 837 ** Return the number of bytes read. The value is stored in *v. 838 */ 839 u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ 840 u32 a,b,s; 841 842 a = *p; 843 /* a: p0 (unmasked) */ 844 if (!(a&0x80)) 845 { 846 *v = a; 847 return 1; 848 } 849 850 p++; 851 b = *p; 852 /* b: p1 (unmasked) */ 853 if (!(b&0x80)) 854 { 855 a &= 0x7f; 856 a = a<<7; 857 a |= b; 858 *v = a; 859 return 2; 860 } 861 862 /* Verify that constants are precomputed correctly */ 863 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); 864 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); 865 866 p++; 867 a = a<<14; 868 a |= *p; 869 /* a: p0<<14 | p2 (unmasked) */ 870 if (!(a&0x80)) 871 { 872 a &= SLOT_2_0; 873 b &= 0x7f; 874 b = b<<7; 875 a |= b; 876 *v = a; 877 return 3; 878 } 879 880 /* CSE1 from below */ 881 a &= SLOT_2_0; 882 p++; 883 b = b<<14; 884 b |= *p; 885 /* b: p1<<14 | p3 (unmasked) */ 886 if (!(b&0x80)) 887 { 888 b &= SLOT_2_0; 889 /* moved CSE1 up */ 890 /* a &= (0x7f<<14)|(0x7f); */ 891 a = a<<7; 892 a |= b; 893 *v = a; 894 return 4; 895 } 896 897 /* a: p0<<14 | p2 (masked) */ 898 /* b: p1<<14 | p3 (unmasked) */ 899 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 900 /* moved CSE1 up */ 901 /* a &= (0x7f<<14)|(0x7f); */ 902 b &= SLOT_2_0; 903 s = a; 904 /* s: p0<<14 | p2 (masked) */ 905 906 p++; 907 a = a<<14; 908 a |= *p; 909 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ 910 if (!(a&0x80)) 911 { 912 /* we can skip these cause they were (effectively) done above 913 ** while calculating s */ 914 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ 915 /* b &= (0x7f<<14)|(0x7f); */ 916 b = b<<7; 917 a |= b; 918 s = s>>18; 919 *v = ((u64)s)<<32 | a; 920 return 5; 921 } 922 923 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 924 s = s<<7; 925 s |= b; 926 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 927 928 p++; 929 b = b<<14; 930 b |= *p; 931 /* b: p1<<28 | p3<<14 | p5 (unmasked) */ 932 if (!(b&0x80)) 933 { 934 /* we can skip this cause it was (effectively) done above in calc'ing s */ 935 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ 936 a &= SLOT_2_0; 937 a = a<<7; 938 a |= b; 939 s = s>>18; 940 *v = ((u64)s)<<32 | a; 941 return 6; 942 } 943 944 p++; 945 a = a<<14; 946 a |= *p; 947 /* a: p2<<28 | p4<<14 | p6 (unmasked) */ 948 if (!(a&0x80)) 949 { 950 a &= SLOT_4_2_0; 951 b &= SLOT_2_0; 952 b = b<<7; 953 a |= b; 954 s = s>>11; 955 *v = ((u64)s)<<32 | a; 956 return 7; 957 } 958 959 /* CSE2 from below */ 960 a &= SLOT_2_0; 961 p++; 962 b = b<<14; 963 b |= *p; 964 /* b: p3<<28 | p5<<14 | p7 (unmasked) */ 965 if (!(b&0x80)) 966 { 967 b &= SLOT_4_2_0; 968 /* moved CSE2 up */ 969 /* a &= (0x7f<<14)|(0x7f); */ 970 a = a<<7; 971 a |= b; 972 s = s>>4; 973 *v = ((u64)s)<<32 | a; 974 return 8; 975 } 976 977 p++; 978 a = a<<15; 979 a |= *p; 980 /* a: p4<<29 | p6<<15 | p8 (unmasked) */ 981 982 /* moved CSE2 up */ 983 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ 984 b &= SLOT_2_0; 985 b = b<<8; 986 a |= b; 987 988 s = s<<4; 989 b = p[-4]; 990 b &= 0x7f; 991 b = b>>3; 992 s |= b; 993 994 *v = ((u64)s)<<32 | a; 995 996 return 9; 997 } 998 999 /* 1000 ** Read a 32-bit variable-length integer from memory starting at p[0]. 1001 ** Return the number of bytes read. The value is stored in *v. 1002 ** 1003 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned 1004 ** integer, then set *v to 0xffffffff. 1005 ** 1006 ** A MACRO version, getVarint32, is provided which inlines the 1007 ** single-byte case. All code should use the MACRO version as 1008 ** this function assumes the single-byte case has already been handled. 1009 */ 1010 u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ 1011 u32 a,b; 1012 1013 /* The 1-byte case. Overwhelmingly the most common. Handled inline 1014 ** by the getVarin32() macro */ 1015 a = *p; 1016 /* a: p0 (unmasked) */ 1017 #ifndef getVarint32 1018 if (!(a&0x80)) 1019 { 1020 /* Values between 0 and 127 */ 1021 *v = a; 1022 return 1; 1023 } 1024 #endif 1025 1026 /* The 2-byte case */ 1027 p++; 1028 b = *p; 1029 /* b: p1 (unmasked) */ 1030 if (!(b&0x80)) 1031 { 1032 /* Values between 128 and 16383 */ 1033 a &= 0x7f; 1034 a = a<<7; 1035 *v = a | b; 1036 return 2; 1037 } 1038 1039 /* The 3-byte case */ 1040 p++; 1041 a = a<<14; 1042 a |= *p; 1043 /* a: p0<<14 | p2 (unmasked) */ 1044 if (!(a&0x80)) 1045 { 1046 /* Values between 16384 and 2097151 */ 1047 a &= (0x7f<<14)|(0x7f); 1048 b &= 0x7f; 1049 b = b<<7; 1050 *v = a | b; 1051 return 3; 1052 } 1053 1054 /* A 32-bit varint is used to store size information in btrees. 1055 ** Objects are rarely larger than 2MiB limit of a 3-byte varint. 1056 ** A 3-byte varint is sufficient, for example, to record the size 1057 ** of a 1048569-byte BLOB or string. 1058 ** 1059 ** We only unroll the first 1-, 2-, and 3- byte cases. The very 1060 ** rare larger cases can be handled by the slower 64-bit varint 1061 ** routine. 1062 */ 1063 #if 1 1064 { 1065 u64 v64; 1066 u8 n; 1067 1068 p -= 2; 1069 n = sqlite3GetVarint(p, &v64); 1070 assert( n>3 && n<=9 ); 1071 if( (v64 & SQLITE_MAX_U32)!=v64 ){ 1072 *v = 0xffffffff; 1073 }else{ 1074 *v = (u32)v64; 1075 } 1076 return n; 1077 } 1078 1079 #else 1080 /* For following code (kept for historical record only) shows an 1081 ** unrolling for the 3- and 4-byte varint cases. This code is 1082 ** slightly faster, but it is also larger and much harder to test. 1083 */ 1084 p++; 1085 b = b<<14; 1086 b |= *p; 1087 /* b: p1<<14 | p3 (unmasked) */ 1088 if (!(b&0x80)) 1089 { 1090 /* Values between 2097152 and 268435455 */ 1091 b &= (0x7f<<14)|(0x7f); 1092 a &= (0x7f<<14)|(0x7f); 1093 a = a<<7; 1094 *v = a | b; 1095 return 4; 1096 } 1097 1098 p++; 1099 a = a<<14; 1100 a |= *p; 1101 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ 1102 if (!(a&0x80)) 1103 { 1104 /* Values between 268435456 and 34359738367 */ 1105 a &= SLOT_4_2_0; 1106 b &= SLOT_4_2_0; 1107 b = b<<7; 1108 *v = a | b; 1109 return 5; 1110 } 1111 1112 /* We can only reach this point when reading a corrupt database 1113 ** file. In that case we are not in any hurry. Use the (relatively 1114 ** slow) general-purpose sqlite3GetVarint() routine to extract the 1115 ** value. */ 1116 { 1117 u64 v64; 1118 u8 n; 1119 1120 p -= 4; 1121 n = sqlite3GetVarint(p, &v64); 1122 assert( n>5 && n<=9 ); 1123 *v = (u32)v64; 1124 return n; 1125 } 1126 #endif 1127 } 1128 1129 /* 1130 ** Return the number of bytes that will be needed to store the given 1131 ** 64-bit integer. 1132 */ 1133 int sqlite3VarintLen(u64 v){ 1134 int i; 1135 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); } 1136 return i; 1137 } 1138 1139 1140 /* 1141 ** Read or write a four-byte big-endian integer value. 1142 */ 1143 u32 sqlite3Get4byte(const u8 *p){ 1144 #if SQLITE_BYTEORDER==4321 1145 u32 x; 1146 memcpy(&x,p,4); 1147 return x; 1148 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 1149 u32 x; 1150 memcpy(&x,p,4); 1151 return __builtin_bswap32(x); 1152 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 1153 u32 x; 1154 memcpy(&x,p,4); 1155 return _byteswap_ulong(x); 1156 #else 1157 testcase( p[0]&0x80 ); 1158 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; 1159 #endif 1160 } 1161 void sqlite3Put4byte(unsigned char *p, u32 v){ 1162 #if SQLITE_BYTEORDER==4321 1163 memcpy(p,&v,4); 1164 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 1165 u32 x = __builtin_bswap32(v); 1166 memcpy(p,&x,4); 1167 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 1168 u32 x = _byteswap_ulong(v); 1169 memcpy(p,&x,4); 1170 #else 1171 p[0] = (u8)(v>>24); 1172 p[1] = (u8)(v>>16); 1173 p[2] = (u8)(v>>8); 1174 p[3] = (u8)v; 1175 #endif 1176 } 1177 1178 1179 1180 /* 1181 ** Translate a single byte of Hex into an integer. 1182 ** This routine only works if h really is a valid hexadecimal 1183 ** character: 0..9a..fA..F 1184 */ 1185 u8 sqlite3HexToInt(int h){ 1186 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); 1187 #ifdef SQLITE_ASCII 1188 h += 9*(1&(h>>6)); 1189 #endif 1190 #ifdef SQLITE_EBCDIC 1191 h += 9*(1&~(h>>4)); 1192 #endif 1193 return (u8)(h & 0xf); 1194 } 1195 1196 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) 1197 /* 1198 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary 1199 ** value. Return a pointer to its binary value. Space to hold the 1200 ** binary value has been obtained from malloc and must be freed by 1201 ** the calling routine. 1202 */ 1203 void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ 1204 char *zBlob; 1205 int i; 1206 1207 zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1); 1208 n--; 1209 if( zBlob ){ 1210 for(i=0; i<n; i+=2){ 1211 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]); 1212 } 1213 zBlob[i/2] = 0; 1214 } 1215 return zBlob; 1216 } 1217 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */ 1218 1219 /* 1220 ** Log an error that is an API call on a connection pointer that should 1221 ** not have been used. The "type" of connection pointer is given as the 1222 ** argument. The zType is a word like "NULL" or "closed" or "invalid". 1223 */ 1224 static void logBadConnection(const char *zType){ 1225 sqlite3_log(SQLITE_MISUSE, 1226 "API call with %s database connection pointer", 1227 zType 1228 ); 1229 } 1230 1231 /* 1232 ** Check to make sure we have a valid db pointer. This test is not 1233 ** foolproof but it does provide some measure of protection against 1234 ** misuse of the interface such as passing in db pointers that are 1235 ** NULL or which have been previously closed. If this routine returns 1236 ** 1 it means that the db pointer is valid and 0 if it should not be 1237 ** dereferenced for any reason. The calling function should invoke 1238 ** SQLITE_MISUSE immediately. 1239 ** 1240 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for 1241 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to 1242 ** open properly and is not fit for general use but which can be 1243 ** used as an argument to sqlite3_errmsg() or sqlite3_close(). 1244 */ 1245 int sqlite3SafetyCheckOk(sqlite3 *db){ 1246 u32 magic; 1247 if( db==0 ){ 1248 logBadConnection("NULL"); 1249 return 0; 1250 } 1251 magic = db->magic; 1252 if( magic!=SQLITE_MAGIC_OPEN ){ 1253 if( sqlite3SafetyCheckSickOrOk(db) ){ 1254 testcase( sqlite3GlobalConfig.xLog!=0 ); 1255 logBadConnection("unopened"); 1256 } 1257 return 0; 1258 }else{ 1259 return 1; 1260 } 1261 } 1262 int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ 1263 u32 magic; 1264 magic = db->magic; 1265 if( magic!=SQLITE_MAGIC_SICK && 1266 magic!=SQLITE_MAGIC_OPEN && 1267 magic!=SQLITE_MAGIC_BUSY ){ 1268 testcase( sqlite3GlobalConfig.xLog!=0 ); 1269 logBadConnection("invalid"); 1270 return 0; 1271 }else{ 1272 return 1; 1273 } 1274 } 1275 1276 /* 1277 ** Attempt to add, substract, or multiply the 64-bit signed value iB against 1278 ** the other 64-bit signed integer at *pA and store the result in *pA. 1279 ** Return 0 on success. Or if the operation would have resulted in an 1280 ** overflow, leave *pA unchanged and return 1. 1281 */ 1282 int sqlite3AddInt64(i64 *pA, i64 iB){ 1283 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) 1284 return __builtin_add_overflow(*pA, iB, pA); 1285 #else 1286 i64 iA = *pA; 1287 testcase( iA==0 ); testcase( iA==1 ); 1288 testcase( iB==-1 ); testcase( iB==0 ); 1289 if( iB>=0 ){ 1290 testcase( iA>0 && LARGEST_INT64 - iA == iB ); 1291 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); 1292 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; 1293 }else{ 1294 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); 1295 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); 1296 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; 1297 } 1298 *pA += iB; 1299 return 0; 1300 #endif 1301 } 1302 int sqlite3SubInt64(i64 *pA, i64 iB){ 1303 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) 1304 return __builtin_sub_overflow(*pA, iB, pA); 1305 #else 1306 testcase( iB==SMALLEST_INT64+1 ); 1307 if( iB==SMALLEST_INT64 ){ 1308 testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); 1309 if( (*pA)>=0 ) return 1; 1310 *pA -= iB; 1311 return 0; 1312 }else{ 1313 return sqlite3AddInt64(pA, -iB); 1314 } 1315 #endif 1316 } 1317 int sqlite3MulInt64(i64 *pA, i64 iB){ 1318 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) 1319 return __builtin_mul_overflow(*pA, iB, pA); 1320 #else 1321 i64 iA = *pA; 1322 if( iB>0 ){ 1323 if( iA>LARGEST_INT64/iB ) return 1; 1324 if( iA<SMALLEST_INT64/iB ) return 1; 1325 }else if( iB<0 ){ 1326 if( iA>0 ){ 1327 if( iB<SMALLEST_INT64/iA ) return 1; 1328 }else if( iA<0 ){ 1329 if( iB==SMALLEST_INT64 ) return 1; 1330 if( iA==SMALLEST_INT64 ) return 1; 1331 if( -iA>LARGEST_INT64/-iB ) return 1; 1332 } 1333 } 1334 *pA = iA*iB; 1335 return 0; 1336 #endif 1337 } 1338 1339 /* 1340 ** Compute the absolute value of a 32-bit signed integer, of possible. Or 1341 ** if the integer has a value of -2147483648, return +2147483647 1342 */ 1343 int sqlite3AbsInt32(int x){ 1344 if( x>=0 ) return x; 1345 if( x==(int)0x80000000 ) return 0x7fffffff; 1346 return -x; 1347 } 1348 1349 #ifdef SQLITE_ENABLE_8_3_NAMES 1350 /* 1351 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database 1352 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and 1353 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than 1354 ** three characters, then shorten the suffix on z[] to be the last three 1355 ** characters of the original suffix. 1356 ** 1357 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always 1358 ** do the suffix shortening regardless of URI parameter. 1359 ** 1360 ** Examples: 1361 ** 1362 ** test.db-journal => test.nal 1363 ** test.db-wal => test.wal 1364 ** test.db-shm => test.shm 1365 ** test.db-mj7f3319fa => test.9fa 1366 */ 1367 void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ 1368 #if SQLITE_ENABLE_8_3_NAMES<2 1369 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) 1370 #endif 1371 { 1372 int i, sz; 1373 sz = sqlite3Strlen30(z); 1374 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} 1375 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); 1376 } 1377 } 1378 #endif 1379 1380 /* 1381 ** Find (an approximate) sum of two LogEst values. This computation is 1382 ** not a simple "+" operator because LogEst is stored as a logarithmic 1383 ** value. 1384 ** 1385 */ 1386 LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ 1387 static const unsigned char x[] = { 1388 10, 10, /* 0,1 */ 1389 9, 9, /* 2,3 */ 1390 8, 8, /* 4,5 */ 1391 7, 7, 7, /* 6,7,8 */ 1392 6, 6, 6, /* 9,10,11 */ 1393 5, 5, 5, /* 12-14 */ 1394 4, 4, 4, 4, /* 15-18 */ 1395 3, 3, 3, 3, 3, 3, /* 19-24 */ 1396 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ 1397 }; 1398 if( a>=b ){ 1399 if( a>b+49 ) return a; 1400 if( a>b+31 ) return a+1; 1401 return a+x[a-b]; 1402 }else{ 1403 if( b>a+49 ) return b; 1404 if( b>a+31 ) return b+1; 1405 return b+x[b-a]; 1406 } 1407 } 1408 1409 /* 1410 ** Convert an integer into a LogEst. In other words, compute an 1411 ** approximation for 10*log2(x). 1412 */ 1413 LogEst sqlite3LogEst(u64 x){ 1414 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; 1415 LogEst y = 40; 1416 if( x<8 ){ 1417 if( x<2 ) return 0; 1418 while( x<8 ){ y -= 10; x <<= 1; } 1419 }else{ 1420 #if GCC_VERSION>=5004000 1421 int i = 60 - __builtin_clzll(x); 1422 y += i*10; 1423 x >>= i; 1424 #else 1425 while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/ 1426 while( x>15 ){ y += 10; x >>= 1; } 1427 #endif 1428 } 1429 return a[x&7] + y - 10; 1430 } 1431 1432 #ifndef SQLITE_OMIT_VIRTUALTABLE 1433 /* 1434 ** Convert a double into a LogEst 1435 ** In other words, compute an approximation for 10*log2(x). 1436 */ 1437 LogEst sqlite3LogEstFromDouble(double x){ 1438 u64 a; 1439 LogEst e; 1440 assert( sizeof(x)==8 && sizeof(a)==8 ); 1441 if( x<=1 ) return 0; 1442 if( x<=2000000000 ) return sqlite3LogEst((u64)x); 1443 memcpy(&a, &x, 8); 1444 e = (a>>52) - 1022; 1445 return e*10; 1446 } 1447 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 1448 1449 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 1450 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \ 1451 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 1452 /* 1453 ** Convert a LogEst into an integer. 1454 ** 1455 ** Note that this routine is only used when one or more of various 1456 ** non-standard compile-time options is enabled. 1457 */ 1458 u64 sqlite3LogEstToInt(LogEst x){ 1459 u64 n; 1460 n = x%10; 1461 x /= 10; 1462 if( n>=5 ) n -= 2; 1463 else if( n>=1 ) n -= 1; 1464 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 1465 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 1466 if( x>60 ) return (u64)LARGEST_INT64; 1467 #else 1468 /* If only SQLITE_ENABLE_STAT3_OR_STAT4 is on, then the largest input 1469 ** possible to this routine is 310, resulting in a maximum x of 31 */ 1470 assert( x<=60 ); 1471 #endif 1472 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x); 1473 } 1474 #endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */ 1475 1476 /* 1477 ** Add a new name/number pair to a VList. This might require that the 1478 ** VList object be reallocated, so return the new VList. If an OOM 1479 ** error occurs, the original VList returned and the 1480 ** db->mallocFailed flag is set. 1481 ** 1482 ** A VList is really just an array of integers. To destroy a VList, 1483 ** simply pass it to sqlite3DbFree(). 1484 ** 1485 ** The first integer is the number of integers allocated for the whole 1486 ** VList. The second integer is the number of integers actually used. 1487 ** Each name/number pair is encoded by subsequent groups of 3 or more 1488 ** integers. 1489 ** 1490 ** Each name/number pair starts with two integers which are the numeric 1491 ** value for the pair and the size of the name/number pair, respectively. 1492 ** The text name overlays one or more following integers. The text name 1493 ** is always zero-terminated. 1494 ** 1495 ** Conceptually: 1496 ** 1497 ** struct VList { 1498 ** int nAlloc; // Number of allocated slots 1499 ** int nUsed; // Number of used slots 1500 ** struct VListEntry { 1501 ** int iValue; // Value for this entry 1502 ** int nSlot; // Slots used by this entry 1503 ** // ... variable name goes here 1504 ** } a[0]; 1505 ** } 1506 ** 1507 ** During code generation, pointers to the variable names within the 1508 ** VList are taken. When that happens, nAlloc is set to zero as an 1509 ** indication that the VList may never again be enlarged, since the 1510 ** accompanying realloc() would invalidate the pointers. 1511 */ 1512 VList *sqlite3VListAdd( 1513 sqlite3 *db, /* The database connection used for malloc() */ 1514 VList *pIn, /* The input VList. Might be NULL */ 1515 const char *zName, /* Name of symbol to add */ 1516 int nName, /* Bytes of text in zName */ 1517 int iVal /* Value to associate with zName */ 1518 ){ 1519 int nInt; /* number of sizeof(int) objects needed for zName */ 1520 char *z; /* Pointer to where zName will be stored */ 1521 int i; /* Index in pIn[] where zName is stored */ 1522 1523 nInt = nName/4 + 3; 1524 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */ 1525 if( pIn==0 || pIn[1]+nInt > pIn[0] ){ 1526 /* Enlarge the allocation */ 1527 int nAlloc = (pIn ? pIn[0]*2 : 10) + nInt; 1528 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int)); 1529 if( pOut==0 ) return pIn; 1530 if( pIn==0 ) pOut[1] = 2; 1531 pIn = pOut; 1532 pIn[0] = nAlloc; 1533 } 1534 i = pIn[1]; 1535 pIn[i] = iVal; 1536 pIn[i+1] = nInt; 1537 z = (char*)&pIn[i+2]; 1538 pIn[1] = i+nInt; 1539 assert( pIn[1]<=pIn[0] ); 1540 memcpy(z, zName, nName); 1541 z[nName] = 0; 1542 return pIn; 1543 } 1544 1545 /* 1546 ** Return a pointer to the name of a variable in the given VList that 1547 ** has the value iVal. Or return a NULL if there is no such variable in 1548 ** the list 1549 */ 1550 const char *sqlite3VListNumToName(VList *pIn, int iVal){ 1551 int i, mx; 1552 if( pIn==0 ) return 0; 1553 mx = pIn[1]; 1554 i = 2; 1555 do{ 1556 if( pIn[i]==iVal ) return (char*)&pIn[i+2]; 1557 i += pIn[i+1]; 1558 }while( i<mx ); 1559 return 0; 1560 } 1561 1562 /* 1563 ** Return the number of the variable named zName, if it is in VList. 1564 ** or return 0 if there is no such variable. 1565 */ 1566 int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){ 1567 int i, mx; 1568 if( pIn==0 ) return 0; 1569 mx = pIn[1]; 1570 i = 2; 1571 do{ 1572 const char *z = (const char*)&pIn[i+2]; 1573 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i]; 1574 i += pIn[i+1]; 1575 }while( i<mx ); 1576 return 0; 1577 } 1578