blob: fc0c2042bdd6dd2f644becf3c0a7ce85bbd69528 [file] [log] [blame]
drhc81c11f2009-11-10 01:30:52 +00001/*
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>
drhef9f7192020-01-17 19:14:08 +000020#ifndef SQLITE_OMIT_FLOATING_POINT
drh7e6dc5d2019-05-10 12:14:51 +000021#include <math.h>
drhef9f7192020-01-17 19:14:08 +000022#endif
drhc81c11f2009-11-10 01:30:52 +000023
24/*
25** Routine needed to support the testcase() macro.
26*/
27#ifdef SQLITE_COVERAGE_TEST
28void sqlite3Coverage(int x){
drh68bf0672011-04-11 15:35:24 +000029 static unsigned dummy = 0;
30 dummy += (unsigned)x;
drhc81c11f2009-11-10 01:30:52 +000031}
32#endif
33
drhc007f612014-05-16 14:17:01 +000034/*
drhce059e52019-04-05 17:22:50 +000035** Calls to sqlite3FaultSim() are used to simulate a failure during testing,
36** or to bypass normal error detection during testing in order to let
37** execute proceed futher downstream.
drhc007f612014-05-16 14:17:01 +000038**
drhce059e52019-04-05 17:22:50 +000039** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The
40** sqlite3FaultSim() function only returns non-zero during testing.
drhc007f612014-05-16 14:17:01 +000041**
drhce059e52019-04-05 17:22:50 +000042** During testing, if the test harness has set a fault-sim callback using
43** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then
44** each call to sqlite3FaultSim() is relayed to that application-supplied
45** callback and the integer return value form the application-supplied
46** callback is returned by sqlite3FaultSim().
47**
48** The integer argument to sqlite3FaultSim() is a code to identify which
49** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim()
50** should have a unique code. To prevent legacy testing applications from
51** breaking, the codes should not be changed or reused.
drhc007f612014-05-16 14:17:01 +000052*/
drhd12602a2016-12-07 15:49:02 +000053#ifndef SQLITE_UNTESTABLE
drhc007f612014-05-16 14:17:01 +000054int sqlite3FaultSim(int iTest){
55 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback;
56 return xCallback ? xCallback(iTest) : SQLITE_OK;
57}
58#endif
59
drh85c8f292010-01-13 17:39:53 +000060#ifndef SQLITE_OMIT_FLOATING_POINT
drhc81c11f2009-11-10 01:30:52 +000061/*
62** Return true if the floating point value is Not a Number (NaN).
drhc81c11f2009-11-10 01:30:52 +000063*/
64int sqlite3IsNaN(double x){
drh05921222019-05-30 00:46:37 +000065 u64 y;
66 memcpy(&y,&x,sizeof(y));
67 return IsNaN(y);
drhc81c11f2009-11-10 01:30:52 +000068}
drh85c8f292010-01-13 17:39:53 +000069#endif /* SQLITE_OMIT_FLOATING_POINT */
drhc81c11f2009-11-10 01:30:52 +000070
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){
drhc81c11f2009-11-10 01:30:52 +000080 if( z==0 ) return 0;
drh1116bf12015-06-30 03:18:33 +000081 return 0x3fffffff & (int)strlen(z);
drhc81c11f2009-11-10 01:30:52 +000082}
83
84/*
drhd7564862016-03-22 20:05:09 +000085** 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.
drh94eaafa2016-02-29 15:53:11 +000090*/
drhd7564862016-03-22 20:05:09 +000091char *sqlite3ColumnType(Column *pCol, char *zDflt){
92 if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt;
93 return pCol->zName + strlen(pCol->zName) + 1;
drh94eaafa2016-02-29 15:53:11 +000094}
95
96/*
drh80fbee02016-03-21 11:57:13 +000097** Helper function for sqlite3Error() - called rarely. Broken out into
98** a separate routine to avoid unnecessary register saves on entry to
99** sqlite3Error().
drh13f40da2014-08-22 18:00:11 +0000100*/
drh8d2f41c2016-03-21 11:38:01 +0000101static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){
102 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
103 sqlite3SystemError(db, err_code);
104}
drh80fbee02016-03-21 11:57:13 +0000105
106/*
107** Set the current error code to err_code and clear any prior error message.
108** Also set iSysErrno (by calling sqlite3System) if the err_code indicates
109** that would be appropriate.
110*/
drh13f40da2014-08-22 18:00:11 +0000111void sqlite3Error(sqlite3 *db, int err_code){
112 assert( db!=0 );
113 db->errCode = err_code;
drh8d2f41c2016-03-21 11:38:01 +0000114 if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code);
drh13f40da2014-08-22 18:00:11 +0000115}
116
117/*
drh88efc792021-01-01 18:23:56 +0000118** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state
119** and error message.
120*/
121void sqlite3ErrorClear(sqlite3 *db){
122 assert( db!=0 );
123 db->errCode = SQLITE_OK;
124 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
125}
126
127/*
drh1b9f2142016-03-17 16:01:23 +0000128** Load the sqlite3.iSysErrno field if that is an appropriate thing
129** to do based on the SQLite error code in rc.
130*/
131void sqlite3SystemError(sqlite3 *db, int rc){
132 if( rc==SQLITE_IOERR_NOMEM ) return;
133 rc &= 0xff;
134 if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){
135 db->iSysErrno = sqlite3OsGetLastError(db->pVfs);
136 }
137}
138
139/*
drhc81c11f2009-11-10 01:30:52 +0000140** Set the most recent error code and error string for the sqlite
141** handle "db". The error code is set to "err_code".
142**
143** If it is not NULL, string zFormat specifies the format of the
144** error string in the style of the printf functions: The following
145** format characters are allowed:
146**
147** %s Insert a string
148** %z A string that should be freed after use
149** %d Insert an integer
150** %T Insert a token
151** %S Insert the first element of a SrcList
152**
153** zFormat and any string tokens that follow it are assumed to be
154** encoded in UTF-8.
155**
156** To clear the most recent error for sqlite handle "db", sqlite3Error
157** should be called with err_code set to SQLITE_OK and zFormat set
158** to NULL.
159*/
drh13f40da2014-08-22 18:00:11 +0000160void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){
drha3cc0072013-12-13 16:23:55 +0000161 assert( db!=0 );
162 db->errCode = err_code;
drh8d2f41c2016-03-21 11:38:01 +0000163 sqlite3SystemError(db, err_code);
drh13f40da2014-08-22 18:00:11 +0000164 if( zFormat==0 ){
165 sqlite3Error(db, err_code);
166 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
drha3cc0072013-12-13 16:23:55 +0000167 char *z;
168 va_list ap;
169 va_start(ap, zFormat);
170 z = sqlite3VMPrintf(db, zFormat, ap);
171 va_end(ap);
172 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
drhc81c11f2009-11-10 01:30:52 +0000173 }
174}
175
176/*
177** Add an error message to pParse->zErrMsg and increment pParse->nErr.
178** The following formatting characters are allowed:
179**
180** %s Insert a string
181** %z A string that should be freed after use
182** %d Insert an integer
183** %T Insert a token
184** %S Insert the first element of a SrcList
185**
drh13f40da2014-08-22 18:00:11 +0000186** This function should be used to report any error that occurs while
drhc81c11f2009-11-10 01:30:52 +0000187** compiling an SQL statement (i.e. within sqlite3_prepare()). The
188** last thing the sqlite3_prepare() function does is copy the error
189** stored by this function into the database handle using sqlite3Error().
drh13f40da2014-08-22 18:00:11 +0000190** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
191** during statement execution (sqlite3_step() etc.).
drhc81c11f2009-11-10 01:30:52 +0000192*/
193void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
drha7564662010-02-22 19:32:31 +0000194 char *zMsg;
drhc81c11f2009-11-10 01:30:52 +0000195 va_list ap;
196 sqlite3 *db = pParse->db;
drhc81c11f2009-11-10 01:30:52 +0000197 va_start(ap, zFormat);
drha7564662010-02-22 19:32:31 +0000198 zMsg = sqlite3VMPrintf(db, zFormat, ap);
drhc81c11f2009-11-10 01:30:52 +0000199 va_end(ap);
drha7564662010-02-22 19:32:31 +0000200 if( db->suppressErr ){
201 sqlite3DbFree(db, zMsg);
202 }else{
203 pParse->nErr++;
204 sqlite3DbFree(db, pParse->zErrMsg);
205 pParse->zErrMsg = zMsg;
206 pParse->rc = SQLITE_ERROR;
drh46a31cd2019-11-09 14:38:58 +0000207 pParse->pWith = 0;
drha7564662010-02-22 19:32:31 +0000208 }
drhc81c11f2009-11-10 01:30:52 +0000209}
210
211/*
drhc3dcdba2019-04-09 21:32:46 +0000212** If database connection db is currently parsing SQL, then transfer
213** error code errCode to that parser if the parser has not already
214** encountered some other kind of error.
215*/
216int sqlite3ErrorToParser(sqlite3 *db, int errCode){
217 Parse *pParse;
218 if( db==0 || (pParse = db->pParse)==0 ) return errCode;
219 pParse->rc = errCode;
220 pParse->nErr++;
221 return errCode;
222}
223
224/*
drhc81c11f2009-11-10 01:30:52 +0000225** Convert an SQL-style quoted string into a normal string by removing
226** the quote characters. The conversion is done in-place. If the
227** input does not begin with a quote character, then this routine
228** is a no-op.
229**
230** The input string must be zero-terminated. A new zero-terminator
231** is added to the dequoted string.
232**
233** The return value is -1 if no dequoting occurs or the length of the
234** dequoted string, exclusive of the zero terminator, if dequoting does
235** occur.
236**
drh51d35b02019-01-11 13:32:23 +0000237** 2002-02-14: This routine is extended to remove MS-Access style
peter.d.reid60ec9142014-09-06 16:39:46 +0000238** brackets from around identifiers. For example: "[a-b-c]" becomes
drhc81c11f2009-11-10 01:30:52 +0000239** "a-b-c".
240*/
drh244b9d62016-04-11 19:01:08 +0000241void sqlite3Dequote(char *z){
drhc81c11f2009-11-10 01:30:52 +0000242 char quote;
243 int i, j;
drh244b9d62016-04-11 19:01:08 +0000244 if( z==0 ) return;
drhc81c11f2009-11-10 01:30:52 +0000245 quote = z[0];
drh244b9d62016-04-11 19:01:08 +0000246 if( !sqlite3Isquote(quote) ) return;
247 if( quote=='[' ) quote = ']';
drh9ccd8652013-09-13 16:36:46 +0000248 for(i=1, j=0;; i++){
249 assert( z[i] );
drhc81c11f2009-11-10 01:30:52 +0000250 if( z[i]==quote ){
251 if( z[i+1]==quote ){
252 z[j++] = quote;
253 i++;
254 }else{
255 break;
256 }
257 }else{
258 z[j++] = z[i];
259 }
260 }
261 z[j] = 0;
drhc81c11f2009-11-10 01:30:52 +0000262}
drh51d35b02019-01-11 13:32:23 +0000263void sqlite3DequoteExpr(Expr *p){
264 assert( sqlite3Isquote(p->u.zToken[0]) );
265 p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted;
266 sqlite3Dequote(p->u.zToken);
267}
drhc81c11f2009-11-10 01:30:52 +0000268
drh40aced52016-01-22 17:48:09 +0000269/*
270** Generate a Token object from a string
271*/
272void sqlite3TokenInit(Token *p, char *z){
273 p->z = z;
274 p->n = sqlite3Strlen30(z);
275}
276
drhc81c11f2009-11-10 01:30:52 +0000277/* Convenient short-hand */
278#define UpperToLower sqlite3UpperToLower
279
280/*
281** Some systems have stricmp(). Others have strcasecmp(). Because
282** there is no consistency, we will define our own.
drh9f129f42010-08-31 15:27:32 +0000283**
drh0299b402012-03-19 17:42:46 +0000284** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
285** sqlite3_strnicmp() APIs allow applications and extensions to compare
286** the contents of two buffers containing UTF-8 strings in a
287** case-independent fashion, using the same definition of "case
288** independence" that SQLite uses internally when comparing identifiers.
drhc81c11f2009-11-10 01:30:52 +0000289*/
drh3fa97302012-02-22 16:58:36 +0000290int sqlite3_stricmp(const char *zLeft, const char *zRight){
drh9ca95732014-10-24 00:35:58 +0000291 if( zLeft==0 ){
292 return zRight ? -1 : 0;
293 }else if( zRight==0 ){
294 return 1;
295 }
drh80738d92016-02-15 00:34:16 +0000296 return sqlite3StrICmp(zLeft, zRight);
297}
298int sqlite3StrICmp(const char *zLeft, const char *zRight){
299 unsigned char *a, *b;
drh7e427332019-04-17 11:34:44 +0000300 int c, x;
drhc81c11f2009-11-10 01:30:52 +0000301 a = (unsigned char *)zLeft;
302 b = (unsigned char *)zRight;
drh80738d92016-02-15 00:34:16 +0000303 for(;;){
drh7e427332019-04-17 11:34:44 +0000304 c = *a;
305 x = *b;
306 if( c==x ){
307 if( c==0 ) break;
308 }else{
309 c = (int)UpperToLower[c] - (int)UpperToLower[x];
310 if( c ) break;
311 }
drh80738d92016-02-15 00:34:16 +0000312 a++;
313 b++;
314 }
315 return c;
drhc81c11f2009-11-10 01:30:52 +0000316}
317int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
318 register unsigned char *a, *b;
drh9ca95732014-10-24 00:35:58 +0000319 if( zLeft==0 ){
320 return zRight ? -1 : 0;
321 }else if( zRight==0 ){
322 return 1;
323 }
drhc81c11f2009-11-10 01:30:52 +0000324 a = (unsigned char *)zLeft;
325 b = (unsigned char *)zRight;
326 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
327 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
328}
329
330/*
drhd44390c2020-04-06 18:16:31 +0000331** Compute an 8-bit hash on a string that is insensitive to case differences
332*/
333u8 sqlite3StrIHash(const char *z){
334 u8 h = 0;
335 if( z==0 ) return 0;
336 while( z[0] ){
337 h += UpperToLower[(unsigned char)z[0]];
338 z++;
339 }
340 return h;
341}
342
343/*
drh02a43f62017-12-26 14:46:20 +0000344** Compute 10 to the E-th power. Examples: E==1 results in 10.
345** E==2 results in 100. E==50 results in 1.0e50.
346**
347** This routine only works for values of E between 1 and 341.
348*/
349static LONGDOUBLE_TYPE sqlite3Pow10(int E){
drh3dc97272018-01-17 21:14:17 +0000350#if defined(_MSC_VER)
351 static const LONGDOUBLE_TYPE x[] = {
drh38a59af2019-05-25 17:41:07 +0000352 1.0e+001L,
353 1.0e+002L,
354 1.0e+004L,
355 1.0e+008L,
356 1.0e+016L,
357 1.0e+032L,
358 1.0e+064L,
359 1.0e+128L,
360 1.0e+256L
drh3dc97272018-01-17 21:14:17 +0000361 };
362 LONGDOUBLE_TYPE r = 1.0;
363 int i;
364 assert( E>=0 && E<=307 );
365 for(i=0; E!=0; i++, E >>=1){
366 if( E & 1 ) r *= x[i];
367 }
368 return r;
369#else
drh02a43f62017-12-26 14:46:20 +0000370 LONGDOUBLE_TYPE x = 10.0;
371 LONGDOUBLE_TYPE r = 1.0;
372 while(1){
373 if( E & 1 ) r *= x;
374 E >>= 1;
375 if( E==0 ) break;
376 x *= x;
377 }
378 return r;
drh3dc97272018-01-17 21:14:17 +0000379#endif
drh02a43f62017-12-26 14:46:20 +0000380}
381
382/*
drh9339da12010-09-30 00:50:49 +0000383** The string z[] is an text representation of a real number.
drh025586a2010-09-30 17:33:11 +0000384** Convert this string to a double and write it into *pResult.
drhc81c11f2009-11-10 01:30:52 +0000385**
drh9339da12010-09-30 00:50:49 +0000386** The string z[] is length bytes in length (bytes, not characters) and
387** uses the encoding enc. The string is not necessarily zero-terminated.
drhc81c11f2009-11-10 01:30:52 +0000388**
drh9339da12010-09-30 00:50:49 +0000389** Return TRUE if the result is a valid real number (or integer) and FALSE
drh8a3884e2019-05-29 21:18:27 +0000390** if the string is empty or contains extraneous text. More specifically
391** return
392** 1 => The input string is a pure integer
393** 2 or more => The input has a decimal point or eNNN clause
drh9a278222019-06-07 22:26:08 +0000394** 0 or less => The input string is not a valid number
395** -1 => Not a valid number, but has a valid prefix which
396** includes a decimal point and/or an eNNN clause
drh8a3884e2019-05-29 21:18:27 +0000397**
398** Valid numbers are in one of these formats:
drh025586a2010-09-30 17:33:11 +0000399**
400** [+-]digits[E[+-]digits]
401** [+-]digits.[digits][E[+-]digits]
402** [+-].digits[E[+-]digits]
403**
404** Leading and trailing whitespace is ignored for the purpose of determining
405** validity.
406**
407** If some prefix of the input string is a valid number, this routine
408** returns FALSE but it still converts the prefix and writes the result
409** into *pResult.
drhc81c11f2009-11-10 01:30:52 +0000410*/
mistachkin6dcf9a42019-10-10 23:58:16 +0000411#if defined(_MSC_VER)
412#pragma warning(disable : 4756)
413#endif
drh9339da12010-09-30 00:50:49 +0000414int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
drhc81c11f2009-11-10 01:30:52 +0000415#ifndef SQLITE_OMIT_FLOATING_POINT
drh0e5fba72013-03-20 12:04:29 +0000416 int incr;
drhe3a4f2c2019-12-13 23:38:57 +0000417 const char *zEnd;
drhc81c11f2009-11-10 01:30:52 +0000418 /* sign * significand * (10 ^ (esign * exponent)) */
drh025586a2010-09-30 17:33:11 +0000419 int sign = 1; /* sign of significand */
420 i64 s = 0; /* significand */
421 int d = 0; /* adjust exponent for shifting decimal point */
422 int esign = 1; /* sign of exponent */
423 int e = 0; /* exponent */
424 int eValid = 1; /* True exponent is either not used or is well-formed */
drhc81c11f2009-11-10 01:30:52 +0000425 double result;
drhc2b893a2019-05-25 18:17:53 +0000426 int nDigit = 0; /* Number of digits processed */
drh8a3884e2019-05-29 21:18:27 +0000427 int eType = 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */
drhc81c11f2009-11-10 01:30:52 +0000428
drh0e5fba72013-03-20 12:04:29 +0000429 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
drh025586a2010-09-30 17:33:11 +0000430 *pResult = 0.0; /* Default return value, in case of an error */
drhe3a4f2c2019-12-13 23:38:57 +0000431 if( length==0 ) return 0;
drh025586a2010-09-30 17:33:11 +0000432
drh0e5fba72013-03-20 12:04:29 +0000433 if( enc==SQLITE_UTF8 ){
434 incr = 1;
drhe3a4f2c2019-12-13 23:38:57 +0000435 zEnd = z + length;
drh0e5fba72013-03-20 12:04:29 +0000436 }else{
437 int i;
438 incr = 2;
drh87969b22020-01-08 12:17:46 +0000439 length &= ~1;
drh0e5fba72013-03-20 12:04:29 +0000440 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
drh84422db2019-05-30 13:47:10 +0000441 testcase( enc==SQLITE_UTF16LE );
442 testcase( enc==SQLITE_UTF16BE );
drh0e5fba72013-03-20 12:04:29 +0000443 for(i=3-enc; i<length && z[i]==0; i+=2){}
drh8a3884e2019-05-29 21:18:27 +0000444 if( i<length ) eType = -100;
drhad975d52016-04-27 15:24:13 +0000445 zEnd = &z[i^1];
drh0e5fba72013-03-20 12:04:29 +0000446 z += (enc&1);
447 }
drh9339da12010-09-30 00:50:49 +0000448
drhc81c11f2009-11-10 01:30:52 +0000449 /* skip leading spaces */
drh9339da12010-09-30 00:50:49 +0000450 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
drh025586a2010-09-30 17:33:11 +0000451 if( z>=zEnd ) return 0;
drh9339da12010-09-30 00:50:49 +0000452
drhc81c11f2009-11-10 01:30:52 +0000453 /* get sign of significand */
454 if( *z=='-' ){
455 sign = -1;
drh9339da12010-09-30 00:50:49 +0000456 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000457 }else if( *z=='+' ){
drh9339da12010-09-30 00:50:49 +0000458 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000459 }
drh9339da12010-09-30 00:50:49 +0000460
drhc81c11f2009-11-10 01:30:52 +0000461 /* copy max significant digits to significand */
drhc2b893a2019-05-25 18:17:53 +0000462 while( z<zEnd && sqlite3Isdigit(*z) ){
drhc81c11f2009-11-10 01:30:52 +0000463 s = s*10 + (*z - '0');
drhc2b893a2019-05-25 18:17:53 +0000464 z+=incr; nDigit++;
465 if( s>=((LARGEST_INT64-9)/10) ){
466 /* skip non-significant significand digits
467 ** (increase exponent by d to shift decimal left) */
468 while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; d++; }
469 }
drhc81c11f2009-11-10 01:30:52 +0000470 }
drh9339da12010-09-30 00:50:49 +0000471 if( z>=zEnd ) goto do_atof_calc;
drhc81c11f2009-11-10 01:30:52 +0000472
473 /* if decimal point is present */
474 if( *z=='.' ){
drh9339da12010-09-30 00:50:49 +0000475 z+=incr;
drh8a3884e2019-05-29 21:18:27 +0000476 eType++;
drhc81c11f2009-11-10 01:30:52 +0000477 /* copy digits from after decimal to significand
478 ** (decrease exponent by d to shift decimal right) */
drh15af62a2016-04-26 23:14:45 +0000479 while( z<zEnd && sqlite3Isdigit(*z) ){
480 if( s<((LARGEST_INT64-9)/10) ){
481 s = s*10 + (*z - '0');
482 d--;
drhc2b893a2019-05-25 18:17:53 +0000483 nDigit++;
drh15af62a2016-04-26 23:14:45 +0000484 }
drhc2b893a2019-05-25 18:17:53 +0000485 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000486 }
drhc81c11f2009-11-10 01:30:52 +0000487 }
drh9339da12010-09-30 00:50:49 +0000488 if( z>=zEnd ) goto do_atof_calc;
drhc81c11f2009-11-10 01:30:52 +0000489
490 /* if exponent is present */
491 if( *z=='e' || *z=='E' ){
drh9339da12010-09-30 00:50:49 +0000492 z+=incr;
drh025586a2010-09-30 17:33:11 +0000493 eValid = 0;
drh8a3884e2019-05-29 21:18:27 +0000494 eType++;
drhad975d52016-04-27 15:24:13 +0000495
496 /* This branch is needed to avoid a (harmless) buffer overread. The
497 ** special comment alerts the mutation tester that the correct answer
498 ** is obtained even if the branch is omitted */
499 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/
500
drhc81c11f2009-11-10 01:30:52 +0000501 /* get sign of exponent */
502 if( *z=='-' ){
503 esign = -1;
drh9339da12010-09-30 00:50:49 +0000504 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000505 }else if( *z=='+' ){
drh9339da12010-09-30 00:50:49 +0000506 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000507 }
508 /* copy digits to exponent */
drh9339da12010-09-30 00:50:49 +0000509 while( z<zEnd && sqlite3Isdigit(*z) ){
drh57db4a72011-10-17 20:41:46 +0000510 e = e<10000 ? (e*10 + (*z - '0')) : 10000;
drh9339da12010-09-30 00:50:49 +0000511 z+=incr;
drh025586a2010-09-30 17:33:11 +0000512 eValid = 1;
drhc81c11f2009-11-10 01:30:52 +0000513 }
514 }
515
drh025586a2010-09-30 17:33:11 +0000516 /* skip trailing spaces */
drhc6daa012016-04-27 02:35:03 +0000517 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
drh025586a2010-09-30 17:33:11 +0000518
drh9339da12010-09-30 00:50:49 +0000519do_atof_calc:
drhc81c11f2009-11-10 01:30:52 +0000520 /* adjust exponent by d, and update sign */
521 e = (e*esign) + d;
522 if( e<0 ) {
523 esign = -1;
524 e *= -1;
525 } else {
526 esign = 1;
527 }
528
drhad975d52016-04-27 15:24:13 +0000529 if( s==0 ) {
530 /* In the IEEE 754 standard, zero is signed. */
drhc6daa012016-04-27 02:35:03 +0000531 result = sign<0 ? -(double)0 : (double)0;
drhc81c11f2009-11-10 01:30:52 +0000532 } else {
drhad975d52016-04-27 15:24:13 +0000533 /* Attempt to reduce exponent.
534 **
535 ** Branches that are not required for the correct answer but which only
536 ** help to obtain the correct answer faster are marked with special
537 ** comments, as a hint to the mutation tester.
538 */
539 while( e>0 ){ /*OPTIMIZATION-IF-TRUE*/
540 if( esign>0 ){
541 if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/
542 s *= 10;
543 }else{
544 if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/
545 s /= 10;
546 }
547 e--;
drhc81c11f2009-11-10 01:30:52 +0000548 }
549
550 /* adjust the sign of significand */
551 s = sign<0 ? -s : s;
552
drhad975d52016-04-27 15:24:13 +0000553 if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/
554 result = (double)s;
555 }else{
drhc81c11f2009-11-10 01:30:52 +0000556 /* attempt to handle extremely small/large numbers better */
drhad975d52016-04-27 15:24:13 +0000557 if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/
558 if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/
drh02a43f62017-12-26 14:46:20 +0000559 LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308);
drhad975d52016-04-27 15:24:13 +0000560 if( esign<0 ){
561 result = s / scale;
562 result /= 1.0e+308;
563 }else{
564 result = s * scale;
565 result *= 1.0e+308;
566 }
567 }else{ assert( e>=342 );
568 if( esign<0 ){
569 result = 0.0*s;
570 }else{
drhb9772e72017-09-12 13:27:43 +0000571#ifdef INFINITY
drh3ba18ad2017-09-12 15:05:34 +0000572 result = INFINITY*s;
drhb9772e72017-09-12 13:27:43 +0000573#else
drhad975d52016-04-27 15:24:13 +0000574 result = 1e308*1e308*s; /* Infinity */
drhb9772e72017-09-12 13:27:43 +0000575#endif
drhad975d52016-04-27 15:24:13 +0000576 }
drh2458a2e2011-10-17 12:14:26 +0000577 }
drhc81c11f2009-11-10 01:30:52 +0000578 }else{
drh02a43f62017-12-26 14:46:20 +0000579 LONGDOUBLE_TYPE scale = sqlite3Pow10(e);
drhc81c11f2009-11-10 01:30:52 +0000580 if( esign<0 ){
581 result = s / scale;
582 }else{
583 result = s * scale;
584 }
585 }
drhc81c11f2009-11-10 01:30:52 +0000586 }
587 }
588
589 /* store the result */
590 *pResult = result;
591
drh025586a2010-09-30 17:33:11 +0000592 /* return true if number and no extra non-whitespace chracters after */
drh9a278222019-06-07 22:26:08 +0000593 if( z==zEnd && nDigit>0 && eValid && eType>0 ){
594 return eType;
drh378a7d32019-06-10 23:45:10 +0000595 }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){
drh9a278222019-06-07 22:26:08 +0000596 return -1;
597 }else{
598 return 0;
599 }
drhc81c11f2009-11-10 01:30:52 +0000600#else
shaneh5f1d6b62010-09-30 16:51:25 +0000601 return !sqlite3Atoi64(z, pResult, length, enc);
drhc81c11f2009-11-10 01:30:52 +0000602#endif /* SQLITE_OMIT_FLOATING_POINT */
603}
mistachkin6dcf9a42019-10-10 23:58:16 +0000604#if defined(_MSC_VER)
605#pragma warning(default : 4756)
606#endif
drhc81c11f2009-11-10 01:30:52 +0000607
608/*
drh82b0f102020-07-21 18:25:19 +0000609** Render an signed 64-bit integer as text. Store the result in zOut[].
610**
611** The caller must ensure that zOut[] is at least 21 bytes in size.
612*/
613void sqlite3Int64ToText(i64 v, char *zOut){
614 int i;
615 u64 x;
616 char zTemp[22];
617 if( v<0 ){
drh8deae5a2020-07-29 12:23:20 +0000618 x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v;
drh82b0f102020-07-21 18:25:19 +0000619 }else{
620 x = v;
621 }
622 i = sizeof(zTemp)-2;
623 zTemp[sizeof(zTemp)-1] = 0;
624 do{
625 zTemp[i--] = (x%10) + '0';
626 x = x/10;
627 }while( x );
628 if( v<0 ) zTemp[i--] = '-';
629 memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i);
630}
631
632/*
drhc81c11f2009-11-10 01:30:52 +0000633** Compare the 19-character string zNum against the text representation
634** value 2^63: 9223372036854775808. Return negative, zero, or positive
635** if zNum is less than, equal to, or greater than the string.
shaneh5f1d6b62010-09-30 16:51:25 +0000636** Note that zNum must contain exactly 19 characters.
drhc81c11f2009-11-10 01:30:52 +0000637**
638** Unlike memcmp() this routine is guaranteed to return the difference
639** in the values of the last digit if the only difference is in the
640** last digit. So, for example,
641**
drh9339da12010-09-30 00:50:49 +0000642** compare2pow63("9223372036854775800", 1)
drhc81c11f2009-11-10 01:30:52 +0000643**
644** will return -8.
645*/
drh9339da12010-09-30 00:50:49 +0000646static int compare2pow63(const char *zNum, int incr){
647 int c = 0;
648 int i;
649 /* 012345678901234567 */
650 const char *pow63 = "922337203685477580";
651 for(i=0; c==0 && i<18; i++){
652 c = (zNum[i*incr]-pow63[i])*10;
653 }
drhc81c11f2009-11-10 01:30:52 +0000654 if( c==0 ){
drh9339da12010-09-30 00:50:49 +0000655 c = zNum[18*incr] - '8';
drh44dbca82010-01-13 04:22:20 +0000656 testcase( c==(-1) );
657 testcase( c==0 );
658 testcase( c==(+1) );
drhc81c11f2009-11-10 01:30:52 +0000659 }
660 return c;
661}
662
drhc81c11f2009-11-10 01:30:52 +0000663/*
drh9296c182014-07-23 13:40:49 +0000664** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
665** routine does *not* accept hexadecimal notation.
drh158b9cb2011-03-05 20:59:46 +0000666**
drh84d4f1a2017-09-20 10:47:10 +0000667** Returns:
drh158b9cb2011-03-05 20:59:46 +0000668**
drh9a278222019-06-07 22:26:08 +0000669** -1 Not even a prefix of the input text looks like an integer
drh84d4f1a2017-09-20 10:47:10 +0000670** 0 Successful transformation. Fits in a 64-bit signed integer.
drh4eb57ce2018-01-26 18:37:34 +0000671** 1 Excess non-space text after the integer value
drh84d4f1a2017-09-20 10:47:10 +0000672** 2 Integer too large for a 64-bit signed integer or is malformed
673** 3 Special case of 9223372036854775808
drhc81c11f2009-11-10 01:30:52 +0000674**
drh9339da12010-09-30 00:50:49 +0000675** length is the number of bytes in the string (bytes, not characters).
676** The string is not necessarily zero-terminated. The encoding is
677** given by enc.
drhc81c11f2009-11-10 01:30:52 +0000678*/
drh9339da12010-09-30 00:50:49 +0000679int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
drh0e5fba72013-03-20 12:04:29 +0000680 int incr;
drh158b9cb2011-03-05 20:59:46 +0000681 u64 u = 0;
shaneh5f1d6b62010-09-30 16:51:25 +0000682 int neg = 0; /* assume positive */
drh9339da12010-09-30 00:50:49 +0000683 int i;
684 int c = 0;
drh609d5842016-04-28 00:32:16 +0000685 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */
drh84d4f1a2017-09-20 10:47:10 +0000686 int rc; /* Baseline return code */
drhc81c11f2009-11-10 01:30:52 +0000687 const char *zStart;
drh9339da12010-09-30 00:50:49 +0000688 const char *zEnd = zNum + length;
drh0e5fba72013-03-20 12:04:29 +0000689 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
690 if( enc==SQLITE_UTF8 ){
691 incr = 1;
692 }else{
693 incr = 2;
drh359941b2020-08-27 16:28:30 +0000694 length &= ~1;
drh0e5fba72013-03-20 12:04:29 +0000695 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
696 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
697 nonNum = i<length;
drh609d5842016-04-28 00:32:16 +0000698 zEnd = &zNum[i^1];
drh0e5fba72013-03-20 12:04:29 +0000699 zNum += (enc&1);
700 }
drh9339da12010-09-30 00:50:49 +0000701 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
drh158b9cb2011-03-05 20:59:46 +0000702 if( zNum<zEnd ){
703 if( *zNum=='-' ){
704 neg = 1;
705 zNum+=incr;
706 }else if( *zNum=='+' ){
707 zNum+=incr;
708 }
drhc81c11f2009-11-10 01:30:52 +0000709 }
710 zStart = zNum;
drh9339da12010-09-30 00:50:49 +0000711 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
712 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
drh158b9cb2011-03-05 20:59:46 +0000713 u = u*10 + c - '0';
drhc81c11f2009-11-10 01:30:52 +0000714 }
drh4eb57ce2018-01-26 18:37:34 +0000715 testcase( i==18*incr );
716 testcase( i==19*incr );
717 testcase( i==20*incr );
drh1822ebf2018-01-27 14:25:27 +0000718 if( u>LARGEST_INT64 ){
719 /* This test and assignment is needed only to suppress UB warnings
720 ** from clang and -fsanitize=undefined. This test and assignment make
721 ** the code a little larger and slower, and no harm comes from omitting
722 ** them, but we must appaise the undefined-behavior pharisees. */
723 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
724 }else if( neg ){
drh158b9cb2011-03-05 20:59:46 +0000725 *pNum = -(i64)u;
726 }else{
727 *pNum = (i64)u;
728 }
drh4eb57ce2018-01-26 18:37:34 +0000729 rc = 0;
drh9a278222019-06-07 22:26:08 +0000730 if( i==0 && zStart==zNum ){ /* No digits */
731 rc = -1;
732 }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */
drh84d4f1a2017-09-20 10:47:10 +0000733 rc = 1;
drh4eb57ce2018-01-26 18:37:34 +0000734 }else if( &zNum[i]<zEnd ){ /* Extra bytes at the end */
735 int jj = i;
736 do{
737 if( !sqlite3Isspace(zNum[jj]) ){
738 rc = 1; /* Extra non-space text after the integer */
739 break;
740 }
741 jj += incr;
742 }while( &zNum[jj]<zEnd );
drh84d4f1a2017-09-20 10:47:10 +0000743 }
drh4eb57ce2018-01-26 18:37:34 +0000744 if( i<19*incr ){
drhc81c11f2009-11-10 01:30:52 +0000745 /* Less than 19 digits, so we know that it fits in 64 bits */
drh158b9cb2011-03-05 20:59:46 +0000746 assert( u<=LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000747 return rc;
drhc81c11f2009-11-10 01:30:52 +0000748 }else{
drh158b9cb2011-03-05 20:59:46 +0000749 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
drh4eb57ce2018-01-26 18:37:34 +0000750 c = i>19*incr ? 1 : compare2pow63(zNum, incr);
drh158b9cb2011-03-05 20:59:46 +0000751 if( c<0 ){
752 /* zNum is less than 9223372036854775808 so it fits */
753 assert( u<=LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000754 return rc;
drh158b9cb2011-03-05 20:59:46 +0000755 }else{
drh4eb57ce2018-01-26 18:37:34 +0000756 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
757 if( c>0 ){
758 /* zNum is greater than 9223372036854775808 so it overflows */
759 return 2;
760 }else{
761 /* zNum is exactly 9223372036854775808. Fits if negative. The
762 ** special case 2 overflow if positive */
763 assert( u-1==LARGEST_INT64 );
764 return neg ? rc : 3;
765 }
drh158b9cb2011-03-05 20:59:46 +0000766 }
drhc81c11f2009-11-10 01:30:52 +0000767 }
768}
769
770/*
drh9296c182014-07-23 13:40:49 +0000771** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
772** into a 64-bit signed integer. This routine accepts hexadecimal literals,
773** whereas sqlite3Atoi64() does not.
774**
775** Returns:
776**
777** 0 Successful transformation. Fits in a 64-bit signed integer.
drh84d4f1a2017-09-20 10:47:10 +0000778** 1 Excess text after the integer value
779** 2 Integer too large for a 64-bit signed integer or is malformed
780** 3 Special case of 9223372036854775808
drh9296c182014-07-23 13:40:49 +0000781*/
782int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
783#ifndef SQLITE_OMIT_HEX_INTEGER
784 if( z[0]=='0'
785 && (z[1]=='x' || z[1]=='X')
drh9296c182014-07-23 13:40:49 +0000786 ){
787 u64 u = 0;
788 int i, k;
789 for(i=2; z[i]=='0'; i++){}
790 for(k=i; sqlite3Isxdigit(z[k]); k++){
791 u = u*16 + sqlite3HexToInt(z[k]);
792 }
793 memcpy(pOut, &u, 8);
drh84d4f1a2017-09-20 10:47:10 +0000794 return (z[k]==0 && k-i<=16) ? 0 : 2;
drh9296c182014-07-23 13:40:49 +0000795 }else
796#endif /* SQLITE_OMIT_HEX_INTEGER */
797 {
798 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
799 }
800}
801
802/*
drhc81c11f2009-11-10 01:30:52 +0000803** If zNum represents an integer that will fit in 32-bits, then set
804** *pValue to that integer and return true. Otherwise return false.
805**
drh9296c182014-07-23 13:40:49 +0000806** This routine accepts both decimal and hexadecimal notation for integers.
807**
drhc81c11f2009-11-10 01:30:52 +0000808** Any non-numeric characters that following zNum are ignored.
809** This is different from sqlite3Atoi64() which requires the
810** input number to be zero-terminated.
811*/
812int sqlite3GetInt32(const char *zNum, int *pValue){
813 sqlite_int64 v = 0;
814 int i, c;
815 int neg = 0;
816 if( zNum[0]=='-' ){
817 neg = 1;
818 zNum++;
819 }else if( zNum[0]=='+' ){
820 zNum++;
821 }
drh28e048c2014-07-23 01:26:51 +0000822#ifndef SQLITE_OMIT_HEX_INTEGER
823 else if( zNum[0]=='0'
824 && (zNum[1]=='x' || zNum[1]=='X')
825 && sqlite3Isxdigit(zNum[2])
826 ){
827 u32 u = 0;
828 zNum += 2;
829 while( zNum[0]=='0' ) zNum++;
830 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
831 u = u*16 + sqlite3HexToInt(zNum[i]);
832 }
833 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
834 memcpy(pValue, &u, 4);
835 return 1;
836 }else{
837 return 0;
838 }
839 }
840#endif
drh313e6fd2017-05-03 17:44:28 +0000841 if( !sqlite3Isdigit(zNum[0]) ) return 0;
drh935f2e72015-04-18 04:45:00 +0000842 while( zNum[0]=='0' ) zNum++;
drhc81c11f2009-11-10 01:30:52 +0000843 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
844 v = v*10 + c;
845 }
846
847 /* The longest decimal representation of a 32 bit integer is 10 digits:
848 **
849 ** 1234567890
850 ** 2^31 -> 2147483648
851 */
drh44dbca82010-01-13 04:22:20 +0000852 testcase( i==10 );
drhc81c11f2009-11-10 01:30:52 +0000853 if( i>10 ){
854 return 0;
855 }
drh44dbca82010-01-13 04:22:20 +0000856 testcase( v-neg==2147483647 );
drhc81c11f2009-11-10 01:30:52 +0000857 if( v-neg>2147483647 ){
858 return 0;
859 }
860 if( neg ){
861 v = -v;
862 }
863 *pValue = (int)v;
864 return 1;
865}
866
867/*
drh60ac3f42010-11-23 18:59:27 +0000868** Return a 32-bit integer value extracted from a string. If the
869** string is not an integer, just return 0.
870*/
871int sqlite3Atoi(const char *z){
872 int x = 0;
drh48bf2d72020-07-30 17:14:55 +0000873 sqlite3GetInt32(z, &x);
drh60ac3f42010-11-23 18:59:27 +0000874 return x;
875}
876
877/*
drhabc38152020-07-22 13:38:04 +0000878** Try to convert z into an unsigned 32-bit integer. Return true on
879** success and false if there is an error.
880**
881** Only decimal notation is accepted.
882*/
883int sqlite3GetUInt32(const char *z, u32 *pI){
884 u64 v = 0;
885 int i;
886 for(i=0; sqlite3Isdigit(z[i]); i++){
887 v = v*10 + z[i] - '0';
drh69306bf2020-07-22 20:12:10 +0000888 if( v>4294967296LL ){ *pI = 0; return 0; }
drhabc38152020-07-22 13:38:04 +0000889 }
drh69306bf2020-07-22 20:12:10 +0000890 if( i==0 || z[i]!=0 ){ *pI = 0; return 0; }
drhabc38152020-07-22 13:38:04 +0000891 *pI = (u32)v;
892 return 1;
893}
894
895/*
drhc81c11f2009-11-10 01:30:52 +0000896** The variable-length integer encoding is as follows:
897**
898** KEY:
899** A = 0xxxxxxx 7 bits of data and one flag bit
900** B = 1xxxxxxx 7 bits of data and one flag bit
901** C = xxxxxxxx 8 bits of data
902**
903** 7 bits - A
904** 14 bits - BA
905** 21 bits - BBA
906** 28 bits - BBBA
907** 35 bits - BBBBA
908** 42 bits - BBBBBA
909** 49 bits - BBBBBBA
910** 56 bits - BBBBBBBA
911** 64 bits - BBBBBBBBC
912*/
913
914/*
915** Write a 64-bit variable-length integer to memory starting at p[0].
916** The length of data write will be between 1 and 9 bytes. The number
917** of bytes written is returned.
918**
919** A variable-length integer consists of the lower 7 bits of each byte
920** for all bytes that have the 8th bit set and one byte with the 8th
921** bit clear. Except, if we get to the 9th byte, it stores the full
922** 8 bits and is the last byte.
923*/
drh2f2b2b82014-08-22 18:48:25 +0000924static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){
drhc81c11f2009-11-10 01:30:52 +0000925 int i, j, n;
926 u8 buf[10];
927 if( v & (((u64)0xff000000)<<32) ){
928 p[8] = (u8)v;
929 v >>= 8;
930 for(i=7; i>=0; i--){
931 p[i] = (u8)((v & 0x7f) | 0x80);
932 v >>= 7;
933 }
934 return 9;
935 }
936 n = 0;
937 do{
938 buf[n++] = (u8)((v & 0x7f) | 0x80);
939 v >>= 7;
940 }while( v!=0 );
941 buf[0] &= 0x7f;
942 assert( n<=9 );
943 for(i=0, j=n-1; j>=0; j--, i++){
944 p[i] = buf[j];
945 }
946 return n;
947}
drh2f2b2b82014-08-22 18:48:25 +0000948int sqlite3PutVarint(unsigned char *p, u64 v){
949 if( v<=0x7f ){
950 p[0] = v&0x7f;
drhc81c11f2009-11-10 01:30:52 +0000951 return 1;
952 }
drh2f2b2b82014-08-22 18:48:25 +0000953 if( v<=0x3fff ){
954 p[0] = ((v>>7)&0x7f)|0x80;
955 p[1] = v&0x7f;
drhc81c11f2009-11-10 01:30:52 +0000956 return 2;
957 }
drh2f2b2b82014-08-22 18:48:25 +0000958 return putVarint64(p,v);
drhc81c11f2009-11-10 01:30:52 +0000959}
960
961/*
drh0b2864c2010-03-03 15:18:38 +0000962** Bitmasks used by sqlite3GetVarint(). These precomputed constants
963** are defined here rather than simply putting the constant expressions
964** inline in order to work around bugs in the RVT compiler.
965**
966** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
967**
968** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
969*/
970#define SLOT_2_0 0x001fc07f
971#define SLOT_4_2_0 0xf01fc07f
972
973
974/*
drhc81c11f2009-11-10 01:30:52 +0000975** Read a 64-bit variable-length integer from memory starting at p[0].
976** Return the number of bytes read. The value is stored in *v.
977*/
978u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
979 u32 a,b,s;
980
drh698c86f2019-04-17 12:07:08 +0000981 if( ((signed char*)p)[0]>=0 ){
982 *v = *p;
drhc81c11f2009-11-10 01:30:52 +0000983 return 1;
984 }
drh698c86f2019-04-17 12:07:08 +0000985 if( ((signed char*)p)[1]>=0 ){
986 *v = ((u32)(p[0]&0x7f)<<7) | p[1];
drhc81c11f2009-11-10 01:30:52 +0000987 return 2;
988 }
989
drh0b2864c2010-03-03 15:18:38 +0000990 /* Verify that constants are precomputed correctly */
991 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
shaneh1da207e2010-03-09 14:41:12 +0000992 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
drh0b2864c2010-03-03 15:18:38 +0000993
drh698c86f2019-04-17 12:07:08 +0000994 a = ((u32)p[0])<<14;
995 b = p[1];
996 p += 2;
drhc81c11f2009-11-10 01:30:52 +0000997 a |= *p;
998 /* a: p0<<14 | p2 (unmasked) */
999 if (!(a&0x80))
1000 {
drh0b2864c2010-03-03 15:18:38 +00001001 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001002 b &= 0x7f;
1003 b = b<<7;
1004 a |= b;
1005 *v = a;
1006 return 3;
1007 }
1008
1009 /* CSE1 from below */
drh0b2864c2010-03-03 15:18:38 +00001010 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001011 p++;
1012 b = b<<14;
1013 b |= *p;
1014 /* b: p1<<14 | p3 (unmasked) */
1015 if (!(b&0x80))
1016 {
drh0b2864c2010-03-03 15:18:38 +00001017 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001018 /* moved CSE1 up */
1019 /* a &= (0x7f<<14)|(0x7f); */
1020 a = a<<7;
1021 a |= b;
1022 *v = a;
1023 return 4;
1024 }
1025
1026 /* a: p0<<14 | p2 (masked) */
1027 /* b: p1<<14 | p3 (unmasked) */
1028 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1029 /* moved CSE1 up */
1030 /* a &= (0x7f<<14)|(0x7f); */
drh0b2864c2010-03-03 15:18:38 +00001031 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001032 s = a;
1033 /* s: p0<<14 | p2 (masked) */
1034
1035 p++;
1036 a = a<<14;
1037 a |= *p;
1038 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1039 if (!(a&0x80))
1040 {
drh62aaa6c2015-11-21 17:27:42 +00001041 /* we can skip these cause they were (effectively) done above
1042 ** while calculating s */
drhc81c11f2009-11-10 01:30:52 +00001043 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
1044 /* b &= (0x7f<<14)|(0x7f); */
1045 b = b<<7;
1046 a |= b;
1047 s = s>>18;
1048 *v = ((u64)s)<<32 | a;
1049 return 5;
1050 }
1051
1052 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1053 s = s<<7;
1054 s |= b;
1055 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1056
1057 p++;
1058 b = b<<14;
1059 b |= *p;
1060 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
1061 if (!(b&0x80))
1062 {
1063 /* we can skip this cause it was (effectively) done above in calc'ing s */
1064 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
drh0b2864c2010-03-03 15:18:38 +00001065 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001066 a = a<<7;
1067 a |= b;
1068 s = s>>18;
1069 *v = ((u64)s)<<32 | a;
1070 return 6;
1071 }
1072
1073 p++;
1074 a = a<<14;
1075 a |= *p;
1076 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
1077 if (!(a&0x80))
1078 {
drh0b2864c2010-03-03 15:18:38 +00001079 a &= SLOT_4_2_0;
1080 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001081 b = b<<7;
1082 a |= b;
1083 s = s>>11;
1084 *v = ((u64)s)<<32 | a;
1085 return 7;
1086 }
1087
1088 /* CSE2 from below */
drh0b2864c2010-03-03 15:18:38 +00001089 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001090 p++;
1091 b = b<<14;
1092 b |= *p;
1093 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
1094 if (!(b&0x80))
1095 {
drh0b2864c2010-03-03 15:18:38 +00001096 b &= SLOT_4_2_0;
drhc81c11f2009-11-10 01:30:52 +00001097 /* moved CSE2 up */
1098 /* a &= (0x7f<<14)|(0x7f); */
1099 a = a<<7;
1100 a |= b;
1101 s = s>>4;
1102 *v = ((u64)s)<<32 | a;
1103 return 8;
1104 }
1105
1106 p++;
1107 a = a<<15;
1108 a |= *p;
1109 /* a: p4<<29 | p6<<15 | p8 (unmasked) */
1110
1111 /* moved CSE2 up */
1112 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
drh0b2864c2010-03-03 15:18:38 +00001113 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001114 b = b<<8;
1115 a |= b;
1116
1117 s = s<<4;
1118 b = p[-4];
1119 b &= 0x7f;
1120 b = b>>3;
1121 s |= b;
1122
1123 *v = ((u64)s)<<32 | a;
1124
1125 return 9;
1126}
1127
1128/*
1129** Read a 32-bit variable-length integer from memory starting at p[0].
1130** Return the number of bytes read. The value is stored in *v.
1131**
1132** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
1133** integer, then set *v to 0xffffffff.
1134**
1135** A MACRO version, getVarint32, is provided which inlines the
1136** single-byte case. All code should use the MACRO version as
1137** this function assumes the single-byte case has already been handled.
1138*/
1139u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
1140 u32 a,b;
1141
1142 /* The 1-byte case. Overwhelmingly the most common. Handled inline
1143 ** by the getVarin32() macro */
1144 a = *p;
1145 /* a: p0 (unmasked) */
1146#ifndef getVarint32
1147 if (!(a&0x80))
1148 {
1149 /* Values between 0 and 127 */
1150 *v = a;
1151 return 1;
1152 }
1153#endif
1154
1155 /* The 2-byte case */
1156 p++;
1157 b = *p;
1158 /* b: p1 (unmasked) */
1159 if (!(b&0x80))
1160 {
1161 /* Values between 128 and 16383 */
1162 a &= 0x7f;
1163 a = a<<7;
1164 *v = a | b;
1165 return 2;
1166 }
1167
1168 /* The 3-byte case */
1169 p++;
1170 a = a<<14;
1171 a |= *p;
1172 /* a: p0<<14 | p2 (unmasked) */
1173 if (!(a&0x80))
1174 {
1175 /* Values between 16384 and 2097151 */
1176 a &= (0x7f<<14)|(0x7f);
1177 b &= 0x7f;
1178 b = b<<7;
1179 *v = a | b;
1180 return 3;
1181 }
1182
1183 /* A 32-bit varint is used to store size information in btrees.
1184 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
1185 ** A 3-byte varint is sufficient, for example, to record the size
1186 ** of a 1048569-byte BLOB or string.
1187 **
1188 ** We only unroll the first 1-, 2-, and 3- byte cases. The very
1189 ** rare larger cases can be handled by the slower 64-bit varint
1190 ** routine.
1191 */
1192#if 1
1193 {
1194 u64 v64;
1195 u8 n;
1196
drh15cedda2020-07-02 17:05:11 +00001197 n = sqlite3GetVarint(p-2, &v64);
drhc81c11f2009-11-10 01:30:52 +00001198 assert( n>3 && n<=9 );
1199 if( (v64 & SQLITE_MAX_U32)!=v64 ){
1200 *v = 0xffffffff;
1201 }else{
1202 *v = (u32)v64;
1203 }
1204 return n;
1205 }
1206
1207#else
1208 /* For following code (kept for historical record only) shows an
1209 ** unrolling for the 3- and 4-byte varint cases. This code is
1210 ** slightly faster, but it is also larger and much harder to test.
1211 */
1212 p++;
1213 b = b<<14;
1214 b |= *p;
1215 /* b: p1<<14 | p3 (unmasked) */
1216 if (!(b&0x80))
1217 {
1218 /* Values between 2097152 and 268435455 */
1219 b &= (0x7f<<14)|(0x7f);
1220 a &= (0x7f<<14)|(0x7f);
1221 a = a<<7;
1222 *v = a | b;
1223 return 4;
1224 }
1225
1226 p++;
1227 a = a<<14;
1228 a |= *p;
1229 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1230 if (!(a&0x80))
1231 {
dan3bbe7612010-03-03 16:02:05 +00001232 /* Values between 268435456 and 34359738367 */
1233 a &= SLOT_4_2_0;
1234 b &= SLOT_4_2_0;
drhc81c11f2009-11-10 01:30:52 +00001235 b = b<<7;
1236 *v = a | b;
1237 return 5;
1238 }
1239
1240 /* We can only reach this point when reading a corrupt database
1241 ** file. In that case we are not in any hurry. Use the (relatively
1242 ** slow) general-purpose sqlite3GetVarint() routine to extract the
1243 ** value. */
1244 {
1245 u64 v64;
1246 u8 n;
1247
1248 p -= 4;
1249 n = sqlite3GetVarint(p, &v64);
1250 assert( n>5 && n<=9 );
1251 *v = (u32)v64;
1252 return n;
1253 }
1254#endif
1255}
1256
1257/*
1258** Return the number of bytes that will be needed to store the given
1259** 64-bit integer.
1260*/
1261int sqlite3VarintLen(u64 v){
drh59a53642015-09-01 22:29:07 +00001262 int i;
drh6f17c092016-03-04 21:18:09 +00001263 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); }
drhc81c11f2009-11-10 01:30:52 +00001264 return i;
1265}
1266
1267
1268/*
1269** Read or write a four-byte big-endian integer value.
1270*/
1271u32 sqlite3Get4byte(const u8 *p){
drh5372e4d2015-06-30 12:47:09 +00001272#if SQLITE_BYTEORDER==4321
1273 u32 x;
1274 memcpy(&x,p,4);
1275 return x;
drhdc5ece82017-02-15 15:09:09 +00001276#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
drh5372e4d2015-06-30 12:47:09 +00001277 u32 x;
1278 memcpy(&x,p,4);
1279 return __builtin_bswap32(x);
drha39284b2017-02-09 17:12:22 +00001280#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
mistachkin647ca462015-06-30 17:28:40 +00001281 u32 x;
1282 memcpy(&x,p,4);
1283 return _byteswap_ulong(x);
drh5372e4d2015-06-30 12:47:09 +00001284#else
drh693e6712014-01-24 22:58:00 +00001285 testcase( p[0]&0x80 );
1286 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
drh5372e4d2015-06-30 12:47:09 +00001287#endif
drhc81c11f2009-11-10 01:30:52 +00001288}
1289void sqlite3Put4byte(unsigned char *p, u32 v){
drh5372e4d2015-06-30 12:47:09 +00001290#if SQLITE_BYTEORDER==4321
1291 memcpy(p,&v,4);
drhdc5ece82017-02-15 15:09:09 +00001292#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
drh5372e4d2015-06-30 12:47:09 +00001293 u32 x = __builtin_bswap32(v);
1294 memcpy(p,&x,4);
drha39284b2017-02-09 17:12:22 +00001295#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
mistachkin647ca462015-06-30 17:28:40 +00001296 u32 x = _byteswap_ulong(v);
1297 memcpy(p,&x,4);
drh5372e4d2015-06-30 12:47:09 +00001298#else
drhc81c11f2009-11-10 01:30:52 +00001299 p[0] = (u8)(v>>24);
1300 p[1] = (u8)(v>>16);
1301 p[2] = (u8)(v>>8);
1302 p[3] = (u8)v;
drh5372e4d2015-06-30 12:47:09 +00001303#endif
drhc81c11f2009-11-10 01:30:52 +00001304}
1305
drh9296c182014-07-23 13:40:49 +00001306
1307
1308/*
1309** Translate a single byte of Hex into an integer.
1310** This routine only works if h really is a valid hexadecimal
1311** character: 0..9a..fA..F
1312*/
1313u8 sqlite3HexToInt(int h){
1314 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
1315#ifdef SQLITE_ASCII
1316 h += 9*(1&(h>>6));
1317#endif
1318#ifdef SQLITE_EBCDIC
1319 h += 9*(1&~(h>>4));
1320#endif
1321 return (u8)(h & 0xf);
1322}
1323
drhb48c0d52020-02-07 01:12:53 +00001324#if !defined(SQLITE_OMIT_BLOB_LITERAL)
drhc81c11f2009-11-10 01:30:52 +00001325/*
1326** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
1327** value. Return a pointer to its binary value. Space to hold the
1328** binary value has been obtained from malloc and must be freed by
1329** the calling routine.
1330*/
1331void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
1332 char *zBlob;
1333 int i;
1334
drh575fad62016-02-05 13:38:36 +00001335 zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
drhc81c11f2009-11-10 01:30:52 +00001336 n--;
1337 if( zBlob ){
1338 for(i=0; i<n; i+=2){
dancd74b612011-04-22 19:37:32 +00001339 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
drhc81c11f2009-11-10 01:30:52 +00001340 }
1341 zBlob[i/2] = 0;
1342 }
1343 return zBlob;
1344}
drhb48c0d52020-02-07 01:12:53 +00001345#endif /* !SQLITE_OMIT_BLOB_LITERAL */
drhc81c11f2009-11-10 01:30:52 +00001346
drh413c3d32010-02-23 20:11:56 +00001347/*
1348** Log an error that is an API call on a connection pointer that should
1349** not have been used. The "type" of connection pointer is given as the
1350** argument. The zType is a word like "NULL" or "closed" or "invalid".
1351*/
1352static void logBadConnection(const char *zType){
1353 sqlite3_log(SQLITE_MISUSE,
1354 "API call with %s database connection pointer",
1355 zType
1356 );
1357}
drhc81c11f2009-11-10 01:30:52 +00001358
1359/*
drhc81c11f2009-11-10 01:30:52 +00001360** Check to make sure we have a valid db pointer. This test is not
1361** foolproof but it does provide some measure of protection against
1362** misuse of the interface such as passing in db pointers that are
1363** NULL or which have been previously closed. If this routine returns
1364** 1 it means that the db pointer is valid and 0 if it should not be
1365** dereferenced for any reason. The calling function should invoke
1366** SQLITE_MISUSE immediately.
1367**
1368** sqlite3SafetyCheckOk() requires that the db pointer be valid for
1369** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
1370** open properly and is not fit for general use but which can be
1371** used as an argument to sqlite3_errmsg() or sqlite3_close().
1372*/
1373int sqlite3SafetyCheckOk(sqlite3 *db){
1374 u32 magic;
drh413c3d32010-02-23 20:11:56 +00001375 if( db==0 ){
1376 logBadConnection("NULL");
1377 return 0;
1378 }
drhc81c11f2009-11-10 01:30:52 +00001379 magic = db->magic;
drh9978c972010-02-23 17:36:32 +00001380 if( magic!=SQLITE_MAGIC_OPEN ){
drhe294da02010-02-25 23:44:15 +00001381 if( sqlite3SafetyCheckSickOrOk(db) ){
1382 testcase( sqlite3GlobalConfig.xLog!=0 );
drh413c3d32010-02-23 20:11:56 +00001383 logBadConnection("unopened");
1384 }
drhc81c11f2009-11-10 01:30:52 +00001385 return 0;
1386 }else{
1387 return 1;
1388 }
1389}
1390int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
1391 u32 magic;
1392 magic = db->magic;
1393 if( magic!=SQLITE_MAGIC_SICK &&
1394 magic!=SQLITE_MAGIC_OPEN &&
drh413c3d32010-02-23 20:11:56 +00001395 magic!=SQLITE_MAGIC_BUSY ){
drhe294da02010-02-25 23:44:15 +00001396 testcase( sqlite3GlobalConfig.xLog!=0 );
drhaf46dc12010-02-24 21:44:07 +00001397 logBadConnection("invalid");
drh413c3d32010-02-23 20:11:56 +00001398 return 0;
1399 }else{
1400 return 1;
1401 }
drhc81c11f2009-11-10 01:30:52 +00001402}
drh158b9cb2011-03-05 20:59:46 +00001403
1404/*
1405** Attempt to add, substract, or multiply the 64-bit signed value iB against
1406** the other 64-bit signed integer at *pA and store the result in *pA.
1407** Return 0 on success. Or if the operation would have resulted in an
1408** overflow, leave *pA unchanged and return 1.
1409*/
1410int sqlite3AddInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001411#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001412 return __builtin_add_overflow(*pA, iB, pA);
1413#else
drh158b9cb2011-03-05 20:59:46 +00001414 i64 iA = *pA;
1415 testcase( iA==0 ); testcase( iA==1 );
1416 testcase( iB==-1 ); testcase( iB==0 );
1417 if( iB>=0 ){
1418 testcase( iA>0 && LARGEST_INT64 - iA == iB );
1419 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
1420 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
drh158b9cb2011-03-05 20:59:46 +00001421 }else{
1422 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
1423 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
1424 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
drh158b9cb2011-03-05 20:59:46 +00001425 }
drh53a6eb32014-02-10 12:59:15 +00001426 *pA += iB;
drh158b9cb2011-03-05 20:59:46 +00001427 return 0;
drh4a477612017-01-03 17:33:43 +00001428#endif
drh158b9cb2011-03-05 20:59:46 +00001429}
1430int sqlite3SubInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001431#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001432 return __builtin_sub_overflow(*pA, iB, pA);
1433#else
drh158b9cb2011-03-05 20:59:46 +00001434 testcase( iB==SMALLEST_INT64+1 );
1435 if( iB==SMALLEST_INT64 ){
1436 testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
1437 if( (*pA)>=0 ) return 1;
1438 *pA -= iB;
1439 return 0;
1440 }else{
1441 return sqlite3AddInt64(pA, -iB);
1442 }
drh4a477612017-01-03 17:33:43 +00001443#endif
drh158b9cb2011-03-05 20:59:46 +00001444}
drh158b9cb2011-03-05 20:59:46 +00001445int sqlite3MulInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001446#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001447 return __builtin_mul_overflow(*pA, iB, pA);
1448#else
drh158b9cb2011-03-05 20:59:46 +00001449 i64 iA = *pA;
drh09952c62016-09-20 22:04:05 +00001450 if( iB>0 ){
1451 if( iA>LARGEST_INT64/iB ) return 1;
1452 if( iA<SMALLEST_INT64/iB ) return 1;
1453 }else if( iB<0 ){
1454 if( iA>0 ){
1455 if( iB<SMALLEST_INT64/iA ) return 1;
1456 }else if( iA<0 ){
1457 if( iB==SMALLEST_INT64 ) return 1;
1458 if( iA==SMALLEST_INT64 ) return 1;
1459 if( -iA>LARGEST_INT64/-iB ) return 1;
drh53a6eb32014-02-10 12:59:15 +00001460 }
drh53a6eb32014-02-10 12:59:15 +00001461 }
drh09952c62016-09-20 22:04:05 +00001462 *pA = iA*iB;
drh158b9cb2011-03-05 20:59:46 +00001463 return 0;
drh4a477612017-01-03 17:33:43 +00001464#endif
drh158b9cb2011-03-05 20:59:46 +00001465}
drhd50ffc42011-03-08 02:38:28 +00001466
1467/*
1468** Compute the absolute value of a 32-bit signed integer, of possible. Or
1469** if the integer has a value of -2147483648, return +2147483647
1470*/
1471int sqlite3AbsInt32(int x){
1472 if( x>=0 ) return x;
drh87e79ae2011-03-08 13:06:41 +00001473 if( x==(int)0x80000000 ) return 0x7fffffff;
drhd50ffc42011-03-08 02:38:28 +00001474 return -x;
1475}
drh81cc5162011-05-17 20:36:21 +00001476
1477#ifdef SQLITE_ENABLE_8_3_NAMES
1478/*
drhb51bf432011-07-21 21:29:35 +00001479** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
drh81cc5162011-05-17 20:36:21 +00001480** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
1481** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
1482** three characters, then shorten the suffix on z[] to be the last three
1483** characters of the original suffix.
1484**
drhb51bf432011-07-21 21:29:35 +00001485** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
1486** do the suffix shortening regardless of URI parameter.
1487**
drh81cc5162011-05-17 20:36:21 +00001488** Examples:
1489**
1490** test.db-journal => test.nal
1491** test.db-wal => test.wal
1492** test.db-shm => test.shm
drhf5808602011-12-16 00:33:04 +00001493** test.db-mj7f3319fa => test.9fa
drh81cc5162011-05-17 20:36:21 +00001494*/
1495void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
drhb51bf432011-07-21 21:29:35 +00001496#if SQLITE_ENABLE_8_3_NAMES<2
drh7d39e172012-01-02 12:41:53 +00001497 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
drhb51bf432011-07-21 21:29:35 +00001498#endif
1499 {
drh81cc5162011-05-17 20:36:21 +00001500 int i, sz;
1501 sz = sqlite3Strlen30(z);
drhc83f2d42011-05-18 02:41:10 +00001502 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
drhc02a43a2012-01-10 23:18:38 +00001503 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
drh81cc5162011-05-17 20:36:21 +00001504 }
1505}
1506#endif
drhbf539c42013-10-05 18:16:02 +00001507
1508/*
1509** Find (an approximate) sum of two LogEst values. This computation is
1510** not a simple "+" operator because LogEst is stored as a logarithmic
1511** value.
1512**
1513*/
1514LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
1515 static const unsigned char x[] = {
1516 10, 10, /* 0,1 */
1517 9, 9, /* 2,3 */
1518 8, 8, /* 4,5 */
1519 7, 7, 7, /* 6,7,8 */
1520 6, 6, 6, /* 9,10,11 */
1521 5, 5, 5, /* 12-14 */
1522 4, 4, 4, 4, /* 15-18 */
1523 3, 3, 3, 3, 3, 3, /* 19-24 */
1524 2, 2, 2, 2, 2, 2, 2, /* 25-31 */
1525 };
1526 if( a>=b ){
1527 if( a>b+49 ) return a;
1528 if( a>b+31 ) return a+1;
1529 return a+x[a-b];
1530 }else{
1531 if( b>a+49 ) return b;
1532 if( b>a+31 ) return b+1;
1533 return b+x[b-a];
1534 }
1535}
1536
1537/*
drh224155d2014-04-30 13:19:09 +00001538** Convert an integer into a LogEst. In other words, compute an
1539** approximation for 10*log2(x).
drhbf539c42013-10-05 18:16:02 +00001540*/
1541LogEst sqlite3LogEst(u64 x){
1542 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
1543 LogEst y = 40;
1544 if( x<8 ){
1545 if( x<2 ) return 0;
1546 while( x<8 ){ y -= 10; x <<= 1; }
1547 }else{
drhceb4b1d2017-08-17 20:53:07 +00001548#if GCC_VERSION>=5004000
1549 int i = 60 - __builtin_clzll(x);
1550 y += i*10;
1551 x >>= i;
1552#else
drh75ab50c2016-04-28 14:15:12 +00001553 while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/
drhbf539c42013-10-05 18:16:02 +00001554 while( x>15 ){ y += 10; x >>= 1; }
drhceb4b1d2017-08-17 20:53:07 +00001555#endif
drhbf539c42013-10-05 18:16:02 +00001556 }
1557 return a[x&7] + y - 10;
1558}
1559
1560#ifndef SQLITE_OMIT_VIRTUALTABLE
1561/*
1562** Convert a double into a LogEst
1563** In other words, compute an approximation for 10*log2(x).
1564*/
1565LogEst sqlite3LogEstFromDouble(double x){
1566 u64 a;
1567 LogEst e;
1568 assert( sizeof(x)==8 && sizeof(a)==8 );
1569 if( x<=1 ) return 0;
1570 if( x<=2000000000 ) return sqlite3LogEst((u64)x);
1571 memcpy(&a, &x, 8);
1572 e = (a>>52) - 1022;
1573 return e*10;
1574}
1575#endif /* SQLITE_OMIT_VIRTUALTABLE */
1576
drh14bfd992016-03-05 14:00:09 +00001577#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
drh175b8f02019-08-08 15:24:17 +00001578 defined(SQLITE_ENABLE_STAT4) || \
drhd566c952016-02-25 21:19:03 +00001579 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
drhbf539c42013-10-05 18:16:02 +00001580/*
1581** Convert a LogEst into an integer.
drhd566c952016-02-25 21:19:03 +00001582**
1583** Note that this routine is only used when one or more of various
1584** non-standard compile-time options is enabled.
drhbf539c42013-10-05 18:16:02 +00001585*/
1586u64 sqlite3LogEstToInt(LogEst x){
1587 u64 n;
drhbf539c42013-10-05 18:16:02 +00001588 n = x%10;
1589 x /= 10;
1590 if( n>=5 ) n -= 2;
1591 else if( n>=1 ) n -= 1;
drhecdf20d2016-03-10 14:28:24 +00001592#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
1593 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
1594 if( x>60 ) return (u64)LARGEST_INT64;
1595#else
drh175b8f02019-08-08 15:24:17 +00001596 /* If only SQLITE_ENABLE_STAT4 is on, then the largest input
drhecdf20d2016-03-10 14:28:24 +00001597 ** possible to this routine is 310, resulting in a maximum x of 31 */
1598 assert( x<=60 );
1599#endif
1600 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x);
drhbf539c42013-10-05 18:16:02 +00001601}
drhd566c952016-02-25 21:19:03 +00001602#endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */
drh9bf755c2016-12-23 03:59:31 +00001603
1604/*
1605** Add a new name/number pair to a VList. This might require that the
1606** VList object be reallocated, so return the new VList. If an OOM
drhce1bbe52016-12-23 13:52:45 +00001607** error occurs, the original VList returned and the
drh9bf755c2016-12-23 03:59:31 +00001608** db->mallocFailed flag is set.
1609**
1610** A VList is really just an array of integers. To destroy a VList,
1611** simply pass it to sqlite3DbFree().
1612**
1613** The first integer is the number of integers allocated for the whole
1614** VList. The second integer is the number of integers actually used.
1615** Each name/number pair is encoded by subsequent groups of 3 or more
1616** integers.
1617**
drhce1bbe52016-12-23 13:52:45 +00001618** Each name/number pair starts with two integers which are the numeric
drh9bf755c2016-12-23 03:59:31 +00001619** value for the pair and the size of the name/number pair, respectively.
1620** The text name overlays one or more following integers. The text name
1621** is always zero-terminated.
drhce1bbe52016-12-23 13:52:45 +00001622**
1623** Conceptually:
1624**
1625** struct VList {
1626** int nAlloc; // Number of allocated slots
1627** int nUsed; // Number of used slots
1628** struct VListEntry {
1629** int iValue; // Value for this entry
1630** int nSlot; // Slots used by this entry
1631** // ... variable name goes here
1632** } a[0];
1633** }
1634**
1635** During code generation, pointers to the variable names within the
1636** VList are taken. When that happens, nAlloc is set to zero as an
1637** indication that the VList may never again be enlarged, since the
1638** accompanying realloc() would invalidate the pointers.
drh9bf755c2016-12-23 03:59:31 +00001639*/
1640VList *sqlite3VListAdd(
1641 sqlite3 *db, /* The database connection used for malloc() */
1642 VList *pIn, /* The input VList. Might be NULL */
1643 const char *zName, /* Name of symbol to add */
1644 int nName, /* Bytes of text in zName */
1645 int iVal /* Value to associate with zName */
1646){
1647 int nInt; /* number of sizeof(int) objects needed for zName */
drhce1bbe52016-12-23 13:52:45 +00001648 char *z; /* Pointer to where zName will be stored */
1649 int i; /* Index in pIn[] where zName is stored */
drh9bf755c2016-12-23 03:59:31 +00001650
1651 nInt = nName/4 + 3;
drhce1bbe52016-12-23 13:52:45 +00001652 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */
drh9bf755c2016-12-23 03:59:31 +00001653 if( pIn==0 || pIn[1]+nInt > pIn[0] ){
1654 /* Enlarge the allocation */
drh0aa32312019-04-13 04:01:12 +00001655 sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt;
drh9bf755c2016-12-23 03:59:31 +00001656 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
drhce1bbe52016-12-23 13:52:45 +00001657 if( pOut==0 ) return pIn;
drh9bf755c2016-12-23 03:59:31 +00001658 if( pIn==0 ) pOut[1] = 2;
1659 pIn = pOut;
1660 pIn[0] = nAlloc;
1661 }
1662 i = pIn[1];
1663 pIn[i] = iVal;
1664 pIn[i+1] = nInt;
1665 z = (char*)&pIn[i+2];
1666 pIn[1] = i+nInt;
1667 assert( pIn[1]<=pIn[0] );
1668 memcpy(z, zName, nName);
1669 z[nName] = 0;
1670 return pIn;
1671}
1672
1673/*
1674** Return a pointer to the name of a variable in the given VList that
1675** has the value iVal. Or return a NULL if there is no such variable in
1676** the list
1677*/
1678const char *sqlite3VListNumToName(VList *pIn, int iVal){
1679 int i, mx;
1680 if( pIn==0 ) return 0;
1681 mx = pIn[1];
1682 i = 2;
1683 do{
1684 if( pIn[i]==iVal ) return (char*)&pIn[i+2];
1685 i += pIn[i+1];
1686 }while( i<mx );
1687 return 0;
1688}
1689
1690/*
1691** Return the number of the variable named zName, if it is in VList.
1692** or return 0 if there is no such variable.
1693*/
1694int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
1695 int i, mx;
1696 if( pIn==0 ) return 0;
1697 mx = pIn[1];
1698 i = 2;
1699 do{
1700 const char *z = (const char*)&pIn[i+2];
1701 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
1702 i += pIn[i+1];
1703 }while( i<mx );
1704 return 0;
1705}