sqlcipher/src/sqliteInt.h at ditto · securitykernel/sqlcipher · GitHub

History

4075 lines (3822 loc) · 171 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

** 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_

** 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

/* What version of GCC is being used. 0 means GCC is not being used */

#ifdef __GNUC__

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

#else

# define GCC_VERSION 0

#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

** 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

/* 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"

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

** autoconf-based build

#ifdef _HAVE_SQLITE_CONFIG_H

#include "config.h"

#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

** 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(__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))

#elif 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))

#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

** 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.

#if defined(HAVE_STDINT_H)

# define SQLITE_WITHIN(P,S,E) \

((uintptr_t)(P)>=(uintptr_t)(S) && (uintptr_t)(P)<(uintptr_t)(E))

#else

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

#endif

** A macro to hint to the compiler that a function should not be

** inlined.

#if defined(__GNUC__)

# define SQLITE_NOINLINE __attribute__((noinline))

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

# define SQLITE_NOINLINE __declspec(noinline)

#else

# define SQLITE_NOINLINE

#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>=1300

# if !defined(_WIN32_WCE)

# include <intrin.h>

# pragma intrinsic(_byteswap_ushort)

# pragma intrinsic(_byteswap_ulong)

# pragma intrinsic(_ReadWriteBarrier)

# else

# include <cmnintrin.h>

# 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.

#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.

#ifdef SQLITE_COVERAGE_TEST

void sqlite3Coverage(int);

# define testcase(X) if( X ){ sqlite3Coverage(__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

** 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_COVERAGE_TEST)

# 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 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

** 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>

** 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

# define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */

#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.

#ifndef SQLITE_DEFAULT_PCACHE_INITSZ

# define SQLITE_DEFAULT_PCACHE_INITSZ 100

#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.

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

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

** 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. This is an unsigned integer type. For 99.9% of

** the world, a 32-bit integer is sufficient. But a 64-bit integer

** can be used at compile-time if desired.

#ifdef SQLITE_64BIT_STATS

typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */

#else

typedef u32 tRowcnt; /* 32-bit is the default */

#endif

** 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)

# define SQLITE_PTRSIZE 4

# else

# define SQLITE_PTRSIZE 8

# endif

#endif

** 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_RUNTIME_BYTEORDER=1 is set, then byte-order is determined

** at run-time.

#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(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER)

# define SQLITE_BYTEORDER 1234

# define SQLITE_BIGENDIAN 0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE SQLITE_UTF16LE

#endif

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

&& !defined(SQLITE_RUNTIME_BYTEORDER)

# define SQLITE_BYTEORDER 4321

# define SQLITE_BIGENDIAN 1

# define SQLITE_LITTLEENDIAN 0

# define SQLITE_UTF16NATIVE SQLITE_UTF16BE

#endif

#if !defined(SQLITE_BYTEORDER)

# ifdef SQLITE_AMALGAMATION

const int sqlite3one = 1;

# else

extern const int sqlite3one;

# endif

# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */

# 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 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.

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

** 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) ((((char*)(X) - (char*)0)&3)==0)

#else

# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)

#endif

** Disable MMAP on platforms where it is known to not work

#if defined(__OpenBSD__) || defined(__QNXNTO__)

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

#endif

** Default maximum size of memory used by memory-mapped I/O in the VFS

#ifdef __APPLE__

# include <TargetConditionals.h>

#endif

#ifndef SQLITE_MAX_MMAP_SIZE

# if defined(__linux__) \

|| defined(_WIN32) \

|| (defined(__APPLE__) && defined(__MACH__)) \

|| defined(__sun) \

|| defined(__FreeBSD__) \

|| defined(__DragonFly__)

# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */

# else

# define SQLITE_MAX_MMAP_SIZE 0

# endif

# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

#endif

** The default MMAP_SIZE is zero on all platforms. Or, even if a larger

** default MMAP_SIZE is specified at compile-time, make sure that it does

** not exceed the maximum mmap size.

#ifndef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE 0

# define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */

#endif

#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE

# undef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE

#endif

** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined.

** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also

** define SQLITE_ENABLE_STAT3_OR_STAT4

#ifdef SQLITE_ENABLE_STAT4

# undef SQLITE_ENABLE_STAT3

# define SQLITE_ENABLE_STAT3_OR_STAT4 1

#elif SQLITE_ENABLE_STAT3

# define SQLITE_ENABLE_STAT3_OR_STAT4 1

#elif SQLITE_ENABLE_STAT3_OR_STAT4

# undef SQLITE_ENABLE_STAT3_OR_STAT4

#endif

** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not

** the Select query generator tracing logic is turned on.

#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_SELECTTRACE)

# define SELECTTRACE_ENABLED 1

#else

# define SELECTTRACE_ENABLED 0

#endif

** An instance of the following structure is used to store the busy-handler

** callback for a given sqlite handle.

** The sqlite.busyHandler member of the sqlite struct contains the busy

** callback for the database handle. Each pager opened via the sqlite

** handle is passed a pointer to sqlite.busyHandler. The busy-handler

** callback is currently invoked only from within pager.c.

typedef struct BusyHandler BusyHandler;

struct BusyHandler {

int (*xFunc)(void *,int); /* The busy callback */

void *pArg; /* First arg to busy callback */

int nBusy; /* Incremented with each busy call */

};

** Name of the master database table. The master database table

** is a special table that holds the names and attributes of all

** user tables and indices.

#define MASTER_NAME "sqlite_master"

#define TEMP_MASTER_NAME "sqlite_temp_master"

** The root-page of the master database table.

#define MASTER_ROOT 1

** The name of the schema table.

#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

** A convenience macro that returns the number of elements in

** an array.

#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))

** Determine if the argument is a power of two

#define IsPowerOfTwo(X) (((X)&((X)-1))==0)

** The following value as a destructor means to use sqlite3DbFree().

** The sqlite3DbFree() routine requires two parameters instead of the

** one parameter that destructors normally want. So we have to introduce

** this magic value that the code knows to handle differently. Any

** pointer will work here as long as it is distinct from SQLITE_STATIC

** and SQLITE_TRANSIENT.

#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)

** When SQLITE_OMIT_WSD is defined, it means that the target platform does

** not support Writable Static Data (WSD) such as global and static variables.

** All variables must either be on the stack or dynamically allocated from

** the heap. When WSD is unsupported, the variable declarations scattered

** throughout the SQLite code must become constants instead. The SQLITE_WSD

** macro is used for this purpose. And instead of referencing the variable

** directly, we use its constant as a key to lookup the run-time allocated

** buffer that holds real variable. The constant is also the initializer

** for the run-time allocated buffer.

** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL

** macros become no-ops and have zero performance impact.

#ifdef SQLITE_OMIT_WSD

#define SQLITE_WSD const

#define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))

#define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)

int sqlite3_wsd_init(int N, int J);

void *sqlite3_wsd_find(void *K, int L);

#else

#define SQLITE_WSD

#define GLOBAL(t,v) v

#define sqlite3GlobalConfig sqlite3Config

#endif

** The following macros are used to suppress compiler warnings and to

** make it clear to human readers when a function parameter is deliberately

** left unused within the body of a function. This usually happens when

** a function is called via a function pointer. For example the

** implementation of an SQL aggregate step callback may not use the

** parameter indicating the number of arguments passed to the aggregate,

** if it knows that this is enforced elsewhere.

** When a function parameter is not used at all within the body of a function,

** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.

** However, these macros may also be used to suppress warnings related to

** parameters that may or may not be used depending on compilation options.

** For example those parameters only used in assert() statements. In these

** cases the parameters are named as per the usual conventions.

#define UNUSED_PARAMETER(x) (void)(x)

#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

** Forward references to structures

typedef struct AggInfo AggInfo;

typedef struct AuthContext AuthContext;

typedef struct AutoincInfo AutoincInfo;

typedef struct Bitvec Bitvec;

typedef struct CollSeq CollSeq;

typedef struct Column Column;

typedef struct Db Db;

typedef struct Schema Schema;

typedef struct Expr Expr;

typedef struct ExprList ExprList;

typedef struct ExprSpan ExprSpan;

typedef struct FKey FKey;

typedef struct FuncDestructor FuncDestructor;

typedef struct FuncDef FuncDef;

typedef struct FuncDefHash FuncDefHash;

typedef struct IdList IdList;

typedef struct Index Index;

typedef struct IndexSample IndexSample;

typedef struct KeyClass KeyClass;

typedef struct KeyInfo KeyInfo;

typedef struct Lookaside Lookaside;

typedef struct LookasideSlot LookasideSlot;

typedef struct Module Module;

typedef struct NameContext NameContext;

typedef struct Parse Parse;

typedef struct PrintfArguments PrintfArguments;

typedef struct RowSet RowSet;

typedef struct Savepoint Savepoint;

typedef struct Select Select;

typedef struct SQLiteThread SQLiteThread;

typedef struct SelectDest SelectDest;

typedef struct SrcList SrcList;

typedef struct StrAccum StrAccum;

typedef struct Table Table;

typedef struct TableLock TableLock;

typedef struct Token Token;

typedef struct TreeView TreeView;

typedef struct Trigger Trigger;

typedef struct TriggerPrg TriggerPrg;

typedef struct TriggerStep TriggerStep;

typedef struct UnpackedRecord UnpackedRecord;

typedef struct VTable VTable;

typedef struct VtabCtx VtabCtx;

typedef struct Walker Walker;

typedef struct WhereInfo WhereInfo;

typedef struct With With;

** Defer sourcing vdbe.h and btree.h until after the "u8" and

** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque

** pointer types (i.e. FuncDef) defined above.

#include "btree.h"

#include "vdbe.h"

#include "pager.h"

#include "pcache.h"

#include "os.h"

#include "mutex.h"

View remainder of file in raw view

sqlcipher/src/sqliteInt.h at ditto · securitykernel/sqlcipher · GitHub

Navigation Menu

Expand file tree

Breadcrumbs

sqliteInt.h

Latest commit

History

Breadcrumbs

sqliteInt.h

File metadata and controls

Footer

Footer navigation