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