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
44int 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*/
57int 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*/
79int 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*/
91char *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*/
107static 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*/
117void 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*/
131void 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*/
142void 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*/
162void 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*/
188void 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*/
219int 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*/
244void 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}
266void 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*/
284void 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*/
298void 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*/
316int 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}
324int 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}
343int 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*/
359u8 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*/
375static 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
440int 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
545do_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*/
639void 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*/
672static 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*/
705int 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*/
808int 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*/
838int 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*/
897int 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*/
909int 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*/
950static 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}
974int 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*/
1004u8 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*/
1165u8 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*/
1287int 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*/
1297u32 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}
1315void 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*/
1339u8 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*/
1357void *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*/
1378static 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*/
1399int 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}
1416int 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*/
1436int 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}
1456int 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}
1471int 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*/
1497int 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*/
1521void 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*/
1540LogEst 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*/
1567LogEst 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*/
1590LogEst 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*/
1604u64 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*/
1650VList *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*/
1688const 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*/
1704int 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