/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** Internal interface definitions for SQLite.

**

*/

#ifndef SQLITEINT_H

#define SQLITEINT_H

/* Special Comments:

**

** Some comments have special meaning to the tools that measure test

** coverage:

**

** NO_TEST - The branches on this line are not

** measured by branch coverage. This is

** used on lines of code that actually

** implement parts of coverage testing.

**

** OPTIMIZATION-IF-TRUE - This branch is allowed to always be false

** and the correct answer is still obtained,

** though perhaps more slowly.

**

** OPTIMIZATION-IF-FALSE - This branch is allowed to always be true

** and the correct answer is still obtained,

** though perhaps more slowly.

**

** PREVENTS-HARMLESS-OVERREAD - This branch prevents a buffer overread

** that would be harmless and undetectable

** if it did occur.

**

** In all cases, the special comment must be enclosed in the usual

** slash-asterisk...asterisk-slash comment marks, with no spaces between the

** asterisks and the comment text.

*/

/*

** Make sure the Tcl calling convention macro is defined. This macro is

** only used by test code and Tcl integration code.

*/

#ifndef SQLITE_TCLAPI

# define SQLITE_TCLAPI

#endif

/*

** Include the header file used to customize the compiler options for MSVC.

** This should be done first so that it can successfully prevent spurious

** compiler warnings due to subsequent content in this file and other files

** that are included by this file.

*/

#include "msvc.h"

/*

** Special setup for VxWorks

*/

#include "vxworks.h"

/*

** These #defines should enable >2GB file support on POSIX if the

** underlying operating system supports it. If the OS lacks

** large file support, or if the OS is windows, these should be no-ops.

**

** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any

** system #includes. Hence, this block of code must be the very first

** code in all source files.

**

** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch

** on the compiler command line. This is necessary if you are compiling

** on a recent machine (ex: Red Hat 7.2) but you want your code to work

** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2

** without this option, LFS is enable. But LFS does not exist in the kernel

** in Red Hat 6.0, so the code won't work. Hence, for maximum binary

** portability you should omit LFS.

**

** The previous paragraph was written in 2005. (This paragraph is written

** on 2008-11-28.) These days, all Linux kernels support large files, so

** you should probably leave LFS enabled. But some embedded platforms might

** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.

**

** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.

*/

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE 1

# ifndef _FILE_OFFSET_BITS

# define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

/* The GCC_VERSION and MSVC_VERSION macros are used to

** conditionally include optimizations for each of these compilers. A

** value of 0 means that compiler is not being used. The

** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific

** optimizations, and hence set all compiler macros to 0

**

** There was once also a CLANG_VERSION macro. However, we learn that the

** version numbers in clang are for "marketing" only and are inconsistent

** and unreliable. Fortunately, all versions of clang also recognize the

** gcc version numbers and have reasonable settings for gcc version numbers,

** so the GCC_VERSION macro will be set to a correct non-zero value even

** when compiling with clang.

*/

#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC)

# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)

#else

# define GCC_VERSION 0

#endif

#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)

# define MSVC_VERSION _MSC_VER

#else

# define MSVC_VERSION 0

#endif

/*

** Some C99 functions in "math.h" are only present for MSVC when its version

** is associated with Visual Studio 2013 or higher.

*/

#ifndef SQLITE_HAVE_C99_MATH_FUNCS

# if MSVC_VERSION==0 || MSVC_VERSION>=1800

# define SQLITE_HAVE_C99_MATH_FUNCS (1)

# else

# define SQLITE_HAVE_C99_MATH_FUNCS (0)

# endif

#endif

/* Needed for various definitions... */

#if defined(__GNUC__) && !defined(_GNU_SOURCE)

# define _GNU_SOURCE

#endif

#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)

# define _BSD_SOURCE

#endif

/*

** Macro to disable warnings about missing "break" at the end of a "case".

*/

#if GCC_VERSION>=7000000

# define deliberate_fall_through __attribute__((fallthrough));

#else

# define deliberate_fall_through

#endif

/*

** For MinGW, check to see if we can include the header file containing its

** version information, among other things. Normally, this internal MinGW

** header file would [only] be included automatically by other MinGW header

** files; however, the contained version information is now required by this

** header file to work around binary compatibility issues (see below) and

** this is the only known way to reliably obtain it. This entire #if block

** would be completely unnecessary if there was any other way of detecting

** MinGW via their preprocessor (e.g. if they customized their GCC to define

** some MinGW-specific macros). When compiling for MinGW, either the

** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be

** defined; otherwise, detection of conditions specific to MinGW will be

** disabled.

*/

#if defined(_HAVE_MINGW_H)

# include "mingw.h"

#elif defined(_HAVE__MINGW_H)

# include "_mingw.h"

#endif

/*

** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T

** define is required to maintain binary compatibility with the MSVC runtime

** library in use (e.g. for Windows XP).

*/

#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \

defined(_WIN32) && !defined(_WIN64) && \

defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \

defined(__MSVCRT__)

# define _USE_32BIT_TIME_T

#endif

/* Optionally #include a user-defined header, whereby compilation options

** may be set prior to where they take effect, but after platform setup.

** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include

** file.

*/

#ifdef SQLITE_CUSTOM_INCLUDE

# define INC_STRINGIFY_(f) #f

# define INC_STRINGIFY(f) INC_STRINGIFY_(f)

# include INC_STRINGIFY(SQLITE_CUSTOM_INCLUDE)

#endif

/* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear

** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for

** MinGW.

*/

#include "sqlite3.h"

/*

** Reuse the STATIC_LRU for mutex access to sqlite3_temp_directory.

*/

#define SQLITE_MUTEX_STATIC_TEMPDIR SQLITE_MUTEX_STATIC_VFS1

/*

** Include the configuration header output by 'configure' if we're using the

** autoconf-based build

*/

#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)

#include "sqlite_cfg.h"

#define SQLITECONFIG_H 1

#endif

#include "sqliteLimit.h"

/* Disable nuisance warnings on Borland compilers */

#if defined(__BORLANDC__)

#pragma warn -rch /* unreachable code */

#pragma warn -ccc /* Condition is always true or false */

#pragma warn -aus /* Assigned value is never used */

#pragma warn -csu /* Comparing signed and unsigned */

#pragma warn -spa /* Suspicious pointer arithmetic */

#endif

/*

** A few places in the code require atomic load/store of aligned

** integer values.

*/

#ifndef __has_extension

# define __has_extension(x) 0 /* compatibility with non-clang compilers */

#endif

#if GCC_VERSION>=4007000 || __has_extension(c_atomic)

# define SQLITE_ATOMIC_INTRINSICS 1

# define AtomicLoad(PTR) __atomic_load_n((PTR),__ATOMIC_RELAXED)

# define AtomicStore(PTR,VAL) __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED)

#else

# define SQLITE_ATOMIC_INTRINSICS 0

# define AtomicLoad(PTR) (*(PTR))

# define AtomicStore(PTR,VAL) (*(PTR) = (VAL))

#endif

/*

** Include standard header files as necessary

*/

#ifdef HAVE_STDINT_H

#include <stdint.h>

#endif

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#endif

/*

** The following macros are used to cast pointers to integers and

** integers to pointers. The way you do this varies from one compiler

** to the next, so we have developed the following set of #if statements

** to generate appropriate macros for a wide range of compilers.

**

** The correct "ANSI" way to do this is to use the intptr_t type.

** Unfortunately, that typedef is not available on all compilers, or

** if it is available, it requires an #include of specific headers

** that vary from one machine to the next.

**

** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on

** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).

** So we have to define the macros in different ways depending on the

** compiler.

*/

#if defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */

# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))

#elif defined(__PTRDIFF_TYPE__) /* This case should work for GCC */

# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))

#elif !defined(__GNUC__) /* Works for compilers other than LLVM */

# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])

# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))

#else /* Generates a warning - but it always works */

# define SQLITE_INT_TO_PTR(X) ((void*)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(X))

#endif

/*

** Macros to hint to the compiler that a function should or should not be

** inlined.

*/

#if defined(__GNUC__)

# define SQLITE_NOINLINE __attribute__((noinline))

# define SQLITE_INLINE __attribute__((always_inline)) inline

#elif defined(_MSC_VER) && _MSC_VER>=1310

# define SQLITE_NOINLINE __declspec(noinline)

# define SQLITE_INLINE __forceinline

#else

# define SQLITE_NOINLINE

# define SQLITE_INLINE

#endif

#if defined(SQLITE_COVERAGE_TEST) || defined(__STRICT_ANSI__)

# undef SQLITE_INLINE

# define SQLITE_INLINE

#endif

/*

** Make sure that the compiler intrinsics we desire are enabled when

** compiling with an appropriate version of MSVC unless prevented by

** the SQLITE_DISABLE_INTRINSIC define.

*/

#if !defined(SQLITE_DISABLE_INTRINSIC)

# if defined(_MSC_VER) && _MSC_VER>=1400

# if !defined(_WIN32_WCE)

# include <intrin.h>

# pragma intrinsic(_byteswap_ushort)

# pragma intrinsic(_byteswap_ulong)

# pragma intrinsic(_byteswap_uint64)

# pragma intrinsic(_ReadWriteBarrier)

# else

# include <cmnintrin.h>

# endif

# endif

#endif

/*

** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.

** 0 means mutexes are permanently disable and the library is never

** threadsafe. 1 means the library is serialized which is the highest

** level of threadsafety. 2 means the library is multithreaded - multiple

** threads can use SQLite as long as no two threads try to use the same

** database connection at the same time.

**

** Older versions of SQLite used an optional THREADSAFE macro.

** We support that for legacy.

**

** To ensure that the correct value of "THREADSAFE" is reported when querying

** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this

** logic is partially replicated in ctime.c. If it is updated here, it should

** also be updated there.

*/

#if !defined(SQLITE_THREADSAFE)

# if defined(THREADSAFE)

# define SQLITE_THREADSAFE THREADSAFE

# else

# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

# endif

#endif

/*

** Powersafe overwrite is on by default. But can be turned off using

** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.

*/

#ifndef SQLITE_POWERSAFE_OVERWRITE

# define SQLITE_POWERSAFE_OVERWRITE 1

#endif

/*

** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by

** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in

** which case memory allocation statistics are disabled by default.

*/

#if !defined(SQLITE_DEFAULT_MEMSTATUS)

# define SQLITE_DEFAULT_MEMSTATUS 1

#endif

/*

** Exactly one of the following macros must be defined in order to

** specify which memory allocation subsystem to use.

**

** SQLITE_SYSTEM_MALLOC // Use normal system malloc()

** SQLITE_WIN32_MALLOC // Use Win32 native heap API

** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails

** SQLITE_MEMDEBUG // Debugging version of system malloc()

**

** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the

** assert() macro is enabled, each call into the Win32 native heap subsystem

** will cause HeapValidate to be called. If heap validation should fail, an

** assertion will be triggered.

**

** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as

** the default.

*/

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)>1

# error "Two or more of the following compile-time configuration options\

are defined but at most one is allowed:\

SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\

SQLITE_ZERO_MALLOC"

#endif

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)==0

# define SQLITE_SYSTEM_MALLOC 1

#endif

/*

** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the

** sizes of memory allocations below this value where possible.

*/

#if !defined(SQLITE_MALLOC_SOFT_LIMIT)

# define SQLITE_MALLOC_SOFT_LIMIT 1024

#endif

/*

** We need to define _XOPEN_SOURCE as follows in order to enable

** recursive mutexes on most Unix systems and fchmod() on OpenBSD.

** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit

** it.

*/

#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)

# define _XOPEN_SOURCE 600

#endif

/*

** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that

** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,

** make it true by defining or undefining NDEBUG.

**

** Setting NDEBUG makes the code smaller and faster by disabling the

** assert() statements in the code. So we want the default action

** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG

** is set. Thus NDEBUG becomes an opt-in rather than an opt-out

** feature.

*/

#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)

# define NDEBUG 1

#endif

#if defined(NDEBUG) && defined(SQLITE_DEBUG)

# undef NDEBUG

#endif

/*

** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.

*/

#if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)

# define SQLITE_ENABLE_EXPLAIN_COMMENTS 1

#endif

/*

** The testcase() macro is used to aid in coverage testing. When

** doing coverage testing, the condition inside the argument to

** testcase() must be evaluated both true and false in order to

** get full branch coverage. The testcase() macro is inserted

** to help ensure adequate test coverage in places where simple

** condition/decision coverage is inadequate. For example, testcase()

** can be used to make sure boundary values are tested. For

** bitmask tests, testcase() can be used to make sure each bit

** is significant and used at least once. On switch statements

** where multiple cases go to the same block of code, testcase()

** can insure that all cases are evaluated.

*/

#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)

# ifndef SQLITE_AMALGAMATION

extern unsigned int sqlite3CoverageCounter;

# endif

# define testcase(X) if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; }

#else

# define testcase(X)

#endif

/*

** The TESTONLY macro is used to enclose variable declarations or

** other bits of code that are needed to support the arguments

** within testcase() and assert() macros.

*/

#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)

# define TESTONLY(X) X

#else

# define TESTONLY(X)

#endif

/*

** Sometimes we need a small amount of code such as a variable initialization

** to setup for a later assert() statement. We do not want this code to

** appear when assert() is disabled. The following macro is therefore

** used to contain that setup code. The "VVA" acronym stands for

** "Verification, Validation, and Accreditation". In other words, the

** code within VVA_ONLY() will only run during verification processes.

*/

#ifndef NDEBUG

# define VVA_ONLY(X) X

#else

# define VVA_ONLY(X)

#endif

/*

** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage

** and mutation testing

*/

#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)

# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1

#endif

/*

** The ALWAYS and NEVER macros surround boolean expressions which

** are intended to always be true or false, respectively. Such

** expressions could be omitted from the code completely. But they

** are included in a few cases in order to enhance the resilience

** of SQLite to unexpected behavior - to make the code "self-healing"

** or "ductile" rather than being "brittle" and crashing at the first

** hint of unplanned behavior.

**

** In other words, ALWAYS and NEVER are added for defensive code.

**

** When doing coverage testing ALWAYS and NEVER are hard-coded to

** be true and false so that the unreachable code they specify will

** not be counted as untested code.

*/

#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)

# define ALWAYS(X) (1)

# define NEVER(X) (0)

#elif !defined(NDEBUG)

# define ALWAYS(X) ((X)?1:(assert(0),0))

# define NEVER(X) ((X)?(assert(0),1):0)

#else

# define ALWAYS(X) (X)

# define NEVER(X) (X)

#endif

/*

** Some conditionals are optimizations only. In other words, if the

** conditionals are replaced with a constant 1 (true) or 0 (false) then

** the correct answer is still obtained, though perhaps not as quickly.

**

** The following macros mark these optimizations conditionals.

*/

#if defined(SQLITE_MUTATION_TEST)

# define OK_IF_ALWAYS_TRUE(X) (1)

# define OK_IF_ALWAYS_FALSE(X) (0)

#else

# define OK_IF_ALWAYS_TRUE(X) (X)

# define OK_IF_ALWAYS_FALSE(X) (X)

#endif

/*

** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is

** defined. We need to defend against those failures when testing with

** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches

** during a normal build. The following macro can be used to disable tests

** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.

*/

#if defined(SQLITE_TEST_REALLOC_STRESS)

# define ONLY_IF_REALLOC_STRESS(X) (X)

#elif !defined(NDEBUG)

# define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0)

#else

# define ONLY_IF_REALLOC_STRESS(X) (0)

#endif

/*

** Declarations used for tracing the operating system interfaces.

*/

#if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \

(defined(SQLITE_DEBUG) && SQLITE_OS_WIN)

extern int sqlite3OSTrace;

# define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X

# define SQLITE_HAVE_OS_TRACE

#else

# define OSTRACE(X)

# undef SQLITE_HAVE_OS_TRACE

#endif

/*

** Is the sqlite3ErrName() function needed in the build? Currently,

** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when

** OSTRACE is enabled), and by several "test*.c" files (which are

** compiled using SQLITE_TEST).

*/

#if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \

(defined(SQLITE_DEBUG) && SQLITE_OS_WIN)

# define SQLITE_NEED_ERR_NAME

#else

# undef SQLITE_NEED_ERR_NAME

#endif

/*

** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN

*/

#ifdef SQLITE_OMIT_EXPLAIN

# undef SQLITE_ENABLE_EXPLAIN_COMMENTS

#endif

/*

** SQLITE_OMIT_VIRTUALTABLE implies SQLITE_OMIT_ALTERTABLE

*/

#if defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_ALTERTABLE)

# define SQLITE_OMIT_ALTERTABLE

#endif

/*

** Return true (non-zero) if the input is an integer that is too large

** to fit in 32-bits. This macro is used inside of various testcase()

** macros to verify that we have tested SQLite for large-file support.

*/

#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)

/*

** The macro unlikely() is a hint that surrounds a boolean

** expression that is usually false. Macro likely() surrounds

** a boolean expression that is usually true. These hints could,

** in theory, be used by the compiler to generate better code, but

** currently they are just comments for human readers.

*/

#define likely(X) (X)

#define unlikely(X) (X)

#include "hash.h"

#include "parse.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <stddef.h>

/*

** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.

** This allows better measurements of where memcpy() is used when running

** cachegrind. But this macro version of memcpy() is very slow so it

** should not be used in production. This is a performance measurement

** hack only.

*/

#ifdef SQLITE_INLINE_MEMCPY

# define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\

int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}

#endif

/*

** If compiling for a processor that lacks floating point support,

** substitute integer for floating-point

*/

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite_int64

# define float sqlite_int64

# define LONGDOUBLE_TYPE sqlite_int64

# ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)

# endif

# define SQLITE_OMIT_DATETIME_FUNCS 1

# define SQLITE_OMIT_TRACE 1

# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT

# undef SQLITE_HAVE_ISNAN

#endif

#ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (1e99)

#endif

/*

** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0

** afterward. Having this macro allows us to cause the C compiler

** to omit code used by TEMP tables without messy #ifndef statements.

*/

#ifdef SQLITE_OMIT_TEMPDB

#define OMIT_TEMPDB 1

#else

#define OMIT_TEMPDB 0

#endif

/*

** The "file format" number is an integer that is incremented whenever

** the VDBE-level file format changes. The following macros define the

** the default file format for new databases and the maximum file format

** that the library can read.

*/

#define SQLITE_MAX_FILE_FORMAT 4

#ifndef SQLITE_DEFAULT_FILE_FORMAT

# define SQLITE_DEFAULT_FILE_FORMAT 4

#endif

/*

** Determine whether triggers are recursive by default. This can be

** changed at run-time using a pragma.

*/

#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS

# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

#endif

/*

** Provide a default value for SQLITE_TEMP_STORE in case it is not specified

** on the command-line

*/

#ifndef SQLITE_TEMP_STORE

# define SQLITE_TEMP_STORE 1

#endif

/*

** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if

** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it

** to zero.

*/

#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0

# undef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS 0

#endif

#ifndef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS 8

#endif

#ifndef SQLITE_DEFAULT_WORKER_THREADS

# define SQLITE_DEFAULT_WORKER_THREADS 0

#endif

#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS

# undef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS

#endif

/*

** The default initial allocation for the pagecache when using separate

** pagecaches for each database connection. A positive number is the

** number of pages. A negative number N translations means that a buffer

** of -1024*N bytes is allocated and used for as many pages as it will hold.

**

** The default value of "20" was chosen to minimize the run-time of the

** speedtest1 test program with options: --shrink-memory --reprepare

*/

#ifndef SQLITE_DEFAULT_PCACHE_INITSZ

# define SQLITE_DEFAULT_PCACHE_INITSZ 20

#endif

/*

** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option.

*/

#ifndef SQLITE_DEFAULT_SORTERREF_SIZE

# define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff

#endif

/*

** The compile-time options SQLITE_MMAP_READWRITE and

** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another.

** You must choose one or the other (or neither) but not both.

*/

#if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)

#error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE

#endif

/*

** GCC does not define the offsetof() macro so we'll have to do it

** ourselves.

*/

#ifndef offsetof

#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))

#endif

/*

** Macros to compute minimum and maximum of two numbers.

*/

#ifndef MIN

# define MIN(A,B) ((A)<(B)?(A):(B))

#endif

#ifndef MAX

# define MAX(A,B) ((A)>(B)?(A):(B))

#endif

/*

** Swap two objects of type TYPE.

*/

#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}

/*

** Check to see if this machine uses EBCDIC. (Yes, believe it or

** not, there are still machines out there that use EBCDIC.)

*/

#if 'A' == '\301'

# define SQLITE_EBCDIC 1

#else

# define SQLITE_ASCII 1

#endif

/*

** Integers of known sizes. These typedefs might change for architectures

** where the sizes very. Preprocessor macros are available so that the

** types can be conveniently redefined at compile-type. Like this:

**

** cc '-DUINTPTR_TYPE=long long int' ...

*/

#ifndef UINT32_TYPE

# ifdef HAVE_UINT32_T

# define UINT32_TYPE uint32_t

# else

# define UINT32_TYPE unsigned int

# endif

#endif

#ifndef UINT16_TYPE

# ifdef HAVE_UINT16_T

# define UINT16_TYPE uint16_t

# else

# define UINT16_TYPE unsigned short int

# endif

#endif

#ifndef INT16_TYPE

# ifdef HAVE_INT16_T

# define INT16_TYPE int16_t

# else

# define INT16_TYPE short int

# endif

#endif

#ifndef UINT8_TYPE

# ifdef HAVE_UINT8_T

# define UINT8_TYPE uint8_t

# else

# define UINT8_TYPE unsigned char

# endif

#endif

#ifndef INT8_TYPE

# ifdef HAVE_INT8_T

# define INT8_TYPE int8_t

# else

# define INT8_TYPE signed char

# endif

#endif

#ifndef LONGDOUBLE_TYPE

# define LONGDOUBLE_TYPE long double

#endif

typedef sqlite_int64 i64; /* 8-byte signed integer */

typedef sqlite_uint64 u64; /* 8-byte unsigned integer */

typedef UINT32_TYPE u32; /* 4-byte unsigned integer */

typedef UINT16_TYPE u16; /* 2-byte unsigned integer */

typedef INT16_TYPE i16; /* 2-byte signed integer */

typedef UINT8_TYPE u8; /* 1-byte unsigned integer */

typedef INT8_TYPE i8; /* 1-byte signed integer */

/*

** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value

** that can be stored in a u32 without loss of data. The value

** is 0x00000000ffffffff. But because of quirks of some compilers, we

** have to specify the value in the less intuitive manner shown:

*/

#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)

/*

** The datatype used to store estimates of the number of rows in a

** table or index.

*/

typedef u64 tRowcnt;

/*

** Estimated quantities used for query planning are stored as 16-bit

** logarithms. For quantity X, the value stored is 10*log2(X). This

** gives a possible range of values of approximately 1.0e986 to 1e-986.

** But the allowed values are "grainy". Not every value is representable.

** For example, quantities 16 and 17 are both represented by a LogEst

** of 40. However, since LogEst quantities are suppose to be estimates,

** not exact values, this imprecision is not a problem.

**

** "LogEst" is short for "Logarithmic Estimate".

**

** Examples:

** 1 -> 0 20 -> 43 10000 -> 132

** 2 -> 10 25 -> 46 25000 -> 146

** 3 -> 16 100 -> 66 1000000 -> 199

** 4 -> 20 1000 -> 99 1048576 -> 200

** 10 -> 33 1024 -> 100 4294967296 -> 320

**

** The LogEst can be negative to indicate fractional values.

** Examples:

**

** 0.5 -> -10 0.1 -> -33 0.0625 -> -40

*/

typedef INT16_TYPE LogEst;

/*

** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer

*/

#ifndef SQLITE_PTRSIZE

# if defined(__SIZEOF_POINTER__)

# define SQLITE_PTRSIZE __SIZEOF_POINTER__

# elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \

defined(_M_ARM) || defined(__arm__) || defined(__x86) || \

(defined(__APPLE__) && defined(__POWERPC__)) || \

(defined(__TOS_AIX__) && !defined(__64BIT__))

# define SQLITE_PTRSIZE 4

# else

# define SQLITE_PTRSIZE 8

# endif

#endif

/* The uptr type is an unsigned integer large enough to hold a pointer

*/

#if defined(HAVE_STDINT_H)

typedef uintptr_t uptr;

#elif SQLITE_PTRSIZE==4

typedef u32 uptr;

#else

typedef u64 uptr;

#endif

/*

** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to

** something between S (inclusive) and E (exclusive).

**

** In other words, S is a buffer and E is a pointer to the first byte after

** the end of buffer S. This macro returns true if P points to something

** contained within the buffer S.

*/

#define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))

/*

** P is one byte past the end of a large buffer. Return true if a span of bytes

** between S..E crosses the end of that buffer. In other words, return true

** if the sub-buffer S..E-1 overflows the buffer whose last byte is P-1.

**

** S is the start of the span. E is one byte past the end of end of span.

**

** P

** |-----------------| FALSE

** |-------|

** S E

**

** P

** |-----------------|

** |-------| TRUE

** S E

**

** P

** |-----------------|

** |-------| FALSE

** S E

*/

#define SQLITE_OVERFLOW(P,S,E) (((uptr)(S)<(uptr)(P))&&((uptr)(E)>(uptr)(P)))

/*

** Macros to determine whether the machine is big or little endian,

** and whether or not that determination is run-time or compile-time.

**

** For best performance, an attempt is made to guess at the byte-order

** using C-preprocessor macros. If that is unsuccessful, or if

** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined

** at run-time.

*/

#ifndef SQLITE_BYTEORDER

# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \

defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \

defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \

defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64)

# define SQLITE_BYTEORDER 1234

# elif defined(sparc) || defined(__ppc__) || \

defined(__ARMEB__) || defined(__AARCH64EB__)

# define SQLITE_BYTEORDER 4321

# else

# define SQLITE_BYTEORDER 0

# endif

#endif

#if SQLITE_BYTEORDER==4321

# define SQLITE_BIGENDIAN 1

# define SQLITE_LITTLEENDIAN 0

# define SQLITE_UTF16NATIVE SQLITE_UTF16BE

#elif SQLITE_BYTEORDER==1234

# define SQLITE_BIGENDIAN 0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE SQLITE_UTF16LE

#else

# ifdef SQLITE_AMALGAMATION

const int sqlite3one = 1;

# else

extern const int sqlite3one;

# endif

# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)

# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#endif

/*

** Constants for the largest and smallest possible 64-bit signed integers.

** These macros are designed to work correctly on both 32-bit and 64-bit

** compilers.

*/

#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))

#define LARGEST_UINT64 (0xffffffff|(((u64)0xffffffff)<<32))

#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

/*

** Round up a number to the next larger multiple of 8. This is used

** to force 8-byte alignment on 64-bit architectures.

**

** ROUND8() always does the rounding, for any argument.

**

** ROUND8P() assumes that the argument is already an integer number of

** pointers in size, and so it is a no-op on systems where the pointer

** size is 8.

*/

#define ROUND8(x) (((x)+7)&~7)

#if SQLITE_PTRSIZE==8

# define ROUND8P(x) (x)

#else

# define ROUND8P(x) (((x)+7)&~7)

#endif

/*

** Round down to the nearest multiple of 8

*/

#define ROUNDDOWN8(x) ((x)&~7)

/*

** Assert that the pointer X is aligned to an 8-byte boundary. This

** macro is used only within assert() to verify that the code gets

** all alignment restrictions correct.

**

** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the

** underlying malloc() implementation might return us 4-byte aligned

** pointers. In that case, only verify 4-byte alignment.

*/

#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC

# define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&3)==0)