000001 /* 000002 ** 2001 September 15 000003 ** 000004 ** The author disclaims copyright to this source code. In place of 000005 ** a legal notice, here is a blessing: 000006 ** 000007 ** May you do good and not evil. 000008 ** May you find forgiveness for yourself and forgive others. 000009 ** May you share freely, never taking more than you give. 000010 ** 000011 ************************************************************************* 000012 ** Utility functions used throughout sqlite. 000013 ** 000014 ** This file contains functions for allocating memory, comparing 000015 ** strings, and stuff like that. 000016 ** 000017 */ 000018 #include "sqliteInt.h" 000019 #include <stdarg.h> 000020 #include <math.h> 000021 000022 /* 000023 ** Routine needed to support the testcase() macro. 000024 */ 000025 #ifdef SQLITE_COVERAGE_TEST 000026 void sqlite3Coverage(int x){ 000027 static unsigned dummy = 0; 000028 dummy += (unsigned)x; 000029 } 000030 #endif 000031 000032 /* 000033 ** Calls to sqlite3FaultSim() are used to simulate a failure during testing, 000034 ** or to bypass normal error detection during testing in order to let 000035 ** execute proceed futher downstream. 000036 ** 000037 ** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The 000038 ** sqlite3FaultSim() function only returns non-zero during testing. 000039 ** 000040 ** During testing, if the test harness has set a fault-sim callback using 000041 ** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then 000042 ** each call to sqlite3FaultSim() is relayed to that application-supplied 000043 ** callback and the integer return value form the application-supplied 000044 ** callback is returned by sqlite3FaultSim(). 000045 ** 000046 ** The integer argument to sqlite3FaultSim() is a code to identify which 000047 ** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim() 000048 ** should have a unique code. To prevent legacy testing applications from 000049 ** breaking, the codes should not be changed or reused. 000050 */ 000051 #ifndef SQLITE_UNTESTABLE 000052 int sqlite3FaultSim(int iTest){ 000053 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback; 000054 return xCallback ? xCallback(iTest) : SQLITE_OK; 000055 } 000056 #endif 000057 000058 #ifndef SQLITE_OMIT_FLOATING_POINT 000059 /* 000060 ** Return true if the floating point value is Not a Number (NaN). 000061 */ 000062 int sqlite3IsNaN(double x){ 000063 u64 y; 000064 memcpy(&y,&x,sizeof(y)); 000065 return IsNaN(y); 000066 } 000067 #endif /* SQLITE_OMIT_FLOATING_POINT */ 000068 000069 /* 000070 ** Compute a string length that is limited to what can be stored in 000071 ** lower 30 bits of a 32-bit signed integer. 000072 ** 000073 ** The value returned will never be negative. Nor will it ever be greater 000074 ** than the actual length of the string. For very long strings (greater 000075 ** than 1GiB) the value returned might be less than the true string length. 000076 */ 000077 int sqlite3Strlen30(const char *z){ 000078 if( z==0 ) return 0; 000079 return 0x3fffffff & (int)strlen(z); 000080 } 000081 000082 /* 000083 ** Return the declared type of a column. Or return zDflt if the column 000084 ** has no declared type. 000085 ** 000086 ** The column type is an extra string stored after the zero-terminator on 000087 ** the column name if and only if the COLFLAG_HASTYPE flag is set. 000088 */ 000089 char *sqlite3ColumnType(Column *pCol, char *zDflt){ 000090 if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt; 000091 return pCol->zName + strlen(pCol->zName) + 1; 000092 } 000093 000094 /* 000095 ** Helper function for sqlite3Error() - called rarely. Broken out into 000096 ** a separate routine to avoid unnecessary register saves on entry to 000097 ** sqlite3Error(). 000098 */ 000099 static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){ 000100 if( db->pErr ) sqlite3ValueSetNull(db->pErr); 000101 sqlite3SystemError(db, err_code); 000102 } 000103 000104 /* 000105 ** Set the current error code to err_code and clear any prior error message. 000106 ** Also set iSysErrno (by calling sqlite3System) if the err_code indicates 000107 ** that would be appropriate. 000108 */ 000109 void sqlite3Error(sqlite3 *db, int err_code){ 000110 assert( db!=0 ); 000111 db->errCode = err_code; 000112 if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code); 000113 } 000114 000115 /* 000116 ** Load the sqlite3.iSysErrno field if that is an appropriate thing 000117 ** to do based on the SQLite error code in rc. 000118 */ 000119 void sqlite3SystemError(sqlite3 *db, int rc){ 000120 if( rc==SQLITE_IOERR_NOMEM ) return; 000121 rc &= 0xff; 000122 if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){ 000123 db->iSysErrno = sqlite3OsGetLastError(db->pVfs); 000124 } 000125 } 000126 000127 /* 000128 ** Set the most recent error code and error string for the sqlite 000129 ** handle "db". The error code is set to "err_code". 000130 ** 000131 ** If it is not NULL, string zFormat specifies the format of the 000132 ** error string in the style of the printf functions: The following 000133 ** format characters are allowed: 000134 ** 000135 ** %s Insert a string 000136 ** %z A string that should be freed after use 000137 ** %d Insert an integer 000138 ** %T Insert a token 000139 ** %S Insert the first element of a SrcList 000140 ** 000141 ** zFormat and any string tokens that follow it are assumed to be 000142 ** encoded in UTF-8. 000143 ** 000144 ** To clear the most recent error for sqlite handle "db", sqlite3Error 000145 ** should be called with err_code set to SQLITE_OK and zFormat set 000146 ** to NULL. 000147 */ 000148 void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ 000149 assert( db!=0 ); 000150 db->errCode = err_code; 000151 sqlite3SystemError(db, err_code); 000152 if( zFormat==0 ){ 000153 sqlite3Error(db, err_code); 000154 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ 000155 char *z; 000156 va_list ap; 000157 va_start(ap, zFormat); 000158 z = sqlite3VMPrintf(db, zFormat, ap); 000159 va_end(ap); 000160 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); 000161 } 000162 } 000163 000164 /* 000165 ** Add an error message to pParse->zErrMsg and increment pParse->nErr. 000166 ** The following formatting characters are allowed: 000167 ** 000168 ** %s Insert a string 000169 ** %z A string that should be freed after use 000170 ** %d Insert an integer 000171 ** %T Insert a token 000172 ** %S Insert the first element of a SrcList 000173 ** 000174 ** This function should be used to report any error that occurs while 000175 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The 000176 ** last thing the sqlite3_prepare() function does is copy the error 000177 ** stored by this function into the database handle using sqlite3Error(). 000178 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used 000179 ** during statement execution (sqlite3_step() etc.). 000180 */ 000181 void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ 000182 char *zMsg; 000183 va_list ap; 000184 sqlite3 *db = pParse->db; 000185 va_start(ap, zFormat); 000186 zMsg = sqlite3VMPrintf(db, zFormat, ap); 000187 va_end(ap); 000188 if( db->suppressErr ){ 000189 sqlite3DbFree(db, zMsg); 000190 }else{ 000191 pParse->nErr++; 000192 sqlite3DbFree(db, pParse->zErrMsg); 000193 pParse->zErrMsg = zMsg; 000194 pParse->rc = SQLITE_ERROR; 000195 pParse->pWith = 0; 000196 } 000197 } 000198 000199 /* 000200 ** If database connection db is currently parsing SQL, then transfer 000201 ** error code errCode to that parser if the parser has not already 000202 ** encountered some other kind of error. 000203 */ 000204 int sqlite3ErrorToParser(sqlite3 *db, int errCode){ 000205 Parse *pParse; 000206 if( db==0 || (pParse = db->pParse)==0 ) return errCode; 000207 pParse->rc = errCode; 000208 pParse->nErr++; 000209 return errCode; 000210 } 000211 000212 /* 000213 ** Convert an SQL-style quoted string into a normal string by removing 000214 ** the quote characters. The conversion is done in-place. If the 000215 ** input does not begin with a quote character, then this routine 000216 ** is a no-op. 000217 ** 000218 ** The input string must be zero-terminated. A new zero-terminator 000219 ** is added to the dequoted string. 000220 ** 000221 ** The return value is -1 if no dequoting occurs or the length of the 000222 ** dequoted string, exclusive of the zero terminator, if dequoting does 000223 ** occur. 000224 ** 000225 ** 2002-02-14: This routine is extended to remove MS-Access style 000226 ** brackets from around identifiers. For example: "[a-b-c]" becomes 000227 ** "a-b-c". 000228 */ 000229 void sqlite3Dequote(char *z){ 000230 char quote; 000231 int i, j; 000232 if( z==0 ) return; 000233 quote = z[0]; 000234 if( !sqlite3Isquote(quote) ) return; 000235 if( quote=='[' ) quote = ']'; 000236 for(i=1, j=0;; i++){ 000237 assert( z[i] ); 000238 if( z[i]==quote ){ 000239 if( z[i+1]==quote ){ 000240 z[j++] = quote; 000241 i++; 000242 }else{ 000243 break; 000244 } 000245 }else{ 000246 z[j++] = z[i]; 000247 } 000248 } 000249 z[j] = 0; 000250 } 000251 void sqlite3DequoteExpr(Expr *p){ 000252 assert( sqlite3Isquote(p->u.zToken[0]) ); 000253 p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted; 000254 sqlite3Dequote(p->u.zToken); 000255 } 000256 000257 /* 000258 ** Generate a Token object from a string 000259 */ 000260 void sqlite3TokenInit(Token *p, char *z){ 000261 p->z = z; 000262 p->n = sqlite3Strlen30(z); 000263 } 000264 000265 /* Convenient short-hand */ 000266 #define UpperToLower sqlite3UpperToLower 000267 000268 /* 000269 ** Some systems have stricmp(). Others have strcasecmp(). Because 000270 ** there is no consistency, we will define our own. 000271 ** 000272 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and 000273 ** sqlite3_strnicmp() APIs allow applications and extensions to compare 000274 ** the contents of two buffers containing UTF-8 strings in a 000275 ** case-independent fashion, using the same definition of "case 000276 ** independence" that SQLite uses internally when comparing identifiers. 000277 */ 000278 int sqlite3_stricmp(const char *zLeft, const char *zRight){ 000279 if( zLeft==0 ){ 000280 return zRight ? -1 : 0; 000281 }else if( zRight==0 ){ 000282 return 1; 000283 } 000284 return sqlite3StrICmp(zLeft, zRight); 000285 } 000286 int sqlite3StrICmp(const char *zLeft, const char *zRight){ 000287 unsigned char *a, *b; 000288 int c, x; 000289 a = (unsigned char *)zLeft; 000290 b = (unsigned char *)zRight; 000291 for(;;){ 000292 c = *a; 000293 x = *b; 000294 if( c==x ){ 000295 if( c==0 ) break; 000296 }else{ 000297 c = (int)UpperToLower[c] - (int)UpperToLower[x]; 000298 if( c ) break; 000299 } 000300 a++; 000301 b++; 000302 } 000303 return c; 000304 } 000305 int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ 000306 register unsigned char *a, *b; 000307 if( zLeft==0 ){ 000308 return zRight ? -1 : 0; 000309 }else if( zRight==0 ){ 000310 return 1; 000311 } 000312 a = (unsigned char *)zLeft; 000313 b = (unsigned char *)zRight; 000314 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } 000315 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; 000316 } 000317 000318 /* 000319 ** Compute 10 to the E-th power. Examples: E==1 results in 10. 000320 ** E==2 results in 100. E==50 results in 1.0e50. 000321 ** 000322 ** This routine only works for values of E between 1 and 341. 000323 */ 000324 static LONGDOUBLE_TYPE sqlite3Pow10(int E){ 000325 #if defined(_MSC_VER) 000326 static const LONGDOUBLE_TYPE x[] = { 000327 1.0e+001L, 000328 1.0e+002L, 000329 1.0e+004L, 000330 1.0e+008L, 000331 1.0e+016L, 000332 1.0e+032L, 000333 1.0e+064L, 000334 1.0e+128L, 000335 1.0e+256L 000336 }; 000337 LONGDOUBLE_TYPE r = 1.0; 000338 int i; 000339 assert( E>=0 && E<=307 ); 000340 for(i=0; E!=0; i++, E >>=1){ 000341 if( E & 1 ) r *= x[i]; 000342 } 000343 return r; 000344 #else 000345 LONGDOUBLE_TYPE x = 10.0; 000346 LONGDOUBLE_TYPE r = 1.0; 000347 while(1){ 000348 if( E & 1 ) r *= x; 000349 E >>= 1; 000350 if( E==0 ) break; 000351 x *= x; 000352 } 000353 return r; 000354 #endif 000355 } 000356 000357 /* 000358 ** The string z[] is an text representation of a real number. 000359 ** Convert this string to a double and write it into *pResult. 000360 ** 000361 ** The string z[] is length bytes in length (bytes, not characters) and 000362 ** uses the encoding enc. The string is not necessarily zero-terminated. 000363 ** 000364 ** Return TRUE if the result is a valid real number (or integer) and FALSE 000365 ** if the string is empty or contains extraneous text. More specifically 000366 ** return 000367 ** 1 => The input string is a pure integer 000368 ** 2 or more => The input has a decimal point or eNNN clause 000369 ** 0 or less => The input string is not a valid number 000370 ** -1 => Not a valid number, but has a valid prefix which 000371 ** includes a decimal point and/or an eNNN clause 000372 ** 000373 ** Valid numbers are in one of these formats: 000374 ** 000375 ** [+-]digits[E[+-]digits] 000376 ** [+-]digits.[digits][E[+-]digits] 000377 ** [+-].digits[E[+-]digits] 000378 ** 000379 ** Leading and trailing whitespace is ignored for the purpose of determining 000380 ** validity. 000381 ** 000382 ** If some prefix of the input string is a valid number, this routine 000383 ** returns FALSE but it still converts the prefix and writes the result 000384 ** into *pResult. 000385 */ 000386 #if defined(_MSC_VER) 000387 #pragma warning(disable : 4756) 000388 #endif 000389 int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ 000390 #ifndef SQLITE_OMIT_FLOATING_POINT 000391 int incr; 000392 const char *zEnd; 000393 /* sign * significand * (10 ^ (esign * exponent)) */ 000394 int sign = 1; /* sign of significand */ 000395 i64 s = 0; /* significand */ 000396 int d = 0; /* adjust exponent for shifting decimal point */ 000397 int esign = 1; /* sign of exponent */ 000398 int e = 0; /* exponent */ 000399 int eValid = 1; /* True exponent is either not used or is well-formed */ 000400 double result; 000401 int nDigit = 0; /* Number of digits processed */ 000402 int eType = 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */ 000403 000404 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); 000405 *pResult = 0.0; /* Default return value, in case of an error */ 000406 if( length==0 ) return 0; 000407 000408 if( enc==SQLITE_UTF8 ){ 000409 incr = 1; 000410 zEnd = z + length; 000411 }else{ 000412 int i; 000413 incr = 2; 000414 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); 000415 testcase( enc==SQLITE_UTF16LE ); 000416 testcase( enc==SQLITE_UTF16BE ); 000417 for(i=3-enc; i<length && z[i]==0; i+=2){} 000418 if( i<length ) eType = -100; 000419 zEnd = &z[i^1]; 000420 z += (enc&1); 000421 } 000422 000423 /* skip leading spaces */ 000424 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; 000425 if( z>=zEnd ) return 0; 000426 000427 /* get sign of significand */ 000428 if( *z=='-' ){ 000429 sign = -1; 000430 z+=incr; 000431 }else if( *z=='+' ){ 000432 z+=incr; 000433 } 000434 000435 /* copy max significant digits to significand */ 000436 while( z<zEnd && sqlite3Isdigit(*z) ){ 000437 s = s*10 + (*z - '0'); 000438 z+=incr; nDigit++; 000439 if( s>=((LARGEST_INT64-9)/10) ){ 000440 /* skip non-significant significand digits 000441 ** (increase exponent by d to shift decimal left) */ 000442 while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; d++; } 000443 } 000444 } 000445 if( z>=zEnd ) goto do_atof_calc; 000446 000447 /* if decimal point is present */ 000448 if( *z=='.' ){ 000449 z+=incr; 000450 eType++; 000451 /* copy digits from after decimal to significand 000452 ** (decrease exponent by d to shift decimal right) */ 000453 while( z<zEnd && sqlite3Isdigit(*z) ){ 000454 if( s<((LARGEST_INT64-9)/10) ){ 000455 s = s*10 + (*z - '0'); 000456 d--; 000457 nDigit++; 000458 } 000459 z+=incr; 000460 } 000461 } 000462 if( z>=zEnd ) goto do_atof_calc; 000463 000464 /* if exponent is present */ 000465 if( *z=='e' || *z=='E' ){ 000466 z+=incr; 000467 eValid = 0; 000468 eType++; 000469 000470 /* This branch is needed to avoid a (harmless) buffer overread. The 000471 ** special comment alerts the mutation tester that the correct answer 000472 ** is obtained even if the branch is omitted */ 000473 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/ 000474 000475 /* get sign of exponent */ 000476 if( *z=='-' ){ 000477 esign = -1; 000478 z+=incr; 000479 }else if( *z=='+' ){ 000480 z+=incr; 000481 } 000482 /* copy digits to exponent */ 000483 while( z<zEnd && sqlite3Isdigit(*z) ){ 000484 e = e<10000 ? (e*10 + (*z - '0')) : 10000; 000485 z+=incr; 000486 eValid = 1; 000487 } 000488 } 000489 000490 /* skip trailing spaces */ 000491 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; 000492 000493 do_atof_calc: 000494 /* adjust exponent by d, and update sign */ 000495 e = (e*esign) + d; 000496 if( e<0 ) { 000497 esign = -1; 000498 e *= -1; 000499 } else { 000500 esign = 1; 000501 } 000502 000503 if( s==0 ) { 000504 /* In the IEEE 754 standard, zero is signed. */ 000505 result = sign<0 ? -(double)0 : (double)0; 000506 } else { 000507 /* Attempt to reduce exponent. 000508 ** 000509 ** Branches that are not required for the correct answer but which only 000510 ** help to obtain the correct answer faster are marked with special 000511 ** comments, as a hint to the mutation tester. 000512 */ 000513 while( e>0 ){ /*OPTIMIZATION-IF-TRUE*/ 000514 if( esign>0 ){ 000515 if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/ 000516 s *= 10; 000517 }else{ 000518 if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/ 000519 s /= 10; 000520 } 000521 e--; 000522 } 000523 000524 /* adjust the sign of significand */ 000525 s = sign<0 ? -s : s; 000526 000527 if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/ 000528 result = (double)s; 000529 }else{ 000530 /* attempt to handle extremely small/large numbers better */ 000531 if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/ 000532 if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/ 000533 LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308); 000534 if( esign<0 ){ 000535 result = s / scale; 000536 result /= 1.0e+308; 000537 }else{ 000538 result = s * scale; 000539 result *= 1.0e+308; 000540 } 000541 }else{ assert( e>=342 ); 000542 if( esign<0 ){ 000543 result = 0.0*s; 000544 }else{ 000545 #ifdef INFINITY 000546 result = INFINITY*s; 000547 #else 000548 result = 1e308*1e308*s; /* Infinity */ 000549 #endif 000550 } 000551 } 000552 }else{ 000553 LONGDOUBLE_TYPE scale = sqlite3Pow10(e); 000554 if( esign<0 ){ 000555 result = s / scale; 000556 }else{ 000557 result = s * scale; 000558 } 000559 } 000560 } 000561 } 000562 000563 /* store the result */ 000564 *pResult = result; 000565 000566 /* return true if number and no extra non-whitespace chracters after */ 000567 if( z==zEnd && nDigit>0 && eValid && eType>0 ){ 000568 return eType; 000569 }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){ 000570 return -1; 000571 }else{ 000572 return 0; 000573 } 000574 #else 000575 return !sqlite3Atoi64(z, pResult, length, enc); 000576 #endif /* SQLITE_OMIT_FLOATING_POINT */ 000577 } 000578 #if defined(_MSC_VER) 000579 #pragma warning(default : 4756) 000580 #endif 000581 000582 /* 000583 ** Compare the 19-character string zNum against the text representation 000584 ** value 2^63: 9223372036854775808. Return negative, zero, or positive 000585 ** if zNum is less than, equal to, or greater than the string. 000586 ** Note that zNum must contain exactly 19 characters. 000587 ** 000588 ** Unlike memcmp() this routine is guaranteed to return the difference 000589 ** in the values of the last digit if the only difference is in the 000590 ** last digit. So, for example, 000591 ** 000592 ** compare2pow63("9223372036854775800", 1) 000593 ** 000594 ** will return -8. 000595 */ 000596 static int compare2pow63(const char *zNum, int incr){ 000597 int c = 0; 000598 int i; 000599 /* 012345678901234567 */ 000600 const char *pow63 = "922337203685477580"; 000601 for(i=0; c==0 && i<18; i++){ 000602 c = (zNum[i*incr]-pow63[i])*10; 000603 } 000604 if( c==0 ){ 000605 c = zNum[18*incr] - '8'; 000606 testcase( c==(-1) ); 000607 testcase( c==0 ); 000608 testcase( c==(+1) ); 000609 } 000610 return c; 000611 } 000612 000613 /* 000614 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This 000615 ** routine does *not* accept hexadecimal notation. 000616 ** 000617 ** Returns: 000618 ** 000619 ** -1 Not even a prefix of the input text looks like an integer 000620 ** 0 Successful transformation. Fits in a 64-bit signed integer. 000621 ** 1 Excess non-space text after the integer value 000622 ** 2 Integer too large for a 64-bit signed integer or is malformed 000623 ** 3 Special case of 9223372036854775808 000624 ** 000625 ** length is the number of bytes in the string (bytes, not characters). 000626 ** The string is not necessarily zero-terminated. The encoding is 000627 ** given by enc. 000628 */ 000629 int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ 000630 int incr; 000631 u64 u = 0; 000632 int neg = 0; /* assume positive */ 000633 int i; 000634 int c = 0; 000635 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */ 000636 int rc; /* Baseline return code */ 000637 const char *zStart; 000638 const char *zEnd = zNum + length; 000639 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); 000640 if( enc==SQLITE_UTF8 ){ 000641 incr = 1; 000642 }else{ 000643 incr = 2; 000644 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); 000645 for(i=3-enc; i<length && zNum[i]==0; i+=2){} 000646 nonNum = i<length; 000647 zEnd = &zNum[i^1]; 000648 zNum += (enc&1); 000649 } 000650 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr; 000651 if( zNum<zEnd ){ 000652 if( *zNum=='-' ){ 000653 neg = 1; 000654 zNum+=incr; 000655 }else if( *zNum=='+' ){ 000656 zNum+=incr; 000657 } 000658 } 000659 zStart = zNum; 000660 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */ 000661 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){ 000662 u = u*10 + c - '0'; 000663 } 000664 testcase( i==18*incr ); 000665 testcase( i==19*incr ); 000666 testcase( i==20*incr ); 000667 if( u>LARGEST_INT64 ){ 000668 /* This test and assignment is needed only to suppress UB warnings 000669 ** from clang and -fsanitize=undefined. This test and assignment make 000670 ** the code a little larger and slower, and no harm comes from omitting 000671 ** them, but we must appaise the undefined-behavior pharisees. */ 000672 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; 000673 }else if( neg ){ 000674 *pNum = -(i64)u; 000675 }else{ 000676 *pNum = (i64)u; 000677 } 000678 rc = 0; 000679 if( i==0 && zStart==zNum ){ /* No digits */ 000680 rc = -1; 000681 }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */ 000682 rc = 1; 000683 }else if( &zNum[i]<zEnd ){ /* Extra bytes at the end */ 000684 int jj = i; 000685 do{ 000686 if( !sqlite3Isspace(zNum[jj]) ){ 000687 rc = 1; /* Extra non-space text after the integer */ 000688 break; 000689 } 000690 jj += incr; 000691 }while( &zNum[jj]<zEnd ); 000692 } 000693 if( i<19*incr ){ 000694 /* Less than 19 digits, so we know that it fits in 64 bits */ 000695 assert( u<=LARGEST_INT64 ); 000696 return rc; 000697 }else{ 000698 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */ 000699 c = i>19*incr ? 1 : compare2pow63(zNum, incr); 000700 if( c<0 ){ 000701 /* zNum is less than 9223372036854775808 so it fits */ 000702 assert( u<=LARGEST_INT64 ); 000703 return rc; 000704 }else{ 000705 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; 000706 if( c>0 ){ 000707 /* zNum is greater than 9223372036854775808 so it overflows */ 000708 return 2; 000709 }else{ 000710 /* zNum is exactly 9223372036854775808. Fits if negative. The 000711 ** special case 2 overflow if positive */ 000712 assert( u-1==LARGEST_INT64 ); 000713 return neg ? rc : 3; 000714 } 000715 } 000716 } 000717 } 000718 000719 /* 000720 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal, 000721 ** into a 64-bit signed integer. This routine accepts hexadecimal literals, 000722 ** whereas sqlite3Atoi64() does not. 000723 ** 000724 ** Returns: 000725 ** 000726 ** 0 Successful transformation. Fits in a 64-bit signed integer. 000727 ** 1 Excess text after the integer value 000728 ** 2 Integer too large for a 64-bit signed integer or is malformed 000729 ** 3 Special case of 9223372036854775808 000730 */ 000731 int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ 000732 #ifndef SQLITE_OMIT_HEX_INTEGER 000733 if( z[0]=='0' 000734 && (z[1]=='x' || z[1]=='X') 000735 ){ 000736 u64 u = 0; 000737 int i, k; 000738 for(i=2; z[i]=='0'; i++){} 000739 for(k=i; sqlite3Isxdigit(z[k]); k++){ 000740 u = u*16 + sqlite3HexToInt(z[k]); 000741 } 000742 memcpy(pOut, &u, 8); 000743 return (z[k]==0 && k-i<=16) ? 0 : 2; 000744 }else 000745 #endif /* SQLITE_OMIT_HEX_INTEGER */ 000746 { 000747 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); 000748 } 000749 } 000750 000751 /* 000752 ** If zNum represents an integer that will fit in 32-bits, then set 000753 ** *pValue to that integer and return true. Otherwise return false. 000754 ** 000755 ** This routine accepts both decimal and hexadecimal notation for integers. 000756 ** 000757 ** Any non-numeric characters that following zNum are ignored. 000758 ** This is different from sqlite3Atoi64() which requires the 000759 ** input number to be zero-terminated. 000760 */ 000761 int sqlite3GetInt32(const char *zNum, int *pValue){ 000762 sqlite_int64 v = 0; 000763 int i, c; 000764 int neg = 0; 000765 if( zNum[0]=='-' ){ 000766 neg = 1; 000767 zNum++; 000768 }else if( zNum[0]=='+' ){ 000769 zNum++; 000770 } 000771 #ifndef SQLITE_OMIT_HEX_INTEGER 000772 else if( zNum[0]=='0' 000773 && (zNum[1]=='x' || zNum[1]=='X') 000774 && sqlite3Isxdigit(zNum[2]) 000775 ){ 000776 u32 u = 0; 000777 zNum += 2; 000778 while( zNum[0]=='0' ) zNum++; 000779 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){ 000780 u = u*16 + sqlite3HexToInt(zNum[i]); 000781 } 000782 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ 000783 memcpy(pValue, &u, 4); 000784 return 1; 000785 }else{ 000786 return 0; 000787 } 000788 } 000789 #endif 000790 if( !sqlite3Isdigit(zNum[0]) ) return 0; 000791 while( zNum[0]=='0' ) zNum++; 000792 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ 000793 v = v*10 + c; 000794 } 000795 000796 /* The longest decimal representation of a 32 bit integer is 10 digits: 000797 ** 000798 ** 1234567890 000799 ** 2^31 -> 2147483648 000800 */ 000801 testcase( i==10 ); 000802 if( i>10 ){ 000803 return 0; 000804 } 000805 testcase( v-neg==2147483647 ); 000806 if( v-neg>2147483647 ){ 000807 return 0; 000808 } 000809 if( neg ){ 000810 v = -v; 000811 } 000812 *pValue = (int)v; 000813 return 1; 000814 } 000815 000816 /* 000817 ** Return a 32-bit integer value extracted from a string. If the 000818 ** string is not an integer, just return 0. 000819 */ 000820 int sqlite3Atoi(const char *z){ 000821 int x = 0; 000822 if( z ) sqlite3GetInt32(z, &x); 000823 return x; 000824 } 000825 000826 /* 000827 ** The variable-length integer encoding is as follows: 000828 ** 000829 ** KEY: 000830 ** A = 0xxxxxxx 7 bits of data and one flag bit 000831 ** B = 1xxxxxxx 7 bits of data and one flag bit 000832 ** C = xxxxxxxx 8 bits of data 000833 ** 000834 ** 7 bits - A 000835 ** 14 bits - BA 000836 ** 21 bits - BBA 000837 ** 28 bits - BBBA 000838 ** 35 bits - BBBBA 000839 ** 42 bits - BBBBBA 000840 ** 49 bits - BBBBBBA 000841 ** 56 bits - BBBBBBBA 000842 ** 64 bits - BBBBBBBBC 000843 */ 000844 000845 /* 000846 ** Write a 64-bit variable-length integer to memory starting at p[0]. 000847 ** The length of data write will be between 1 and 9 bytes. The number 000848 ** of bytes written is returned. 000849 ** 000850 ** A variable-length integer consists of the lower 7 bits of each byte 000851 ** for all bytes that have the 8th bit set and one byte with the 8th 000852 ** bit clear. Except, if we get to the 9th byte, it stores the full 000853 ** 8 bits and is the last byte. 000854 */ 000855 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ 000856 int i, j, n; 000857 u8 buf[10]; 000858 if( v & (((u64)0xff000000)<<32) ){ 000859 p[8] = (u8)v; 000860 v >>= 8; 000861 for(i=7; i>=0; i--){ 000862 p[i] = (u8)((v & 0x7f) | 0x80); 000863 v >>= 7; 000864 } 000865 return 9; 000866 } 000867 n = 0; 000868 do{ 000869 buf[n++] = (u8)((v & 0x7f) | 0x80); 000870 v >>= 7; 000871 }while( v!=0 ); 000872 buf[0] &= 0x7f; 000873 assert( n<=9 ); 000874 for(i=0, j=n-1; j>=0; j--, i++){ 000875 p[i] = buf[j]; 000876 } 000877 return n; 000878 } 000879 int sqlite3PutVarint(unsigned char *p, u64 v){ 000880 if( v<=0x7f ){ 000881 p[0] = v&0x7f; 000882 return 1; 000883 } 000884 if( v<=0x3fff ){ 000885 p[0] = ((v>>7)&0x7f)|0x80; 000886 p[1] = v&0x7f; 000887 return 2; 000888 } 000889 return putVarint64(p,v); 000890 } 000891 000892 /* 000893 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants 000894 ** are defined here rather than simply putting the constant expressions 000895 ** inline in order to work around bugs in the RVT compiler. 000896 ** 000897 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f 000898 ** 000899 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 000900 */ 000901 #define SLOT_2_0 0x001fc07f 000902 #define SLOT_4_2_0 0xf01fc07f 000903 000904 000905 /* 000906 ** Read a 64-bit variable-length integer from memory starting at p[0]. 000907 ** Return the number of bytes read. The value is stored in *v. 000908 */ 000909 u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ 000910 u32 a,b,s; 000911 000912 if( ((signed char*)p)[0]>=0 ){ 000913 *v = *p; 000914 return 1; 000915 } 000916 if( ((signed char*)p)[1]>=0 ){ 000917 *v = ((u32)(p[0]&0x7f)<<7) | p[1]; 000918 return 2; 000919 } 000920 000921 /* Verify that constants are precomputed correctly */ 000922 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); 000923 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); 000924 000925 a = ((u32)p[0])<<14; 000926 b = p[1]; 000927 p += 2; 000928 a |= *p; 000929 /* a: p0<<14 | p2 (unmasked) */ 000930 if (!(a&0x80)) 000931 { 000932 a &= SLOT_2_0; 000933 b &= 0x7f; 000934 b = b<<7; 000935 a |= b; 000936 *v = a; 000937 return 3; 000938 } 000939 000940 /* CSE1 from below */ 000941 a &= SLOT_2_0; 000942 p++; 000943 b = b<<14; 000944 b |= *p; 000945 /* b: p1<<14 | p3 (unmasked) */ 000946 if (!(b&0x80)) 000947 { 000948 b &= SLOT_2_0; 000949 /* moved CSE1 up */ 000950 /* a &= (0x7f<<14)|(0x7f); */ 000951 a = a<<7; 000952 a |= b; 000953 *v = a; 000954 return 4; 000955 } 000956 000957 /* a: p0<<14 | p2 (masked) */ 000958 /* b: p1<<14 | p3 (unmasked) */ 000959 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 000960 /* moved CSE1 up */ 000961 /* a &= (0x7f<<14)|(0x7f); */ 000962 b &= SLOT_2_0; 000963 s = a; 000964 /* s: p0<<14 | p2 (masked) */ 000965 000966 p++; 000967 a = a<<14; 000968 a |= *p; 000969 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ 000970 if (!(a&0x80)) 000971 { 000972 /* we can skip these cause they were (effectively) done above 000973 ** while calculating s */ 000974 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ 000975 /* b &= (0x7f<<14)|(0x7f); */ 000976 b = b<<7; 000977 a |= b; 000978 s = s>>18; 000979 *v = ((u64)s)<<32 | a; 000980 return 5; 000981 } 000982 000983 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 000984 s = s<<7; 000985 s |= b; 000986 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 000987 000988 p++; 000989 b = b<<14; 000990 b |= *p; 000991 /* b: p1<<28 | p3<<14 | p5 (unmasked) */ 000992 if (!(b&0x80)) 000993 { 000994 /* we can skip this cause it was (effectively) done above in calc'ing s */ 000995 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ 000996 a &= SLOT_2_0; 000997 a = a<<7; 000998 a |= b; 000999 s = s>>18; 001000 *v = ((u64)s)<<32 | a; 001001 return 6; 001002 } 001003 001004 p++; 001005 a = a<<14; 001006 a |= *p; 001007 /* a: p2<<28 | p4<<14 | p6 (unmasked) */ 001008 if (!(a&0x80)) 001009 { 001010 a &= SLOT_4_2_0; 001011 b &= SLOT_2_0; 001012 b = b<<7; 001013 a |= b; 001014 s = s>>11; 001015 *v = ((u64)s)<<32 | a; 001016 return 7; 001017 } 001018 001019 /* CSE2 from below */ 001020 a &= SLOT_2_0; 001021 p++; 001022 b = b<<14; 001023 b |= *p; 001024 /* b: p3<<28 | p5<<14 | p7 (unmasked) */ 001025 if (!(b&0x80)) 001026 { 001027 b &= SLOT_4_2_0; 001028 /* moved CSE2 up */ 001029 /* a &= (0x7f<<14)|(0x7f); */ 001030 a = a<<7; 001031 a |= b; 001032 s = s>>4; 001033 *v = ((u64)s)<<32 | a; 001034 return 8; 001035 } 001036 001037 p++; 001038 a = a<<15; 001039 a |= *p; 001040 /* a: p4<<29 | p6<<15 | p8 (unmasked) */ 001041 001042 /* moved CSE2 up */ 001043 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ 001044 b &= SLOT_2_0; 001045 b = b<<8; 001046 a |= b; 001047 001048 s = s<<4; 001049 b = p[-4]; 001050 b &= 0x7f; 001051 b = b>>3; 001052 s |= b; 001053 001054 *v = ((u64)s)<<32 | a; 001055 001056 return 9; 001057 } 001058 001059 /* 001060 ** Read a 32-bit variable-length integer from memory starting at p[0]. 001061 ** Return the number of bytes read. The value is stored in *v. 001062 ** 001063 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned 001064 ** integer, then set *v to 0xffffffff. 001065 ** 001066 ** A MACRO version, getVarint32, is provided which inlines the 001067 ** single-byte case. All code should use the MACRO version as 001068 ** this function assumes the single-byte case has already been handled. 001069 */ 001070 u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ 001071 u32 a,b; 001072 001073 /* The 1-byte case. Overwhelmingly the most common. Handled inline 001074 ** by the getVarin32() macro */ 001075 a = *p; 001076 /* a: p0 (unmasked) */ 001077 #ifndef getVarint32 001078 if (!(a&0x80)) 001079 { 001080 /* Values between 0 and 127 */ 001081 *v = a; 001082 return 1; 001083 } 001084 #endif 001085 001086 /* The 2-byte case */ 001087 p++; 001088 b = *p; 001089 /* b: p1 (unmasked) */ 001090 if (!(b&0x80)) 001091 { 001092 /* Values between 128 and 16383 */ 001093 a &= 0x7f; 001094 a = a<<7; 001095 *v = a | b; 001096 return 2; 001097 } 001098 001099 /* The 3-byte case */ 001100 p++; 001101 a = a<<14; 001102 a |= *p; 001103 /* a: p0<<14 | p2 (unmasked) */ 001104 if (!(a&0x80)) 001105 { 001106 /* Values between 16384 and 2097151 */ 001107 a &= (0x7f<<14)|(0x7f); 001108 b &= 0x7f; 001109 b = b<<7; 001110 *v = a | b; 001111 return 3; 001112 } 001113 001114 /* A 32-bit varint is used to store size information in btrees. 001115 ** Objects are rarely larger than 2MiB limit of a 3-byte varint. 001116 ** A 3-byte varint is sufficient, for example, to record the size 001117 ** of a 1048569-byte BLOB or string. 001118 ** 001119 ** We only unroll the first 1-, 2-, and 3- byte cases. The very 001120 ** rare larger cases can be handled by the slower 64-bit varint 001121 ** routine. 001122 */ 001123 #if 1 001124 { 001125 u64 v64; 001126 u8 n; 001127 001128 p -= 2; 001129 n = sqlite3GetVarint(p, &v64); 001130 assert( n>3 && n<=9 ); 001131 if( (v64 & SQLITE_MAX_U32)!=v64 ){ 001132 *v = 0xffffffff; 001133 }else{ 001134 *v = (u32)v64; 001135 } 001136 return n; 001137 } 001138 001139 #else 001140 /* For following code (kept for historical record only) shows an 001141 ** unrolling for the 3- and 4-byte varint cases. This code is 001142 ** slightly faster, but it is also larger and much harder to test. 001143 */ 001144 p++; 001145 b = b<<14; 001146 b |= *p; 001147 /* b: p1<<14 | p3 (unmasked) */ 001148 if (!(b&0x80)) 001149 { 001150 /* Values between 2097152 and 268435455 */ 001151 b &= (0x7f<<14)|(0x7f); 001152 a &= (0x7f<<14)|(0x7f); 001153 a = a<<7; 001154 *v = a | b; 001155 return 4; 001156 } 001157 001158 p++; 001159 a = a<<14; 001160 a |= *p; 001161 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ 001162 if (!(a&0x80)) 001163 { 001164 /* Values between 268435456 and 34359738367 */ 001165 a &= SLOT_4_2_0; 001166 b &= SLOT_4_2_0; 001167 b = b<<7; 001168 *v = a | b; 001169 return 5; 001170 } 001171 001172 /* We can only reach this point when reading a corrupt database 001173 ** file. In that case we are not in any hurry. Use the (relatively 001174 ** slow) general-purpose sqlite3GetVarint() routine to extract the 001175 ** value. */ 001176 { 001177 u64 v64; 001178 u8 n; 001179 001180 p -= 4; 001181 n = sqlite3GetVarint(p, &v64); 001182 assert( n>5 && n<=9 ); 001183 *v = (u32)v64; 001184 return n; 001185 } 001186 #endif 001187 } 001188 001189 /* 001190 ** Return the number of bytes that will be needed to store the given 001191 ** 64-bit integer. 001192 */ 001193 int sqlite3VarintLen(u64 v){ 001194 int i; 001195 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); } 001196 return i; 001197 } 001198 001199 001200 /* 001201 ** Read or write a four-byte big-endian integer value. 001202 */ 001203 u32 sqlite3Get4byte(const u8 *p){ 001204 #if SQLITE_BYTEORDER==4321 001205 u32 x; 001206 memcpy(&x,p,4); 001207 return x; 001208 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 001209 u32 x; 001210 memcpy(&x,p,4); 001211 return __builtin_bswap32(x); 001212 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 001213 u32 x; 001214 memcpy(&x,p,4); 001215 return _byteswap_ulong(x); 001216 #else 001217 testcase( p[0]&0x80 ); 001218 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; 001219 #endif 001220 } 001221 void sqlite3Put4byte(unsigned char *p, u32 v){ 001222 #if SQLITE_BYTEORDER==4321 001223 memcpy(p,&v,4); 001224 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 001225 u32 x = __builtin_bswap32(v); 001226 memcpy(p,&x,4); 001227 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 001228 u32 x = _byteswap_ulong(v); 001229 memcpy(p,&x,4); 001230 #else 001231 p[0] = (u8)(v>>24); 001232 p[1] = (u8)(v>>16); 001233 p[2] = (u8)(v>>8); 001234 p[3] = (u8)v; 001235 #endif 001236 } 001237 001238 001239 001240 /* 001241 ** Translate a single byte of Hex into an integer. 001242 ** This routine only works if h really is a valid hexadecimal 001243 ** character: 0..9a..fA..F 001244 */ 001245 u8 sqlite3HexToInt(int h){ 001246 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); 001247 #ifdef SQLITE_ASCII 001248 h += 9*(1&(h>>6)); 001249 #endif 001250 #ifdef SQLITE_EBCDIC 001251 h += 9*(1&~(h>>4)); 001252 #endif 001253 return (u8)(h & 0xf); 001254 } 001255 001256 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) 001257 /* 001258 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary 001259 ** value. Return a pointer to its binary value. Space to hold the 001260 ** binary value has been obtained from malloc and must be freed by 001261 ** the calling routine. 001262 */ 001263 void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ 001264 char *zBlob; 001265 int i; 001266 001267 zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1); 001268 n--; 001269 if( zBlob ){ 001270 for(i=0; i<n; i+=2){ 001271 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]); 001272 } 001273 zBlob[i/2] = 0; 001274 } 001275 return zBlob; 001276 } 001277 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */ 001278 001279 /* 001280 ** Log an error that is an API call on a connection pointer that should 001281 ** not have been used. The "type" of connection pointer is given as the 001282 ** argument. The zType is a word like "NULL" or "closed" or "invalid". 001283 */ 001284 static void logBadConnection(const char *zType){ 001285 sqlite3_log(SQLITE_MISUSE, 001286 "API call with %s database connection pointer", 001287 zType 001288 ); 001289 } 001290 001291 /* 001292 ** Check to make sure we have a valid db pointer. This test is not 001293 ** foolproof but it does provide some measure of protection against 001294 ** misuse of the interface such as passing in db pointers that are 001295 ** NULL or which have been previously closed. If this routine returns 001296 ** 1 it means that the db pointer is valid and 0 if it should not be 001297 ** dereferenced for any reason. The calling function should invoke 001298 ** SQLITE_MISUSE immediately. 001299 ** 001300 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for 001301 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to 001302 ** open properly and is not fit for general use but which can be 001303 ** used as an argument to sqlite3_errmsg() or sqlite3_close(). 001304 */ 001305 int sqlite3SafetyCheckOk(sqlite3 *db){ 001306 u32 magic; 001307 if( db==0 ){ 001308 logBadConnection("NULL"); 001309 return 0; 001310 } 001311 magic = db->magic; 001312 if( magic!=SQLITE_MAGIC_OPEN ){ 001313 if( sqlite3SafetyCheckSickOrOk(db) ){ 001314 testcase( sqlite3GlobalConfig.xLog!=0 ); 001315 logBadConnection("unopened"); 001316 } 001317 return 0; 001318 }else{ 001319 return 1; 001320 } 001321 } 001322 int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ 001323 u32 magic; 001324 magic = db->magic; 001325 if( magic!=SQLITE_MAGIC_SICK && 001326 magic!=SQLITE_MAGIC_OPEN && 001327 magic!=SQLITE_MAGIC_BUSY ){ 001328 testcase( sqlite3GlobalConfig.xLog!=0 ); 001329 logBadConnection("invalid"); 001330 return 0; 001331 }else{ 001332 return 1; 001333 } 001334 } 001335 001336 /* 001337 ** Attempt to add, substract, or multiply the 64-bit signed value iB against 001338 ** the other 64-bit signed integer at *pA and store the result in *pA. 001339 ** Return 0 on success. Or if the operation would have resulted in an 001340 ** overflow, leave *pA unchanged and return 1. 001341 */ 001342 int sqlite3AddInt64(i64 *pA, i64 iB){ 001343 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) 001344 return __builtin_add_overflow(*pA, iB, pA); 001345 #else 001346 i64 iA = *pA; 001347 testcase( iA==0 ); testcase( iA==1 ); 001348 testcase( iB==-1 ); testcase( iB==0 ); 001349 if( iB>=0 ){ 001350 testcase( iA>0 && LARGEST_INT64 - iA == iB ); 001351 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); 001352 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; 001353 }else{ 001354 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); 001355 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); 001356 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; 001357 } 001358 *pA += iB; 001359 return 0; 001360 #endif 001361 } 001362 int sqlite3SubInt64(i64 *pA, i64 iB){ 001363 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) 001364 return __builtin_sub_overflow(*pA, iB, pA); 001365 #else 001366 testcase( iB==SMALLEST_INT64+1 ); 001367 if( iB==SMALLEST_INT64 ){ 001368 testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); 001369 if( (*pA)>=0 ) return 1; 001370 *pA -= iB; 001371 return 0; 001372 }else{ 001373 return sqlite3AddInt64(pA, -iB); 001374 } 001375 #endif 001376 } 001377 int sqlite3MulInt64(i64 *pA, i64 iB){ 001378 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) 001379 return __builtin_mul_overflow(*pA, iB, pA); 001380 #else 001381 i64 iA = *pA; 001382 if( iB>0 ){ 001383 if( iA>LARGEST_INT64/iB ) return 1; 001384 if( iA<SMALLEST_INT64/iB ) return 1; 001385 }else if( iB<0 ){ 001386 if( iA>0 ){ 001387 if( iB<SMALLEST_INT64/iA ) return 1; 001388 }else if( iA<0 ){ 001389 if( iB==SMALLEST_INT64 ) return 1; 001390 if( iA==SMALLEST_INT64 ) return 1; 001391 if( -iA>LARGEST_INT64/-iB ) return 1; 001392 } 001393 } 001394 *pA = iA*iB; 001395 return 0; 001396 #endif 001397 } 001398 001399 /* 001400 ** Compute the absolute value of a 32-bit signed integer, of possible. Or 001401 ** if the integer has a value of -2147483648, return +2147483647 001402 */ 001403 int sqlite3AbsInt32(int x){ 001404 if( x>=0 ) return x; 001405 if( x==(int)0x80000000 ) return 0x7fffffff; 001406 return -x; 001407 } 001408 001409 #ifdef SQLITE_ENABLE_8_3_NAMES 001410 /* 001411 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database 001412 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and 001413 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than 001414 ** three characters, then shorten the suffix on z[] to be the last three 001415 ** characters of the original suffix. 001416 ** 001417 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always 001418 ** do the suffix shortening regardless of URI parameter. 001419 ** 001420 ** Examples: 001421 ** 001422 ** test.db-journal => test.nal 001423 ** test.db-wal => test.wal 001424 ** test.db-shm => test.shm 001425 ** test.db-mj7f3319fa => test.9fa 001426 */ 001427 void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ 001428 #if SQLITE_ENABLE_8_3_NAMES<2 001429 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) 001430 #endif 001431 { 001432 int i, sz; 001433 sz = sqlite3Strlen30(z); 001434 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} 001435 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); 001436 } 001437 } 001438 #endif 001439 001440 /* 001441 ** Find (an approximate) sum of two LogEst values. This computation is 001442 ** not a simple "+" operator because LogEst is stored as a logarithmic 001443 ** value. 001444 ** 001445 */ 001446 LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ 001447 static const unsigned char x[] = { 001448 10, 10, /* 0,1 */ 001449 9, 9, /* 2,3 */ 001450 8, 8, /* 4,5 */ 001451 7, 7, 7, /* 6,7,8 */ 001452 6, 6, 6, /* 9,10,11 */ 001453 5, 5, 5, /* 12-14 */ 001454 4, 4, 4, 4, /* 15-18 */ 001455 3, 3, 3, 3, 3, 3, /* 19-24 */ 001456 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ 001457 }; 001458 if( a>=b ){ 001459 if( a>b+49 ) return a; 001460 if( a>b+31 ) return a+1; 001461 return a+x[a-b]; 001462 }else{ 001463 if( b>a+49 ) return b; 001464 if( b>a+31 ) return b+1; 001465 return b+x[b-a]; 001466 } 001467 } 001468 001469 /* 001470 ** Convert an integer into a LogEst. In other words, compute an 001471 ** approximation for 10*log2(x). 001472 */ 001473 LogEst sqlite3LogEst(u64 x){ 001474 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; 001475 LogEst y = 40; 001476 if( x<8 ){ 001477 if( x<2 ) return 0; 001478 while( x<8 ){ y -= 10; x <<= 1; } 001479 }else{ 001480 #if GCC_VERSION>=5004000 001481 int i = 60 - __builtin_clzll(x); 001482 y += i*10; 001483 x >>= i; 001484 #else 001485 while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/ 001486 while( x>15 ){ y += 10; x >>= 1; } 001487 #endif 001488 } 001489 return a[x&7] + y - 10; 001490 } 001491 001492 #ifndef SQLITE_OMIT_VIRTUALTABLE 001493 /* 001494 ** Convert a double into a LogEst 001495 ** In other words, compute an approximation for 10*log2(x). 001496 */ 001497 LogEst sqlite3LogEstFromDouble(double x){ 001498 u64 a; 001499 LogEst e; 001500 assert( sizeof(x)==8 && sizeof(a)==8 ); 001501 if( x<=1 ) return 0; 001502 if( x<=2000000000 ) return sqlite3LogEst((u64)x); 001503 memcpy(&a, &x, 8); 001504 e = (a>>52) - 1022; 001505 return e*10; 001506 } 001507 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 001508 001509 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 001510 defined(SQLITE_ENABLE_STAT4) || \ 001511 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 001512 /* 001513 ** Convert a LogEst into an integer. 001514 ** 001515 ** Note that this routine is only used when one or more of various 001516 ** non-standard compile-time options is enabled. 001517 */ 001518 u64 sqlite3LogEstToInt(LogEst x){ 001519 u64 n; 001520 n = x%10; 001521 x /= 10; 001522 if( n>=5 ) n -= 2; 001523 else if( n>=1 ) n -= 1; 001524 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 001525 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 001526 if( x>60 ) return (u64)LARGEST_INT64; 001527 #else 001528 /* If only SQLITE_ENABLE_STAT4 is on, then the largest input 001529 ** possible to this routine is 310, resulting in a maximum x of 31 */ 001530 assert( x<=60 ); 001531 #endif 001532 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x); 001533 } 001534 #endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */ 001535 001536 /* 001537 ** Add a new name/number pair to a VList. This might require that the 001538 ** VList object be reallocated, so return the new VList. If an OOM 001539 ** error occurs, the original VList returned and the 001540 ** db->mallocFailed flag is set. 001541 ** 001542 ** A VList is really just an array of integers. To destroy a VList, 001543 ** simply pass it to sqlite3DbFree(). 001544 ** 001545 ** The first integer is the number of integers allocated for the whole 001546 ** VList. The second integer is the number of integers actually used. 001547 ** Each name/number pair is encoded by subsequent groups of 3 or more 001548 ** integers. 001549 ** 001550 ** Each name/number pair starts with two integers which are the numeric 001551 ** value for the pair and the size of the name/number pair, respectively. 001552 ** The text name overlays one or more following integers. The text name 001553 ** is always zero-terminated. 001554 ** 001555 ** Conceptually: 001556 ** 001557 ** struct VList { 001558 ** int nAlloc; // Number of allocated slots 001559 ** int nUsed; // Number of used slots 001560 ** struct VListEntry { 001561 ** int iValue; // Value for this entry 001562 ** int nSlot; // Slots used by this entry 001563 ** // ... variable name goes here 001564 ** } a[0]; 001565 ** } 001566 ** 001567 ** During code generation, pointers to the variable names within the 001568 ** VList are taken. When that happens, nAlloc is set to zero as an 001569 ** indication that the VList may never again be enlarged, since the 001570 ** accompanying realloc() would invalidate the pointers. 001571 */ 001572 VList *sqlite3VListAdd( 001573 sqlite3 *db, /* The database connection used for malloc() */ 001574 VList *pIn, /* The input VList. Might be NULL */ 001575 const char *zName, /* Name of symbol to add */ 001576 int nName, /* Bytes of text in zName */ 001577 int iVal /* Value to associate with zName */ 001578 ){ 001579 int nInt; /* number of sizeof(int) objects needed for zName */ 001580 char *z; /* Pointer to where zName will be stored */ 001581 int i; /* Index in pIn[] where zName is stored */ 001582 001583 nInt = nName/4 + 3; 001584 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */ 001585 if( pIn==0 || pIn[1]+nInt > pIn[0] ){ 001586 /* Enlarge the allocation */ 001587 sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt; 001588 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int)); 001589 if( pOut==0 ) return pIn; 001590 if( pIn==0 ) pOut[1] = 2; 001591 pIn = pOut; 001592 pIn[0] = nAlloc; 001593 } 001594 i = pIn[1]; 001595 pIn[i] = iVal; 001596 pIn[i+1] = nInt; 001597 z = (char*)&pIn[i+2]; 001598 pIn[1] = i+nInt; 001599 assert( pIn[1]<=pIn[0] ); 001600 memcpy(z, zName, nName); 001601 z[nName] = 0; 001602 return pIn; 001603 } 001604 001605 /* 001606 ** Return a pointer to the name of a variable in the given VList that 001607 ** has the value iVal. Or return a NULL if there is no such variable in 001608 ** the list 001609 */ 001610 const char *sqlite3VListNumToName(VList *pIn, int iVal){ 001611 int i, mx; 001612 if( pIn==0 ) return 0; 001613 mx = pIn[1]; 001614 i = 2; 001615 do{ 001616 if( pIn[i]==iVal ) return (char*)&pIn[i+2]; 001617 i += pIn[i+1]; 001618 }while( i<mx ); 001619 return 0; 001620 } 001621 001622 /* 001623 ** Return the number of the variable named zName, if it is in VList. 001624 ** or return 0 if there is no such variable. 001625 */ 001626 int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){ 001627 int i, mx; 001628 if( pIn==0 ) return 0; 001629 mx = pIn[1]; 001630 i = 2; 001631 do{ 001632 const char *z = (const char*)&pIn[i+2]; 001633 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i]; 001634 i += pIn[i+1]; 001635 }while( i<mx ); 001636 return 0; 001637 }