blob: 632d317e317cf154577276e408ec2b9147005c7c [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/*
drhce059e52019-04-05 17:22:50 +000025** 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.
drhc007f612014-05-16 14:17:01 +000028**
drhce059e52019-04-05 17:22:50 +000029** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The
30** sqlite3FaultSim() function only returns non-zero during testing.
drhc007f612014-05-16 14:17:01 +000031**
drhce059e52019-04-05 17:22:50 +000032** 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.
drhc007f612014-05-16 14:17:01 +000042*/
drhd12602a2016-12-07 15:49:02 +000043#ifndef SQLITE_UNTESTABLE
drhc007f612014-05-16 14:17:01 +000044int sqlite3FaultSim(int iTest){
45 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback;
46 return xCallback ? xCallback(iTest) : SQLITE_OK;
47}
48#endif
49
drh85c8f292010-01-13 17:39:53 +000050#ifndef SQLITE_OMIT_FLOATING_POINT
drhc81c11f2009-11-10 01:30:52 +000051/*
52** Return true if the floating point value is Not a Number (NaN).
drhe534c7b2021-09-06 11:44:19 +000053**
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.
drhc81c11f2009-11-10 01:30:52 +000056*/
57int sqlite3IsNaN(double x){
drhe534c7b2021-09-06 11:44:19 +000058 int rc; /* The value return */
59#if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
drh05921222019-05-30 00:46:37 +000060 u64 y;
61 memcpy(&y,&x,sizeof(y));
drhe534c7b2021-09-06 11:44:19 +000062 rc = IsNaN(y);
63#else
64 rc = isnan(x);
65#endif /* HAVE_ISNAN */
66 testcase( rc );
67 return rc;
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){
drh77441fa2021-07-30 18:39:59 +000092 if( pCol->colFlags & COLFLAG_HASTYPE ){
drhcf9d36d2021-08-02 18:03:43 +000093 return pCol->zCnName + strlen(pCol->zCnName) + 1;
drhb70f2ea2021-08-18 12:05:22 +000094 }else if( pCol->eCType ){
95 assert( pCol->eCType<=SQLITE_N_STDTYPE );
96 return (char*)sqlite3StdType[pCol->eCType-1];
drh77441fa2021-07-30 18:39:59 +000097 }else{
98 return zDflt;
99 }
drh94eaafa2016-02-29 15:53:11 +0000100}
101
102/*
drh80fbee02016-03-21 11:57:13 +0000103** Helper function for sqlite3Error() - called rarely. Broken out into
104** a separate routine to avoid unnecessary register saves on entry to
105** sqlite3Error().
drh13f40da2014-08-22 18:00:11 +0000106*/
drh8d2f41c2016-03-21 11:38:01 +0000107static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){
108 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
109 sqlite3SystemError(db, err_code);
110}
drh80fbee02016-03-21 11:57:13 +0000111
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*/
drh13f40da2014-08-22 18:00:11 +0000117void sqlite3Error(sqlite3 *db, int err_code){
118 assert( db!=0 );
119 db->errCode = err_code;
drhf62641e2021-12-24 20:22:13 +0000120 if( err_code || db->pErr ){
121 sqlite3ErrorFinish(db, err_code);
122 }else{
123 db->errByteOffset = -1;
124 }
drh13f40da2014-08-22 18:00:11 +0000125}
126
127/*
drh88efc792021-01-01 18:23:56 +0000128** 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;
drhf62641e2021-12-24 20:22:13 +0000134 db->errByteOffset = -1;
drh88efc792021-01-01 18:23:56 +0000135 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
136}
137
138/*
drh1b9f2142016-03-17 16:01:23 +0000139** 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/*
drhc81c11f2009-11-10 01:30:52 +0000151** 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
drhf62641e2021-12-24 20:22:13 +0000155** error string. zFormat and any string tokens that follow it are
156** assumed to be encoded in UTF-8.
drhc81c11f2009-11-10 01:30:52 +0000157**
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*/
drh13f40da2014-08-22 18:00:11 +0000162void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){
drha3cc0072013-12-13 16:23:55 +0000163 assert( db!=0 );
164 db->errCode = err_code;
drh8d2f41c2016-03-21 11:38:01 +0000165 sqlite3SystemError(db, err_code);
drh13f40da2014-08-22 18:00:11 +0000166 if( zFormat==0 ){
167 sqlite3Error(db, err_code);
168 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
drha3cc0072013-12-13 16:23:55 +0000169 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);
drhc81c11f2009-11-10 01:30:52 +0000175 }
176}
177
178/*
drhf84cbd12023-01-12 13:25:48 +0000179** Check for interrupts and invoke progress callback.
180*/
181void sqlite3ProgressCheck(Parse *p){
182 sqlite3 *db = p->db;
183 if( AtomicLoad(&db->u1.isInterrupted) ){
184 p->nErr++;
185 p->rc = SQLITE_INTERRUPT;
186 }
187#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
drh2fc9dc92023-01-12 19:51:49 +0000188 if( db->xProgress && (++p->nProgressSteps)>=db->nProgressOps ){
189 if( db->xProgress(db->pProgressArg) ){
190 p->nErr++;
191 p->rc = SQLITE_INTERRUPT;
192 }
193 p->nProgressSteps = 0;
drhf84cbd12023-01-12 13:25:48 +0000194 }
195#endif
196}
197
198/*
drhc81c11f2009-11-10 01:30:52 +0000199** Add an error message to pParse->zErrMsg and increment pParse->nErr.
drhc81c11f2009-11-10 01:30:52 +0000200**
drh13f40da2014-08-22 18:00:11 +0000201** This function should be used to report any error that occurs while
drhc81c11f2009-11-10 01:30:52 +0000202** compiling an SQL statement (i.e. within sqlite3_prepare()). The
203** last thing the sqlite3_prepare() function does is copy the error
204** stored by this function into the database handle using sqlite3Error().
drh13f40da2014-08-22 18:00:11 +0000205** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
206** during statement execution (sqlite3_step() etc.).
drhc81c11f2009-11-10 01:30:52 +0000207*/
208void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
drha7564662010-02-22 19:32:31 +0000209 char *zMsg;
drhc81c11f2009-11-10 01:30:52 +0000210 va_list ap;
211 sqlite3 *db = pParse->db;
drhc692df22022-01-24 15:34:55 +0000212 assert( db!=0 );
drh173b4182022-09-02 17:25:25 +0000213 assert( db->pParse==pParse || db->pParse->pToplevel==pParse );
drhf62641e2021-12-24 20:22:13 +0000214 db->errByteOffset = -2;
drhc81c11f2009-11-10 01:30:52 +0000215 va_start(ap, zFormat);
drha7564662010-02-22 19:32:31 +0000216 zMsg = sqlite3VMPrintf(db, zFormat, ap);
drhc81c11f2009-11-10 01:30:52 +0000217 va_end(ap);
drhf62641e2021-12-24 20:22:13 +0000218 if( db->errByteOffset<-1 ) db->errByteOffset = -1;
drha7564662010-02-22 19:32:31 +0000219 if( db->suppressErr ){
220 sqlite3DbFree(db, zMsg);
drh0c7d3d32022-01-24 16:47:12 +0000221 if( db->mallocFailed ){
222 pParse->nErr++;
223 pParse->rc = SQLITE_NOMEM;
224 }
drha7564662010-02-22 19:32:31 +0000225 }else{
226 pParse->nErr++;
227 sqlite3DbFree(db, pParse->zErrMsg);
228 pParse->zErrMsg = zMsg;
229 pParse->rc = SQLITE_ERROR;
drh46a31cd2019-11-09 14:38:58 +0000230 pParse->pWith = 0;
drha7564662010-02-22 19:32:31 +0000231 }
drhc81c11f2009-11-10 01:30:52 +0000232}
233
234/*
drhc3dcdba2019-04-09 21:32:46 +0000235** If database connection db is currently parsing SQL, then transfer
236** error code errCode to that parser if the parser has not already
237** encountered some other kind of error.
238*/
239int sqlite3ErrorToParser(sqlite3 *db, int errCode){
240 Parse *pParse;
241 if( db==0 || (pParse = db->pParse)==0 ) return errCode;
242 pParse->rc = errCode;
243 pParse->nErr++;
244 return errCode;
245}
246
247/*
drhc81c11f2009-11-10 01:30:52 +0000248** Convert an SQL-style quoted string into a normal string by removing
249** the quote characters. The conversion is done in-place. If the
250** input does not begin with a quote character, then this routine
251** is a no-op.
252**
253** The input string must be zero-terminated. A new zero-terminator
254** is added to the dequoted string.
255**
256** The return value is -1 if no dequoting occurs or the length of the
257** dequoted string, exclusive of the zero terminator, if dequoting does
258** occur.
259**
drh51d35b02019-01-11 13:32:23 +0000260** 2002-02-14: This routine is extended to remove MS-Access style
peter.d.reid60ec9142014-09-06 16:39:46 +0000261** brackets from around identifiers. For example: "[a-b-c]" becomes
drhc81c11f2009-11-10 01:30:52 +0000262** "a-b-c".
263*/
drh244b9d62016-04-11 19:01:08 +0000264void sqlite3Dequote(char *z){
drhc81c11f2009-11-10 01:30:52 +0000265 char quote;
266 int i, j;
drh244b9d62016-04-11 19:01:08 +0000267 if( z==0 ) return;
drhc81c11f2009-11-10 01:30:52 +0000268 quote = z[0];
drh244b9d62016-04-11 19:01:08 +0000269 if( !sqlite3Isquote(quote) ) return;
270 if( quote=='[' ) quote = ']';
drh9ccd8652013-09-13 16:36:46 +0000271 for(i=1, j=0;; i++){
272 assert( z[i] );
drhc81c11f2009-11-10 01:30:52 +0000273 if( z[i]==quote ){
274 if( z[i+1]==quote ){
275 z[j++] = quote;
276 i++;
277 }else{
278 break;
279 }
280 }else{
281 z[j++] = z[i];
282 }
283 }
284 z[j] = 0;
drhc81c11f2009-11-10 01:30:52 +0000285}
drh51d35b02019-01-11 13:32:23 +0000286void sqlite3DequoteExpr(Expr *p){
drhf9751072021-10-07 13:40:29 +0000287 assert( !ExprHasProperty(p, EP_IntValue) );
drh51d35b02019-01-11 13:32:23 +0000288 assert( sqlite3Isquote(p->u.zToken[0]) );
289 p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted;
290 sqlite3Dequote(p->u.zToken);
291}
drhc81c11f2009-11-10 01:30:52 +0000292
drh40aced52016-01-22 17:48:09 +0000293/*
drh77441fa2021-07-30 18:39:59 +0000294** If the input token p is quoted, try to adjust the token to remove
295** the quotes. This is not always possible:
296**
297** "abc" -> abc
298** "ab""cd" -> (not possible because of the interior "")
299**
300** Remove the quotes if possible. This is a optimization. The overall
301** system should still return the correct answer even if this routine
302** is always a no-op.
303*/
304void sqlite3DequoteToken(Token *p){
drh15482bc2021-08-06 15:26:01 +0000305 unsigned int i;
drh77441fa2021-07-30 18:39:59 +0000306 if( p->n<2 ) return;
307 if( !sqlite3Isquote(p->z[0]) ) return;
308 for(i=1; i<p->n-1; i++){
309 if( sqlite3Isquote(p->z[i]) ) return;
310 }
311 p->n -= 2;
312 p->z++;
313}
314
315/*
drh40aced52016-01-22 17:48:09 +0000316** Generate a Token object from a string
317*/
318void sqlite3TokenInit(Token *p, char *z){
319 p->z = z;
320 p->n = sqlite3Strlen30(z);
321}
322
drhc81c11f2009-11-10 01:30:52 +0000323/* Convenient short-hand */
324#define UpperToLower sqlite3UpperToLower
325
326/*
327** Some systems have stricmp(). Others have strcasecmp(). Because
328** there is no consistency, we will define our own.
drh9f129f42010-08-31 15:27:32 +0000329**
drh0299b402012-03-19 17:42:46 +0000330** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
331** sqlite3_strnicmp() APIs allow applications and extensions to compare
332** the contents of two buffers containing UTF-8 strings in a
333** case-independent fashion, using the same definition of "case
334** independence" that SQLite uses internally when comparing identifiers.
drhc81c11f2009-11-10 01:30:52 +0000335*/
drh3fa97302012-02-22 16:58:36 +0000336int sqlite3_stricmp(const char *zLeft, const char *zRight){
drh9ca95732014-10-24 00:35:58 +0000337 if( zLeft==0 ){
338 return zRight ? -1 : 0;
339 }else if( zRight==0 ){
340 return 1;
341 }
drh80738d92016-02-15 00:34:16 +0000342 return sqlite3StrICmp(zLeft, zRight);
343}
344int sqlite3StrICmp(const char *zLeft, const char *zRight){
345 unsigned char *a, *b;
drh7e427332019-04-17 11:34:44 +0000346 int c, x;
drhc81c11f2009-11-10 01:30:52 +0000347 a = (unsigned char *)zLeft;
348 b = (unsigned char *)zRight;
drh80738d92016-02-15 00:34:16 +0000349 for(;;){
drh7e427332019-04-17 11:34:44 +0000350 c = *a;
351 x = *b;
352 if( c==x ){
353 if( c==0 ) break;
354 }else{
355 c = (int)UpperToLower[c] - (int)UpperToLower[x];
356 if( c ) break;
357 }
drh80738d92016-02-15 00:34:16 +0000358 a++;
359 b++;
360 }
361 return c;
drhc81c11f2009-11-10 01:30:52 +0000362}
363int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
364 register unsigned char *a, *b;
drh9ca95732014-10-24 00:35:58 +0000365 if( zLeft==0 ){
366 return zRight ? -1 : 0;
367 }else if( zRight==0 ){
368 return 1;
369 }
drhc81c11f2009-11-10 01:30:52 +0000370 a = (unsigned char *)zLeft;
371 b = (unsigned char *)zRight;
372 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
373 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
374}
375
376/*
drhd44390c2020-04-06 18:16:31 +0000377** Compute an 8-bit hash on a string that is insensitive to case differences
378*/
379u8 sqlite3StrIHash(const char *z){
380 u8 h = 0;
381 if( z==0 ) return 0;
382 while( z[0] ){
383 h += UpperToLower[(unsigned char)z[0]];
384 z++;
385 }
386 return h;
387}
388
389/*
drh02a43f62017-12-26 14:46:20 +0000390** Compute 10 to the E-th power. Examples: E==1 results in 10.
391** E==2 results in 100. E==50 results in 1.0e50.
392**
393** This routine only works for values of E between 1 and 341.
394*/
395static LONGDOUBLE_TYPE sqlite3Pow10(int E){
drh3dc97272018-01-17 21:14:17 +0000396#if defined(_MSC_VER)
397 static const LONGDOUBLE_TYPE x[] = {
drh38a59af2019-05-25 17:41:07 +0000398 1.0e+001L,
399 1.0e+002L,
400 1.0e+004L,
401 1.0e+008L,
402 1.0e+016L,
403 1.0e+032L,
404 1.0e+064L,
405 1.0e+128L,
406 1.0e+256L
drh3dc97272018-01-17 21:14:17 +0000407 };
408 LONGDOUBLE_TYPE r = 1.0;
409 int i;
410 assert( E>=0 && E<=307 );
411 for(i=0; E!=0; i++, E >>=1){
412 if( E & 1 ) r *= x[i];
413 }
414 return r;
415#else
drh02a43f62017-12-26 14:46:20 +0000416 LONGDOUBLE_TYPE x = 10.0;
417 LONGDOUBLE_TYPE r = 1.0;
418 while(1){
419 if( E & 1 ) r *= x;
420 E >>= 1;
421 if( E==0 ) break;
422 x *= x;
423 }
424 return r;
drh3dc97272018-01-17 21:14:17 +0000425#endif
drh02a43f62017-12-26 14:46:20 +0000426}
427
428/*
drh9339da12010-09-30 00:50:49 +0000429** The string z[] is an text representation of a real number.
drh025586a2010-09-30 17:33:11 +0000430** Convert this string to a double and write it into *pResult.
drhc81c11f2009-11-10 01:30:52 +0000431**
drh9339da12010-09-30 00:50:49 +0000432** The string z[] is length bytes in length (bytes, not characters) and
433** uses the encoding enc. The string is not necessarily zero-terminated.
drhc81c11f2009-11-10 01:30:52 +0000434**
drh9339da12010-09-30 00:50:49 +0000435** Return TRUE if the result is a valid real number (or integer) and FALSE
drh8a3884e2019-05-29 21:18:27 +0000436** if the string is empty or contains extraneous text. More specifically
437** return
438** 1 => The input string is a pure integer
439** 2 or more => The input has a decimal point or eNNN clause
drh9a278222019-06-07 22:26:08 +0000440** 0 or less => The input string is not a valid number
441** -1 => Not a valid number, but has a valid prefix which
442** includes a decimal point and/or an eNNN clause
drh8a3884e2019-05-29 21:18:27 +0000443**
444** Valid numbers are in one of these formats:
drh025586a2010-09-30 17:33:11 +0000445**
446** [+-]digits[E[+-]digits]
447** [+-]digits.[digits][E[+-]digits]
448** [+-].digits[E[+-]digits]
449**
450** Leading and trailing whitespace is ignored for the purpose of determining
451** validity.
452**
453** If some prefix of the input string is a valid number, this routine
454** returns FALSE but it still converts the prefix and writes the result
455** into *pResult.
drhc81c11f2009-11-10 01:30:52 +0000456*/
mistachkin6dcf9a42019-10-10 23:58:16 +0000457#if defined(_MSC_VER)
458#pragma warning(disable : 4756)
459#endif
drh9339da12010-09-30 00:50:49 +0000460int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
drhc81c11f2009-11-10 01:30:52 +0000461#ifndef SQLITE_OMIT_FLOATING_POINT
drh0e5fba72013-03-20 12:04:29 +0000462 int incr;
drhe3a4f2c2019-12-13 23:38:57 +0000463 const char *zEnd;
drhc81c11f2009-11-10 01:30:52 +0000464 /* sign * significand * (10 ^ (esign * exponent)) */
drh025586a2010-09-30 17:33:11 +0000465 int sign = 1; /* sign of significand */
466 i64 s = 0; /* significand */
467 int d = 0; /* adjust exponent for shifting decimal point */
468 int esign = 1; /* sign of exponent */
469 int e = 0; /* exponent */
470 int eValid = 1; /* True exponent is either not used or is well-formed */
drhc81c11f2009-11-10 01:30:52 +0000471 double result;
drhc2b893a2019-05-25 18:17:53 +0000472 int nDigit = 0; /* Number of digits processed */
drh8a3884e2019-05-29 21:18:27 +0000473 int eType = 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */
drhc81c11f2009-11-10 01:30:52 +0000474
drh0e5fba72013-03-20 12:04:29 +0000475 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
drh025586a2010-09-30 17:33:11 +0000476 *pResult = 0.0; /* Default return value, in case of an error */
drhe3a4f2c2019-12-13 23:38:57 +0000477 if( length==0 ) return 0;
drh025586a2010-09-30 17:33:11 +0000478
drh0e5fba72013-03-20 12:04:29 +0000479 if( enc==SQLITE_UTF8 ){
480 incr = 1;
drhe3a4f2c2019-12-13 23:38:57 +0000481 zEnd = z + length;
drh0e5fba72013-03-20 12:04:29 +0000482 }else{
483 int i;
484 incr = 2;
drh87969b22020-01-08 12:17:46 +0000485 length &= ~1;
drh0e5fba72013-03-20 12:04:29 +0000486 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
drh84422db2019-05-30 13:47:10 +0000487 testcase( enc==SQLITE_UTF16LE );
488 testcase( enc==SQLITE_UTF16BE );
drh0e5fba72013-03-20 12:04:29 +0000489 for(i=3-enc; i<length && z[i]==0; i+=2){}
drh8a3884e2019-05-29 21:18:27 +0000490 if( i<length ) eType = -100;
drhad975d52016-04-27 15:24:13 +0000491 zEnd = &z[i^1];
drh0e5fba72013-03-20 12:04:29 +0000492 z += (enc&1);
493 }
drh9339da12010-09-30 00:50:49 +0000494
drhc81c11f2009-11-10 01:30:52 +0000495 /* skip leading spaces */
drh9339da12010-09-30 00:50:49 +0000496 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
drh025586a2010-09-30 17:33:11 +0000497 if( z>=zEnd ) return 0;
drh9339da12010-09-30 00:50:49 +0000498
drhc81c11f2009-11-10 01:30:52 +0000499 /* get sign of significand */
500 if( *z=='-' ){
501 sign = -1;
drh9339da12010-09-30 00:50:49 +0000502 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000503 }else if( *z=='+' ){
drh9339da12010-09-30 00:50:49 +0000504 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000505 }
drh9339da12010-09-30 00:50:49 +0000506
drhc81c11f2009-11-10 01:30:52 +0000507 /* copy max significant digits to significand */
drhc2b893a2019-05-25 18:17:53 +0000508 while( z<zEnd && sqlite3Isdigit(*z) ){
drhc81c11f2009-11-10 01:30:52 +0000509 s = s*10 + (*z - '0');
drhc2b893a2019-05-25 18:17:53 +0000510 z+=incr; nDigit++;
511 if( s>=((LARGEST_INT64-9)/10) ){
512 /* skip non-significant significand digits
513 ** (increase exponent by d to shift decimal left) */
514 while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; d++; }
515 }
drhc81c11f2009-11-10 01:30:52 +0000516 }
drh9339da12010-09-30 00:50:49 +0000517 if( z>=zEnd ) goto do_atof_calc;
drhc81c11f2009-11-10 01:30:52 +0000518
519 /* if decimal point is present */
520 if( *z=='.' ){
drh9339da12010-09-30 00:50:49 +0000521 z+=incr;
drh8a3884e2019-05-29 21:18:27 +0000522 eType++;
drhc81c11f2009-11-10 01:30:52 +0000523 /* copy digits from after decimal to significand
524 ** (decrease exponent by d to shift decimal right) */
drh15af62a2016-04-26 23:14:45 +0000525 while( z<zEnd && sqlite3Isdigit(*z) ){
526 if( s<((LARGEST_INT64-9)/10) ){
527 s = s*10 + (*z - '0');
528 d--;
drhc2b893a2019-05-25 18:17:53 +0000529 nDigit++;
drh15af62a2016-04-26 23:14:45 +0000530 }
drhc2b893a2019-05-25 18:17:53 +0000531 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000532 }
drhc81c11f2009-11-10 01:30:52 +0000533 }
drh9339da12010-09-30 00:50:49 +0000534 if( z>=zEnd ) goto do_atof_calc;
drhc81c11f2009-11-10 01:30:52 +0000535
536 /* if exponent is present */
537 if( *z=='e' || *z=='E' ){
drh9339da12010-09-30 00:50:49 +0000538 z+=incr;
drh025586a2010-09-30 17:33:11 +0000539 eValid = 0;
drh8a3884e2019-05-29 21:18:27 +0000540 eType++;
drhad975d52016-04-27 15:24:13 +0000541
542 /* This branch is needed to avoid a (harmless) buffer overread. The
543 ** special comment alerts the mutation tester that the correct answer
544 ** is obtained even if the branch is omitted */
545 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/
546
drhc81c11f2009-11-10 01:30:52 +0000547 /* get sign of exponent */
548 if( *z=='-' ){
549 esign = -1;
drh9339da12010-09-30 00:50:49 +0000550 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000551 }else if( *z=='+' ){
drh9339da12010-09-30 00:50:49 +0000552 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000553 }
554 /* copy digits to exponent */
drh9339da12010-09-30 00:50:49 +0000555 while( z<zEnd && sqlite3Isdigit(*z) ){
drh57db4a72011-10-17 20:41:46 +0000556 e = e<10000 ? (e*10 + (*z - '0')) : 10000;
drh9339da12010-09-30 00:50:49 +0000557 z+=incr;
drh025586a2010-09-30 17:33:11 +0000558 eValid = 1;
drhc81c11f2009-11-10 01:30:52 +0000559 }
560 }
561
drh025586a2010-09-30 17:33:11 +0000562 /* skip trailing spaces */
drhc6daa012016-04-27 02:35:03 +0000563 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
drh025586a2010-09-30 17:33:11 +0000564
drh9339da12010-09-30 00:50:49 +0000565do_atof_calc:
drhc81c11f2009-11-10 01:30:52 +0000566 /* adjust exponent by d, and update sign */
567 e = (e*esign) + d;
568 if( e<0 ) {
569 esign = -1;
570 e *= -1;
571 } else {
572 esign = 1;
573 }
574
drhad975d52016-04-27 15:24:13 +0000575 if( s==0 ) {
576 /* In the IEEE 754 standard, zero is signed. */
drhc6daa012016-04-27 02:35:03 +0000577 result = sign<0 ? -(double)0 : (double)0;
drhc81c11f2009-11-10 01:30:52 +0000578 } else {
drhad975d52016-04-27 15:24:13 +0000579 /* Attempt to reduce exponent.
580 **
581 ** Branches that are not required for the correct answer but which only
582 ** help to obtain the correct answer faster are marked with special
583 ** comments, as a hint to the mutation tester.
584 */
585 while( e>0 ){ /*OPTIMIZATION-IF-TRUE*/
586 if( esign>0 ){
587 if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/
588 s *= 10;
589 }else{
590 if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/
591 s /= 10;
592 }
593 e--;
drhc81c11f2009-11-10 01:30:52 +0000594 }
595
596 /* adjust the sign of significand */
597 s = sign<0 ? -s : s;
598
drhad975d52016-04-27 15:24:13 +0000599 if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/
600 result = (double)s;
601 }else{
drhc81c11f2009-11-10 01:30:52 +0000602 /* attempt to handle extremely small/large numbers better */
drhad975d52016-04-27 15:24:13 +0000603 if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/
604 if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/
drh02a43f62017-12-26 14:46:20 +0000605 LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308);
drhad975d52016-04-27 15:24:13 +0000606 if( esign<0 ){
607 result = s / scale;
608 result /= 1.0e+308;
609 }else{
610 result = s * scale;
611 result *= 1.0e+308;
612 }
613 }else{ assert( e>=342 );
614 if( esign<0 ){
615 result = 0.0*s;
616 }else{
drhb9772e72017-09-12 13:27:43 +0000617#ifdef INFINITY
drh3ba18ad2017-09-12 15:05:34 +0000618 result = INFINITY*s;
drhb9772e72017-09-12 13:27:43 +0000619#else
drhad975d52016-04-27 15:24:13 +0000620 result = 1e308*1e308*s; /* Infinity */
drhb9772e72017-09-12 13:27:43 +0000621#endif
drhad975d52016-04-27 15:24:13 +0000622 }
drh2458a2e2011-10-17 12:14:26 +0000623 }
drhc81c11f2009-11-10 01:30:52 +0000624 }else{
drh02a43f62017-12-26 14:46:20 +0000625 LONGDOUBLE_TYPE scale = sqlite3Pow10(e);
drhc81c11f2009-11-10 01:30:52 +0000626 if( esign<0 ){
627 result = s / scale;
628 }else{
629 result = s * scale;
630 }
631 }
drhc81c11f2009-11-10 01:30:52 +0000632 }
633 }
634
635 /* store the result */
636 *pResult = result;
637
drh025586a2010-09-30 17:33:11 +0000638 /* return true if number and no extra non-whitespace chracters after */
drh9a278222019-06-07 22:26:08 +0000639 if( z==zEnd && nDigit>0 && eValid && eType>0 ){
640 return eType;
drh378a7d32019-06-10 23:45:10 +0000641 }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){
drh9a278222019-06-07 22:26:08 +0000642 return -1;
643 }else{
644 return 0;
645 }
drhc81c11f2009-11-10 01:30:52 +0000646#else
shaneh5f1d6b62010-09-30 16:51:25 +0000647 return !sqlite3Atoi64(z, pResult, length, enc);
drhc81c11f2009-11-10 01:30:52 +0000648#endif /* SQLITE_OMIT_FLOATING_POINT */
649}
mistachkin6dcf9a42019-10-10 23:58:16 +0000650#if defined(_MSC_VER)
651#pragma warning(default : 4756)
652#endif
drhc81c11f2009-11-10 01:30:52 +0000653
654/*
drhfbde3f52023-01-03 18:51:18 +0000655** Render an signed 64-bit integer as text. Store the result in zOut[] and
656** return the length of the string that was stored, in bytes. The value
657** returned does not include the zero terminator at the end of the output
658** string.
drh82b0f102020-07-21 18:25:19 +0000659**
660** The caller must ensure that zOut[] is at least 21 bytes in size.
661*/
drhfbde3f52023-01-03 18:51:18 +0000662int sqlite3Int64ToText(i64 v, char *zOut){
drh82b0f102020-07-21 18:25:19 +0000663 int i;
664 u64 x;
665 char zTemp[22];
666 if( v<0 ){
drh8deae5a2020-07-29 12:23:20 +0000667 x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v;
drh82b0f102020-07-21 18:25:19 +0000668 }else{
669 x = v;
670 }
671 i = sizeof(zTemp)-2;
672 zTemp[sizeof(zTemp)-1] = 0;
673 do{
674 zTemp[i--] = (x%10) + '0';
675 x = x/10;
676 }while( x );
677 if( v<0 ) zTemp[i--] = '-';
678 memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i);
drhfbde3f52023-01-03 18:51:18 +0000679 return sizeof(zTemp)-2-i;
drh82b0f102020-07-21 18:25:19 +0000680}
681
682/*
drhc81c11f2009-11-10 01:30:52 +0000683** Compare the 19-character string zNum against the text representation
684** value 2^63: 9223372036854775808. Return negative, zero, or positive
685** if zNum is less than, equal to, or greater than the string.
shaneh5f1d6b62010-09-30 16:51:25 +0000686** Note that zNum must contain exactly 19 characters.
drhc81c11f2009-11-10 01:30:52 +0000687**
688** Unlike memcmp() this routine is guaranteed to return the difference
689** in the values of the last digit if the only difference is in the
690** last digit. So, for example,
691**
drh9339da12010-09-30 00:50:49 +0000692** compare2pow63("9223372036854775800", 1)
drhc81c11f2009-11-10 01:30:52 +0000693**
694** will return -8.
695*/
drh9339da12010-09-30 00:50:49 +0000696static int compare2pow63(const char *zNum, int incr){
697 int c = 0;
698 int i;
699 /* 012345678901234567 */
700 const char *pow63 = "922337203685477580";
701 for(i=0; c==0 && i<18; i++){
702 c = (zNum[i*incr]-pow63[i])*10;
703 }
drhc81c11f2009-11-10 01:30:52 +0000704 if( c==0 ){
drh9339da12010-09-30 00:50:49 +0000705 c = zNum[18*incr] - '8';
drh44dbca82010-01-13 04:22:20 +0000706 testcase( c==(-1) );
707 testcase( c==0 );
708 testcase( c==(+1) );
drhc81c11f2009-11-10 01:30:52 +0000709 }
710 return c;
711}
712
drhc81c11f2009-11-10 01:30:52 +0000713/*
drh9296c182014-07-23 13:40:49 +0000714** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
715** routine does *not* accept hexadecimal notation.
drh158b9cb2011-03-05 20:59:46 +0000716**
drh84d4f1a2017-09-20 10:47:10 +0000717** Returns:
drh158b9cb2011-03-05 20:59:46 +0000718**
drh9a278222019-06-07 22:26:08 +0000719** -1 Not even a prefix of the input text looks like an integer
drh84d4f1a2017-09-20 10:47:10 +0000720** 0 Successful transformation. Fits in a 64-bit signed integer.
drh4eb57ce2018-01-26 18:37:34 +0000721** 1 Excess non-space text after the integer value
drh84d4f1a2017-09-20 10:47:10 +0000722** 2 Integer too large for a 64-bit signed integer or is malformed
723** 3 Special case of 9223372036854775808
drhc81c11f2009-11-10 01:30:52 +0000724**
drh9339da12010-09-30 00:50:49 +0000725** length is the number of bytes in the string (bytes, not characters).
726** The string is not necessarily zero-terminated. The encoding is
727** given by enc.
drhc81c11f2009-11-10 01:30:52 +0000728*/
drh9339da12010-09-30 00:50:49 +0000729int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
drh0e5fba72013-03-20 12:04:29 +0000730 int incr;
drh158b9cb2011-03-05 20:59:46 +0000731 u64 u = 0;
shaneh5f1d6b62010-09-30 16:51:25 +0000732 int neg = 0; /* assume positive */
drh9339da12010-09-30 00:50:49 +0000733 int i;
734 int c = 0;
drh609d5842016-04-28 00:32:16 +0000735 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */
drh84d4f1a2017-09-20 10:47:10 +0000736 int rc; /* Baseline return code */
drhc81c11f2009-11-10 01:30:52 +0000737 const char *zStart;
drh9339da12010-09-30 00:50:49 +0000738 const char *zEnd = zNum + length;
drh0e5fba72013-03-20 12:04:29 +0000739 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
740 if( enc==SQLITE_UTF8 ){
741 incr = 1;
742 }else{
743 incr = 2;
drh359941b2020-08-27 16:28:30 +0000744 length &= ~1;
drh0e5fba72013-03-20 12:04:29 +0000745 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
746 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
747 nonNum = i<length;
drh609d5842016-04-28 00:32:16 +0000748 zEnd = &zNum[i^1];
drh0e5fba72013-03-20 12:04:29 +0000749 zNum += (enc&1);
750 }
drh9339da12010-09-30 00:50:49 +0000751 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
drh158b9cb2011-03-05 20:59:46 +0000752 if( zNum<zEnd ){
753 if( *zNum=='-' ){
754 neg = 1;
755 zNum+=incr;
756 }else if( *zNum=='+' ){
757 zNum+=incr;
758 }
drhc81c11f2009-11-10 01:30:52 +0000759 }
760 zStart = zNum;
drh9339da12010-09-30 00:50:49 +0000761 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
762 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
drh158b9cb2011-03-05 20:59:46 +0000763 u = u*10 + c - '0';
drhc81c11f2009-11-10 01:30:52 +0000764 }
drh4eb57ce2018-01-26 18:37:34 +0000765 testcase( i==18*incr );
766 testcase( i==19*incr );
767 testcase( i==20*incr );
drh1822ebf2018-01-27 14:25:27 +0000768 if( u>LARGEST_INT64 ){
769 /* This test and assignment is needed only to suppress UB warnings
770 ** from clang and -fsanitize=undefined. This test and assignment make
771 ** the code a little larger and slower, and no harm comes from omitting
772 ** them, but we must appaise the undefined-behavior pharisees. */
773 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
774 }else if( neg ){
drh158b9cb2011-03-05 20:59:46 +0000775 *pNum = -(i64)u;
776 }else{
777 *pNum = (i64)u;
778 }
drh4eb57ce2018-01-26 18:37:34 +0000779 rc = 0;
drh9a278222019-06-07 22:26:08 +0000780 if( i==0 && zStart==zNum ){ /* No digits */
781 rc = -1;
782 }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */
drh84d4f1a2017-09-20 10:47:10 +0000783 rc = 1;
drh4eb57ce2018-01-26 18:37:34 +0000784 }else if( &zNum[i]<zEnd ){ /* Extra bytes at the end */
785 int jj = i;
786 do{
787 if( !sqlite3Isspace(zNum[jj]) ){
788 rc = 1; /* Extra non-space text after the integer */
789 break;
790 }
791 jj += incr;
792 }while( &zNum[jj]<zEnd );
drh84d4f1a2017-09-20 10:47:10 +0000793 }
drh4eb57ce2018-01-26 18:37:34 +0000794 if( i<19*incr ){
drhc81c11f2009-11-10 01:30:52 +0000795 /* Less than 19 digits, so we know that it fits in 64 bits */
drh158b9cb2011-03-05 20:59:46 +0000796 assert( u<=LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000797 return rc;
drhc81c11f2009-11-10 01:30:52 +0000798 }else{
drh158b9cb2011-03-05 20:59:46 +0000799 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
drh4eb57ce2018-01-26 18:37:34 +0000800 c = i>19*incr ? 1 : compare2pow63(zNum, incr);
drh158b9cb2011-03-05 20:59:46 +0000801 if( c<0 ){
802 /* zNum is less than 9223372036854775808 so it fits */
803 assert( u<=LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000804 return rc;
drh158b9cb2011-03-05 20:59:46 +0000805 }else{
drh4eb57ce2018-01-26 18:37:34 +0000806 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
807 if( c>0 ){
808 /* zNum is greater than 9223372036854775808 so it overflows */
809 return 2;
810 }else{
811 /* zNum is exactly 9223372036854775808. Fits if negative. The
812 ** special case 2 overflow if positive */
813 assert( u-1==LARGEST_INT64 );
814 return neg ? rc : 3;
815 }
drh158b9cb2011-03-05 20:59:46 +0000816 }
drhc81c11f2009-11-10 01:30:52 +0000817 }
818}
819
820/*
drh9296c182014-07-23 13:40:49 +0000821** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
822** into a 64-bit signed integer. This routine accepts hexadecimal literals,
823** whereas sqlite3Atoi64() does not.
824**
825** Returns:
826**
827** 0 Successful transformation. Fits in a 64-bit signed integer.
drh84d4f1a2017-09-20 10:47:10 +0000828** 1 Excess text after the integer value
829** 2 Integer too large for a 64-bit signed integer or is malformed
830** 3 Special case of 9223372036854775808
drh9296c182014-07-23 13:40:49 +0000831*/
832int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
833#ifndef SQLITE_OMIT_HEX_INTEGER
834 if( z[0]=='0'
835 && (z[1]=='x' || z[1]=='X')
drh9296c182014-07-23 13:40:49 +0000836 ){
837 u64 u = 0;
838 int i, k;
839 for(i=2; z[i]=='0'; i++){}
840 for(k=i; sqlite3Isxdigit(z[k]); k++){
841 u = u*16 + sqlite3HexToInt(z[k]);
842 }
843 memcpy(pOut, &u, 8);
drh84d4f1a2017-09-20 10:47:10 +0000844 return (z[k]==0 && k-i<=16) ? 0 : 2;
drh9296c182014-07-23 13:40:49 +0000845 }else
846#endif /* SQLITE_OMIT_HEX_INTEGER */
847 {
848 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
849 }
850}
851
852/*
drhc81c11f2009-11-10 01:30:52 +0000853** If zNum represents an integer that will fit in 32-bits, then set
854** *pValue to that integer and return true. Otherwise return false.
855**
drh9296c182014-07-23 13:40:49 +0000856** This routine accepts both decimal and hexadecimal notation for integers.
857**
drhc81c11f2009-11-10 01:30:52 +0000858** Any non-numeric characters that following zNum are ignored.
859** This is different from sqlite3Atoi64() which requires the
860** input number to be zero-terminated.
861*/
862int sqlite3GetInt32(const char *zNum, int *pValue){
863 sqlite_int64 v = 0;
864 int i, c;
865 int neg = 0;
866 if( zNum[0]=='-' ){
867 neg = 1;
868 zNum++;
869 }else if( zNum[0]=='+' ){
870 zNum++;
871 }
drh28e048c2014-07-23 01:26:51 +0000872#ifndef SQLITE_OMIT_HEX_INTEGER
873 else if( zNum[0]=='0'
874 && (zNum[1]=='x' || zNum[1]=='X')
875 && sqlite3Isxdigit(zNum[2])
876 ){
877 u32 u = 0;
878 zNum += 2;
879 while( zNum[0]=='0' ) zNum++;
880 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
881 u = u*16 + sqlite3HexToInt(zNum[i]);
882 }
883 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
884 memcpy(pValue, &u, 4);
885 return 1;
886 }else{
887 return 0;
888 }
889 }
890#endif
drh313e6fd2017-05-03 17:44:28 +0000891 if( !sqlite3Isdigit(zNum[0]) ) return 0;
drh935f2e72015-04-18 04:45:00 +0000892 while( zNum[0]=='0' ) zNum++;
drhc81c11f2009-11-10 01:30:52 +0000893 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
894 v = v*10 + c;
895 }
896
897 /* The longest decimal representation of a 32 bit integer is 10 digits:
898 **
899 ** 1234567890
900 ** 2^31 -> 2147483648
901 */
drh44dbca82010-01-13 04:22:20 +0000902 testcase( i==10 );
drhc81c11f2009-11-10 01:30:52 +0000903 if( i>10 ){
904 return 0;
905 }
drh44dbca82010-01-13 04:22:20 +0000906 testcase( v-neg==2147483647 );
drhc81c11f2009-11-10 01:30:52 +0000907 if( v-neg>2147483647 ){
908 return 0;
909 }
910 if( neg ){
911 v = -v;
912 }
913 *pValue = (int)v;
914 return 1;
915}
916
917/*
drh60ac3f42010-11-23 18:59:27 +0000918** Return a 32-bit integer value extracted from a string. If the
919** string is not an integer, just return 0.
920*/
921int sqlite3Atoi(const char *z){
922 int x = 0;
drh48bf2d72020-07-30 17:14:55 +0000923 sqlite3GetInt32(z, &x);
drh60ac3f42010-11-23 18:59:27 +0000924 return x;
925}
926
927/*
drhabc38152020-07-22 13:38:04 +0000928** Try to convert z into an unsigned 32-bit integer. Return true on
929** success and false if there is an error.
930**
931** Only decimal notation is accepted.
932*/
933int sqlite3GetUInt32(const char *z, u32 *pI){
934 u64 v = 0;
935 int i;
936 for(i=0; sqlite3Isdigit(z[i]); i++){
937 v = v*10 + z[i] - '0';
drh69306bf2020-07-22 20:12:10 +0000938 if( v>4294967296LL ){ *pI = 0; return 0; }
drhabc38152020-07-22 13:38:04 +0000939 }
drh69306bf2020-07-22 20:12:10 +0000940 if( i==0 || z[i]!=0 ){ *pI = 0; return 0; }
drhabc38152020-07-22 13:38:04 +0000941 *pI = (u32)v;
942 return 1;
943}
944
945/*
drhc81c11f2009-11-10 01:30:52 +0000946** The variable-length integer encoding is as follows:
947**
948** KEY:
949** A = 0xxxxxxx 7 bits of data and one flag bit
950** B = 1xxxxxxx 7 bits of data and one flag bit
951** C = xxxxxxxx 8 bits of data
952**
953** 7 bits - A
954** 14 bits - BA
955** 21 bits - BBA
956** 28 bits - BBBA
957** 35 bits - BBBBA
958** 42 bits - BBBBBA
959** 49 bits - BBBBBBA
960** 56 bits - BBBBBBBA
961** 64 bits - BBBBBBBBC
962*/
963
964/*
965** Write a 64-bit variable-length integer to memory starting at p[0].
966** The length of data write will be between 1 and 9 bytes. The number
967** of bytes written is returned.
968**
969** A variable-length integer consists of the lower 7 bits of each byte
970** for all bytes that have the 8th bit set and one byte with the 8th
971** bit clear. Except, if we get to the 9th byte, it stores the full
972** 8 bits and is the last byte.
973*/
drh2f2b2b82014-08-22 18:48:25 +0000974static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){
drhc81c11f2009-11-10 01:30:52 +0000975 int i, j, n;
976 u8 buf[10];
977 if( v & (((u64)0xff000000)<<32) ){
978 p[8] = (u8)v;
979 v >>= 8;
980 for(i=7; i>=0; i--){
981 p[i] = (u8)((v & 0x7f) | 0x80);
982 v >>= 7;
983 }
984 return 9;
985 }
986 n = 0;
987 do{
988 buf[n++] = (u8)((v & 0x7f) | 0x80);
989 v >>= 7;
990 }while( v!=0 );
991 buf[0] &= 0x7f;
992 assert( n<=9 );
993 for(i=0, j=n-1; j>=0; j--, i++){
994 p[i] = buf[j];
995 }
996 return n;
997}
drh2f2b2b82014-08-22 18:48:25 +0000998int sqlite3PutVarint(unsigned char *p, u64 v){
999 if( v<=0x7f ){
1000 p[0] = v&0x7f;
drhc81c11f2009-11-10 01:30:52 +00001001 return 1;
1002 }
drh2f2b2b82014-08-22 18:48:25 +00001003 if( v<=0x3fff ){
1004 p[0] = ((v>>7)&0x7f)|0x80;
1005 p[1] = v&0x7f;
drhc81c11f2009-11-10 01:30:52 +00001006 return 2;
1007 }
drh2f2b2b82014-08-22 18:48:25 +00001008 return putVarint64(p,v);
drhc81c11f2009-11-10 01:30:52 +00001009}
1010
1011/*
drh0b2864c2010-03-03 15:18:38 +00001012** Bitmasks used by sqlite3GetVarint(). These precomputed constants
1013** are defined here rather than simply putting the constant expressions
1014** inline in order to work around bugs in the RVT compiler.
1015**
1016** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
1017**
1018** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
1019*/
1020#define SLOT_2_0 0x001fc07f
1021#define SLOT_4_2_0 0xf01fc07f
1022
1023
1024/*
drhc81c11f2009-11-10 01:30:52 +00001025** Read a 64-bit variable-length integer from memory starting at p[0].
1026** Return the number of bytes read. The value is stored in *v.
1027*/
1028u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
1029 u32 a,b,s;
1030
drh698c86f2019-04-17 12:07:08 +00001031 if( ((signed char*)p)[0]>=0 ){
1032 *v = *p;
drhc81c11f2009-11-10 01:30:52 +00001033 return 1;
1034 }
drh698c86f2019-04-17 12:07:08 +00001035 if( ((signed char*)p)[1]>=0 ){
1036 *v = ((u32)(p[0]&0x7f)<<7) | p[1];
drhc81c11f2009-11-10 01:30:52 +00001037 return 2;
1038 }
1039
drh0b2864c2010-03-03 15:18:38 +00001040 /* Verify that constants are precomputed correctly */
1041 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
shaneh1da207e2010-03-09 14:41:12 +00001042 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
drh0b2864c2010-03-03 15:18:38 +00001043
drh698c86f2019-04-17 12:07:08 +00001044 a = ((u32)p[0])<<14;
1045 b = p[1];
1046 p += 2;
drhc81c11f2009-11-10 01:30:52 +00001047 a |= *p;
1048 /* a: p0<<14 | p2 (unmasked) */
1049 if (!(a&0x80))
1050 {
drh0b2864c2010-03-03 15:18:38 +00001051 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001052 b &= 0x7f;
1053 b = b<<7;
1054 a |= b;
1055 *v = a;
1056 return 3;
1057 }
1058
1059 /* CSE1 from below */
drh0b2864c2010-03-03 15:18:38 +00001060 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001061 p++;
1062 b = b<<14;
1063 b |= *p;
1064 /* b: p1<<14 | p3 (unmasked) */
1065 if (!(b&0x80))
1066 {
drh0b2864c2010-03-03 15:18:38 +00001067 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001068 /* moved CSE1 up */
1069 /* a &= (0x7f<<14)|(0x7f); */
1070 a = a<<7;
1071 a |= b;
1072 *v = a;
1073 return 4;
1074 }
1075
1076 /* a: p0<<14 | p2 (masked) */
1077 /* b: p1<<14 | p3 (unmasked) */
1078 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1079 /* moved CSE1 up */
1080 /* a &= (0x7f<<14)|(0x7f); */
drh0b2864c2010-03-03 15:18:38 +00001081 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001082 s = a;
1083 /* s: p0<<14 | p2 (masked) */
1084
1085 p++;
1086 a = a<<14;
1087 a |= *p;
1088 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1089 if (!(a&0x80))
1090 {
drh62aaa6c2015-11-21 17:27:42 +00001091 /* we can skip these cause they were (effectively) done above
1092 ** while calculating s */
drhc81c11f2009-11-10 01:30:52 +00001093 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
1094 /* b &= (0x7f<<14)|(0x7f); */
1095 b = b<<7;
1096 a |= b;
1097 s = s>>18;
1098 *v = ((u64)s)<<32 | a;
1099 return 5;
1100 }
1101
1102 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1103 s = s<<7;
1104 s |= b;
1105 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1106
1107 p++;
1108 b = b<<14;
1109 b |= *p;
1110 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
1111 if (!(b&0x80))
1112 {
1113 /* we can skip this cause it was (effectively) done above in calc'ing s */
1114 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
drh0b2864c2010-03-03 15:18:38 +00001115 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001116 a = a<<7;
1117 a |= b;
1118 s = s>>18;
1119 *v = ((u64)s)<<32 | a;
1120 return 6;
1121 }
1122
1123 p++;
1124 a = a<<14;
1125 a |= *p;
1126 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
1127 if (!(a&0x80))
1128 {
drh0b2864c2010-03-03 15:18:38 +00001129 a &= SLOT_4_2_0;
1130 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001131 b = b<<7;
1132 a |= b;
1133 s = s>>11;
1134 *v = ((u64)s)<<32 | a;
1135 return 7;
1136 }
1137
1138 /* CSE2 from below */
drh0b2864c2010-03-03 15:18:38 +00001139 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001140 p++;
1141 b = b<<14;
1142 b |= *p;
1143 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
1144 if (!(b&0x80))
1145 {
drh0b2864c2010-03-03 15:18:38 +00001146 b &= SLOT_4_2_0;
drhc81c11f2009-11-10 01:30:52 +00001147 /* moved CSE2 up */
1148 /* a &= (0x7f<<14)|(0x7f); */
1149 a = a<<7;
1150 a |= b;
1151 s = s>>4;
1152 *v = ((u64)s)<<32 | a;
1153 return 8;
1154 }
1155
1156 p++;
1157 a = a<<15;
1158 a |= *p;
1159 /* a: p4<<29 | p6<<15 | p8 (unmasked) */
1160
1161 /* moved CSE2 up */
1162 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
drh0b2864c2010-03-03 15:18:38 +00001163 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +00001164 b = b<<8;
1165 a |= b;
1166
1167 s = s<<4;
1168 b = p[-4];
1169 b &= 0x7f;
1170 b = b>>3;
1171 s |= b;
1172
1173 *v = ((u64)s)<<32 | a;
1174
1175 return 9;
1176}
1177
1178/*
1179** Read a 32-bit variable-length integer from memory starting at p[0].
1180** Return the number of bytes read. The value is stored in *v.
1181**
1182** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
1183** integer, then set *v to 0xffffffff.
1184**
1185** A MACRO version, getVarint32, is provided which inlines the
1186** single-byte case. All code should use the MACRO version as
1187** this function assumes the single-byte case has already been handled.
1188*/
1189u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
1190 u32 a,b;
1191
1192 /* The 1-byte case. Overwhelmingly the most common. Handled inline
1193 ** by the getVarin32() macro */
1194 a = *p;
1195 /* a: p0 (unmasked) */
1196#ifndef getVarint32
1197 if (!(a&0x80))
1198 {
1199 /* Values between 0 and 127 */
1200 *v = a;
1201 return 1;
1202 }
1203#endif
1204
1205 /* The 2-byte case */
1206 p++;
1207 b = *p;
1208 /* b: p1 (unmasked) */
1209 if (!(b&0x80))
1210 {
1211 /* Values between 128 and 16383 */
1212 a &= 0x7f;
1213 a = a<<7;
1214 *v = a | b;
1215 return 2;
1216 }
1217
1218 /* The 3-byte case */
1219 p++;
1220 a = a<<14;
1221 a |= *p;
1222 /* a: p0<<14 | p2 (unmasked) */
1223 if (!(a&0x80))
1224 {
1225 /* Values between 16384 and 2097151 */
1226 a &= (0x7f<<14)|(0x7f);
1227 b &= 0x7f;
1228 b = b<<7;
1229 *v = a | b;
1230 return 3;
1231 }
1232
1233 /* A 32-bit varint is used to store size information in btrees.
1234 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
1235 ** A 3-byte varint is sufficient, for example, to record the size
1236 ** of a 1048569-byte BLOB or string.
1237 **
1238 ** We only unroll the first 1-, 2-, and 3- byte cases. The very
1239 ** rare larger cases can be handled by the slower 64-bit varint
1240 ** routine.
1241 */
1242#if 1
1243 {
1244 u64 v64;
1245 u8 n;
1246
drh15cedda2020-07-02 17:05:11 +00001247 n = sqlite3GetVarint(p-2, &v64);
drhc81c11f2009-11-10 01:30:52 +00001248 assert( n>3 && n<=9 );
1249 if( (v64 & SQLITE_MAX_U32)!=v64 ){
1250 *v = 0xffffffff;
1251 }else{
1252 *v = (u32)v64;
1253 }
1254 return n;
1255 }
1256
1257#else
1258 /* For following code (kept for historical record only) shows an
1259 ** unrolling for the 3- and 4-byte varint cases. This code is
1260 ** slightly faster, but it is also larger and much harder to test.
1261 */
1262 p++;
1263 b = b<<14;
1264 b |= *p;
1265 /* b: p1<<14 | p3 (unmasked) */
1266 if (!(b&0x80))
1267 {
1268 /* Values between 2097152 and 268435455 */
1269 b &= (0x7f<<14)|(0x7f);
1270 a &= (0x7f<<14)|(0x7f);
1271 a = a<<7;
1272 *v = a | b;
1273 return 4;
1274 }
1275
1276 p++;
1277 a = a<<14;
1278 a |= *p;
1279 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1280 if (!(a&0x80))
1281 {
dan3bbe7612010-03-03 16:02:05 +00001282 /* Values between 268435456 and 34359738367 */
1283 a &= SLOT_4_2_0;
1284 b &= SLOT_4_2_0;
drhc81c11f2009-11-10 01:30:52 +00001285 b = b<<7;
1286 *v = a | b;
1287 return 5;
1288 }
1289
1290 /* We can only reach this point when reading a corrupt database
1291 ** file. In that case we are not in any hurry. Use the (relatively
1292 ** slow) general-purpose sqlite3GetVarint() routine to extract the
1293 ** value. */
1294 {
1295 u64 v64;
1296 u8 n;
1297
1298 p -= 4;
1299 n = sqlite3GetVarint(p, &v64);
1300 assert( n>5 && n<=9 );
1301 *v = (u32)v64;
1302 return n;
1303 }
1304#endif
1305}
1306
1307/*
1308** Return the number of bytes that will be needed to store the given
1309** 64-bit integer.
1310*/
1311int sqlite3VarintLen(u64 v){
drh59a53642015-09-01 22:29:07 +00001312 int i;
drh6f17c092016-03-04 21:18:09 +00001313 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); }
drhc81c11f2009-11-10 01:30:52 +00001314 return i;
1315}
1316
1317
1318/*
1319** Read or write a four-byte big-endian integer value.
1320*/
1321u32 sqlite3Get4byte(const u8 *p){
drh5372e4d2015-06-30 12:47:09 +00001322#if SQLITE_BYTEORDER==4321
1323 u32 x;
1324 memcpy(&x,p,4);
1325 return x;
drhdc5ece82017-02-15 15:09:09 +00001326#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
drh5372e4d2015-06-30 12:47:09 +00001327 u32 x;
1328 memcpy(&x,p,4);
1329 return __builtin_bswap32(x);
drha39284b2017-02-09 17:12:22 +00001330#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
mistachkin647ca462015-06-30 17:28:40 +00001331 u32 x;
1332 memcpy(&x,p,4);
1333 return _byteswap_ulong(x);
drh5372e4d2015-06-30 12:47:09 +00001334#else
drh693e6712014-01-24 22:58:00 +00001335 testcase( p[0]&0x80 );
1336 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
drh5372e4d2015-06-30 12:47:09 +00001337#endif
drhc81c11f2009-11-10 01:30:52 +00001338}
1339void sqlite3Put4byte(unsigned char *p, u32 v){
drh5372e4d2015-06-30 12:47:09 +00001340#if SQLITE_BYTEORDER==4321
1341 memcpy(p,&v,4);
drhdc5ece82017-02-15 15:09:09 +00001342#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
drh5372e4d2015-06-30 12:47:09 +00001343 u32 x = __builtin_bswap32(v);
1344 memcpy(p,&x,4);
drha39284b2017-02-09 17:12:22 +00001345#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
mistachkin647ca462015-06-30 17:28:40 +00001346 u32 x = _byteswap_ulong(v);
1347 memcpy(p,&x,4);
drh5372e4d2015-06-30 12:47:09 +00001348#else
drhc81c11f2009-11-10 01:30:52 +00001349 p[0] = (u8)(v>>24);
1350 p[1] = (u8)(v>>16);
1351 p[2] = (u8)(v>>8);
1352 p[3] = (u8)v;
drh5372e4d2015-06-30 12:47:09 +00001353#endif
drhc81c11f2009-11-10 01:30:52 +00001354}
1355
drh9296c182014-07-23 13:40:49 +00001356
1357
1358/*
1359** Translate a single byte of Hex into an integer.
1360** This routine only works if h really is a valid hexadecimal
1361** character: 0..9a..fA..F
1362*/
1363u8 sqlite3HexToInt(int h){
1364 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
1365#ifdef SQLITE_ASCII
1366 h += 9*(1&(h>>6));
1367#endif
1368#ifdef SQLITE_EBCDIC
1369 h += 9*(1&~(h>>4));
1370#endif
1371 return (u8)(h & 0xf);
1372}
1373
drhb48c0d52020-02-07 01:12:53 +00001374#if !defined(SQLITE_OMIT_BLOB_LITERAL)
drhc81c11f2009-11-10 01:30:52 +00001375/*
1376** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
1377** value. Return a pointer to its binary value. Space to hold the
1378** binary value has been obtained from malloc and must be freed by
1379** the calling routine.
1380*/
1381void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
1382 char *zBlob;
1383 int i;
1384
drh575fad62016-02-05 13:38:36 +00001385 zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
drhc81c11f2009-11-10 01:30:52 +00001386 n--;
1387 if( zBlob ){
1388 for(i=0; i<n; i+=2){
dancd74b612011-04-22 19:37:32 +00001389 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
drhc81c11f2009-11-10 01:30:52 +00001390 }
1391 zBlob[i/2] = 0;
1392 }
1393 return zBlob;
1394}
drhb48c0d52020-02-07 01:12:53 +00001395#endif /* !SQLITE_OMIT_BLOB_LITERAL */
drhc81c11f2009-11-10 01:30:52 +00001396
drh413c3d32010-02-23 20:11:56 +00001397/*
1398** Log an error that is an API call on a connection pointer that should
1399** not have been used. The "type" of connection pointer is given as the
1400** argument. The zType is a word like "NULL" or "closed" or "invalid".
1401*/
1402static void logBadConnection(const char *zType){
1403 sqlite3_log(SQLITE_MISUSE,
1404 "API call with %s database connection pointer",
1405 zType
1406 );
1407}
drhc81c11f2009-11-10 01:30:52 +00001408
1409/*
drhc81c11f2009-11-10 01:30:52 +00001410** Check to make sure we have a valid db pointer. This test is not
1411** foolproof but it does provide some measure of protection against
1412** misuse of the interface such as passing in db pointers that are
1413** NULL or which have been previously closed. If this routine returns
1414** 1 it means that the db pointer is valid and 0 if it should not be
1415** dereferenced for any reason. The calling function should invoke
1416** SQLITE_MISUSE immediately.
1417**
1418** sqlite3SafetyCheckOk() requires that the db pointer be valid for
1419** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
1420** open properly and is not fit for general use but which can be
1421** used as an argument to sqlite3_errmsg() or sqlite3_close().
1422*/
1423int sqlite3SafetyCheckOk(sqlite3 *db){
drh5f9de6e2021-08-07 23:16:52 +00001424 u8 eOpenState;
drh413c3d32010-02-23 20:11:56 +00001425 if( db==0 ){
1426 logBadConnection("NULL");
1427 return 0;
1428 }
drh5f9de6e2021-08-07 23:16:52 +00001429 eOpenState = db->eOpenState;
1430 if( eOpenState!=SQLITE_STATE_OPEN ){
drhe294da02010-02-25 23:44:15 +00001431 if( sqlite3SafetyCheckSickOrOk(db) ){
1432 testcase( sqlite3GlobalConfig.xLog!=0 );
drh413c3d32010-02-23 20:11:56 +00001433 logBadConnection("unopened");
1434 }
drhc81c11f2009-11-10 01:30:52 +00001435 return 0;
1436 }else{
1437 return 1;
1438 }
1439}
1440int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
drh5f9de6e2021-08-07 23:16:52 +00001441 u8 eOpenState;
1442 eOpenState = db->eOpenState;
1443 if( eOpenState!=SQLITE_STATE_SICK &&
1444 eOpenState!=SQLITE_STATE_OPEN &&
1445 eOpenState!=SQLITE_STATE_BUSY ){
drhe294da02010-02-25 23:44:15 +00001446 testcase( sqlite3GlobalConfig.xLog!=0 );
drhaf46dc12010-02-24 21:44:07 +00001447 logBadConnection("invalid");
drh413c3d32010-02-23 20:11:56 +00001448 return 0;
1449 }else{
1450 return 1;
1451 }
drhc81c11f2009-11-10 01:30:52 +00001452}
drh158b9cb2011-03-05 20:59:46 +00001453
1454/*
1455** Attempt to add, substract, or multiply the 64-bit signed value iB against
1456** the other 64-bit signed integer at *pA and store the result in *pA.
1457** Return 0 on success. Or if the operation would have resulted in an
1458** overflow, leave *pA unchanged and return 1.
1459*/
1460int sqlite3AddInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001461#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001462 return __builtin_add_overflow(*pA, iB, pA);
1463#else
drh158b9cb2011-03-05 20:59:46 +00001464 i64 iA = *pA;
1465 testcase( iA==0 ); testcase( iA==1 );
1466 testcase( iB==-1 ); testcase( iB==0 );
1467 if( iB>=0 ){
1468 testcase( iA>0 && LARGEST_INT64 - iA == iB );
1469 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
1470 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
drh158b9cb2011-03-05 20:59:46 +00001471 }else{
1472 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
1473 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
1474 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
drh158b9cb2011-03-05 20:59:46 +00001475 }
drh53a6eb32014-02-10 12:59:15 +00001476 *pA += iB;
drh158b9cb2011-03-05 20:59:46 +00001477 return 0;
drh4a477612017-01-03 17:33:43 +00001478#endif
drh158b9cb2011-03-05 20:59:46 +00001479}
1480int sqlite3SubInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001481#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001482 return __builtin_sub_overflow(*pA, iB, pA);
1483#else
drh158b9cb2011-03-05 20:59:46 +00001484 testcase( iB==SMALLEST_INT64+1 );
1485 if( iB==SMALLEST_INT64 ){
1486 testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
1487 if( (*pA)>=0 ) return 1;
1488 *pA -= iB;
1489 return 0;
1490 }else{
1491 return sqlite3AddInt64(pA, -iB);
1492 }
drh4a477612017-01-03 17:33:43 +00001493#endif
drh158b9cb2011-03-05 20:59:46 +00001494}
drh158b9cb2011-03-05 20:59:46 +00001495int sqlite3MulInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001496#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001497 return __builtin_mul_overflow(*pA, iB, pA);
1498#else
drh158b9cb2011-03-05 20:59:46 +00001499 i64 iA = *pA;
drh09952c62016-09-20 22:04:05 +00001500 if( iB>0 ){
1501 if( iA>LARGEST_INT64/iB ) return 1;
1502 if( iA<SMALLEST_INT64/iB ) return 1;
1503 }else if( iB<0 ){
1504 if( iA>0 ){
1505 if( iB<SMALLEST_INT64/iA ) return 1;
1506 }else if( iA<0 ){
1507 if( iB==SMALLEST_INT64 ) return 1;
1508 if( iA==SMALLEST_INT64 ) return 1;
1509 if( -iA>LARGEST_INT64/-iB ) return 1;
drh53a6eb32014-02-10 12:59:15 +00001510 }
drh53a6eb32014-02-10 12:59:15 +00001511 }
drh09952c62016-09-20 22:04:05 +00001512 *pA = iA*iB;
drh158b9cb2011-03-05 20:59:46 +00001513 return 0;
drh4a477612017-01-03 17:33:43 +00001514#endif
drh158b9cb2011-03-05 20:59:46 +00001515}
drhd50ffc42011-03-08 02:38:28 +00001516
1517/*
1518** Compute the absolute value of a 32-bit signed integer, of possible. Or
1519** if the integer has a value of -2147483648, return +2147483647
1520*/
1521int sqlite3AbsInt32(int x){
1522 if( x>=0 ) return x;
drh87e79ae2011-03-08 13:06:41 +00001523 if( x==(int)0x80000000 ) return 0x7fffffff;
drhd50ffc42011-03-08 02:38:28 +00001524 return -x;
1525}
drh81cc5162011-05-17 20:36:21 +00001526
1527#ifdef SQLITE_ENABLE_8_3_NAMES
1528/*
drhb51bf432011-07-21 21:29:35 +00001529** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
drh81cc5162011-05-17 20:36:21 +00001530** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
1531** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
1532** three characters, then shorten the suffix on z[] to be the last three
1533** characters of the original suffix.
1534**
drhb51bf432011-07-21 21:29:35 +00001535** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
1536** do the suffix shortening regardless of URI parameter.
1537**
drh81cc5162011-05-17 20:36:21 +00001538** Examples:
1539**
1540** test.db-journal => test.nal
1541** test.db-wal => test.wal
1542** test.db-shm => test.shm
drhf5808602011-12-16 00:33:04 +00001543** test.db-mj7f3319fa => test.9fa
drh81cc5162011-05-17 20:36:21 +00001544*/
1545void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
drhb51bf432011-07-21 21:29:35 +00001546#if SQLITE_ENABLE_8_3_NAMES<2
drh7d39e172012-01-02 12:41:53 +00001547 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
drhb51bf432011-07-21 21:29:35 +00001548#endif
1549 {
drh81cc5162011-05-17 20:36:21 +00001550 int i, sz;
1551 sz = sqlite3Strlen30(z);
drhc83f2d42011-05-18 02:41:10 +00001552 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
drhc02a43a2012-01-10 23:18:38 +00001553 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
drh81cc5162011-05-17 20:36:21 +00001554 }
1555}
1556#endif
drhbf539c42013-10-05 18:16:02 +00001557
1558/*
1559** Find (an approximate) sum of two LogEst values. This computation is
1560** not a simple "+" operator because LogEst is stored as a logarithmic
1561** value.
1562**
1563*/
1564LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
1565 static const unsigned char x[] = {
1566 10, 10, /* 0,1 */
1567 9, 9, /* 2,3 */
1568 8, 8, /* 4,5 */
1569 7, 7, 7, /* 6,7,8 */
1570 6, 6, 6, /* 9,10,11 */
1571 5, 5, 5, /* 12-14 */
1572 4, 4, 4, 4, /* 15-18 */
1573 3, 3, 3, 3, 3, 3, /* 19-24 */
1574 2, 2, 2, 2, 2, 2, 2, /* 25-31 */
1575 };
1576 if( a>=b ){
1577 if( a>b+49 ) return a;
1578 if( a>b+31 ) return a+1;
1579 return a+x[a-b];
1580 }else{
1581 if( b>a+49 ) return b;
1582 if( b>a+31 ) return b+1;
1583 return b+x[b-a];
1584 }
1585}
1586
1587/*
drh224155d2014-04-30 13:19:09 +00001588** Convert an integer into a LogEst. In other words, compute an
1589** approximation for 10*log2(x).
drhbf539c42013-10-05 18:16:02 +00001590*/
1591LogEst sqlite3LogEst(u64 x){
1592 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
1593 LogEst y = 40;
1594 if( x<8 ){
1595 if( x<2 ) return 0;
1596 while( x<8 ){ y -= 10; x <<= 1; }
1597 }else{
drhceb4b1d2017-08-17 20:53:07 +00001598#if GCC_VERSION>=5004000
1599 int i = 60 - __builtin_clzll(x);
1600 y += i*10;
1601 x >>= i;
1602#else
drh75ab50c2016-04-28 14:15:12 +00001603 while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/
drhbf539c42013-10-05 18:16:02 +00001604 while( x>15 ){ y += 10; x >>= 1; }
drhceb4b1d2017-08-17 20:53:07 +00001605#endif
drhbf539c42013-10-05 18:16:02 +00001606 }
1607 return a[x&7] + y - 10;
1608}
1609
drhbf539c42013-10-05 18:16:02 +00001610/*
1611** Convert a double into a LogEst
1612** In other words, compute an approximation for 10*log2(x).
1613*/
1614LogEst sqlite3LogEstFromDouble(double x){
1615 u64 a;
1616 LogEst e;
1617 assert( sizeof(x)==8 && sizeof(a)==8 );
1618 if( x<=1 ) return 0;
1619 if( x<=2000000000 ) return sqlite3LogEst((u64)x);
1620 memcpy(&a, &x, 8);
1621 e = (a>>52) - 1022;
1622 return e*10;
1623}
drhbf539c42013-10-05 18:16:02 +00001624
1625/*
1626** Convert a LogEst into an integer.
1627*/
1628u64 sqlite3LogEstToInt(LogEst x){
1629 u64 n;
drhbf539c42013-10-05 18:16:02 +00001630 n = x%10;
1631 x /= 10;
1632 if( n>=5 ) n -= 2;
1633 else if( n>=1 ) n -= 1;
drhecdf20d2016-03-10 14:28:24 +00001634 if( x>60 ) return (u64)LARGEST_INT64;
drhecdf20d2016-03-10 14:28:24 +00001635 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x);
drhbf539c42013-10-05 18:16:02 +00001636}
drh9bf755c2016-12-23 03:59:31 +00001637
1638/*
1639** Add a new name/number pair to a VList. This might require that the
1640** VList object be reallocated, so return the new VList. If an OOM
drhce1bbe52016-12-23 13:52:45 +00001641** error occurs, the original VList returned and the
drh9bf755c2016-12-23 03:59:31 +00001642** db->mallocFailed flag is set.
1643**
1644** A VList is really just an array of integers. To destroy a VList,
1645** simply pass it to sqlite3DbFree().
1646**
1647** The first integer is the number of integers allocated for the whole
1648** VList. The second integer is the number of integers actually used.
1649** Each name/number pair is encoded by subsequent groups of 3 or more
1650** integers.
1651**
drhce1bbe52016-12-23 13:52:45 +00001652** Each name/number pair starts with two integers which are the numeric
drh9bf755c2016-12-23 03:59:31 +00001653** value for the pair and the size of the name/number pair, respectively.
1654** The text name overlays one or more following integers. The text name
1655** is always zero-terminated.
drhce1bbe52016-12-23 13:52:45 +00001656**
1657** Conceptually:
1658**
1659** struct VList {
1660** int nAlloc; // Number of allocated slots
1661** int nUsed; // Number of used slots
1662** struct VListEntry {
1663** int iValue; // Value for this entry
1664** int nSlot; // Slots used by this entry
1665** // ... variable name goes here
1666** } a[0];
1667** }
1668**
1669** During code generation, pointers to the variable names within the
1670** VList are taken. When that happens, nAlloc is set to zero as an
1671** indication that the VList may never again be enlarged, since the
1672** accompanying realloc() would invalidate the pointers.
drh9bf755c2016-12-23 03:59:31 +00001673*/
1674VList *sqlite3VListAdd(
1675 sqlite3 *db, /* The database connection used for malloc() */
1676 VList *pIn, /* The input VList. Might be NULL */
1677 const char *zName, /* Name of symbol to add */
1678 int nName, /* Bytes of text in zName */
1679 int iVal /* Value to associate with zName */
1680){
1681 int nInt; /* number of sizeof(int) objects needed for zName */
drhce1bbe52016-12-23 13:52:45 +00001682 char *z; /* Pointer to where zName will be stored */
1683 int i; /* Index in pIn[] where zName is stored */
drh9bf755c2016-12-23 03:59:31 +00001684
1685 nInt = nName/4 + 3;
drhce1bbe52016-12-23 13:52:45 +00001686 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */
drh9bf755c2016-12-23 03:59:31 +00001687 if( pIn==0 || pIn[1]+nInt > pIn[0] ){
1688 /* Enlarge the allocation */
drh0aa32312019-04-13 04:01:12 +00001689 sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt;
drh9bf755c2016-12-23 03:59:31 +00001690 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
drhce1bbe52016-12-23 13:52:45 +00001691 if( pOut==0 ) return pIn;
drh9bf755c2016-12-23 03:59:31 +00001692 if( pIn==0 ) pOut[1] = 2;
1693 pIn = pOut;
1694 pIn[0] = nAlloc;
1695 }
1696 i = pIn[1];
1697 pIn[i] = iVal;
1698 pIn[i+1] = nInt;
1699 z = (char*)&pIn[i+2];
1700 pIn[1] = i+nInt;
1701 assert( pIn[1]<=pIn[0] );
1702 memcpy(z, zName, nName);
1703 z[nName] = 0;
1704 return pIn;
1705}
1706
1707/*
1708** Return a pointer to the name of a variable in the given VList that
1709** has the value iVal. Or return a NULL if there is no such variable in
1710** the list
1711*/
1712const char *sqlite3VListNumToName(VList *pIn, int iVal){
1713 int i, mx;
1714 if( pIn==0 ) return 0;
1715 mx = pIn[1];
1716 i = 2;
1717 do{
1718 if( pIn[i]==iVal ) return (char*)&pIn[i+2];
1719 i += pIn[i+1];
1720 }while( i<mx );
1721 return 0;
1722}
1723
1724/*
1725** Return the number of the variable named zName, if it is in VList.
1726** or return 0 if there is no such variable.
1727*/
1728int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
1729 int i, mx;
1730 if( pIn==0 ) return 0;
1731 mx = pIn[1];
1732 i = 2;
1733 do{
1734 const char *z = (const char*)&pIn[i+2];
1735 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
1736 i += pIn[i+1];
1737 }while( i<mx );
1738 return 0;
1739}
drh7741f342022-11-29 17:52:04 +00001740
1741/*
1742** High-resolution hardware timer used for debugging and testing only.
1743*/
dan231ff4b2022-12-02 20:32:22 +00001744#if defined(VDBE_PROFILE) \
1745 || defined(SQLITE_PERFORMANCE_TRACE) \
1746 || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
drh7741f342022-11-29 17:52:04 +00001747# include "hwtime.h"
1748#endif