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