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