blob: fbe3714b77317f0e5c41c5ed6aabc32817816d1d [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>
drh0ede9eb2015-01-10 16:49:23 +000020#if HAVE_ISNAN || SQLITE_HAVE_ISNAN
drhc81c11f2009-11-10 01:30:52 +000021# include <math.h>
22#endif
23
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/*
35** Give a callback to the test harness that can be used to simulate faults
36** in places where it is difficult or expensive to do so purely by means
37** of inputs.
38**
39** The intent of the integer argument is to let the fault simulator know
40** which of multiple sqlite3FaultSim() calls has been hit.
41**
42** Return whatever integer value the test callback returns, or return
43** SQLITE_OK if no test callback is installed.
44*/
drhd12602a2016-12-07 15:49:02 +000045#ifndef SQLITE_UNTESTABLE
drhc007f612014-05-16 14:17:01 +000046int sqlite3FaultSim(int iTest){
47 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback;
48 return xCallback ? xCallback(iTest) : SQLITE_OK;
49}
50#endif
51
drh85c8f292010-01-13 17:39:53 +000052#ifndef SQLITE_OMIT_FLOATING_POINT
drhc81c11f2009-11-10 01:30:52 +000053/*
54** Return true if the floating point value is Not a Number (NaN).
55**
56** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
57** Otherwise, we have our own implementation that works on most systems.
58*/
59int sqlite3IsNaN(double x){
60 int rc; /* The value return */
drh0ede9eb2015-01-10 16:49:23 +000061#if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
drhc81c11f2009-11-10 01:30:52 +000062 /*
63 ** Systems that support the isnan() library function should probably
64 ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have
65 ** found that many systems do not have a working isnan() function so
66 ** this implementation is provided as an alternative.
67 **
68 ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
69 ** On the other hand, the use of -ffast-math comes with the following
70 ** warning:
71 **
72 ** This option [-ffast-math] should never be turned on by any
73 ** -O option since it can result in incorrect output for programs
74 ** which depend on an exact implementation of IEEE or ISO
75 ** rules/specifications for math functions.
76 **
77 ** Under MSVC, this NaN test may fail if compiled with a floating-
78 ** point precision mode other than /fp:precise. From the MSDN
79 ** documentation:
80 **
81 ** The compiler [with /fp:precise] will properly handle comparisons
82 ** involving NaN. For example, x != x evaluates to true if x is NaN
83 ** ...
84 */
85#ifdef __FAST_MATH__
86# error SQLite will not work correctly with the -ffast-math option of GCC.
87#endif
88 volatile double y = x;
89 volatile double z = y;
90 rc = (y!=z);
drh0ede9eb2015-01-10 16:49:23 +000091#else /* if HAVE_ISNAN */
drhc81c11f2009-11-10 01:30:52 +000092 rc = isnan(x);
drh0ede9eb2015-01-10 16:49:23 +000093#endif /* HAVE_ISNAN */
drhc81c11f2009-11-10 01:30:52 +000094 testcase( rc );
95 return rc;
96}
drh85c8f292010-01-13 17:39:53 +000097#endif /* SQLITE_OMIT_FLOATING_POINT */
drhc81c11f2009-11-10 01:30:52 +000098
99/*
100** Compute a string length that is limited to what can be stored in
101** lower 30 bits of a 32-bit signed integer.
102**
103** The value returned will never be negative. Nor will it ever be greater
104** than the actual length of the string. For very long strings (greater
105** than 1GiB) the value returned might be less than the true string length.
106*/
107int sqlite3Strlen30(const char *z){
drhc81c11f2009-11-10 01:30:52 +0000108 if( z==0 ) return 0;
drh1116bf12015-06-30 03:18:33 +0000109 return 0x3fffffff & (int)strlen(z);
drhc81c11f2009-11-10 01:30:52 +0000110}
111
112/*
drhd7564862016-03-22 20:05:09 +0000113** Return the declared type of a column. Or return zDflt if the column
114** has no declared type.
115**
116** The column type is an extra string stored after the zero-terminator on
117** the column name if and only if the COLFLAG_HASTYPE flag is set.
drh94eaafa2016-02-29 15:53:11 +0000118*/
drhd7564862016-03-22 20:05:09 +0000119char *sqlite3ColumnType(Column *pCol, char *zDflt){
120 if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt;
121 return pCol->zName + strlen(pCol->zName) + 1;
drh94eaafa2016-02-29 15:53:11 +0000122}
123
124/*
drh80fbee02016-03-21 11:57:13 +0000125** Helper function for sqlite3Error() - called rarely. Broken out into
126** a separate routine to avoid unnecessary register saves on entry to
127** sqlite3Error().
drh13f40da2014-08-22 18:00:11 +0000128*/
drh8d2f41c2016-03-21 11:38:01 +0000129static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){
130 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
131 sqlite3SystemError(db, err_code);
132}
drh80fbee02016-03-21 11:57:13 +0000133
134/*
135** Set the current error code to err_code and clear any prior error message.
136** Also set iSysErrno (by calling sqlite3System) if the err_code indicates
137** that would be appropriate.
138*/
drh13f40da2014-08-22 18:00:11 +0000139void sqlite3Error(sqlite3 *db, int err_code){
140 assert( db!=0 );
141 db->errCode = err_code;
drh8d2f41c2016-03-21 11:38:01 +0000142 if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code);
drh13f40da2014-08-22 18:00:11 +0000143}
144
145/*
drh1b9f2142016-03-17 16:01:23 +0000146** Load the sqlite3.iSysErrno field if that is an appropriate thing
147** to do based on the SQLite error code in rc.
148*/
149void sqlite3SystemError(sqlite3 *db, int rc){
150 if( rc==SQLITE_IOERR_NOMEM ) return;
151 rc &= 0xff;
152 if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){
153 db->iSysErrno = sqlite3OsGetLastError(db->pVfs);
154 }
155}
156
157/*
drhc81c11f2009-11-10 01:30:52 +0000158** Set the most recent error code and error string for the sqlite
159** handle "db". The error code is set to "err_code".
160**
161** If it is not NULL, string zFormat specifies the format of the
162** error string in the style of the printf functions: The following
163** format characters are allowed:
164**
165** %s Insert a string
166** %z A string that should be freed after use
167** %d Insert an integer
168** %T Insert a token
169** %S Insert the first element of a SrcList
170**
171** zFormat and any string tokens that follow it are assumed to be
172** encoded in UTF-8.
173**
174** To clear the most recent error for sqlite handle "db", sqlite3Error
175** should be called with err_code set to SQLITE_OK and zFormat set
176** to NULL.
177*/
drh13f40da2014-08-22 18:00:11 +0000178void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){
drha3cc0072013-12-13 16:23:55 +0000179 assert( db!=0 );
180 db->errCode = err_code;
drh8d2f41c2016-03-21 11:38:01 +0000181 sqlite3SystemError(db, err_code);
drh13f40da2014-08-22 18:00:11 +0000182 if( zFormat==0 ){
183 sqlite3Error(db, err_code);
184 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
drha3cc0072013-12-13 16:23:55 +0000185 char *z;
186 va_list ap;
187 va_start(ap, zFormat);
188 z = sqlite3VMPrintf(db, zFormat, ap);
189 va_end(ap);
190 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
drhc81c11f2009-11-10 01:30:52 +0000191 }
192}
193
194/*
195** Add an error message to pParse->zErrMsg and increment pParse->nErr.
196** The following formatting characters are allowed:
197**
198** %s Insert a string
199** %z A string that should be freed after use
200** %d Insert an integer
201** %T Insert a token
202** %S Insert the first element of a SrcList
203**
drh13f40da2014-08-22 18:00:11 +0000204** This function should be used to report any error that occurs while
drhc81c11f2009-11-10 01:30:52 +0000205** compiling an SQL statement (i.e. within sqlite3_prepare()). The
206** last thing the sqlite3_prepare() function does is copy the error
207** stored by this function into the database handle using sqlite3Error().
drh13f40da2014-08-22 18:00:11 +0000208** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
209** during statement execution (sqlite3_step() etc.).
drhc81c11f2009-11-10 01:30:52 +0000210*/
211void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
drha7564662010-02-22 19:32:31 +0000212 char *zMsg;
drhc81c11f2009-11-10 01:30:52 +0000213 va_list ap;
214 sqlite3 *db = pParse->db;
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);
drha7564662010-02-22 19:32:31 +0000218 if( db->suppressErr ){
219 sqlite3DbFree(db, zMsg);
220 }else{
221 pParse->nErr++;
222 sqlite3DbFree(db, pParse->zErrMsg);
223 pParse->zErrMsg = zMsg;
224 pParse->rc = SQLITE_ERROR;
drha7564662010-02-22 19:32:31 +0000225 }
drhc81c11f2009-11-10 01:30:52 +0000226}
227
228/*
229** Convert an SQL-style quoted string into a normal string by removing
230** the quote characters. The conversion is done in-place. If the
231** input does not begin with a quote character, then this routine
232** is a no-op.
233**
234** The input string must be zero-terminated. A new zero-terminator
235** is added to the dequoted string.
236**
237** The return value is -1 if no dequoting occurs or the length of the
238** dequoted string, exclusive of the zero terminator, if dequoting does
239** occur.
240**
241** 2002-Feb-14: This routine is extended to remove MS-Access style
peter.d.reid60ec9142014-09-06 16:39:46 +0000242** brackets from around identifiers. For example: "[a-b-c]" becomes
drhc81c11f2009-11-10 01:30:52 +0000243** "a-b-c".
244*/
drh244b9d62016-04-11 19:01:08 +0000245void sqlite3Dequote(char *z){
drhc81c11f2009-11-10 01:30:52 +0000246 char quote;
247 int i, j;
drh244b9d62016-04-11 19:01:08 +0000248 if( z==0 ) return;
drhc81c11f2009-11-10 01:30:52 +0000249 quote = z[0];
drh244b9d62016-04-11 19:01:08 +0000250 if( !sqlite3Isquote(quote) ) return;
251 if( quote=='[' ) quote = ']';
drh9ccd8652013-09-13 16:36:46 +0000252 for(i=1, j=0;; i++){
253 assert( z[i] );
drhc81c11f2009-11-10 01:30:52 +0000254 if( z[i]==quote ){
255 if( z[i+1]==quote ){
256 z[j++] = quote;
257 i++;
258 }else{
259 break;
260 }
261 }else{
262 z[j++] = z[i];
263 }
264 }
265 z[j] = 0;
drhc81c11f2009-11-10 01:30:52 +0000266}
267
drh40aced52016-01-22 17:48:09 +0000268/*
269** Generate a Token object from a string
270*/
271void sqlite3TokenInit(Token *p, char *z){
272 p->z = z;
273 p->n = sqlite3Strlen30(z);
274}
275
drhc81c11f2009-11-10 01:30:52 +0000276/* Convenient short-hand */
277#define UpperToLower sqlite3UpperToLower
278
279/*
280** Some systems have stricmp(). Others have strcasecmp(). Because
281** there is no consistency, we will define our own.
drh9f129f42010-08-31 15:27:32 +0000282**
drh0299b402012-03-19 17:42:46 +0000283** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
284** sqlite3_strnicmp() APIs allow applications and extensions to compare
285** the contents of two buffers containing UTF-8 strings in a
286** case-independent fashion, using the same definition of "case
287** independence" that SQLite uses internally when comparing identifiers.
drhc81c11f2009-11-10 01:30:52 +0000288*/
drh3fa97302012-02-22 16:58:36 +0000289int sqlite3_stricmp(const char *zLeft, const char *zRight){
drh9ca95732014-10-24 00:35:58 +0000290 if( zLeft==0 ){
291 return zRight ? -1 : 0;
292 }else if( zRight==0 ){
293 return 1;
294 }
drh80738d92016-02-15 00:34:16 +0000295 return sqlite3StrICmp(zLeft, zRight);
296}
297int sqlite3StrICmp(const char *zLeft, const char *zRight){
298 unsigned char *a, *b;
299 int c;
drhc81c11f2009-11-10 01:30:52 +0000300 a = (unsigned char *)zLeft;
301 b = (unsigned char *)zRight;
drh80738d92016-02-15 00:34:16 +0000302 for(;;){
303 c = (int)UpperToLower[*a] - (int)UpperToLower[*b];
304 if( c || *a==0 ) break;
305 a++;
306 b++;
307 }
308 return c;
drhc81c11f2009-11-10 01:30:52 +0000309}
310int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
311 register unsigned char *a, *b;
drh9ca95732014-10-24 00:35:58 +0000312 if( zLeft==0 ){
313 return zRight ? -1 : 0;
314 }else if( zRight==0 ){
315 return 1;
316 }
drhc81c11f2009-11-10 01:30:52 +0000317 a = (unsigned char *)zLeft;
318 b = (unsigned char *)zRight;
319 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
320 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
321}
322
323/*
drh9339da12010-09-30 00:50:49 +0000324** The string z[] is an text representation of a real number.
drh025586a2010-09-30 17:33:11 +0000325** Convert this string to a double and write it into *pResult.
drhc81c11f2009-11-10 01:30:52 +0000326**
drh9339da12010-09-30 00:50:49 +0000327** The string z[] is length bytes in length (bytes, not characters) and
328** uses the encoding enc. The string is not necessarily zero-terminated.
drhc81c11f2009-11-10 01:30:52 +0000329**
drh9339da12010-09-30 00:50:49 +0000330** Return TRUE if the result is a valid real number (or integer) and FALSE
drh025586a2010-09-30 17:33:11 +0000331** if the string is empty or contains extraneous text. Valid numbers
332** are in one of these formats:
333**
334** [+-]digits[E[+-]digits]
335** [+-]digits.[digits][E[+-]digits]
336** [+-].digits[E[+-]digits]
337**
338** Leading and trailing whitespace is ignored for the purpose of determining
339** validity.
340**
341** If some prefix of the input string is a valid number, this routine
342** returns FALSE but it still converts the prefix and writes the result
343** into *pResult.
drhc81c11f2009-11-10 01:30:52 +0000344*/
drh9339da12010-09-30 00:50:49 +0000345int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
drhc81c11f2009-11-10 01:30:52 +0000346#ifndef SQLITE_OMIT_FLOATING_POINT
drh0e5fba72013-03-20 12:04:29 +0000347 int incr;
drh9339da12010-09-30 00:50:49 +0000348 const char *zEnd = z + length;
drhc81c11f2009-11-10 01:30:52 +0000349 /* sign * significand * (10 ^ (esign * exponent)) */
drh025586a2010-09-30 17:33:11 +0000350 int sign = 1; /* sign of significand */
351 i64 s = 0; /* significand */
352 int d = 0; /* adjust exponent for shifting decimal point */
353 int esign = 1; /* sign of exponent */
354 int e = 0; /* exponent */
355 int eValid = 1; /* True exponent is either not used or is well-formed */
drhc81c11f2009-11-10 01:30:52 +0000356 double result;
357 int nDigits = 0;
drhad975d52016-04-27 15:24:13 +0000358 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */
drhc81c11f2009-11-10 01:30:52 +0000359
drh0e5fba72013-03-20 12:04:29 +0000360 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
drh025586a2010-09-30 17:33:11 +0000361 *pResult = 0.0; /* Default return value, in case of an error */
362
drh0e5fba72013-03-20 12:04:29 +0000363 if( enc==SQLITE_UTF8 ){
364 incr = 1;
365 }else{
366 int i;
367 incr = 2;
368 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
369 for(i=3-enc; i<length && z[i]==0; i+=2){}
370 nonNum = i<length;
drhad975d52016-04-27 15:24:13 +0000371 zEnd = &z[i^1];
drh0e5fba72013-03-20 12:04:29 +0000372 z += (enc&1);
373 }
drh9339da12010-09-30 00:50:49 +0000374
drhc81c11f2009-11-10 01:30:52 +0000375 /* skip leading spaces */
drh9339da12010-09-30 00:50:49 +0000376 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
drh025586a2010-09-30 17:33:11 +0000377 if( z>=zEnd ) return 0;
drh9339da12010-09-30 00:50:49 +0000378
drhc81c11f2009-11-10 01:30:52 +0000379 /* get sign of significand */
380 if( *z=='-' ){
381 sign = -1;
drh9339da12010-09-30 00:50:49 +0000382 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000383 }else if( *z=='+' ){
drh9339da12010-09-30 00:50:49 +0000384 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000385 }
drh9339da12010-09-30 00:50:49 +0000386
drhc81c11f2009-11-10 01:30:52 +0000387 /* copy max significant digits to significand */
drh9339da12010-09-30 00:50:49 +0000388 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
drhc81c11f2009-11-10 01:30:52 +0000389 s = s*10 + (*z - '0');
drh9339da12010-09-30 00:50:49 +0000390 z+=incr, nDigits++;
drhc81c11f2009-11-10 01:30:52 +0000391 }
drh9339da12010-09-30 00:50:49 +0000392
drhc81c11f2009-11-10 01:30:52 +0000393 /* skip non-significant significand digits
394 ** (increase exponent by d to shift decimal left) */
drh9339da12010-09-30 00:50:49 +0000395 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
396 if( z>=zEnd ) goto do_atof_calc;
drhc81c11f2009-11-10 01:30:52 +0000397
398 /* if decimal point is present */
399 if( *z=='.' ){
drh9339da12010-09-30 00:50:49 +0000400 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000401 /* copy digits from after decimal to significand
402 ** (decrease exponent by d to shift decimal right) */
drh15af62a2016-04-26 23:14:45 +0000403 while( z<zEnd && sqlite3Isdigit(*z) ){
404 if( s<((LARGEST_INT64-9)/10) ){
405 s = s*10 + (*z - '0');
406 d--;
407 }
408 z+=incr, nDigits++;
drhc81c11f2009-11-10 01:30:52 +0000409 }
drhc81c11f2009-11-10 01:30:52 +0000410 }
drh9339da12010-09-30 00:50:49 +0000411 if( z>=zEnd ) goto do_atof_calc;
drhc81c11f2009-11-10 01:30:52 +0000412
413 /* if exponent is present */
414 if( *z=='e' || *z=='E' ){
drh9339da12010-09-30 00:50:49 +0000415 z+=incr;
drh025586a2010-09-30 17:33:11 +0000416 eValid = 0;
drhad975d52016-04-27 15:24:13 +0000417
418 /* This branch is needed to avoid a (harmless) buffer overread. The
419 ** special comment alerts the mutation tester that the correct answer
420 ** is obtained even if the branch is omitted */
421 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/
422
drhc81c11f2009-11-10 01:30:52 +0000423 /* get sign of exponent */
424 if( *z=='-' ){
425 esign = -1;
drh9339da12010-09-30 00:50:49 +0000426 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000427 }else if( *z=='+' ){
drh9339da12010-09-30 00:50:49 +0000428 z+=incr;
drhc81c11f2009-11-10 01:30:52 +0000429 }
430 /* copy digits to exponent */
drh9339da12010-09-30 00:50:49 +0000431 while( z<zEnd && sqlite3Isdigit(*z) ){
drh57db4a72011-10-17 20:41:46 +0000432 e = e<10000 ? (e*10 + (*z - '0')) : 10000;
drh9339da12010-09-30 00:50:49 +0000433 z+=incr;
drh025586a2010-09-30 17:33:11 +0000434 eValid = 1;
drhc81c11f2009-11-10 01:30:52 +0000435 }
436 }
437
drh025586a2010-09-30 17:33:11 +0000438 /* skip trailing spaces */
drhc6daa012016-04-27 02:35:03 +0000439 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
drh025586a2010-09-30 17:33:11 +0000440
drh9339da12010-09-30 00:50:49 +0000441do_atof_calc:
drhc81c11f2009-11-10 01:30:52 +0000442 /* adjust exponent by d, and update sign */
443 e = (e*esign) + d;
444 if( e<0 ) {
445 esign = -1;
446 e *= -1;
447 } else {
448 esign = 1;
449 }
450
drhad975d52016-04-27 15:24:13 +0000451 if( s==0 ) {
452 /* In the IEEE 754 standard, zero is signed. */
drhc6daa012016-04-27 02:35:03 +0000453 result = sign<0 ? -(double)0 : (double)0;
drhc81c11f2009-11-10 01:30:52 +0000454 } else {
drhad975d52016-04-27 15:24:13 +0000455 /* Attempt to reduce exponent.
456 **
457 ** Branches that are not required for the correct answer but which only
458 ** help to obtain the correct answer faster are marked with special
459 ** comments, as a hint to the mutation tester.
460 */
461 while( e>0 ){ /*OPTIMIZATION-IF-TRUE*/
462 if( esign>0 ){
463 if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/
464 s *= 10;
465 }else{
466 if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/
467 s /= 10;
468 }
469 e--;
drhc81c11f2009-11-10 01:30:52 +0000470 }
471
472 /* adjust the sign of significand */
473 s = sign<0 ? -s : s;
474
drhad975d52016-04-27 15:24:13 +0000475 if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/
476 result = (double)s;
477 }else{
drh89f15082012-06-19 00:45:16 +0000478 LONGDOUBLE_TYPE scale = 1.0;
drhc81c11f2009-11-10 01:30:52 +0000479 /* attempt to handle extremely small/large numbers better */
drhad975d52016-04-27 15:24:13 +0000480 if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/
481 if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/
482 while( e%308 ) { scale *= 1.0e+1; e -= 1; }
483 if( esign<0 ){
484 result = s / scale;
485 result /= 1.0e+308;
486 }else{
487 result = s * scale;
488 result *= 1.0e+308;
489 }
490 }else{ assert( e>=342 );
491 if( esign<0 ){
492 result = 0.0*s;
493 }else{
drhb9772e72017-09-12 13:27:43 +0000494#ifdef INFINITY
drh3ba18ad2017-09-12 15:05:34 +0000495 result = INFINITY*s;
drhb9772e72017-09-12 13:27:43 +0000496#else
drhad975d52016-04-27 15:24:13 +0000497 result = 1e308*1e308*s; /* Infinity */
drhb9772e72017-09-12 13:27:43 +0000498#endif
drhad975d52016-04-27 15:24:13 +0000499 }
drh2458a2e2011-10-17 12:14:26 +0000500 }
drhc81c11f2009-11-10 01:30:52 +0000501 }else{
502 /* 1.0e+22 is the largest power of 10 than can be
503 ** represented exactly. */
504 while( e%22 ) { scale *= 1.0e+1; e -= 1; }
505 while( e>0 ) { scale *= 1.0e+22; e -= 22; }
506 if( esign<0 ){
507 result = s / scale;
508 }else{
509 result = s * scale;
510 }
511 }
drhc81c11f2009-11-10 01:30:52 +0000512 }
513 }
514
515 /* store the result */
516 *pResult = result;
517
drh025586a2010-09-30 17:33:11 +0000518 /* return true if number and no extra non-whitespace chracters after */
drhad975d52016-04-27 15:24:13 +0000519 return z==zEnd && nDigits>0 && eValid && nonNum==0;
drhc81c11f2009-11-10 01:30:52 +0000520#else
shaneh5f1d6b62010-09-30 16:51:25 +0000521 return !sqlite3Atoi64(z, pResult, length, enc);
drhc81c11f2009-11-10 01:30:52 +0000522#endif /* SQLITE_OMIT_FLOATING_POINT */
523}
524
525/*
526** Compare the 19-character string zNum against the text representation
527** value 2^63: 9223372036854775808. Return negative, zero, or positive
528** if zNum is less than, equal to, or greater than the string.
shaneh5f1d6b62010-09-30 16:51:25 +0000529** Note that zNum must contain exactly 19 characters.
drhc81c11f2009-11-10 01:30:52 +0000530**
531** Unlike memcmp() this routine is guaranteed to return the difference
532** in the values of the last digit if the only difference is in the
533** last digit. So, for example,
534**
drh9339da12010-09-30 00:50:49 +0000535** compare2pow63("9223372036854775800", 1)
drhc81c11f2009-11-10 01:30:52 +0000536**
537** will return -8.
538*/
drh9339da12010-09-30 00:50:49 +0000539static int compare2pow63(const char *zNum, int incr){
540 int c = 0;
541 int i;
542 /* 012345678901234567 */
543 const char *pow63 = "922337203685477580";
544 for(i=0; c==0 && i<18; i++){
545 c = (zNum[i*incr]-pow63[i])*10;
546 }
drhc81c11f2009-11-10 01:30:52 +0000547 if( c==0 ){
drh9339da12010-09-30 00:50:49 +0000548 c = zNum[18*incr] - '8';
drh44dbca82010-01-13 04:22:20 +0000549 testcase( c==(-1) );
550 testcase( c==0 );
551 testcase( c==(+1) );
drhc81c11f2009-11-10 01:30:52 +0000552 }
553 return c;
554}
555
drhc81c11f2009-11-10 01:30:52 +0000556/*
drh9296c182014-07-23 13:40:49 +0000557** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
558** routine does *not* accept hexadecimal notation.
drh158b9cb2011-03-05 20:59:46 +0000559**
drh84d4f1a2017-09-20 10:47:10 +0000560** Returns:
drh158b9cb2011-03-05 20:59:46 +0000561**
drh84d4f1a2017-09-20 10:47:10 +0000562** 0 Successful transformation. Fits in a 64-bit signed integer.
563** 1 Excess text after the integer value
564** 2 Integer too large for a 64-bit signed integer or is malformed
565** 3 Special case of 9223372036854775808
drhc81c11f2009-11-10 01:30:52 +0000566**
drh9339da12010-09-30 00:50:49 +0000567** length is the number of bytes in the string (bytes, not characters).
568** The string is not necessarily zero-terminated. The encoding is
569** given by enc.
drhc81c11f2009-11-10 01:30:52 +0000570*/
drh9339da12010-09-30 00:50:49 +0000571int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
drh0e5fba72013-03-20 12:04:29 +0000572 int incr;
drh158b9cb2011-03-05 20:59:46 +0000573 u64 u = 0;
shaneh5f1d6b62010-09-30 16:51:25 +0000574 int neg = 0; /* assume positive */
drh9339da12010-09-30 00:50:49 +0000575 int i;
576 int c = 0;
drh609d5842016-04-28 00:32:16 +0000577 int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */
drh84d4f1a2017-09-20 10:47:10 +0000578 int rc; /* Baseline return code */
drhc81c11f2009-11-10 01:30:52 +0000579 const char *zStart;
drh9339da12010-09-30 00:50:49 +0000580 const char *zEnd = zNum + length;
drh0e5fba72013-03-20 12:04:29 +0000581 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
582 if( enc==SQLITE_UTF8 ){
583 incr = 1;
584 }else{
585 incr = 2;
586 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
587 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
588 nonNum = i<length;
drh609d5842016-04-28 00:32:16 +0000589 zEnd = &zNum[i^1];
drh0e5fba72013-03-20 12:04:29 +0000590 zNum += (enc&1);
591 }
drh9339da12010-09-30 00:50:49 +0000592 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
drh158b9cb2011-03-05 20:59:46 +0000593 if( zNum<zEnd ){
594 if( *zNum=='-' ){
595 neg = 1;
596 zNum+=incr;
597 }else if( *zNum=='+' ){
598 zNum+=incr;
599 }
drhc81c11f2009-11-10 01:30:52 +0000600 }
601 zStart = zNum;
drh9339da12010-09-30 00:50:49 +0000602 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
603 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
drh158b9cb2011-03-05 20:59:46 +0000604 u = u*10 + c - '0';
drhc81c11f2009-11-10 01:30:52 +0000605 }
drh158b9cb2011-03-05 20:59:46 +0000606 if( u>LARGEST_INT64 ){
drhde1a8b82013-11-26 15:45:02 +0000607 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
drh158b9cb2011-03-05 20:59:46 +0000608 }else if( neg ){
609 *pNum = -(i64)u;
610 }else{
611 *pNum = (i64)u;
612 }
drh44dbca82010-01-13 04:22:20 +0000613 testcase( i==18 );
614 testcase( i==19 );
615 testcase( i==20 );
drh609d5842016-04-28 00:32:16 +0000616 if( &zNum[i]<zEnd /* Extra bytes at the end */
617 || (i==0 && zStart==zNum) /* No digits */
drh609d5842016-04-28 00:32:16 +0000618 || nonNum /* UTF16 with high-order bytes non-zero */
619 ){
drh84d4f1a2017-09-20 10:47:10 +0000620 rc = 1;
621 }else{
622 rc = 0;
623 }
624 if( i>19*incr ){ /* Too many digits */
drhc81c11f2009-11-10 01:30:52 +0000625 /* zNum is empty or contains non-numeric text or is longer
shaneh5f1d6b62010-09-30 16:51:25 +0000626 ** than 19 digits (thus guaranteeing that it is too large) */
drh84d4f1a2017-09-20 10:47:10 +0000627 return 2;
drh9339da12010-09-30 00:50:49 +0000628 }else if( i<19*incr ){
drhc81c11f2009-11-10 01:30:52 +0000629 /* Less than 19 digits, so we know that it fits in 64 bits */
drh158b9cb2011-03-05 20:59:46 +0000630 assert( u<=LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000631 return rc;
drhc81c11f2009-11-10 01:30:52 +0000632 }else{
drh158b9cb2011-03-05 20:59:46 +0000633 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
634 c = compare2pow63(zNum, incr);
635 if( c<0 ){
636 /* zNum is less than 9223372036854775808 so it fits */
637 assert( u<=LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000638 return rc;
drh158b9cb2011-03-05 20:59:46 +0000639 }else if( c>0 ){
640 /* zNum is greater than 9223372036854775808 so it overflows */
drh84d4f1a2017-09-20 10:47:10 +0000641 return 2;
drh158b9cb2011-03-05 20:59:46 +0000642 }else{
643 /* zNum is exactly 9223372036854775808. Fits if negative. The
644 ** special case 2 overflow if positive */
645 assert( u-1==LARGEST_INT64 );
drh84d4f1a2017-09-20 10:47:10 +0000646 return neg ? rc : 3;
drh158b9cb2011-03-05 20:59:46 +0000647 }
drhc81c11f2009-11-10 01:30:52 +0000648 }
649}
650
651/*
drh9296c182014-07-23 13:40:49 +0000652** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
653** into a 64-bit signed integer. This routine accepts hexadecimal literals,
654** whereas sqlite3Atoi64() does not.
655**
656** Returns:
657**
658** 0 Successful transformation. Fits in a 64-bit signed integer.
drh84d4f1a2017-09-20 10:47:10 +0000659** 1 Excess text after the integer value
660** 2 Integer too large for a 64-bit signed integer or is malformed
661** 3 Special case of 9223372036854775808
drh9296c182014-07-23 13:40:49 +0000662*/
663int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
664#ifndef SQLITE_OMIT_HEX_INTEGER
665 if( z[0]=='0'
666 && (z[1]=='x' || z[1]=='X')
drh9296c182014-07-23 13:40:49 +0000667 ){
668 u64 u = 0;
669 int i, k;
670 for(i=2; z[i]=='0'; i++){}
671 for(k=i; sqlite3Isxdigit(z[k]); k++){
672 u = u*16 + sqlite3HexToInt(z[k]);
673 }
674 memcpy(pOut, &u, 8);
drh84d4f1a2017-09-20 10:47:10 +0000675 return (z[k]==0 && k-i<=16) ? 0 : 2;
drh9296c182014-07-23 13:40:49 +0000676 }else
677#endif /* SQLITE_OMIT_HEX_INTEGER */
678 {
679 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
680 }
681}
682
683/*
drhc81c11f2009-11-10 01:30:52 +0000684** If zNum represents an integer that will fit in 32-bits, then set
685** *pValue to that integer and return true. Otherwise return false.
686**
drh9296c182014-07-23 13:40:49 +0000687** This routine accepts both decimal and hexadecimal notation for integers.
688**
drhc81c11f2009-11-10 01:30:52 +0000689** Any non-numeric characters that following zNum are ignored.
690** This is different from sqlite3Atoi64() which requires the
691** input number to be zero-terminated.
692*/
693int sqlite3GetInt32(const char *zNum, int *pValue){
694 sqlite_int64 v = 0;
695 int i, c;
696 int neg = 0;
697 if( zNum[0]=='-' ){
698 neg = 1;
699 zNum++;
700 }else if( zNum[0]=='+' ){
701 zNum++;
702 }
drh28e048c2014-07-23 01:26:51 +0000703#ifndef SQLITE_OMIT_HEX_INTEGER
704 else if( zNum[0]=='0'
705 && (zNum[1]=='x' || zNum[1]=='X')
706 && sqlite3Isxdigit(zNum[2])
707 ){
708 u32 u = 0;
709 zNum += 2;
710 while( zNum[0]=='0' ) zNum++;
711 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
712 u = u*16 + sqlite3HexToInt(zNum[i]);
713 }
714 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
715 memcpy(pValue, &u, 4);
716 return 1;
717 }else{
718 return 0;
719 }
720 }
721#endif
drh313e6fd2017-05-03 17:44:28 +0000722 if( !sqlite3Isdigit(zNum[0]) ) return 0;
drh935f2e72015-04-18 04:45:00 +0000723 while( zNum[0]=='0' ) zNum++;
drhc81c11f2009-11-10 01:30:52 +0000724 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
725 v = v*10 + c;
726 }
727
728 /* The longest decimal representation of a 32 bit integer is 10 digits:
729 **
730 ** 1234567890
731 ** 2^31 -> 2147483648
732 */
drh44dbca82010-01-13 04:22:20 +0000733 testcase( i==10 );
drhc81c11f2009-11-10 01:30:52 +0000734 if( i>10 ){
735 return 0;
736 }
drh44dbca82010-01-13 04:22:20 +0000737 testcase( v-neg==2147483647 );
drhc81c11f2009-11-10 01:30:52 +0000738 if( v-neg>2147483647 ){
739 return 0;
740 }
741 if( neg ){
742 v = -v;
743 }
744 *pValue = (int)v;
745 return 1;
746}
747
748/*
drh60ac3f42010-11-23 18:59:27 +0000749** Return a 32-bit integer value extracted from a string. If the
750** string is not an integer, just return 0.
751*/
752int sqlite3Atoi(const char *z){
753 int x = 0;
754 if( z ) sqlite3GetInt32(z, &x);
755 return x;
756}
757
758/*
drhc81c11f2009-11-10 01:30:52 +0000759** The variable-length integer encoding is as follows:
760**
761** KEY:
762** A = 0xxxxxxx 7 bits of data and one flag bit
763** B = 1xxxxxxx 7 bits of data and one flag bit
764** C = xxxxxxxx 8 bits of data
765**
766** 7 bits - A
767** 14 bits - BA
768** 21 bits - BBA
769** 28 bits - BBBA
770** 35 bits - BBBBA
771** 42 bits - BBBBBA
772** 49 bits - BBBBBBA
773** 56 bits - BBBBBBBA
774** 64 bits - BBBBBBBBC
775*/
776
777/*
778** Write a 64-bit variable-length integer to memory starting at p[0].
779** The length of data write will be between 1 and 9 bytes. The number
780** of bytes written is returned.
781**
782** A variable-length integer consists of the lower 7 bits of each byte
783** for all bytes that have the 8th bit set and one byte with the 8th
784** bit clear. Except, if we get to the 9th byte, it stores the full
785** 8 bits and is the last byte.
786*/
drh2f2b2b82014-08-22 18:48:25 +0000787static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){
drhc81c11f2009-11-10 01:30:52 +0000788 int i, j, n;
789 u8 buf[10];
790 if( v & (((u64)0xff000000)<<32) ){
791 p[8] = (u8)v;
792 v >>= 8;
793 for(i=7; i>=0; i--){
794 p[i] = (u8)((v & 0x7f) | 0x80);
795 v >>= 7;
796 }
797 return 9;
798 }
799 n = 0;
800 do{
801 buf[n++] = (u8)((v & 0x7f) | 0x80);
802 v >>= 7;
803 }while( v!=0 );
804 buf[0] &= 0x7f;
805 assert( n<=9 );
806 for(i=0, j=n-1; j>=0; j--, i++){
807 p[i] = buf[j];
808 }
809 return n;
810}
drh2f2b2b82014-08-22 18:48:25 +0000811int sqlite3PutVarint(unsigned char *p, u64 v){
812 if( v<=0x7f ){
813 p[0] = v&0x7f;
drhc81c11f2009-11-10 01:30:52 +0000814 return 1;
815 }
drh2f2b2b82014-08-22 18:48:25 +0000816 if( v<=0x3fff ){
817 p[0] = ((v>>7)&0x7f)|0x80;
818 p[1] = v&0x7f;
drhc81c11f2009-11-10 01:30:52 +0000819 return 2;
820 }
drh2f2b2b82014-08-22 18:48:25 +0000821 return putVarint64(p,v);
drhc81c11f2009-11-10 01:30:52 +0000822}
823
824/*
drh0b2864c2010-03-03 15:18:38 +0000825** Bitmasks used by sqlite3GetVarint(). These precomputed constants
826** are defined here rather than simply putting the constant expressions
827** inline in order to work around bugs in the RVT compiler.
828**
829** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
830**
831** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
832*/
833#define SLOT_2_0 0x001fc07f
834#define SLOT_4_2_0 0xf01fc07f
835
836
837/*
drhc81c11f2009-11-10 01:30:52 +0000838** Read a 64-bit variable-length integer from memory starting at p[0].
839** Return the number of bytes read. The value is stored in *v.
840*/
841u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
842 u32 a,b,s;
843
844 a = *p;
845 /* a: p0 (unmasked) */
846 if (!(a&0x80))
847 {
848 *v = a;
849 return 1;
850 }
851
852 p++;
853 b = *p;
854 /* b: p1 (unmasked) */
855 if (!(b&0x80))
856 {
857 a &= 0x7f;
858 a = a<<7;
859 a |= b;
860 *v = a;
861 return 2;
862 }
863
drh0b2864c2010-03-03 15:18:38 +0000864 /* Verify that constants are precomputed correctly */
865 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
shaneh1da207e2010-03-09 14:41:12 +0000866 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
drh0b2864c2010-03-03 15:18:38 +0000867
drhc81c11f2009-11-10 01:30:52 +0000868 p++;
869 a = a<<14;
870 a |= *p;
871 /* a: p0<<14 | p2 (unmasked) */
872 if (!(a&0x80))
873 {
drh0b2864c2010-03-03 15:18:38 +0000874 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000875 b &= 0x7f;
876 b = b<<7;
877 a |= b;
878 *v = a;
879 return 3;
880 }
881
882 /* CSE1 from below */
drh0b2864c2010-03-03 15:18:38 +0000883 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000884 p++;
885 b = b<<14;
886 b |= *p;
887 /* b: p1<<14 | p3 (unmasked) */
888 if (!(b&0x80))
889 {
drh0b2864c2010-03-03 15:18:38 +0000890 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000891 /* moved CSE1 up */
892 /* a &= (0x7f<<14)|(0x7f); */
893 a = a<<7;
894 a |= b;
895 *v = a;
896 return 4;
897 }
898
899 /* a: p0<<14 | p2 (masked) */
900 /* b: p1<<14 | p3 (unmasked) */
901 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
902 /* moved CSE1 up */
903 /* a &= (0x7f<<14)|(0x7f); */
drh0b2864c2010-03-03 15:18:38 +0000904 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000905 s = a;
906 /* s: p0<<14 | p2 (masked) */
907
908 p++;
909 a = a<<14;
910 a |= *p;
911 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
912 if (!(a&0x80))
913 {
drh62aaa6c2015-11-21 17:27:42 +0000914 /* we can skip these cause they were (effectively) done above
915 ** while calculating s */
drhc81c11f2009-11-10 01:30:52 +0000916 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
917 /* b &= (0x7f<<14)|(0x7f); */
918 b = b<<7;
919 a |= b;
920 s = s>>18;
921 *v = ((u64)s)<<32 | a;
922 return 5;
923 }
924
925 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
926 s = s<<7;
927 s |= b;
928 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
929
930 p++;
931 b = b<<14;
932 b |= *p;
933 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
934 if (!(b&0x80))
935 {
936 /* we can skip this cause it was (effectively) done above in calc'ing s */
937 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
drh0b2864c2010-03-03 15:18:38 +0000938 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000939 a = a<<7;
940 a |= b;
941 s = s>>18;
942 *v = ((u64)s)<<32 | a;
943 return 6;
944 }
945
946 p++;
947 a = a<<14;
948 a |= *p;
949 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
950 if (!(a&0x80))
951 {
drh0b2864c2010-03-03 15:18:38 +0000952 a &= SLOT_4_2_0;
953 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000954 b = b<<7;
955 a |= b;
956 s = s>>11;
957 *v = ((u64)s)<<32 | a;
958 return 7;
959 }
960
961 /* CSE2 from below */
drh0b2864c2010-03-03 15:18:38 +0000962 a &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000963 p++;
964 b = b<<14;
965 b |= *p;
966 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
967 if (!(b&0x80))
968 {
drh0b2864c2010-03-03 15:18:38 +0000969 b &= SLOT_4_2_0;
drhc81c11f2009-11-10 01:30:52 +0000970 /* moved CSE2 up */
971 /* a &= (0x7f<<14)|(0x7f); */
972 a = a<<7;
973 a |= b;
974 s = s>>4;
975 *v = ((u64)s)<<32 | a;
976 return 8;
977 }
978
979 p++;
980 a = a<<15;
981 a |= *p;
982 /* a: p4<<29 | p6<<15 | p8 (unmasked) */
983
984 /* moved CSE2 up */
985 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
drh0b2864c2010-03-03 15:18:38 +0000986 b &= SLOT_2_0;
drhc81c11f2009-11-10 01:30:52 +0000987 b = b<<8;
988 a |= b;
989
990 s = s<<4;
991 b = p[-4];
992 b &= 0x7f;
993 b = b>>3;
994 s |= b;
995
996 *v = ((u64)s)<<32 | a;
997
998 return 9;
999}
1000
1001/*
1002** Read a 32-bit variable-length integer from memory starting at p[0].
1003** Return the number of bytes read. The value is stored in *v.
1004**
1005** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
1006** integer, then set *v to 0xffffffff.
1007**
1008** A MACRO version, getVarint32, is provided which inlines the
1009** single-byte case. All code should use the MACRO version as
1010** this function assumes the single-byte case has already been handled.
1011*/
1012u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
1013 u32 a,b;
1014
1015 /* The 1-byte case. Overwhelmingly the most common. Handled inline
1016 ** by the getVarin32() macro */
1017 a = *p;
1018 /* a: p0 (unmasked) */
1019#ifndef getVarint32
1020 if (!(a&0x80))
1021 {
1022 /* Values between 0 and 127 */
1023 *v = a;
1024 return 1;
1025 }
1026#endif
1027
1028 /* The 2-byte case */
1029 p++;
1030 b = *p;
1031 /* b: p1 (unmasked) */
1032 if (!(b&0x80))
1033 {
1034 /* Values between 128 and 16383 */
1035 a &= 0x7f;
1036 a = a<<7;
1037 *v = a | b;
1038 return 2;
1039 }
1040
1041 /* The 3-byte case */
1042 p++;
1043 a = a<<14;
1044 a |= *p;
1045 /* a: p0<<14 | p2 (unmasked) */
1046 if (!(a&0x80))
1047 {
1048 /* Values between 16384 and 2097151 */
1049 a &= (0x7f<<14)|(0x7f);
1050 b &= 0x7f;
1051 b = b<<7;
1052 *v = a | b;
1053 return 3;
1054 }
1055
1056 /* A 32-bit varint is used to store size information in btrees.
1057 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
1058 ** A 3-byte varint is sufficient, for example, to record the size
1059 ** of a 1048569-byte BLOB or string.
1060 **
1061 ** We only unroll the first 1-, 2-, and 3- byte cases. The very
1062 ** rare larger cases can be handled by the slower 64-bit varint
1063 ** routine.
1064 */
1065#if 1
1066 {
1067 u64 v64;
1068 u8 n;
1069
1070 p -= 2;
1071 n = sqlite3GetVarint(p, &v64);
1072 assert( n>3 && n<=9 );
1073 if( (v64 & SQLITE_MAX_U32)!=v64 ){
1074 *v = 0xffffffff;
1075 }else{
1076 *v = (u32)v64;
1077 }
1078 return n;
1079 }
1080
1081#else
1082 /* For following code (kept for historical record only) shows an
1083 ** unrolling for the 3- and 4-byte varint cases. This code is
1084 ** slightly faster, but it is also larger and much harder to test.
1085 */
1086 p++;
1087 b = b<<14;
1088 b |= *p;
1089 /* b: p1<<14 | p3 (unmasked) */
1090 if (!(b&0x80))
1091 {
1092 /* Values between 2097152 and 268435455 */
1093 b &= (0x7f<<14)|(0x7f);
1094 a &= (0x7f<<14)|(0x7f);
1095 a = a<<7;
1096 *v = a | b;
1097 return 4;
1098 }
1099
1100 p++;
1101 a = a<<14;
1102 a |= *p;
1103 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1104 if (!(a&0x80))
1105 {
dan3bbe7612010-03-03 16:02:05 +00001106 /* Values between 268435456 and 34359738367 */
1107 a &= SLOT_4_2_0;
1108 b &= SLOT_4_2_0;
drhc81c11f2009-11-10 01:30:52 +00001109 b = b<<7;
1110 *v = a | b;
1111 return 5;
1112 }
1113
1114 /* We can only reach this point when reading a corrupt database
1115 ** file. In that case we are not in any hurry. Use the (relatively
1116 ** slow) general-purpose sqlite3GetVarint() routine to extract the
1117 ** value. */
1118 {
1119 u64 v64;
1120 u8 n;
1121
1122 p -= 4;
1123 n = sqlite3GetVarint(p, &v64);
1124 assert( n>5 && n<=9 );
1125 *v = (u32)v64;
1126 return n;
1127 }
1128#endif
1129}
1130
1131/*
1132** Return the number of bytes that will be needed to store the given
1133** 64-bit integer.
1134*/
1135int sqlite3VarintLen(u64 v){
drh59a53642015-09-01 22:29:07 +00001136 int i;
drh6f17c092016-03-04 21:18:09 +00001137 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); }
drhc81c11f2009-11-10 01:30:52 +00001138 return i;
1139}
1140
1141
1142/*
1143** Read or write a four-byte big-endian integer value.
1144*/
1145u32 sqlite3Get4byte(const u8 *p){
drh5372e4d2015-06-30 12:47:09 +00001146#if SQLITE_BYTEORDER==4321
1147 u32 x;
1148 memcpy(&x,p,4);
1149 return x;
drhdc5ece82017-02-15 15:09:09 +00001150#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
drh5372e4d2015-06-30 12:47:09 +00001151 u32 x;
1152 memcpy(&x,p,4);
1153 return __builtin_bswap32(x);
drha39284b2017-02-09 17:12:22 +00001154#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
mistachkin647ca462015-06-30 17:28:40 +00001155 u32 x;
1156 memcpy(&x,p,4);
1157 return _byteswap_ulong(x);
drh5372e4d2015-06-30 12:47:09 +00001158#else
drh693e6712014-01-24 22:58:00 +00001159 testcase( p[0]&0x80 );
1160 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
drh5372e4d2015-06-30 12:47:09 +00001161#endif
drhc81c11f2009-11-10 01:30:52 +00001162}
1163void sqlite3Put4byte(unsigned char *p, u32 v){
drh5372e4d2015-06-30 12:47:09 +00001164#if SQLITE_BYTEORDER==4321
1165 memcpy(p,&v,4);
drhdc5ece82017-02-15 15:09:09 +00001166#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
drh5372e4d2015-06-30 12:47:09 +00001167 u32 x = __builtin_bswap32(v);
1168 memcpy(p,&x,4);
drha39284b2017-02-09 17:12:22 +00001169#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
mistachkin647ca462015-06-30 17:28:40 +00001170 u32 x = _byteswap_ulong(v);
1171 memcpy(p,&x,4);
drh5372e4d2015-06-30 12:47:09 +00001172#else
drhc81c11f2009-11-10 01:30:52 +00001173 p[0] = (u8)(v>>24);
1174 p[1] = (u8)(v>>16);
1175 p[2] = (u8)(v>>8);
1176 p[3] = (u8)v;
drh5372e4d2015-06-30 12:47:09 +00001177#endif
drhc81c11f2009-11-10 01:30:52 +00001178}
1179
drh9296c182014-07-23 13:40:49 +00001180
1181
1182/*
1183** Translate a single byte of Hex into an integer.
1184** This routine only works if h really is a valid hexadecimal
1185** character: 0..9a..fA..F
1186*/
1187u8 sqlite3HexToInt(int h){
1188 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
1189#ifdef SQLITE_ASCII
1190 h += 9*(1&(h>>6));
1191#endif
1192#ifdef SQLITE_EBCDIC
1193 h += 9*(1&~(h>>4));
1194#endif
1195 return (u8)(h & 0xf);
1196}
1197
drhc81c11f2009-11-10 01:30:52 +00001198#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
1199/*
1200** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
1201** value. Return a pointer to its binary value. Space to hold the
1202** binary value has been obtained from malloc and must be freed by
1203** the calling routine.
1204*/
1205void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
1206 char *zBlob;
1207 int i;
1208
drh575fad62016-02-05 13:38:36 +00001209 zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
drhc81c11f2009-11-10 01:30:52 +00001210 n--;
1211 if( zBlob ){
1212 for(i=0; i<n; i+=2){
dancd74b612011-04-22 19:37:32 +00001213 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
drhc81c11f2009-11-10 01:30:52 +00001214 }
1215 zBlob[i/2] = 0;
1216 }
1217 return zBlob;
1218}
1219#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
1220
drh413c3d32010-02-23 20:11:56 +00001221/*
1222** Log an error that is an API call on a connection pointer that should
1223** not have been used. The "type" of connection pointer is given as the
1224** argument. The zType is a word like "NULL" or "closed" or "invalid".
1225*/
1226static void logBadConnection(const char *zType){
1227 sqlite3_log(SQLITE_MISUSE,
1228 "API call with %s database connection pointer",
1229 zType
1230 );
1231}
drhc81c11f2009-11-10 01:30:52 +00001232
1233/*
drhc81c11f2009-11-10 01:30:52 +00001234** Check to make sure we have a valid db pointer. This test is not
1235** foolproof but it does provide some measure of protection against
1236** misuse of the interface such as passing in db pointers that are
1237** NULL or which have been previously closed. If this routine returns
1238** 1 it means that the db pointer is valid and 0 if it should not be
1239** dereferenced for any reason. The calling function should invoke
1240** SQLITE_MISUSE immediately.
1241**
1242** sqlite3SafetyCheckOk() requires that the db pointer be valid for
1243** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
1244** open properly and is not fit for general use but which can be
1245** used as an argument to sqlite3_errmsg() or sqlite3_close().
1246*/
1247int sqlite3SafetyCheckOk(sqlite3 *db){
1248 u32 magic;
drh413c3d32010-02-23 20:11:56 +00001249 if( db==0 ){
1250 logBadConnection("NULL");
1251 return 0;
1252 }
drhc81c11f2009-11-10 01:30:52 +00001253 magic = db->magic;
drh9978c972010-02-23 17:36:32 +00001254 if( magic!=SQLITE_MAGIC_OPEN ){
drhe294da02010-02-25 23:44:15 +00001255 if( sqlite3SafetyCheckSickOrOk(db) ){
1256 testcase( sqlite3GlobalConfig.xLog!=0 );
drh413c3d32010-02-23 20:11:56 +00001257 logBadConnection("unopened");
1258 }
drhc81c11f2009-11-10 01:30:52 +00001259 return 0;
1260 }else{
1261 return 1;
1262 }
1263}
1264int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
1265 u32 magic;
1266 magic = db->magic;
1267 if( magic!=SQLITE_MAGIC_SICK &&
1268 magic!=SQLITE_MAGIC_OPEN &&
drh413c3d32010-02-23 20:11:56 +00001269 magic!=SQLITE_MAGIC_BUSY ){
drhe294da02010-02-25 23:44:15 +00001270 testcase( sqlite3GlobalConfig.xLog!=0 );
drhaf46dc12010-02-24 21:44:07 +00001271 logBadConnection("invalid");
drh413c3d32010-02-23 20:11:56 +00001272 return 0;
1273 }else{
1274 return 1;
1275 }
drhc81c11f2009-11-10 01:30:52 +00001276}
drh158b9cb2011-03-05 20:59:46 +00001277
1278/*
1279** Attempt to add, substract, or multiply the 64-bit signed value iB against
1280** the other 64-bit signed integer at *pA and store the result in *pA.
1281** Return 0 on success. Or if the operation would have resulted in an
1282** overflow, leave *pA unchanged and return 1.
1283*/
1284int sqlite3AddInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001285#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001286 return __builtin_add_overflow(*pA, iB, pA);
1287#else
drh158b9cb2011-03-05 20:59:46 +00001288 i64 iA = *pA;
1289 testcase( iA==0 ); testcase( iA==1 );
1290 testcase( iB==-1 ); testcase( iB==0 );
1291 if( iB>=0 ){
1292 testcase( iA>0 && LARGEST_INT64 - iA == iB );
1293 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
1294 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
drh158b9cb2011-03-05 20:59:46 +00001295 }else{
1296 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
1297 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
1298 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
drh158b9cb2011-03-05 20:59:46 +00001299 }
drh53a6eb32014-02-10 12:59:15 +00001300 *pA += iB;
drh158b9cb2011-03-05 20:59:46 +00001301 return 0;
drh4a477612017-01-03 17:33:43 +00001302#endif
drh158b9cb2011-03-05 20:59:46 +00001303}
1304int sqlite3SubInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001305#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001306 return __builtin_sub_overflow(*pA, iB, pA);
1307#else
drh158b9cb2011-03-05 20:59:46 +00001308 testcase( iB==SMALLEST_INT64+1 );
1309 if( iB==SMALLEST_INT64 ){
1310 testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
1311 if( (*pA)>=0 ) return 1;
1312 *pA -= iB;
1313 return 0;
1314 }else{
1315 return sqlite3AddInt64(pA, -iB);
1316 }
drh4a477612017-01-03 17:33:43 +00001317#endif
drh158b9cb2011-03-05 20:59:46 +00001318}
drh158b9cb2011-03-05 20:59:46 +00001319int sqlite3MulInt64(i64 *pA, i64 iB){
drhb9772e72017-09-12 13:27:43 +00001320#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
drh4a477612017-01-03 17:33:43 +00001321 return __builtin_mul_overflow(*pA, iB, pA);
1322#else
drh158b9cb2011-03-05 20:59:46 +00001323 i64 iA = *pA;
drh09952c62016-09-20 22:04:05 +00001324 if( iB>0 ){
1325 if( iA>LARGEST_INT64/iB ) return 1;
1326 if( iA<SMALLEST_INT64/iB ) return 1;
1327 }else if( iB<0 ){
1328 if( iA>0 ){
1329 if( iB<SMALLEST_INT64/iA ) return 1;
1330 }else if( iA<0 ){
1331 if( iB==SMALLEST_INT64 ) return 1;
1332 if( iA==SMALLEST_INT64 ) return 1;
1333 if( -iA>LARGEST_INT64/-iB ) return 1;
drh53a6eb32014-02-10 12:59:15 +00001334 }
drh53a6eb32014-02-10 12:59:15 +00001335 }
drh09952c62016-09-20 22:04:05 +00001336 *pA = iA*iB;
drh158b9cb2011-03-05 20:59:46 +00001337 return 0;
drh4a477612017-01-03 17:33:43 +00001338#endif
drh158b9cb2011-03-05 20:59:46 +00001339}
drhd50ffc42011-03-08 02:38:28 +00001340
1341/*
1342** Compute the absolute value of a 32-bit signed integer, of possible. Or
1343** if the integer has a value of -2147483648, return +2147483647
1344*/
1345int sqlite3AbsInt32(int x){
1346 if( x>=0 ) return x;
drh87e79ae2011-03-08 13:06:41 +00001347 if( x==(int)0x80000000 ) return 0x7fffffff;
drhd50ffc42011-03-08 02:38:28 +00001348 return -x;
1349}
drh81cc5162011-05-17 20:36:21 +00001350
1351#ifdef SQLITE_ENABLE_8_3_NAMES
1352/*
drhb51bf432011-07-21 21:29:35 +00001353** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
drh81cc5162011-05-17 20:36:21 +00001354** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
1355** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
1356** three characters, then shorten the suffix on z[] to be the last three
1357** characters of the original suffix.
1358**
drhb51bf432011-07-21 21:29:35 +00001359** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
1360** do the suffix shortening regardless of URI parameter.
1361**
drh81cc5162011-05-17 20:36:21 +00001362** Examples:
1363**
1364** test.db-journal => test.nal
1365** test.db-wal => test.wal
1366** test.db-shm => test.shm
drhf5808602011-12-16 00:33:04 +00001367** test.db-mj7f3319fa => test.9fa
drh81cc5162011-05-17 20:36:21 +00001368*/
1369void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
drhb51bf432011-07-21 21:29:35 +00001370#if SQLITE_ENABLE_8_3_NAMES<2
drh7d39e172012-01-02 12:41:53 +00001371 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
drhb51bf432011-07-21 21:29:35 +00001372#endif
1373 {
drh81cc5162011-05-17 20:36:21 +00001374 int i, sz;
1375 sz = sqlite3Strlen30(z);
drhc83f2d42011-05-18 02:41:10 +00001376 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
drhc02a43a2012-01-10 23:18:38 +00001377 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
drh81cc5162011-05-17 20:36:21 +00001378 }
1379}
1380#endif
drhbf539c42013-10-05 18:16:02 +00001381
1382/*
1383** Find (an approximate) sum of two LogEst values. This computation is
1384** not a simple "+" operator because LogEst is stored as a logarithmic
1385** value.
1386**
1387*/
1388LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
1389 static const unsigned char x[] = {
1390 10, 10, /* 0,1 */
1391 9, 9, /* 2,3 */
1392 8, 8, /* 4,5 */
1393 7, 7, 7, /* 6,7,8 */
1394 6, 6, 6, /* 9,10,11 */
1395 5, 5, 5, /* 12-14 */
1396 4, 4, 4, 4, /* 15-18 */
1397 3, 3, 3, 3, 3, 3, /* 19-24 */
1398 2, 2, 2, 2, 2, 2, 2, /* 25-31 */
1399 };
1400 if( a>=b ){
1401 if( a>b+49 ) return a;
1402 if( a>b+31 ) return a+1;
1403 return a+x[a-b];
1404 }else{
1405 if( b>a+49 ) return b;
1406 if( b>a+31 ) return b+1;
1407 return b+x[b-a];
1408 }
1409}
1410
1411/*
drh224155d2014-04-30 13:19:09 +00001412** Convert an integer into a LogEst. In other words, compute an
1413** approximation for 10*log2(x).
drhbf539c42013-10-05 18:16:02 +00001414*/
1415LogEst sqlite3LogEst(u64 x){
1416 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
1417 LogEst y = 40;
1418 if( x<8 ){
1419 if( x<2 ) return 0;
1420 while( x<8 ){ y -= 10; x <<= 1; }
1421 }else{
drhceb4b1d2017-08-17 20:53:07 +00001422#if GCC_VERSION>=5004000
1423 int i = 60 - __builtin_clzll(x);
1424 y += i*10;
1425 x >>= i;
1426#else
drh75ab50c2016-04-28 14:15:12 +00001427 while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/
drhbf539c42013-10-05 18:16:02 +00001428 while( x>15 ){ y += 10; x >>= 1; }
drhceb4b1d2017-08-17 20:53:07 +00001429#endif
drhbf539c42013-10-05 18:16:02 +00001430 }
1431 return a[x&7] + y - 10;
1432}
1433
1434#ifndef SQLITE_OMIT_VIRTUALTABLE
1435/*
1436** Convert a double into a LogEst
1437** In other words, compute an approximation for 10*log2(x).
1438*/
1439LogEst sqlite3LogEstFromDouble(double x){
1440 u64 a;
1441 LogEst e;
1442 assert( sizeof(x)==8 && sizeof(a)==8 );
1443 if( x<=1 ) return 0;
1444 if( x<=2000000000 ) return sqlite3LogEst((u64)x);
1445 memcpy(&a, &x, 8);
1446 e = (a>>52) - 1022;
1447 return e*10;
1448}
1449#endif /* SQLITE_OMIT_VIRTUALTABLE */
1450
drh14bfd992016-03-05 14:00:09 +00001451#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
drhd566c952016-02-25 21:19:03 +00001452 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
1453 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
drhbf539c42013-10-05 18:16:02 +00001454/*
1455** Convert a LogEst into an integer.
drhd566c952016-02-25 21:19:03 +00001456**
1457** Note that this routine is only used when one or more of various
1458** non-standard compile-time options is enabled.
drhbf539c42013-10-05 18:16:02 +00001459*/
1460u64 sqlite3LogEstToInt(LogEst x){
1461 u64 n;
drhbf539c42013-10-05 18:16:02 +00001462 n = x%10;
1463 x /= 10;
1464 if( n>=5 ) n -= 2;
1465 else if( n>=1 ) n -= 1;
drhecdf20d2016-03-10 14:28:24 +00001466#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
1467 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
1468 if( x>60 ) return (u64)LARGEST_INT64;
1469#else
1470 /* If only SQLITE_ENABLE_STAT3_OR_STAT4 is on, then the largest input
1471 ** possible to this routine is 310, resulting in a maximum x of 31 */
1472 assert( x<=60 );
1473#endif
1474 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x);
drhbf539c42013-10-05 18:16:02 +00001475}
drhd566c952016-02-25 21:19:03 +00001476#endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */
drh9bf755c2016-12-23 03:59:31 +00001477
1478/*
1479** Add a new name/number pair to a VList. This might require that the
1480** VList object be reallocated, so return the new VList. If an OOM
drhce1bbe52016-12-23 13:52:45 +00001481** error occurs, the original VList returned and the
drh9bf755c2016-12-23 03:59:31 +00001482** db->mallocFailed flag is set.
1483**
1484** A VList is really just an array of integers. To destroy a VList,
1485** simply pass it to sqlite3DbFree().
1486**
1487** The first integer is the number of integers allocated for the whole
1488** VList. The second integer is the number of integers actually used.
1489** Each name/number pair is encoded by subsequent groups of 3 or more
1490** integers.
1491**
drhce1bbe52016-12-23 13:52:45 +00001492** Each name/number pair starts with two integers which are the numeric
drh9bf755c2016-12-23 03:59:31 +00001493** value for the pair and the size of the name/number pair, respectively.
1494** The text name overlays one or more following integers. The text name
1495** is always zero-terminated.
drhce1bbe52016-12-23 13:52:45 +00001496**
1497** Conceptually:
1498**
1499** struct VList {
1500** int nAlloc; // Number of allocated slots
1501** int nUsed; // Number of used slots
1502** struct VListEntry {
1503** int iValue; // Value for this entry
1504** int nSlot; // Slots used by this entry
1505** // ... variable name goes here
1506** } a[0];
1507** }
1508**
1509** During code generation, pointers to the variable names within the
1510** VList are taken. When that happens, nAlloc is set to zero as an
1511** indication that the VList may never again be enlarged, since the
1512** accompanying realloc() would invalidate the pointers.
drh9bf755c2016-12-23 03:59:31 +00001513*/
1514VList *sqlite3VListAdd(
1515 sqlite3 *db, /* The database connection used for malloc() */
1516 VList *pIn, /* The input VList. Might be NULL */
1517 const char *zName, /* Name of symbol to add */
1518 int nName, /* Bytes of text in zName */
1519 int iVal /* Value to associate with zName */
1520){
1521 int nInt; /* number of sizeof(int) objects needed for zName */
drhce1bbe52016-12-23 13:52:45 +00001522 char *z; /* Pointer to where zName will be stored */
1523 int i; /* Index in pIn[] where zName is stored */
drh9bf755c2016-12-23 03:59:31 +00001524
1525 nInt = nName/4 + 3;
drhce1bbe52016-12-23 13:52:45 +00001526 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */
drh9bf755c2016-12-23 03:59:31 +00001527 if( pIn==0 || pIn[1]+nInt > pIn[0] ){
1528 /* Enlarge the allocation */
1529 int nAlloc = (pIn ? pIn[0]*2 : 10) + nInt;
1530 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
drhce1bbe52016-12-23 13:52:45 +00001531 if( pOut==0 ) return pIn;
drh9bf755c2016-12-23 03:59:31 +00001532 if( pIn==0 ) pOut[1] = 2;
1533 pIn = pOut;
1534 pIn[0] = nAlloc;
1535 }
1536 i = pIn[1];
1537 pIn[i] = iVal;
1538 pIn[i+1] = nInt;
1539 z = (char*)&pIn[i+2];
1540 pIn[1] = i+nInt;
1541 assert( pIn[1]<=pIn[0] );
1542 memcpy(z, zName, nName);
1543 z[nName] = 0;
1544 return pIn;
1545}
1546
1547/*
1548** Return a pointer to the name of a variable in the given VList that
1549** has the value iVal. Or return a NULL if there is no such variable in
1550** the list
1551*/
1552const char *sqlite3VListNumToName(VList *pIn, int iVal){
1553 int i, mx;
1554 if( pIn==0 ) return 0;
1555 mx = pIn[1];
1556 i = 2;
1557 do{
1558 if( pIn[i]==iVal ) return (char*)&pIn[i+2];
1559 i += pIn[i+1];
1560 }while( i<mx );
1561 return 0;
1562}
1563
1564/*
1565** Return the number of the variable named zName, if it is in VList.
1566** or return 0 if there is no such variable.
1567*/
1568int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
1569 int i, mx;
1570 if( pIn==0 ) return 0;
1571 mx = pIn[1];
1572 i = 2;
1573 do{
1574 const char *z = (const char*)&pIn[i+2];
1575 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
1576 i += pIn[i+1];
1577 }while( i<mx );
1578 return 0;
1579}