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