Update maxRow size after shrinking the row buffer (CSV).

FossilOrigin-Name: d474195a997b9d94bea8976738c942662f7c4751

.fossil-settings/empty-dirs

@@ -1 +0,0 @@
-compat

.fossil-settings/ignore-glob

@@ -1 +0,0 @@
-compat/*

LICENSE.md

@@ -1,6 +0,0 @@
-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.

Makefile.arm-wince-mingw32ce-gcc

@@ -0,0 +1,138 @@
+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This is a template makefile for SQLite.  Most people prefer to
+# use the autoconf generated "configure" script to generate the
+# makefile automatically.  But that does not work for everybody
+# and in every situation.  If you are having problems with the
+# "configure" script, you might want to try this makefile as an
+# alternative.  Create a copy of this file, edit the parameters
+# below and type "make".
+#
+
+#### The directory where to find the mingw32ce tools
+MINGW32CE = /opt/mingw32ce/bin
+
+#### The target prefix of the mingw32ce tools
+TARGET = arm-wince-mingw32ce
+
+#### The toplevel directory of the source tree.  This is the directory
+#    that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = ../sqlite
+
+#### C Compiler and options for use in building executables that
+#    will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+#BCC = /opt/ancic/bin/c89 -0
+
+#### If the target operating system supports the "usleep()" system
+#    call, then define the HAVE_USLEEP macro for all C modules.
+#
+USLEEP = 
+#USLEEP = -DHAVE_USLEEP=1
+
+#### If you want the SQLite library to be safe for use within a 
+#    multi-threaded program, then define the following macro
+#    appropriately:
+#
+THREADSAFE = -DTHREADSAFE=1
+#THREADSAFE = -DTHREADSAFE=0
+
+#### Specify any extra linker options needed to make the library
+#    thread safe
+#
+#THREADLIB = -lpthread
+THREADLIB = 
+
+#### Specify any extra libraries needed to access required functions.
+#
+#TLIBS = -lrt    # fdatasync on Solaris 8
+TLIBS = 
+
+#### Leave SQLITE_DEBUG undefined for maximum speed.  Use SQLITE_DEBUG=1
+#    to check for memory leaks.  Use SQLITE_DEBUG=2 to print a log of all
+#    malloc()s and free()s in order to track down memory leaks.
+#    
+#    SQLite uses some expensive assert() statements in the inner loop.
+#    You can make the library go almost twice as fast if you compile
+#    with -DNDEBUG=1
+#
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1 -DSQLITE_OS_WIN=1 -D_WIN32_WCE=1
+#OPTS += -DHAVE_FDATASYNC=1
+
+#### The suffix to add to executable files.  ".exe" for windows.
+#    Nothing for unix.
+#
+EXE = .exe
+#EXE =
+
+#### C Compile and options for use in building executables that 
+#    will run on the target platform.  This is usually the same
+#    as BCC, unless you are cross-compiling.
+#
+#TCC = gcc -O6
+#TCC = gcc -g -O0 -Wall
+#TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
+#TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
+TCC = $(MINGW32CE)/$(TARGET)-gcc -O2
+#TCC = /opt/ansic/bin/c89 -O +z -Wl,-a,archive
+
+#### Tools used to build a static library.
+#
+#AR = ar cr
+#AR = /opt/mingw/bin/i386-mingw32-ar cr
+AR = $(MINGW32CE)/$(TARGET)-ar cr
+#RANLIB = ranlib
+#RANLIB = /opt/mingw/bin/i386-mingw32-ranlib
+RANLIB = $(MINGW32CE)/$(TARGET)-ranlib
+
+#MKSHLIB = gcc -shared
+#SO = so
+#SHPREFIX = lib
+MKSHLIB = $(MINGW32CE)/$(TARGET)-gcc -shared
+SO = dll
+SHPREFIX =
+
+#### Extra compiler options needed for programs that use the TCL library.
+#
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.4linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.4win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
+
+#### Linker options needed to link against the TCL library.
+#
+#LIBTCL = -ltcl -lm -ldl
+LIBTCL = /home/drh/tcltk/8.4linux/libtcl8.4g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.4win/libtcl84s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
+
+#### Additional objects for SQLite library when TCL support is enabled.
+TCLOBJ =
+#TCLOBJ = tclsqlite.o
+
+#### Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS =
+#READLINE_FLAGS = -DHAVE_READLINE=1 -I/usr/include/readline
+
+#### Linker options needed by programs using readline() must link against.
+#
+LIBREADLINE =
+#LIBREADLINE = -static -lreadline -ltermcap
+
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
+# You should not have to change anything below this line
+###############################################################################
+include $(TOP)/main.mk

Makefile.linux-gcc

@@ -19,7 +19,7 @@ TOP = ../sqlite
 #### C Compiler and options for use in building executables that
 #    will run on the platform that is doing the build.
 #
-BCC = gcc -g -O0
+BCC = gcc -g -O2
 #BCC = /opt/ancic/bin/c89 -0
 
 #### If the target operating system supports the "usleep()" system
@@ -38,8 +38,8 @@ THREADSAFE = -DTHREADSAFE=0
 #### Specify any extra linker options needed to make the library
 #    thread safe
 #
-THREADLIB = -lpthread -lm -ldl
-#THREADLIB = 
+#THREADLIB = -lpthread
+THREADLIB = 
 
 #### Specify any extra libraries needed to access required functions.
 #
@@ -54,9 +54,11 @@ TLIBS =
 #    You can make the library go almost twice as fast if you compile
 #    with -DNDEBUG=1
 #
-OPTS += -DSQLITE_DEBUG=1
-OPTS += -DSQLITE_ENABLE_WHERETRACE
-OPTS += -DSQLITE_ENABLE_SELECTTRACE
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1
+OPTS += -DHAVE_FDATASYNC=1
 
 #### The suffix to add to executable files.  ".exe" for windows.
 #    Nothing for unix.
@@ -68,7 +70,7 @@ EXE =
 #    will run on the target platform.  This is usually the same
 #    as BCC, unless you are cross-compiling.
 #
-TCC = gcc -O0
+TCC = gcc -O6
 #TCC = gcc -g -O0 -Wall
 #TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
 #TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
@@ -89,12 +91,18 @@ SHPREFIX = lib
 
 #### Extra compiler options needed for programs that use the TCL library.
 #
-TCL_FLAGS = -I/home/drh/tcl/include/tcl8.6
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.4linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.4win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
 
 #### Linker options needed to link against the TCL library.
 #
 #LIBTCL = -ltcl -lm -ldl
-LIBTCL = /home/drh/tcl/lib/libtcl8.6.a -lm -lpthread -ldl -lz
+LIBTCL = /home/drh/tcltk/8.4linux/libtcl8.4g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.4win/libtcl84s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
 
 #### Additional objects for SQLite library when TCL support is enabled.
 #TCLOBJ =
@@ -110,6 +118,11 @@ READLINE_FLAGS =
 LIBREADLINE =
 #LIBREADLINE = -static -lreadline -ltermcap
 
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
 # You should not have to change anything below this line
 ###############################################################################
 include $(TOP)/main.mk

Makefile.vxworks

@@ -0,0 +1,661 @@
+#!/usr/make
+#
+# Makefile for SQLITE on VxWorks
+
+ifeq ($(FORCPU),)
+  FORCPU = SH32gnule
+endif
+
+TOOL_FAMILY = gnu
+
+include $(WIND_USR)/tool/gnu/make.$(FORCPU)
+
+#### The toplevel directory of the source tree.  This is the directory
+#    that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = .
+
+#### C Compiler and options for use in building executables that
+#    will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+#BCC = /opt/ancic/bin/c89 -0
+
+#### If the target operating system supports the "usleep()" system
+#    call, then define the HAVE_USLEEP macro for all C modules.
+#
+USLEEP = 
+#USLEEP = -DHAVE_USLEEP=1
+
+#### If you want the SQLite library to be safe for use within a 
+#    multi-threaded program, then define the following macro
+#    appropriately:
+#
+THREADSAFE = -DSQLITE_THREADSAFE=1
+#THREADSAFE = -DSQLITE_THREADSAFE=0
+
+#### Specify any extra linker options needed to make the library
+#    thread safe
+#
+#THREADLIB = -lpthread
+THREADLIB = 
+
+#### Specify any extra libraries needed to access required functions.
+#
+ifeq ($(CPU),SH32) 
+  # for SH4 shared library
+  TLIBS_SHARED += -L$(WIND_USR)/lib/sh/SH32/commonle/PIC
+else 
+  # for all other CPUs shared library
+  TLIBS_SHARED += $(LD_LINK_PATH_ATEND) $(LD_PARTIAL_LAST_FLAGS)
+endif
+# for static library
+TLIBS += $(LD_LINK_PATH_ATEND) $(LD_PARTIAL_LAST_FLAGS)
+
+#### Leave SQLITE_DEBUG undefined for maximum speed.  Use SQLITE_DEBUG=1
+#    to check for memory leaks.  Use SQLITE_DEBUG=2 to print a log of all
+#    malloc()s and free()s in order to track down memory leaks.
+#    
+#    SQLite uses some expensive assert() statements in the inner loop.
+#    You can make the library go almost twice as fast if you compile
+#    with -DNDEBUG=1
+#
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1 -DSQLITE_OS_UNIX=1 $(THREADSAFE)
+OPTS += -DSQLITE_OMIT_LOAD_EXTENSION=1
+OPTS += -DSQLITE_ENABLE_LOCKING_STYLE=1
+OPTS += -DSQLITE_THREAD_OVERRIDE_LOCK=0
+OPTS += -DSQLITE_ENABLE_COLUMN_METADATA=1
+OPTS += -DHAVE_FDATASYNC=1
+
+#### The suffix to add to executable files.  ".exe" for windows.
+#    Nothing for unix.
+#
+EXE = .vxe
+#EXE =
+
+#### C Compile and options for use in building executables that 
+#    will run on the target platform.  This is usually the same
+#    as BCC, unless you are cross-compiling.
+#
+#TCC = gcc -O6
+#TCC = gcc -g -O0 -Wall
+#TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
+#TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
+TCC = $(CC) $(DEFINE_CC) -O2 -g -mrtp $(CC_ARCH_SPEC) -D_REENTRANT=1 -D_VX_CPU=_VX_$(CPU) -D_VX_TOOL_FAMILY=$(TOOL_FAMILY) -D_VX_TOOL=$(TOOL)
+TCC += -I$(WIND_USR)/h -I$(WIND_USR)/h/wrn/coreip
+#TCC = /opt/ansic/bin/c89 -O +z -Wl,-a,archive
+
+#TCC_SHARED = $(TCC) -fPIC
+TCC_SHARED = $(TCC)
+
+#### Tools used to build a static library.
+#
+#ARX = ar cr
+#ARX = /opt/mingw/bin/i386-mingw32-ar cr
+AR += cr
+#RANLIB = ranlib
+#RANLIB = /opt/mingw/bin/i386-mingw32-ranlib
+
+#MKSHLIB = gcc -shared
+#SO = so
+#SHPREFIX = lib
+MKSHLIB = $(CC) $(DEFINE_CC) -mrtp -shared $(CC_ARCH_SPEC) -D_VX_CPU=_VX_$(CPU) -D_VX_TOOL_FAMILY=$(TOOL_FAMILY) -D_VX_TOOL=$(TOOL)
+SO = so
+SHPREFIX = lib
+
+#### Extra compiler options needed for programs that use the TCL library.
+#
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.4linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.4win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
+
+#### Linker options needed to link against the TCL library.
+#
+#LIBTCL = -ltcl -lm -ldl
+LIBTCL = /home/drh/tcltk/8.4linux/libtcl8.4g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.4win/libtcl84s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
+
+#### Additional objects for SQLite library when TCL support is enabled.
+TCLOBJ =
+#TCLOBJ = tclsqlite.o
+
+#### Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS =
+#READLINE_FLAGS = -DHAVE_READLINE=1 -I/usr/include/readline
+
+#### Linker options needed by programs using readline() must link against.
+#
+LIBREADLINE =
+#LIBREADLINE = -static -lreadline -ltermcap
+
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
+
+#### Pasted and adapted main.mk file
+###############################################################################
+# The following macros should be defined before this script is
+# invoked:
+#
+# TOP              The toplevel directory of the source tree.  This is the
+#                  directory that contains this "Makefile.in" and the
+#                  "configure.in" script.
+#
+# BCC              C Compiler and options for use in building executables that
+#                  will run on the platform that is doing the build.
+#
+# THREADLIB        Specify any extra linker options needed to make the library
+#                  thread safe
+#
+# OPTS             Extra compiler command-line options.
+#
+# EXE              The suffix to add to executable files.  ".exe" for windows
+#                  and "" for Unix.
+#
+# TCC              C Compiler and options for use in building executables that 
+#                  will run on the target platform.  This is usually the same
+#                  as BCC, unless you are cross-compiling.
+#
+# AR               Tools used to build a static library.
+# RANLIB
+#
+# TCL_FLAGS        Extra compiler options needed for programs that use the
+#                  TCL library.
+#
+# LIBTCL           Linker options needed to link against the TCL library.
+#
+# READLINE_FLAGS   Compiler options needed for programs that use the
+#                  readline() library.
+#
+# LIBREADLINE      Linker options needed by programs using readline() must
+#                  link against.
+#
+# NAWK             Nawk compatible awk program.  Older (obsolete?) solaris
+#                  systems need this to avoid using the original AT&T AWK.
+#
+# Once the macros above are defined, the rest of this make script will
+# build the SQLite library and testing tools.
+################################################################################
+
+# This is how we compile
+#
+TCCX = $(TCC) $(OPTS) -I. -I$(TOP)/src -I$(TOP)
+TCCX_SHARED = $(TCC_SHARED) $(OPTS) -I. -I$(TOP)/src -I$(TOP) \
+	-I$(TOP)/ext/rtree -I$(TOP)/ext/icu -I$(TOP)/ext/fts3 \
+	-I$(TOP)/ext/async
+
+# Object files for the SQLite library.
+#
+LIBOBJ+= alter.o analyze.o attach.o auth.o \
+         backup.o bitvec.o btmutex.o btree.o build.o \
+         callback.o complete.o date.o delete.o expr.o fault.o \
+         fts3.o fts3_expr.o fts3_hash.o fts3_icu.o fts3_porter.o \
+         fts3_tokenizer.o fts3_tokenizer1.o \
+         func.o global.o hash.o \
+         icu.o insert.o journal.o legacy.o loadext.o \
+         main.o malloc.o mem0.o mem1.o mem2.o mem3.o mem5.o \
+         memjournal.o \
+         mutex.o mutex_noop.o mutex_os2.o mutex_unix.o mutex_w32.o \
+         notify.o opcodes.o os.o os_os2.o os_unix.o os_win.o \
+         pager.o parse.o pcache.o pcache1.o pragma.o prepare.o printf.o \
+         random.o resolve.o rowset.o rtree.o select.o status.o \
+         table.o tokenize.o trigger.o \
+         update.o util.o vacuum.o \
+         vdbe.o vdbeapi.o vdbeaux.o vdbeblob.o vdbemem.o \
+         walker.o where.o utf.o vtab.o
+
+
+
+# All of the source code files.
+#
+SRC = \
+  $(TOP)/src/alter.c \
+  $(TOP)/src/analyze.c \
+  $(TOP)/src/attach.c \
+  $(TOP)/src/auth.c \
+  $(TOP)/src/backup.c \
+  $(TOP)/src/bitvec.c \
+  $(TOP)/src/btmutex.c \
+  $(TOP)/src/btree.c \
+  $(TOP)/src/btree.h \
+  $(TOP)/src/btreeInt.h \
+  $(TOP)/src/build.c \
+  $(TOP)/src/callback.c \
+  $(TOP)/src/complete.c \
+  $(TOP)/src/date.c \
+  $(TOP)/src/delete.c \
+  $(TOP)/src/expr.c \
+  $(TOP)/src/fault.c \
+  $(TOP)/src/func.c \
+  $(TOP)/src/global.c \
+  $(TOP)/src/hash.c \
+  $(TOP)/src/hash.h \
+  $(TOP)/src/hwtime.h \
+  $(TOP)/src/insert.c \
+  $(TOP)/src/journal.c \
+  $(TOP)/src/legacy.c \
+  $(TOP)/src/loadext.c \
+  $(TOP)/src/main.c \
+  $(TOP)/src/malloc.c \
+  $(TOP)/src/mem0.c \
+  $(TOP)/src/mem1.c \
+  $(TOP)/src/mem2.c \
+  $(TOP)/src/mem3.c \
+  $(TOP)/src/mem5.c \
+  $(TOP)/src/memjournal.c \
+  $(TOP)/src/mutex.c \
+  $(TOP)/src/mutex.h \
+  $(TOP)/src/mutex_noop.c \
+  $(TOP)/src/mutex_os2.c \
+  $(TOP)/src/mutex_unix.c \
+  $(TOP)/src/mutex_w32.c \
+  $(TOP)/src/notify.c \
+  $(TOP)/src/os.c \
+  $(TOP)/src/os.h \
+  $(TOP)/src/os_common.h \
+  $(TOP)/src/os_os2.c \
+  $(TOP)/src/os_unix.c \
+  $(TOP)/src/os_win.c \
+  $(TOP)/src/pager.c \
+  $(TOP)/src/pager.h \
+  $(TOP)/src/parse.y \
+  $(TOP)/src/pcache.c \
+  $(TOP)/src/pcache.h \
+  $(TOP)/src/pcache1.c \
+  $(TOP)/src/pragma.c \
+  $(TOP)/src/prepare.c \
+  $(TOP)/src/printf.c \
+  $(TOP)/src/random.c \
+  $(TOP)/src/resolve.c \
+  $(TOP)/src/rowset.c \
+  $(TOP)/src/select.c \
+  $(TOP)/src/status.c \
+  $(TOP)/src/shell.c \
+  $(TOP)/src/sqlite.h.in \
+  $(TOP)/src/sqlite3ext.h \
+  $(TOP)/src/sqliteInt.h \
+  $(TOP)/src/sqliteLimit.h \
+  $(TOP)/src/table.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/src/tokenize.c \
+  $(TOP)/src/trigger.c \
+  $(TOP)/src/utf.c \
+  $(TOP)/src/update.c \
+  $(TOP)/src/util.c \
+  $(TOP)/src/vacuum.c \
+  $(TOP)/src/vdbe.c \
+  $(TOP)/src/vdbe.h \
+  $(TOP)/src/vdbeapi.c \
+  $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbeblob.c \
+  $(TOP)/src/vdbemem.c \
+  $(TOP)/src/vdbeInt.h \
+  $(TOP)/src/vtab.c \
+  $(TOP)/src/walker.c \
+  $(TOP)/src/where.c
+
+# Source code for extensions
+#
+SRC += \
+  $(TOP)/ext/fts1/fts1.c \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.c \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_porter.c \
+  $(TOP)/ext/fts1/fts1_tokenizer.h \
+  $(TOP)/ext/fts1/fts1_tokenizer1.c
+SRC += \
+  $(TOP)/ext/fts2/fts2.c \
+  $(TOP)/ext/fts2/fts2.h \
+  $(TOP)/ext/fts2/fts2_hash.c \
+  $(TOP)/ext/fts2/fts2_hash.h \
+  $(TOP)/ext/fts2/fts2_icu.c \
+  $(TOP)/ext/fts2/fts2_porter.c \
+  $(TOP)/ext/fts2/fts2_tokenizer.h \
+  $(TOP)/ext/fts2/fts2_tokenizer.c \
+  $(TOP)/ext/fts2/fts2_tokenizer1.c
+SRC += \
+  $(TOP)/ext/fts3/fts3.c \
+  $(TOP)/ext/fts3/fts3.h \
+  $(TOP)/ext/fts3/fts3_expr.c \
+  $(TOP)/ext/fts3/fts3_expr.h \
+  $(TOP)/ext/fts3/fts3_hash.c \
+  $(TOP)/ext/fts3/fts3_hash.h \
+  $(TOP)/ext/fts3/fts3_icu.c \
+  $(TOP)/ext/fts3/fts3_porter.c \
+  $(TOP)/ext/fts3/fts3_tokenizer.h \
+  $(TOP)/ext/fts3/fts3_tokenizer.c \
+  $(TOP)/ext/fts3/fts3_tokenizer1.c
+SRC += \
+  $(TOP)/ext/icu/sqliteicu.h \
+  $(TOP)/ext/icu/icu.c 
+SRC += \
+  $(TOP)/ext/rtree/rtree.h \
+  $(TOP)/ext/rtree/rtree.c
+
+
+# Generated source code files
+#
+SRC += \
+  keywordhash.h \
+  opcodes.c \
+  opcodes.h \
+  parse.c \
+  parse.h \
+  sqlite3.h
+
+
+# Source code to the test files.
+#
+TESTSRC = \
+  $(TOP)/src/test1.c \
+  $(TOP)/src/test2.c \
+  $(TOP)/src/test3.c \
+  $(TOP)/src/test4.c \
+  $(TOP)/src/test5.c \
+  $(TOP)/src/test6.c \
+  $(TOP)/src/test7.c \
+  $(TOP)/src/test8.c \
+  $(TOP)/src/test9.c \
+  $(TOP)/src/test_autoext.c \
+  $(TOP)/src/test_async.c \
+  $(TOP)/src/test_backup.c \
+  $(TOP)/src/test_btree.c \
+  $(TOP)/src/test_config.c \
+  $(TOP)/src/test_devsym.c \
+  $(TOP)/src/test_func.c \
+  $(TOP)/src/test_hexio.c \
+  $(TOP)/src/test_journal.c \
+  $(TOP)/src/test_malloc.c \
+  $(TOP)/src/test_md5.c \
+  $(TOP)/src/test_mutex.c \
+  $(TOP)/src/test_onefile.c \
+  $(TOP)/src/test_osinst.c \
+  $(TOP)/src/test_pcache.c \
+  $(TOP)/src/test_schema.c \
+  $(TOP)/src/test_server.c \
+  $(TOP)/src/test_tclvar.c \
+  $(TOP)/src/test_thread.c \
+  $(TOP)/src/test_wsd.c \
+
+#TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c
+#TESTSRC += $(TOP)/ext/fts3/fts3_tokenizer.c
+
+TESTSRC2 = \
+  $(TOP)/src/attach.c $(TOP)/src/backup.c $(TOP)/src/btree.c                   \
+  $(TOP)/src/build.c $(TOP)/src/date.c                                         \
+  $(TOP)/src/expr.c $(TOP)/src/func.c $(TOP)/src/insert.c $(TOP)/src/os.c      \
+  $(TOP)/src/os_os2.c $(TOP)/src/os_unix.c $(TOP)/src/os_win.c                 \
+  $(TOP)/src/pager.c $(TOP)/src/pragma.c $(TOP)/src/prepare.c                  \
+  $(TOP)/src/printf.c $(TOP)/src/random.c $(TOP)/src/pcache.c                  \
+  $(TOP)/src/pcache1.c $(TOP)/src/select.c $(TOP)/src/tokenize.c               \
+  $(TOP)/src/utf.c $(TOP)/src/util.c $(TOP)/src/vdbeapi.c $(TOP)/src/vdbeaux.c \
+  $(TOP)/src/vdbe.c $(TOP)/src/vdbemem.c $(TOP)/src/where.c parse.c            \
+  $(TOP)/ext/fts3/fts3.c $(TOP)/ext/fts3/fts3_expr.c                           \
+  $(TOP)/ext/fts3/fts3_tokenizer.c                                             \
+  $(TOP)/ext/async/sqlite3async.c
+
+# Header files used by all library source files.
+#
+HDR = \
+   $(TOP)/src/btree.h \
+   $(TOP)/src/btreeInt.h \
+   $(TOP)/src/hash.h \
+   $(TOP)/src/hwtime.h \
+   keywordhash.h \
+   $(TOP)/src/mutex.h \
+   opcodes.h \
+   $(TOP)/src/os.h \
+   $(TOP)/src/os_common.h \
+   $(TOP)/src/pager.h \
+   $(TOP)/src/pcache.h \
+   parse.h  \
+   sqlite3.h  \
+   $(TOP)/src/sqlite3ext.h \
+   $(TOP)/src/sqliteInt.h  \
+   $(TOP)/src/sqliteLimit.h \
+   $(TOP)/src/vdbe.h \
+   $(TOP)/src/vdbeInt.h
+
+# Header files used by extensions
+#
+EXTHDR += \
+  $(TOP)/ext/fts1/fts1.h \
+  $(TOP)/ext/fts1/fts1_hash.h \
+  $(TOP)/ext/fts1/fts1_tokenizer.h
+EXTHDR += \
+  $(TOP)/ext/fts2/fts2.h \
+  $(TOP)/ext/fts2/fts2_hash.h \
+  $(TOP)/ext/fts2/fts2_tokenizer.h
+EXTHDR += \
+  $(TOP)/ext/fts3/fts3.h \
+  $(TOP)/ext/fts3/fts3_expr.h \
+  $(TOP)/ext/fts3/fts3_hash.h \
+  $(TOP)/ext/fts3/fts3_tokenizer.h
+EXTHDR += \
+  $(TOP)/ext/rtree/rtree.h
+EXTHDR += \
+  $(TOP)/ext/icu/sqliteicu.h
+
+# This is the default Makefile target.  The objects listed here
+# are what get build when you type just "make" with no arguments.
+#
+all:	sqlite3.h libsqlite3.a sqlite3$(EXE)
+
+libsqlite3.a:	$(LIBOBJ)
+	$(AR) libsqlite3.a $(LIBOBJ)
+	$(RANLIB) libsqlite3.a
+
+$(SHPREFIX)sqlite3.$(SO):	$(LIBOBJ)
+	$(MKSHLIB) -o $(SHPREFIX)sqlite3.$(SO) $(LIBOBJ) $(TLIBS_SHARED)
+
+sqlite3$(EXE):	$(TOP)/src/shell.c libsqlite3.a sqlite3.h
+	$(TCCX) $(READLINE_FLAGS) -o sqlite3$(EXE)      \
+		$(TOP)/src/shell.c                      \
+		$(LIBREADLINE) $(TLIBS) $(THREADLIB) -L. -lsqlite3
+
+# This target creates a directory named "tsrc" and fills it with
+# copies of all of the C source code and header files needed to
+# build on the target system.  Some of the C source code and header
+# files are automatically generated.  This target takes care of
+# all that automatic generation.
+#
+target_source:	$(SRC)
+	rm -rf tsrc
+	mkdir tsrc
+	cp -f $(SRC) tsrc
+	rm tsrc/sqlite.h.in tsrc/parse.y
+	touch target_source
+
+sqlite3.c:	target_source $(TOP)/tool/mksqlite3c.tcl
+	tclsh $(TOP)/tool/mksqlite3c.tcl
+	cp sqlite3.c tclsqlite3.c
+	cat $(TOP)/src/tclsqlite.c >>tclsqlite3.c
+
+fts2amal.c:	target_source $(TOP)/ext/fts2/mkfts2amal.tcl
+	tclsh $(TOP)/ext/fts2/mkfts2amal.tcl
+
+fts3amal.c:	target_source $(TOP)/ext/fts3/mkfts3amal.tcl
+	tclsh $(TOP)/ext/fts3/mkfts3amal.tcl
+
+# Rules to build the LEMON compiler generator
+#
+lemon:	$(TOP)/tool/lemon.c $(TOP)/src/lempar.c
+	$(BCC) -o lemon $(TOP)/tool/lemon.c
+	cp $(TOP)/src/lempar.c .
+
+# Rules to build individual *.o files from generated *.c files. This
+# applies to:
+#
+#     parse.o
+#     opcodes.o
+#
+%.o: %.c $(HDR)
+	$(TCCX_SHARED) -c $<
+
+# Rules to build individual *.o files from files in the src directory.
+#
+%.o: $(TOP)/src/%.c $(HDR)
+	$(TCCX_SHARED) -c $<
+
+tclsqlite.o:	$(TOP)/src/tclsqlite.c $(HDR)
+	$(TCCX_SHARED) $(TCL_FLAGS) -c $(TOP)/src/tclsqlite.c
+
+
+
+# Rules to build opcodes.c and opcodes.h
+#
+opcodes.c:	opcodes.h $(TOP)/mkopcodec.awk
+	sort -n -b -k 3 opcodes.h | $(NAWK) -f $(TOP)/mkopcodec.awk >opcodes.c
+
+opcodes.h:	parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
+	cat parse.h $(TOP)/src/vdbe.c | \
+		$(NAWK) -f $(TOP)/mkopcodeh.awk >opcodes.h
+
+# Rules to build parse.c and parse.h - the outputs of lemon.
+#
+parse.h:	parse.c
+
+parse.c:	$(TOP)/src/parse.y lemon $(TOP)/addopcodes.awk
+	cp $(TOP)/src/parse.y .
+	rm -f parse.h
+	./lemon $(OPTS) parse.y
+	mv parse.h parse.h.temp
+	awk -f $(TOP)/addopcodes.awk parse.h.temp >parse.h
+
+sqlite3.h:	$(TOP)/src/sqlite.h.in 
+	sed -e s/--VERS--/`cat ${TOP}/VERSION`/ \
+	    -e s/--VERSION-NUMBER--/`cat ${TOP}/VERSION | sed 's/[^0-9]/ /g' | $(NAWK) '{printf "%d%03d%03d",$$1,$$2,$$3}'`/ \
+                 $(TOP)/src/sqlite.h.in >sqlite3.h
+
+keywordhash.h:	$(TOP)/tool/mkkeywordhash.c
+	$(BCC) -o mkkeywordhash $(OPTS) $(TOP)/tool/mkkeywordhash.c
+	./mkkeywordhash >keywordhash.h
+
+
+
+# Rules to build the extension objects.
+#
+icu.o:	$(TOP)/ext/icu/icu.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/icu/icu.c
+
+fts2.o:	$(TOP)/ext/fts2/fts2.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2.c
+
+fts2_hash.o:	$(TOP)/ext/fts2/fts2_hash.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_hash.c
+
+fts2_icu.o:	$(TOP)/ext/fts2/fts2_icu.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_icu.c
+
+fts2_porter.o:	$(TOP)/ext/fts2/fts2_porter.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_porter.c
+
+fts2_tokenizer.o:	$(TOP)/ext/fts2/fts2_tokenizer.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_tokenizer.c
+
+fts2_tokenizer1.o:	$(TOP)/ext/fts2/fts2_tokenizer1.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts2/fts2_tokenizer1.c
+
+fts3.o:	$(TOP)/ext/fts3/fts3.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3.c
+
+fts3_expr.o:	$(TOP)/ext/fts3/fts3_expr.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_expr.c
+
+fts3_hash.o:	$(TOP)/ext/fts3/fts3_hash.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_hash.c
+
+fts3_icu.o:	$(TOP)/ext/fts3/fts3_icu.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_icu.c
+
+fts3_porter.o:	$(TOP)/ext/fts3/fts3_porter.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_porter.c
+
+fts3_tokenizer.o:	$(TOP)/ext/fts3/fts3_tokenizer.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer.c
+
+fts3_tokenizer1.o:	$(TOP)/ext/fts3/fts3_tokenizer1.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer1.c
+
+rtree.o:	$(TOP)/ext/rtree/rtree.c $(HDR) $(EXTHDR)
+	$(TCCX_SHARED) -DSQLITE_CORE -c $(TOP)/ext/rtree/rtree.c
+
+
+# Rules for building test programs and for running tests
+#
+tclsqlite3:	$(TOP)/src/tclsqlite.c libsqlite3.a
+	$(TCCX_SHARED) $(TCL_FLAGS) -DTCLSH=1 -o tclsqlite3 \
+		$(TOP)/src/tclsqlite.c libsqlite3.a $(LIBTCL) $(THREADLIB)
+
+
+# Rules to build the 'testfixture' application.
+#
+TESTFIXTURE_FLAGS  = -DTCLSH=1 -DSQLITE_TEST=1 -DSQLITE_CRASH_TEST=1
+TESTFIXTURE_FLAGS += -DSQLITE_SERVER=1 -DSQLITE_PRIVATE="" -DSQLITE_CORE 
+
+testfixture$(EXE): $(TESTSRC2) libsqlite3.a $(TESTSRC) $(TOP)/src/tclsqlite.c
+	$(TCCX) $(TCL_FLAGS) $(TESTFIXTURE_FLAGS)                            \
+		$(TESTSRC) $(TESTSRC2) $(TOP)/src/tclsqlite.c                \
+		-o testfixture$(EXE) $(LIBTCL) $(THREADLIB) libsqlite3.a
+
+amalgamation-testfixture$(EXE): sqlite3.c $(TESTSRC) $(TOP)/src/tclsqlite.c
+	$(TCCX) $(TCL_FLAGS) $(TESTFIXTURE_FLAGS)                            \
+		$(TESTSRC) $(TOP)/src/tclsqlite.c sqlite3.c                  \
+		-o testfixture$(EXE) $(LIBTCL) $(THREADLIB)
+
+fts3-testfixture$(EXE): sqlite3.c fts3amal.c $(TESTSRC) $(TOP)/src/tclsqlite.c
+	$(TCCX) $(TCL_FLAGS) $(TESTFIXTURE_FLAGS)                            \
+	-DSQLITE_ENABLE_FTS3=1                                               \
+		$(TESTSRC) $(TOP)/src/tclsqlite.c sqlite3.c fts3amal.c       \
+		-o testfixture$(EXE) $(LIBTCL) $(THREADLIB)
+
+fulltest:	testfixture$(EXE) sqlite3$(EXE)
+	./testfixture$(EXE) $(TOP)/test/all.test
+
+soaktest:	testfixture$(EXE) sqlite3$(EXE)
+	./testfixture$(EXE) $(TOP)/test/all.test -soak 1
+
+test:	testfixture$(EXE) sqlite3$(EXE)
+	./testfixture$(EXE) $(TOP)/test/veryquick.test
+
+sqlite3_analyzer$(EXE):	$(TOP)/src/tclsqlite.c sqlite3.c $(TESTSRC) \
+			$(TOP)/tool/spaceanal.tcl
+	sed \
+	  -e '/^#/d' \
+	  -e 's,\\,\\\\,g' \
+	  -e 's,",\\",g' \
+	  -e 's,^,",' \
+	  -e 's,$$,\\n",' \
+	  $(TOP)/tool/spaceanal.tcl >spaceanal_tcl.h
+	$(TCCX) $(TCL_FLAGS)                  $(TESTFIXTURE_FLAGS)                                 \
+		-DTCLSH=2 -DSQLITE_TEST=1 -DSQLITE_DEBUG=1 -DSQLITE_PRIVATE="" \
+		$(TESTSRC) $(TOP)/src/tclsqlite.c sqlite3.c                    \
+		-o sqlite3_analyzer$(EXE)                                      \
+		$(LIBTCL) $(THREADLIB)
+
+TEST_EXTENSION = $(SHPREFIX)testloadext.$(SO)
+$(TEST_EXTENSION): $(TOP)/src/test_loadext.c
+	$(MKSHLIB) $(TOP)/src/test_loadext.c -o $(TEST_EXTENSION)
+
+extensiontest: testfixture$(EXE) $(TEST_EXTENSION)
+	./testfixture$(EXE) $(TOP)/test/loadext.test
+
+clean:	
+	rm -f *.o sqlite3$(EXE) libsqlite3.a sqlite3.h opcodes.*
+	rm -f lemon lempar.c parse.* sqlite*.tar.gz mkkeywordhash keywordhash.h
+	rm -f $(PUBLISH)
+	rm -f *.da *.bb *.bbg gmon.out
+	rm -rf tsrc target_source
+	rm -f testloadext.dll libtestloadext.so
+	rm -f sqlite3.c fts?amal.c tclsqlite3.c
+	rm -f $(SHPREFIX)sqlite3.$(SO)

README

@@ -0,0 +1,39 @@
+This directory contains source code to 
+
+    SQLite: An Embeddable SQL Database Engine
+
+To compile the project, first create a directory in which to place
+the build products.  It is recommended, but not required, that the
+build directory be separate from the source directory.  Cd into the
+build directory and then from the build directory run the configure
+script found at the root of the source tree.  Then run "make".
+
+For example:
+
+    tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
+    mkdir bld                ;#  Build will occur in a sibling directory
+    cd bld                   ;#  Change to the build directory
+    ../sqlite/configure      ;#  Run the configure script
+    make                     ;#  Run the makefile.
+    make install             ;#  (Optional) Install the build products
+
+The configure script uses autoconf 2.61 and libtool.  If the configure
+script does not work out for you, there is a generic makefile named
+"Makefile.linux-gcc" in the top directory of the source tree that you
+can copy and edit to suit your needs.  Comments on the generic makefile
+show what changes are needed.
+
+The linux binaries on the website are created using the generic makefile,
+not the configure script.  The windows binaries on the website are created
+using MinGW32 configured as a cross-compiler running under Linux.  For 
+details, see the ./publish.sh script at the top-level of the source tree.
+The developers do not use teh configure script.
+
+SQLite does not require TCL to run, but a TCL installation is required
+by the makefiles.  SQLite contains a lot of generated code and TCL is
+used to do much of that code generation.  The makefile also requires
+AWK.
+
+Contacts:
+
+   http://www.sqlite.org/

README.md

@@ -1,327 +0,0 @@
-<h1 align="center">SQLite Source Repository</h1>
-
-This repository contains the complete source code for the 
-[SQLite database engine](https://sqlite.org/).  Some test scripts 
-are also included.  However, many other test scripts
-and most of the documentation are managed separately.
-
-## Version Control
-
-SQLite sources are managed using the
-[Fossil](https://www.fossil-scm.org/), a distributed version control system
-that was specifically designed and written to support SQLite development.
-The [Fossil repository](https://sqlite.org/src/timeline) contains the urtext.
-
-If you are reading this on GitHub or some other Git repository or service,
-then you are looking at a mirror.  The names of check-ins and
-other artifacts in a Git mirror are different from the official
-names for those objects.  The offical names for check-ins are
-found in a footer on the check-in comment for authorized mirrors.
-The official check-in name can also be seen in the `manifest.uuid` file
-in the root of the tree.  Always use the official name, not  the
-Git-name, when communicating about an SQLite check-in.
-
-If you pulled your SQLite source code from a secondary source and want to
-verify its integrity, there are hints on how to do that in the
-[Verifying Code Authenticity](#vauth) section below.
-
-## Obtaining The Code
-
-If you do not want to use Fossil, you can download tarballs or ZIP
-archives or [SQLite archives](https://sqlite.org/cli.html#sqlar) as follows:
-
-  *  Lastest trunk check-in as
-     [Tarball](https://www.sqlite.org/src/tarball/sqlite.tar.gz),
-     [ZIP-archive](https://www.sqlite.org/src/zip/sqlite.zip), or
-     [SQLite-archive](https://www.sqlite.org/src/sqlar/sqlite.sqlar).
-
-  *  Latest release as
-     [Tarball](https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=release),
-     [ZIP-archive](https://www.sqlite.org/src/zip/sqlite.zip?r=release), or
-     [SQLite-archive](https://www.sqlite.org/src/sqlar/sqlite.sqlar?r=release).
-
-  *  For other check-ins, substitute an appropriate branch name or
-     tag or hash prefix in place of "release" in the URLs of the previous
-     bullet.  Or browse the [timeline](https://www.sqlite.org/src/timeline)
-     to locate the check-in desired, click on its information page link,
-     then click on the "Tarball" or "ZIP Archive" links on the information
-     page.
-
-If you do want to use Fossil to check out the source tree, 
-first install Fossil version 2.0 or later.
-(Source tarballs and precompiled binaries available
-[here](https://www.fossil-scm.org/fossil/uv/download.html).  Fossil is
-a stand-alone program.  To install, simply download or build the single 
-executable file and put that file someplace on your $PATH.)
-Then run commands like this:
-
-        mkdir ~/sqlite
-        cd ~/sqlite
-        fossil clone https://www.sqlite.org/src sqlite.fossil
-        fossil open sqlite.fossil
-    
-After setting up a repository using the steps above, you can always
-update to the lastest version using:
-
-        fossil update trunk   ;# latest trunk check-in
-        fossil update release ;# latest official release
-
-Or type "fossil ui" to get a web-based user interface.
-
-## Compiling
-
-First create a directory in which to place
-the build products.  It is recommended, but not required, that the
-build directory be separate from the source directory.  Cd into the
-build directory and then from the build directory run the configure
-script found at the root of the source tree.  Then run "make".
-
-For example:
-
-        tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
-        mkdir bld                ;#  Build will occur in a sibling directory
-        cd bld                   ;#  Change to the build directory
-        ../sqlite/configure      ;#  Run the configure script
-        make                     ;#  Run the makefile.
-        make sqlite3.c           ;#  Build the "amalgamation" source file
-        make test                ;#  Run some tests (requires Tcl)
-
-See the makefile for additional targets.
-
-The configure script uses autoconf 2.61 and libtool.  If the configure
-script does not work out for you, there is a generic makefile named
-"Makefile.linux-gcc" in the top directory of the source tree that you
-can copy and edit to suit your needs.  Comments on the generic makefile
-show what changes are needed.
-
-## Using MSVC
-
-On Windows, all applicable build products can be compiled with MSVC.
-First open the command prompt window associated with the desired compiler
-version (e.g. "Developer Command Prompt for VS2013").  Next, use NMAKE
-with the provided "Makefile.msc" to build one of the supported targets.
-
-For example:
-
-        mkdir bld
-        cd bld
-        nmake /f Makefile.msc TOP=..\sqlite
-        nmake /f Makefile.msc sqlite3.c TOP=..\sqlite
-        nmake /f Makefile.msc sqlite3.dll TOP=..\sqlite
-        nmake /f Makefile.msc sqlite3.exe TOP=..\sqlite
-        nmake /f Makefile.msc test TOP=..\sqlite
-
-There are several build options that can be set via the NMAKE command
-line.  For example, to build for WinRT, simply add "FOR_WINRT=1" argument
-to the "sqlite3.dll" command line above.  When debugging into the SQLite
-code, adding the "DEBUG=1" argument to one of the above command lines is
-recommended.
-
-SQLite does not require [Tcl](http://www.tcl.tk/) to run, but a Tcl installation
-is required by the makefiles (including those for MSVC).  SQLite contains
-a lot of generated code and Tcl is used to do much of that code generation.
-
-## Source Code Tour
-
-Most of the core source files are in the **src/** subdirectory.  The
-**src/** folder also contains files used to build the "testfixture" test
-harness. The names of the source files used by "testfixture" all begin
-with "test".
-The **src/** also contains the "shell.c" file
-which is the main program for the "sqlite3.exe"
-[command-line shell](https://sqlite.org/cli.html) and
-the "tclsqlite.c" file which implements the
-[Tcl bindings](https://sqlite.org/tclsqlite.html) for SQLite.
-(Historical note:  SQLite began as a Tcl
-extension and only later escaped to the wild as an independent library.)
-
-Test scripts and programs are found in the **test/** subdirectory.
-Addtional test code is found in other source repositories.
-See [How SQLite Is Tested](http://www.sqlite.org/testing.html) for
-additional information.
-
-The **ext/** subdirectory contains code for extensions.  The
-Full-text search engine is in **ext/fts3**.  The R-Tree engine is in
-**ext/rtree**.  The **ext/misc** subdirectory contains a number of
-smaller, single-file extensions, such as a REGEXP operator.
-
-The **tool/** subdirectory contains various scripts and programs used
-for building generated source code files or for testing or for generating
-accessory programs such as "sqlite3_analyzer(.exe)".
-
-### Generated Source Code Files
-
-Several of the C-language source files used by SQLite are generated from
-other sources rather than being typed in manually by a programmer.  This
-section will summarize those automatically-generated files.  To create all
-of the automatically-generated files, simply run "make target&#95;source".
-The "target&#95;source" make target will create a subdirectory "tsrc/" and
-fill it with all the source files needed to build SQLite, both
-manually-edited files and automatically-generated files.
-
-The SQLite interface is defined by the **sqlite3.h** header file, which is
-generated from src/sqlite.h.in, ./manifest.uuid, and ./VERSION.  The
-[Tcl script](http://www.tcl.tk) at tool/mksqlite3h.tcl does the conversion.
-The manifest.uuid file contains the SHA3 hash of the particular check-in
-and is used to generate the SQLITE\_SOURCE\_ID macro.  The VERSION file
-contains the current SQLite version number.  The sqlite3.h header is really
-just a copy of src/sqlite.h.in with the source-id and version number inserted
-at just the right spots. Note that comment text in the sqlite3.h file is
-used to generate much of the SQLite API documentation.  The Tcl scripts
-used to generate that documentation are in a separate source repository.
-
-The SQL language parser is **parse.c** which is generate from a grammar in
-the src/parse.y file.  The conversion of "parse.y" into "parse.c" is done
-by the [lemon](./doc/lemon.html) LALR(1) parser generator.  The source code
-for lemon is at tool/lemon.c.  Lemon uses the tool/lempar.c file as a
-template for generating its parser.
-Lemon also generates the **parse.h** header file, at the same time it
-generates parse.c.
-
-The **opcodes.h** header file contains macros that define the numbers
-corresponding to opcodes in the "VDBE" virtual machine.  The opcodes.h
-file is generated by the scanning the src/vdbe.c source file.  The
-Tcl script at ./mkopcodeh.tcl does this scan and generates opcodes.h.
-A second Tcl script, ./mkopcodec.tcl, then scans opcodes.h to generate
-the **opcodes.c** source file, which contains a reverse mapping from
-opcode-number to opcode-name that is used for EXPLAIN output.
-
-The **keywordhash.h** header file contains the definition of a hash table
-that maps SQL language keywords (ex: "CREATE", "SELECT", "INDEX", etc.) into
-the numeric codes used by the parse.c parser.  The keywordhash.h file is
-generated by a C-language program at tool mkkeywordhash.c.
-
-The **pragma.h** header file contains various definitions used to parse
-and implement the PRAGMA statements.  The header is generated by a
-script **tool/mkpragmatab.tcl**. If you want to add a new PRAGMA, edit
-the **tool/mkpragmatab.tcl** file to insert the information needed by the
-parser for your new PRAGMA, then run the script to regenerate the
-**pragma.h** header file.
-
-### The Amalgamation
-
-All of the individual C source code and header files (both manually-edited
-and automatically-generated) can be combined into a single big source file
-**sqlite3.c** called "the amalgamation".  The amalgamation is the recommended
-way of using SQLite in a larger application.  Combining all individual
-source code files into a single big source code file allows the C compiler
-to perform more cross-procedure analysis and generate better code.  SQLite
-runs about 5% faster when compiled from the amalgamation versus when compiled
-from individual source files.
-
-The amalgamation is generated from the tool/mksqlite3c.tcl Tcl script.
-First, all of the individual source files must be gathered into the tsrc/
-subdirectory (using the equivalent of "make target_source") then the
-tool/mksqlite3c.tcl script is run to copy them all together in just the
-right order while resolving internal "#include" references.
-
-The amalgamation source file is more than 200K lines long.  Some symbolic
-debuggers (most notably MSVC) are unable to deal with files longer than 64K
-lines.  To work around this, a separate Tcl script, tool/split-sqlite3c.tcl,
-can be run on the amalgamation to break it up into a single small C file
-called **sqlite3-all.c** that does #include on about seven other files
-named **sqlite3-1.c**, **sqlite3-2.c**, ..., **sqlite3-7.c**.  In this way,
-all of the source code is contained within a single translation unit so
-that the compiler can do extra cross-procedure optimization, but no
-individual source file exceeds 32K lines in length.
-
-## How It All Fits Together
-
-SQLite is modular in design.
-See the [architectural description](http://www.sqlite.org/arch.html)
-for details. Other documents that are useful in
-(helping to understand how SQLite works include the
-[file format](http://www.sqlite.org/fileformat2.html) description,
-the [virtual machine](http://www.sqlite.org/opcode.html) that runs
-prepared statements, the description of
-[how transactions work](http://www.sqlite.org/atomiccommit.html), and
-the [overview of the query planner](http://www.sqlite.org/optoverview.html).
-
-Years of effort have gone into optimizating SQLite, both
-for small size and high performance.  And optimizations tend to result in
-complex code.  So there is a lot of complexity in the current SQLite
-implementation.  It will not be the easiest library in the world to hack.
-
-Key files:
-
-  *  **sqlite.h.in** - This file defines the public interface to the SQLite
-     library.  Readers will need to be familiar with this interface before
-     trying to understand how the library works internally.
-
-  *  **sqliteInt.h** - this header file defines many of the data objects
-     used internally by SQLite.  In addition to "sqliteInt.h", some
-     subsystems have their own header files.
-
-  *  **parse.y** - This file describes the LALR(1) grammar that SQLite uses
-     to parse SQL statements, and the actions that are taken at each step
-     in the parsing process.
-
-  *  **vdbe.c** - This file implements the virtual machine that runs
-     prepared statements.  There are various helper files whose names
-     begin with "vdbe".  The VDBE has access to the vdbeInt.h header file
-     which defines internal data objects.  The rest of SQLite interacts
-     with the VDBE through an interface defined by vdbe.h.
-
-  *  **where.c** - This file (together with its helper files named
-     by "where*.c") analyzes the WHERE clause and generates
-     virtual machine code to run queries efficiently.  This file is
-     sometimes called the "query optimizer".  It has its own private
-     header file, whereInt.h, that defines data objects used internally.
-
-  *  **btree.c** - This file contains the implementation of the B-Tree
-     storage engine used by SQLite.  The interface to the rest of the system
-     is defined by "btree.h".  The "btreeInt.h" header defines objects
-     used internally by btree.c and not published to the rest of the system.
-
-  *  **pager.c** - This file contains the "pager" implementation, the
-     module that implements transactions.  The "pager.h" header file
-     defines the interface between pager.c and the rest of the system.
-
-  *  **os_unix.c** and **os_win.c** - These two files implement the interface
-     between SQLite and the underlying operating system using the run-time
-     pluggable VFS interface.
-
-  *  **shell.c.in** - This file is not part of the core SQLite library.  This
-     is the file that, when linked against sqlite3.a, generates the
-     "sqlite3.exe" command-line shell.  The "shell.c.in" file is transformed
-     into "shell.c" as part of the build process.
-
-  *  **tclsqlite.c** - This file implements the Tcl bindings for SQLite.  It
-     is not part of the core SQLite library.  But as most of the tests in this
-     repository are written in Tcl, the Tcl language bindings are important.
-
-  *  **test*.c** - Files in the src/ folder that begin with "test" go into
-     building the "testfixture.exe" program.  The testfixture.exe program is
-     an enhanced Tcl shell.  The testfixture.exe program runs scripts in the
-     test/ folder to validate the core SQLite code.  The testfixture program
-     (and some other test programs too) is build and run when you type
-     "make test".
-
-  *  **ext/misc/json1.c** - This file implements the various JSON functions
-     that are build into SQLite.
-
-There are many other source files.  Each has a succinct header comment that
-describes its purpose and role within the larger system.
-
-<a name="vauth"></a>
-## Verifying Code Authenticity
-
-The `manifest` file at the root directory of the source tree
-contains either a SHA3-256 hash (for newer files) or a SHA1 hash (for 
-older files) for every source file in the repository.
-The SHA3-256 hash of the `manifest`
-file itself is the official name of the version of the source tree that you
-have. The `manifest.uuid` file should contain the SHA3-256 hash of the
-`manifest` file. If all of the above hash comparisons are correct, then
-you can be confident that your source tree is authentic and unadulterated.
-
-The format of the `manifest` file should be mostly self-explanatory, but
-if you want details, they are available
-[here](https://fossil-scm.org/fossil/doc/trunk/www/fileformat.wiki#manifest).
-
-## Contacts
-
-The main SQLite website is [http://www.sqlite.org/](http://www.sqlite.org/)
-with geographically distributed backups at
-[http://www2.sqlite.org/](http://www2.sqlite.org) and
-[http://www3.sqlite.org/](http://www3.sqlite.org).

VERSION

@@ -1 +1 @@
-3.32.0
+3.6.20

addopcodes.awk

@@ -0,0 +1,34 @@
+#!/usr/bin/awk
+#
+# This script appends additional token codes to the end of the
+# parse.h file that lemon generates.  These extra token codes are
+# not used by the parser.  But they are used by the tokenizer and/or
+# the code generator.
+#
+#
+BEGIN {
+  max = 0
+}
+/^#define TK_/ {
+  print $0
+  if( max<$3 ) max = $3
+}
+END {
+  printf "#define TK_%-29s %4d\n", "TO_TEXT",         ++max
+  printf "#define TK_%-29s %4d\n", "TO_BLOB",         ++max
+  printf "#define TK_%-29s %4d\n", "TO_NUMERIC",      ++max
+  printf "#define TK_%-29s %4d\n", "TO_INT",          ++max
+  printf "#define TK_%-29s %4d\n", "TO_REAL",         ++max
+  printf "#define TK_%-29s %4d\n", "ISNOT",           ++max
+  printf "#define TK_%-29s %4d\n", "END_OF_FILE",     ++max
+  printf "#define TK_%-29s %4d\n", "ILLEGAL",         ++max
+  printf "#define TK_%-29s %4d\n", "SPACE",           ++max
+  printf "#define TK_%-29s %4d\n", "UNCLOSED_STRING", ++max
+  printf "#define TK_%-29s %4d\n", "FUNCTION",        ++max
+  printf "#define TK_%-29s %4d\n", "COLUMN",          ++max
+  printf "#define TK_%-29s %4d\n", "AGG_FUNCTION",    ++max
+  printf "#define TK_%-29s %4d\n", "AGG_COLUMN",      ++max
+  printf "#define TK_%-29s %4d\n", "CONST_FUNC",      ++max
+  printf "#define TK_%-29s %4d\n", "UMINUS",          ++max
+  printf "#define TK_%-29s %4d\n", "UPLUS",           ++max
+}

autoconf/INSTALL

@@ -1,370 +0,0 @@
-Installation Instructions
-*************************
-
-Copyright (C) 1994-1996, 1999-2002, 2004-2011 Free Software Foundation,
-Inc.
-
-   Copying and distribution of this file, with or without modification,
-are permitted in any medium without royalty provided the copyright
-notice and this notice are preserved.  This file is offered as-is,
-without warranty of any kind.
-
-Basic Installation
-==================
-
-   Briefly, the shell commands `./configure; make; make install' should
-configure, build, and install this package.  The following
-more-detailed instructions are generic; see the `README' file for
-instructions specific to this package.  Some packages provide this
-`INSTALL' file but do not implement all of the features documented
-below.  The lack of an optional feature in a given package is not
-necessarily a bug.  More recommendations for GNU packages can be found
-in *note Makefile Conventions: (standards)Makefile Conventions.
-
-   The `configure' shell script attempts to guess correct values for
-various system-dependent variables used during compilation.  It uses
-those values to create a `Makefile' in each directory of the package.
-It may also create one or more `.h' files containing system-dependent
-definitions.  Finally, it creates a shell script `config.status' that
-you can run in the future to recreate the current configuration, and a
-file `config.log' containing compiler output (useful mainly for
-debugging `configure').
-
-   It can also use an optional file (typically called `config.cache'
-and enabled with `--cache-file=config.cache' or simply `-C') that saves
-the results of its tests to speed up reconfiguring.  Caching is
-disabled by default to prevent problems with accidental use of stale
-cache files.
-
-   If you need to do unusual things to compile the package, please try
-to figure out how `configure' could check whether to do them, and mail
-diffs or instructions to the address given in the `README' so they can
-be considered for the next release.  If you are using the cache, and at
-some point `config.cache' contains results you don't want to keep, you
-may remove or edit it.
-
-   The file `configure.ac' (or `configure.in') is used to create
-`configure' by a program called `autoconf'.  You need `configure.ac' if
-you want to change it or regenerate `configure' using a newer version
-of `autoconf'.
-
-   The simplest way to compile this package is:
-
-  1. `cd' to the directory containing the package's source code and type
-     `./configure' to configure the package for your system.
-
-     Running `configure' might take a while.  While running, it prints
-     some messages telling which features it is checking for.
-
-  2. Type `make' to compile the package.
-
-  3. Optionally, type `make check' to run any self-tests that come with
-     the package, generally using the just-built uninstalled binaries.
-
-  4. Type `make install' to install the programs and any data files and
-     documentation.  When installing into a prefix owned by root, it is
-     recommended that the package be configured and built as a regular
-     user, and only the `make install' phase executed with root
-     privileges.
-
-  5. Optionally, type `make installcheck' to repeat any self-tests, but
-     this time using the binaries in their final installed location.
-     This target does not install anything.  Running this target as a
-     regular user, particularly if the prior `make install' required
-     root privileges, verifies that the installation completed
-     correctly.
-
-  6. You can remove the program binaries and object files from the
-     source code directory by typing `make clean'.  To also remove the
-     files that `configure' created (so you can compile the package for
-     a different kind of computer), type `make distclean'.  There is
-     also a `make maintainer-clean' target, but that is intended mainly
-     for the package's developers.  If you use it, you may have to get
-     all sorts of other programs in order to regenerate files that came
-     with the distribution.
-
-  7. Often, you can also type `make uninstall' to remove the installed
-     files again.  In practice, not all packages have tested that
-     uninstallation works correctly, even though it is required by the
-     GNU Coding Standards.
-
-  8. Some packages, particularly those that use Automake, provide `make
-     distcheck', which can by used by developers to test that all other
-     targets like `make install' and `make uninstall' work correctly.
-     This target is generally not run by end users.
-
-Compilers and Options
-=====================
-
-   Some systems require unusual options for compilation or linking that
-the `configure' script does not know about.  Run `./configure --help'
-for details on some of the pertinent environment variables.
-
-   You can give `configure' initial values for configuration parameters
-by setting variables in the command line or in the environment.  Here
-is an example:
-
-     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
-
-   *Note Defining Variables::, for more details.
-
-Compiling For Multiple Architectures
-====================================
-
-   You can compile the package for more than one kind of computer at the
-same time, by placing the object files for each architecture in their
-own directory.  To do this, you can use GNU `make'.  `cd' to the
-directory where you want the object files and executables to go and run
-the `configure' script.  `configure' automatically checks for the
-source code in the directory that `configure' is in and in `..'.  This
-is known as a "VPATH" build.
-
-   With a non-GNU `make', it is safer to compile the package for one
-architecture at a time in the source code directory.  After you have
-installed the package for one architecture, use `make distclean' before
-reconfiguring for another architecture.
-
-   On MacOS X 10.5 and later systems, you can create libraries and
-executables that work on multiple system types--known as "fat" or
-"universal" binaries--by specifying multiple `-arch' options to the
-compiler but only a single `-arch' option to the preprocessor.  Like
-this:
-
-     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
-                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
-                 CPP="gcc -E" CXXCPP="g++ -E"
-
-   This is not guaranteed to produce working output in all cases, you
-may have to build one architecture at a time and combine the results
-using the `lipo' tool if you have problems.
-
-Installation Names
-==================
-
-   By default, `make install' installs the package's commands under
-`/usr/local/bin', include files under `/usr/local/include', etc.  You
-can specify an installation prefix other than `/usr/local' by giving
-`configure' the option `--prefix=PREFIX', where PREFIX must be an
-absolute file name.
-
-   You can specify separate installation prefixes for
-architecture-specific files and architecture-independent files.  If you
-pass the option `--exec-prefix=PREFIX' to `configure', the package uses
-PREFIX as the prefix for installing programs and libraries.
-Documentation and other data files still use the regular prefix.
-
-   In addition, if you use an unusual directory layout you can give
-options like `--bindir=DIR' to specify different values for particular
-kinds of files.  Run `configure --help' for a list of the directories
-you can set and what kinds of files go in them.  In general, the
-default for these options is expressed in terms of `${prefix}', so that
-specifying just `--prefix' will affect all of the other directory
-specifications that were not explicitly provided.
-
-   The most portable way to affect installation locations is to pass the
-correct locations to `configure'; however, many packages provide one or
-both of the following shortcuts of passing variable assignments to the
-`make install' command line to change installation locations without
-having to reconfigure or recompile.
-
-   The first method involves providing an override variable for each
-affected directory.  For example, `make install
-prefix=/alternate/directory' will choose an alternate location for all
-directory configuration variables that were expressed in terms of
-`${prefix}'.  Any directories that were specified during `configure',
-but not in terms of `${prefix}', must each be overridden at install
-time for the entire installation to be relocated.  The approach of
-makefile variable overrides for each directory variable is required by
-the GNU Coding Standards, and ideally causes no recompilation.
-However, some platforms have known limitations with the semantics of
-shared libraries that end up requiring recompilation when using this
-method, particularly noticeable in packages that use GNU Libtool.
-
-   The second method involves providing the `DESTDIR' variable.  For
-example, `make install DESTDIR=/alternate/directory' will prepend
-`/alternate/directory' before all installation names.  The approach of
-`DESTDIR' overrides is not required by the GNU Coding Standards, and
-does not work on platforms that have drive letters.  On the other hand,
-it does better at avoiding recompilation issues, and works well even
-when some directory options were not specified in terms of `${prefix}'
-at `configure' time.
-
-Optional Features
-=================
-
-   If the package supports it, you can cause programs to be installed
-with an extra prefix or suffix on their names by giving `configure' the
-option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
-
-   Some packages pay attention to `--enable-FEATURE' options to
-`configure', where FEATURE indicates an optional part of the package.
-They may also pay attention to `--with-PACKAGE' options, where PACKAGE
-is something like `gnu-as' or `x' (for the X Window System).  The
-`README' should mention any `--enable-' and `--with-' options that the
-package recognizes.
-
-   For packages that use the X Window System, `configure' can usually
-find the X include and library files automatically, but if it doesn't,
-you can use the `configure' options `--x-includes=DIR' and
-`--x-libraries=DIR' to specify their locations.
-
-   Some packages offer the ability to configure how verbose the
-execution of `make' will be.  For these packages, running `./configure
---enable-silent-rules' sets the default to minimal output, which can be
-overridden with `make V=1'; while running `./configure
---disable-silent-rules' sets the default to verbose, which can be
-overridden with `make V=0'.
-
-Particular systems
-==================
-
-   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
-CC is not installed, it is recommended to use the following options in
-order to use an ANSI C compiler:
-
-     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
-
-and if that doesn't work, install pre-built binaries of GCC for HP-UX.
-
-   HP-UX `make' updates targets which have the same time stamps as
-their prerequisites, which makes it generally unusable when shipped
-generated files such as `configure' are involved.  Use GNU `make'
-instead.
-
-   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
-parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
-a workaround.  If GNU CC is not installed, it is therefore recommended
-to try
-
-     ./configure CC="cc"
-
-and if that doesn't work, try
-
-     ./configure CC="cc -nodtk"
-
-   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
-directory contains several dysfunctional programs; working variants of
-these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
-in your `PATH', put it _after_ `/usr/bin'.
-
-   On Haiku, software installed for all users goes in `/boot/common',
-not `/usr/local'.  It is recommended to use the following options:
-
-     ./configure --prefix=/boot/common
-
-Specifying the System Type
-==========================
-
-   There may be some features `configure' cannot figure out
-automatically, but needs to determine by the type of machine the package
-will run on.  Usually, assuming the package is built to be run on the
-_same_ architectures, `configure' can figure that out, but if it prints
-a message saying it cannot guess the machine type, give it the
-`--build=TYPE' option.  TYPE can either be a short name for the system
-type, such as `sun4', or a canonical name which has the form:
-
-     CPU-COMPANY-SYSTEM
-
-where SYSTEM can have one of these forms:
-
-     OS
-     KERNEL-OS
-
-   See the file `config.sub' for the possible values of each field.  If
-`config.sub' isn't included in this package, then this package doesn't
-need to know the machine type.
-
-   If you are _building_ compiler tools for cross-compiling, you should
-use the option `--target=TYPE' to select the type of system they will
-produce code for.
-
-   If you want to _use_ a cross compiler, that generates code for a
-platform different from the build platform, you should specify the
-"host" platform (i.e., that on which the generated programs will
-eventually be run) with `--host=TYPE'.
-
-Sharing Defaults
-================
-
-   If you want to set default values for `configure' scripts to share,
-you can create a site shell script called `config.site' that gives
-default values for variables like `CC', `cache_file', and `prefix'.
-`configure' looks for `PREFIX/share/config.site' if it exists, then
-`PREFIX/etc/config.site' if it exists.  Or, you can set the
-`CONFIG_SITE' environment variable to the location of the site script.
-A warning: not all `configure' scripts look for a site script.
-
-Defining Variables
-==================
-
-   Variables not defined in a site shell script can be set in the
-environment passed to `configure'.  However, some packages may run
-configure again during the build, and the customized values of these
-variables may be lost.  In order to avoid this problem, you should set
-them in the `configure' command line, using `VAR=value'.  For example:
-
-     ./configure CC=/usr/local2/bin/gcc
-
-causes the specified `gcc' to be used as the C compiler (unless it is
-overridden in the site shell script).
-
-Unfortunately, this technique does not work for `CONFIG_SHELL' due to
-an Autoconf bug.  Until the bug is fixed you can use this workaround:
-
-     CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
-
-`configure' Invocation
-======================
-
-   `configure' recognizes the following options to control how it
-operates.
-
-`--help'
-`-h'
-     Print a summary of all of the options to `configure', and exit.
-
-`--help=short'
-`--help=recursive'
-     Print a summary of the options unique to this package's
-     `configure', and exit.  The `short' variant lists options used
-     only in the top level, while the `recursive' variant lists options
-     also present in any nested packages.
-
-`--version'
-`-V'
-     Print the version of Autoconf used to generate the `configure'
-     script, and exit.
-
-`--cache-file=FILE'
-     Enable the cache: use and save the results of the tests in FILE,
-     traditionally `config.cache'.  FILE defaults to `/dev/null' to
-     disable caching.
-
-`--config-cache'
-`-C'
-     Alias for `--cache-file=config.cache'.
-
-`--quiet'
-`--silent'
-`-q'
-     Do not print messages saying which checks are being made.  To
-     suppress all normal output, redirect it to `/dev/null' (any error
-     messages will still be shown).
-
-`--srcdir=DIR'
-     Look for the package's source code in directory DIR.  Usually
-     `configure' can determine that directory automatically.
-
-`--prefix=DIR'
-     Use DIR as the installation prefix.  *note Installation Names::
-     for more details, including other options available for fine-tuning
-     the installation locations.
-
-`--no-create'
-`-n'
-     Run the configure checks, but stop before creating any output
-     files.
-
-`configure' also accepts some other, not widely useful, options.  Run
-`configure --help' for more details.
-

autoconf/Makefile.am

@@ -1,20 +0,0 @@
-
-AM_CFLAGS = @BUILD_CFLAGS@ 
-lib_LTLIBRARIES = libsqlite3.la
-libsqlite3_la_SOURCES = sqlite3.c
-libsqlite3_la_LDFLAGS = -no-undefined -version-info 8:6:8
-
-bin_PROGRAMS = sqlite3
-sqlite3_SOURCES = shell.c sqlite3.h
-EXTRA_sqlite3_SOURCES = sqlite3.c
-sqlite3_LDADD = @EXTRA_SHELL_OBJ@ @READLINE_LIBS@
-sqlite3_DEPENDENCIES = @EXTRA_SHELL_OBJ@
-sqlite3_CFLAGS = $(AM_CFLAGS) -DSQLITE_ENABLE_EXPLAIN_COMMENTS -DSQLITE_ENABLE_DBPAGE_VTAB -DSQLITE_ENABLE_STMTVTAB -DSQLITE_ENABLE_DBSTAT_VTAB $(SHELL_CFLAGS)
-
-include_HEADERS = sqlite3.h sqlite3ext.h
-
-EXTRA_DIST = sqlite3.1 tea Makefile.msc sqlite3.rc README.txt Replace.cs Makefile.fallback
-pkgconfigdir = ${libdir}/pkgconfig
-pkgconfig_DATA = sqlite3.pc
-
-man_MANS = sqlite3.1

autoconf/Makefile.fallback

@@ -1,19 +0,0 @@
-#!/usr/bin/make
-#
-# If the configure script does not work, then this Makefile is available
-# as a backup.  Manually configure the variables below.
-#
-# Note:  This makefile works out-of-the-box on MacOS 10.2 (Jaguar)
-#
-CC = gcc
-CFLAGS = -O0 -I.
-LIBS = -lz
-COPTS += -D_BSD_SOURCE
-COPTS += -DSQLITE_ENABLE_LOCKING_STYLE=0
-COPTS += -DSQLITE_THREADSAFE=0
-COPTS += -DSQLITE_OMIT_LOAD_EXTENSION
-COPTS += -DSQLITE_WITHOUT_ZONEMALLOC
-COPTS += -DSQLITE_ENABLE_RTREE
-
-sqlite3:	shell.c sqlite3.c
-	$(CC) $(CFLAGS) $(COPTS) -o sqlite3 shell.c sqlite3.c $(LIBS)

autoconf/README.first

@@ -1,11 +0,0 @@
-This directory contains components use to build an autoconf-ready package
-of the SQLite amalgamation:  sqlite-autoconf-30XXXXXX.tar.gz
-
-To build the autoconf amalgamation, run from the top-level:
-
-   ./configure
-   make amalgamation-tarball
-
-The amalgamation-tarball target (also available in "main.mk") runs the
-script tool/mkautoconfamal.sh which does the work.  Refer to that script
-for details.

autoconf/README.txt

@@ -1,113 +0,0 @@
-This package contains:
-
- * the SQLite library amalgamation source code file: sqlite3.c
- * the sqlite3.h and sqlite3ext.h header files that define the C-language
-   interface to the sqlite3.c library file
- * the shell.c file used to build the sqlite3 command-line shell program
- * autoconf/automake installation infrastucture for building on POSIX
-   compliant systems
- * a Makefile.msc, sqlite3.rc, and Replace.cs for building with Microsoft
-   Visual C++ on Windows
-
-SUMMARY OF HOW TO BUILD
-=======================
-
-  Unix:      ./configure; make
-  Windows:   nmake /f Makefile.msc
-
-BUILDING ON POSIX
-=================
-
-The generic installation instructions for autoconf/automake are found
-in the INSTALL file.
-
-The following SQLite specific boolean options are supported:
-
-  --enable-readline           use readline in shell tool   [default=yes]
-  --enable-threadsafe         build a thread-safe library  [default=yes]
-  --enable-dynamic-extensions support loadable extensions  [default=yes]
-
-The default value for the CFLAGS variable (options passed to the C
-compiler) includes debugging symbols in the build, resulting in larger
-binaries than are necessary. Override it on the configure command
-line like this:
-
-  $ CFLAGS="-Os" ./configure
-
-to produce a smaller installation footprint.
-
-Other SQLite compilation parameters can also be set using CFLAGS. For
-example:
-
-  $ CFLAGS="-Os -DSQLITE_THREADSAFE=0" ./configure
-
-
-BUILDING WITH MICROSOFT VISUAL C++
-==================================
-
-To compile for Windows using Microsoft Visual C++:
-
-  $ nmake /f Makefile.msc
-
-Using Microsoft Visual C++ 2005 (or later) is recommended.  Several Windows
-platform variants may be built by adding additional macros to the NMAKE
-command line.
-
-Building for WinRT 8.0
-----------------------
-
-  FOR_WINRT=1
-
-Using Microsoft Visual C++ 2012 (or later) is required.  When using the
-above, something like the following macro will need to be added to the
-NMAKE command line as well:
-
-  "NSDKLIBPATH=%WindowsSdkDir%\..\8.0\lib\win8\um\x86"
-
-Building for WinRT 8.1
-----------------------
-
-  FOR_WINRT=1
-
-Using Microsoft Visual C++ 2013 (or later) is required.  When using the
-above, something like the following macro will need to be added to the
-NMAKE command line as well:
-
-  "NSDKLIBPATH=%WindowsSdkDir%\..\8.1\lib\winv6.3\um\x86"
-
-Building for UWP 10.0
----------------------
-
-  FOR_WINRT=1 FOR_UWP=1
-
-Using Microsoft Visual C++ 2015 (or later) is required.  When using the
-above, something like the following macros will need to be added to the
-NMAKE command line as well:
-
-  "NSDKLIBPATH=%WindowsSdkDir%\..\10\lib\10.0.10586.0\um\x86"
-  "PSDKLIBPATH=%WindowsSdkDir%\..\10\lib\10.0.10586.0\um\x86"
-  "NUCRTLIBPATH=%UniversalCRTSdkDir%\..\10\lib\10.0.10586.0\ucrt\x86"
-
-Building for the Windows 10 SDK
--------------------------------
-
-  FOR_WIN10=1
-
-Using Microsoft Visual C++ 2015 (or later) is required.  When using the
-above, no other macros should be needed on the NMAKE command line.
-
-Other preprocessor defines
---------------------------
-
-Additionally, preprocessor defines may be specified by using the OPTS macro
-on the NMAKE command line.  However, not all possible preprocessor defines
-may be specified in this manner as some require the amalgamation to be built
-with them enabled (see http://www.sqlite.org/compile.html). For example, the
-following will work:
-
-  "OPTS=-DSQLITE_ENABLE_STAT4=1 -DSQLITE_ENABLE_JSON1=1"
-
-However, the following will not compile unless the amalgamation was built
-with it enabled:
-
-  "OPTS=-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT=1"

autoconf/configure.ac

@@ -1,239 +0,0 @@
-
-#-----------------------------------------------------------------------
-# Supports the following non-standard switches.
-#
-#   --enable-threadsafe
-#   --enable-readline
-#   --enable-editline
-#   --enable-static-shell
-#   --enable-dynamic-extensions
-#
-
-AC_PREREQ(2.61)
-AC_INIT(sqlite, --SQLITE-VERSION--, http://www.sqlite.org)
-AC_CONFIG_SRCDIR([sqlite3.c])
-AC_CONFIG_AUX_DIR([.])
-
-# Use automake.
-AM_INIT_AUTOMAKE([foreign])
-
-AC_SYS_LARGEFILE
-
-# Check for required programs.
-AC_PROG_CC
-AC_PROG_LIBTOOL
-AC_PROG_MKDIR_P
-
-# Check for library functions that SQLite can optionally use.
-AC_CHECK_FUNCS([fdatasync usleep fullfsync localtime_r gmtime_r])
-AC_FUNC_STRERROR_R
-
-AC_CONFIG_FILES([Makefile sqlite3.pc])
-BUILD_CFLAGS=
-AC_SUBST(BUILD_CFLAGS)
-
-#-------------------------------------------------------------------------
-# Two options to enable readline compatible libraries: 
-#
-#   --enable-editline
-#   --enable-readline
-#
-# Both are enabled by default. If, after command line processing both are
-# still enabled, the script searches for editline first and automatically
-# disables readline if it is found. So, to use readline explicitly, the
-# user must pass "--disable-editline". To disable command line editing
-# support altogether, "--disable-editline --disable-readline".
-#
-# When searching for either library, check for headers before libraries 
-# as some distros supply packages that contain libraries but not header
-# files, which come as a separate development package.
-#
-AC_ARG_ENABLE(editline, [AS_HELP_STRING([--enable-editline],[use BSD libedit])])
-AC_ARG_ENABLE(readline, [AS_HELP_STRING([--enable-readline],[use readline])])
-
-AS_IF([ test x"$enable_editline" != xno ],[
-  AC_CHECK_HEADERS([editline/readline.h],[
-    sLIBS=$LIBS
-    LIBS=""
-    AC_SEARCH_LIBS([readline],[edit],[
-      AC_DEFINE([HAVE_EDITLINE],1,Define to use BSD editline)
-      READLINE_LIBS="$LIBS -ltinfo"
-      enable_readline=no
-    ],[],[-ltinfo])
-    AS_UNSET(ac_cv_search_readline)
-    LIBS=$sLIBS
-  ])
-])
-
-AS_IF([ test x"$enable_readline" != xno ],[
-  AC_CHECK_HEADERS([readline/readline.h],[
-    sLIBS=$LIBS
-    LIBS=""
-    AC_SEARCH_LIBS(tgetent, termcap curses ncurses ncursesw, [], [])
-    AC_SEARCH_LIBS(readline,[readline edit], [
-      AC_DEFINE([HAVE_READLINE],1,Define to use readline or wrapper)
-      READLINE_LIBS=$LIBS
-    ])
-    LIBS=$sLIBS
-  ])
-])
-
-AC_SUBST(READLINE_LIBS)
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-threadsafe
-#
-AC_ARG_ENABLE(threadsafe, [AS_HELP_STRING(
-  [--enable-threadsafe], [build a thread-safe library [default=yes]])], 
-  [], [enable_threadsafe=yes])
-if test x"$enable_threadsafe" != "xno"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -D_REENTRANT=1 -DSQLITE_THREADSAFE=1"
-  AC_SEARCH_LIBS(pthread_create, pthread)
-  AC_SEARCH_LIBS(pthread_mutexattr_init, pthread)
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-dynamic-extensions
-#
-AC_ARG_ENABLE(dynamic-extensions, [AS_HELP_STRING(
-  [--enable-dynamic-extensions], [support loadable extensions [default=yes]])], 
-  [], [enable_dynamic_extensions=yes])
-if test x"$enable_dynamic_extensions" != "xno"; then
-  AC_SEARCH_LIBS(dlopen, dl)
-else
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_OMIT_LOAD_EXTENSION=1"
-fi
-AC_MSG_CHECKING([for whether to support dynamic extensions])
-AC_MSG_RESULT($enable_dynamic_extensions)
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-fts4
-#
-AC_ARG_ENABLE(fts4, [AS_HELP_STRING(
-  [--enable-fts4], [include fts4 support [default=yes]])], 
-  [], [enable_fts4=yes])
-if test x"$enable_fts4" = "xyes"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_FTS4"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-fts3
-#
-AC_ARG_ENABLE(fts3, [AS_HELP_STRING(
-  [--enable-fts3], [include fts3 support [default=no]])], 
-  [], [])
-if test x"$enable_fts3" = "xyes" -a x"$enable_fts4" = "xno"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_FTS3"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-fts5
-#
-AC_ARG_ENABLE(fts5, [AS_HELP_STRING(
-  [--enable-fts5], [include fts5 support [default=yes]])], 
-  [], [enable_fts5=yes])
-if test x"$enable_fts5" = "xyes"; then
-  AC_SEARCH_LIBS(log, m)
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_FTS5"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-json1
-#
-AC_ARG_ENABLE(json1, [AS_HELP_STRING(
-  [--enable-json1], [include json1 support [default=yes]])], 
-  [],[enable_json1=yes])
-if test x"$enable_json1" = "xyes"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_JSON1"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-rtree
-#
-AC_ARG_ENABLE(rtree, [AS_HELP_STRING(
-  [--enable-rtree], [include rtree support [default=yes]])], 
-  [], [enable_rtree=yes])
-if test x"$enable_rtree" = "xyes"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_GEOPOLY"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-session
-#
-AC_ARG_ENABLE(session, [AS_HELP_STRING(
-  [--enable-session], [enable the session extension [default=no]])], 
-  [], [])
-if test x"$enable_session" = "xyes"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_SESSION -DSQLITE_ENABLE_PREUPDATE_HOOK"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-debug
-#
-AC_ARG_ENABLE(debug, [AS_HELP_STRING(
-  [--enable-debug], [build with debugging features enabled [default=no]])], 
-  [], [])
-if test x"$enable_debug" = "xyes"; then
-  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_DEBUG -DSQLITE_ENABLE_SELECTTRACE -DSQLITE_ENABLE_WHERETRACE"
-  CFLAGS="-g -O0"
-fi
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-#   --enable-static-shell
-#
-AC_ARG_ENABLE(static-shell, [AS_HELP_STRING(
-  [--enable-static-shell], 
-  [statically link libsqlite3 into shell tool [default=yes]])], 
-  [], [enable_static_shell=yes])
-if test x"$enable_static_shell" = "xyes"; then
-  EXTRA_SHELL_OBJ=sqlite3-sqlite3.$OBJEXT
-else
-  EXTRA_SHELL_OBJ=libsqlite3.la
-fi
-AC_SUBST(EXTRA_SHELL_OBJ)
-#-----------------------------------------------------------------------
-
-AC_CHECK_FUNCS(posix_fallocate)
-AC_CHECK_HEADERS(zlib.h,[
-  AC_SEARCH_LIBS(deflate,z,[BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_HAVE_ZLIB"])
-])
-
-AC_SEARCH_LIBS(system,,,[SHELL_CFLAGS="-DSQLITE_NOHAVE_SYSTEM"])
-AC_SUBST(SHELL_CFLAGS)
-
-#-----------------------------------------------------------------------
-# UPDATE: Maybe it's better if users just set CFLAGS before invoking
-# configure. This option doesn't really add much...
-#
-#   --enable-tempstore
-#
-# AC_ARG_ENABLE(tempstore, [AS_HELP_STRING(
-#   [--enable-tempstore], 
-#   [in-memory temporary tables (never, no, yes, always) [default=no]])], 
-#   [], [enable_tempstore=no])
-# AC_MSG_CHECKING([for whether or not to store temp tables in-memory])
-# case "$enable_tempstore" in
-#   never )  TEMP_STORE=0 ;;
-#   no )     TEMP_STORE=1 ;;
-#   always ) TEMP_STORE=3 ;;
-#   yes )    TEMP_STORE=3 ;;
-#   * )
-#     TEMP_STORE=1
-#     enable_tempstore=yes
-#   ;;
-# esac
-# AC_MSG_RESULT($enable_tempstore)
-# AC_SUBST(TEMP_STORE)
-#-----------------------------------------------------------------------
-
-AC_OUTPUT

autoconf/tea/Makefile.in

@@ -1,440 +0,0 @@
-# Makefile.in --
-#
-#	This file is a Makefile for Sample TEA Extension.  If it has the name
-#	"Makefile.in" then it is a template for a Makefile;  to generate the
-#	actual Makefile, run "./configure", which is a configuration script
-#	generated by the "autoconf" program (constructs like "@foo@" will get
-#	replaced in the actual Makefile.
-#
-# Copyright (c) 1999 Scriptics Corporation.
-# Copyright (c) 2002-2005 ActiveState Corporation.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: Makefile.in,v 1.59 2005/07/26 19:17:02 mdejong Exp $
-
-#========================================================================
-# Add additional lines to handle any additional AC_SUBST cases that
-# have been added in a customized configure script.
-#========================================================================
-
-#SAMPLE_NEW_VAR	= @SAMPLE_NEW_VAR@
-
-#========================================================================
-# Nothing of the variables below this line should need to be changed.
-# Please check the TARGETS section below to make sure the make targets
-# are correct.
-#========================================================================
-
-#========================================================================
-# The names of the source files is defined in the configure script.
-# The object files are used for linking into the final library.
-# This will be used when a dist target is added to the Makefile.
-# It is not important to specify the directory, as long as it is the
-# $(srcdir) or in the generic, win or unix subdirectory.
-#========================================================================
-
-PKG_SOURCES	= @PKG_SOURCES@
-PKG_OBJECTS	= @PKG_OBJECTS@
-
-PKG_STUB_SOURCES = @PKG_STUB_SOURCES@
-PKG_STUB_OBJECTS = @PKG_STUB_OBJECTS@
-
-#========================================================================
-# PKG_TCL_SOURCES identifies Tcl runtime files that are associated with
-# this package that need to be installed, if any.
-#========================================================================
-
-PKG_TCL_SOURCES = @PKG_TCL_SOURCES@
-
-#========================================================================
-# This is a list of public header files to be installed, if any.
-#========================================================================
-
-PKG_HEADERS	= @PKG_HEADERS@
-
-#========================================================================
-# "PKG_LIB_FILE" refers to the library (dynamic or static as per
-# configuration options) composed of the named objects.
-#========================================================================
-
-PKG_LIB_FILE	= @PKG_LIB_FILE@
-PKG_STUB_LIB_FILE = @PKG_STUB_LIB_FILE@
-
-lib_BINARIES	= $(PKG_LIB_FILE)
-BINARIES	= $(lib_BINARIES)
-
-SHELL		= @SHELL@
-
-srcdir		= @srcdir@
-prefix		= @prefix@
-exec_prefix	= @exec_prefix@
-
-bindir		= @bindir@
-libdir		= @libdir@
-datarootdir	= @datarootdir@
-datadir		= @datadir@
-mandir		= @mandir@
-includedir	= @includedir@
-
-DESTDIR		=
-
-PKG_DIR		= $(PACKAGE_NAME)$(PACKAGE_VERSION)
-pkgdatadir	= $(datadir)/$(PKG_DIR)
-pkglibdir	= $(libdir)/$(PKG_DIR)
-pkgincludedir	= $(includedir)/$(PKG_DIR)
-
-top_builddir	= .
-
-INSTALL		= @INSTALL@
-INSTALL_PROGRAM	= @INSTALL_PROGRAM@
-INSTALL_DATA	= @INSTALL_DATA@
-INSTALL_SCRIPT	= @INSTALL_SCRIPT@
-
-PACKAGE_NAME	= @PACKAGE_NAME@
-PACKAGE_VERSION	= @PACKAGE_VERSION@
-CC		= @CC@
-CFLAGS_DEFAULT	= @CFLAGS_DEFAULT@
-CFLAGS_WARNING	= @CFLAGS_WARNING@
-CLEANFILES	= @CLEANFILES@
-EXEEXT		= @EXEEXT@
-LDFLAGS_DEFAULT	= @LDFLAGS_DEFAULT@
-MAKE_LIB	= @MAKE_LIB@
-MAKE_SHARED_LIB	= @MAKE_SHARED_LIB@
-MAKE_STATIC_LIB	= @MAKE_STATIC_LIB@
-MAKE_STUB_LIB	= @MAKE_STUB_LIB@
-OBJEXT		= @OBJEXT@
-RANLIB		= @RANLIB@
-RANLIB_STUB	= @RANLIB_STUB@
-SHLIB_CFLAGS	= @SHLIB_CFLAGS@
-SHLIB_LD	= @SHLIB_LD@
-SHLIB_LD_LIBS	= @SHLIB_LD_LIBS@
-STLIB_LD	= @STLIB_LD@
-#TCL_DEFS	= @TCL_DEFS@
-TCL_BIN_DIR	= @TCL_BIN_DIR@
-TCL_SRC_DIR	= @TCL_SRC_DIR@
-#TK_BIN_DIR	= @TK_BIN_DIR@
-#TK_SRC_DIR	= @TK_SRC_DIR@
-
-# This is no longer necessary even for packages that use private Tcl headers
-#TCL_TOP_DIR_NATIVE	= @TCL_TOP_DIR_NATIVE@
-# Not used, but retained for reference of what libs Tcl required
-#TCL_LIBS	= @TCL_LIBS@
-
-#========================================================================
-# TCLLIBPATH seeds the auto_path in Tcl's init.tcl so we can test our
-# package without installing.  The other environment variables allow us
-# to test against an uninstalled Tcl.  Add special env vars that you
-# require for testing here (like TCLX_LIBRARY).
-#========================================================================
-
-EXTRA_PATH	= $(top_builddir):$(TCL_BIN_DIR)
-#EXTRA_PATH	= $(top_builddir):$(TCL_BIN_DIR):$(TK_BIN_DIR)
-TCLLIBPATH	= $(top_builddir)
-TCLSH_ENV	= TCL_LIBRARY=`@CYGPATH@ $(TCL_SRC_DIR)/library` \
-		  @LD_LIBRARY_PATH_VAR@="$(EXTRA_PATH):$(@LD_LIBRARY_PATH_VAR@)" \
-		  PATH="$(EXTRA_PATH):$(PATH)" \
-		  TCLLIBPATH="$(TCLLIBPATH)"
-#		  TK_LIBRARY=`@CYGPATH@ $(TK_SRC_DIR)/library`
-
-TCLSH_PROG	= @TCLSH_PROG@
-TCLSH	= $(TCLSH_ENV) $(TCLSH_PROG)
-
-#WISH_PROG	= @WISH_PROG@
-#WISH	= $(TCLSH_ENV) $(WISH_PROG)
-
-
-SHARED_BUILD	= @SHARED_BUILD@
-
-INCLUDES	= @PKG_INCLUDES@ @TCL_INCLUDES@ -I$(srcdir)/..
-#INCLUDES	= @PKG_INCLUDES@ @TCL_INCLUDES@ @TK_INCLUDES@ @TK_XINCLUDES@
-
-PKG_CFLAGS	= @PKG_CFLAGS@
-
-# TCL_DEFS is not strictly need here, but if you remove it, then you
-# must make sure that configure.in checks for the necessary components
-# that your library may use.  TCL_DEFS can actually be a problem if
-# you do not compile with a similar machine setup as the Tcl core was
-# compiled with.
-#DEFS		= $(TCL_DEFS) @DEFS@ $(PKG_CFLAGS)
-DEFS		= @DEFS@ $(PKG_CFLAGS)
-
-CONFIG_CLEAN_FILES = Makefile pkgIndex.tcl
-
-CPPFLAGS	= @CPPFLAGS@
-LIBS		= @PKG_LIBS@ @LIBS@
-AR		= @AR@
-CFLAGS		= @CFLAGS@
-COMPILE		= $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
-
-#========================================================================
-# Start of user-definable TARGETS section
-#========================================================================
-
-#========================================================================
-# TEA TARGETS.  Please note that the "libraries:" target refers to platform
-# independent files, and the "binaries:" target inclues executable programs and
-# platform-dependent libraries.  Modify these targets so that they install
-# the various pieces of your package.  The make and install rules
-# for the BINARIES that you specified above have already been done.
-#========================================================================
-
-all: binaries libraries doc
-
-#========================================================================
-# The binaries target builds executable programs, Windows .dll's, unix
-# shared/static libraries, and any other platform-dependent files.
-# The list of targets to build for "binaries:" is specified at the top
-# of the Makefile, in the "BINARIES" variable.
-#========================================================================
-
-binaries: $(BINARIES)
-
-libraries:
-
-
-#========================================================================
-# Your doc target should differentiate from doc builds (by the developer)
-# and doc installs (see install-doc), which just install the docs on the
-# end user machine when building from source.
-#========================================================================
-
-doc:
-	@echo "If you have documentation to create, place the commands to"
-	@echo "build the docs in the 'doc:' target.  For example:"
-	@echo "        xml2nroff sample.xml > sample.n"
-	@echo "        xml2html sample.xml > sample.html"
-
-install: all install-binaries install-libraries install-doc
-
-install-binaries: binaries install-lib-binaries install-bin-binaries
-
-#========================================================================
-# This rule installs platform-independent files, such as header files.
-# The list=...; for p in $$list handles the empty list case x-platform.
-#========================================================================
-
-install-libraries: libraries
-	@mkdir -p $(DESTDIR)$(includedir)
-	@echo "Installing header files in $(DESTDIR)$(includedir)"
-	@list='$(PKG_HEADERS)'; for i in $$list; do \
-	    echo "Installing $(srcdir)/$$i" ; \
-	    $(INSTALL_DATA) $(srcdir)/$$i $(DESTDIR)$(includedir) ; \
-	done;
-
-#========================================================================
-# Install documentation.  Unix manpages should go in the $(mandir)
-# directory.
-#========================================================================
-
-install-doc: doc
-	@mkdir -p $(DESTDIR)$(mandir)/mann
-	@echo "Installing documentation in $(DESTDIR)$(mandir)"
-	@list='$(srcdir)/doc/*.n'; for i in $$list; do \
-	    echo "Installing $$i"; \
-	    rm -f $(DESTDIR)$(mandir)/mann/`basename $$i`; \
-	    $(INSTALL_DATA) $$i $(DESTDIR)$(mandir)/mann ; \
-	done
-
-test: binaries libraries
-	@echo "SQLite TEA distribution does not include tests"
-
-shell: binaries libraries
-	@$(TCLSH) $(SCRIPT)
-
-gdb:
-	$(TCLSH_ENV) gdb $(TCLSH_PROG) $(SCRIPT)
-
-depend:
-
-#========================================================================
-# $(PKG_LIB_FILE) should be listed as part of the BINARIES variable
-# mentioned above.  That will ensure that this target is built when you
-# run "make binaries".
-#
-# The $(PKG_OBJECTS) objects are created and linked into the final
-# library.  In most cases these object files will correspond to the
-# source files above.
-#========================================================================
-
-$(PKG_LIB_FILE): $(PKG_OBJECTS)
-	-rm -f $(PKG_LIB_FILE)
-	${MAKE_LIB}
-	$(RANLIB) $(PKG_LIB_FILE)
-
-$(PKG_STUB_LIB_FILE): $(PKG_STUB_OBJECTS)
-	-rm -f $(PKG_STUB_LIB_FILE)
-	${MAKE_STUB_LIB}
-	$(RANLIB_STUB) $(PKG_STUB_LIB_FILE)
-
-#========================================================================
-# We need to enumerate the list of .c to .o lines here.
-#
-# In the following lines, $(srcdir) refers to the toplevel directory
-# containing your extension.  If your sources are in a subdirectory,
-# you will have to modify the paths to reflect this:
-#
-# sample.$(OBJEXT): $(srcdir)/generic/sample.c
-# 	$(COMPILE) -c `@CYGPATH@ $(srcdir)/generic/sample.c` -o $@
-#
-# Setting the VPATH variable to a list of paths will cause the makefile
-# to look into these paths when resolving .c to .obj dependencies.
-# As necessary, add $(srcdir):$(srcdir)/compat:....
-#========================================================================
-
-VPATH = $(srcdir):$(srcdir)/generic:$(srcdir)/unix:$(srcdir)/win
-
-.c.@OBJEXT@:
-	$(COMPILE) -c `@CYGPATH@ $<` -o $@
-
-#========================================================================
-# Distribution creation
-# You may need to tweak this target to make it work correctly.
-#========================================================================
-
-#COMPRESS	= tar cvf $(PKG_DIR).tar $(PKG_DIR); compress $(PKG_DIR).tar
-COMPRESS	= gtar zcvf $(PKG_DIR).tar.gz $(PKG_DIR)
-DIST_ROOT	= /tmp/dist
-DIST_DIR	= $(DIST_ROOT)/$(PKG_DIR)
-
-dist-clean:
-	rm -rf $(DIST_DIR) $(DIST_ROOT)/$(PKG_DIR).tar.*
-
-dist: dist-clean
-	mkdir -p $(DIST_DIR)
-	cp -p $(srcdir)/README* $(srcdir)/license* \
-		$(srcdir)/aclocal.m4 $(srcdir)/configure $(srcdir)/*.in \
-		$(DIST_DIR)/
-	chmod 664 $(DIST_DIR)/Makefile.in $(DIST_DIR)/aclocal.m4
-	chmod 775 $(DIST_DIR)/configure $(DIST_DIR)/configure.in
-
-	for i in $(srcdir)/*.[ch]; do \
-	    if [ -f $$i ]; then \
-		cp -p $$i $(DIST_DIR)/ ; \
-	    fi; \
-	done;
-
-	mkdir $(DIST_DIR)/tclconfig
-	cp $(srcdir)/tclconfig/install-sh $(srcdir)/tclconfig/tcl.m4 \
-		$(DIST_DIR)/tclconfig/
-	chmod 664 $(DIST_DIR)/tclconfig/tcl.m4
-	chmod +x $(DIST_DIR)/tclconfig/install-sh
-
-	list='demos doc generic library mac tests unix win'; \
-	for p in $$list; do \
-	    if test -d $(srcdir)/$$p ; then \
-		mkdir $(DIST_DIR)/$$p; \
-		cp -p $(srcdir)/$$p/*.* $(DIST_DIR)/$$p/; \
-	    fi; \
-	done
-
-	(cd $(DIST_ROOT); $(COMPRESS);)
-
-#========================================================================
-# End of user-definable section
-#========================================================================
-
-#========================================================================
-# Don't modify the file to clean here.  Instead, set the "CLEANFILES"
-# variable in configure.in
-#========================================================================
-
-clean:  
-	-test -z "$(BINARIES)" || rm -f $(BINARIES)
-	-rm -f *.$(OBJEXT) core *.core
-	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
-
-distclean: clean
-	-rm -f *.tab.c
-	-rm -f $(CONFIG_CLEAN_FILES)
-	-rm -f config.h config.cache config.log config.status
-
-#========================================================================
-# Install binary object libraries.  On Windows this includes both .dll and
-# .lib files.  Because the .lib files are not explicitly listed anywhere,
-# we need to deduce their existence from the .dll file of the same name.
-# Library files go into the lib directory.
-# In addition, this will generate the pkgIndex.tcl
-# file in the install location (assuming it can find a usable tclsh shell)
-#
-# You should not have to modify this target.
-#========================================================================
-
-install-lib-binaries: binaries
-	@mkdir -p $(DESTDIR)$(pkglibdir)
-	@list='$(lib_BINARIES)'; for p in $$list; do \
-	  if test -f $$p; then \
-	    echo " $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkglibdir)/$$p"; \
-	    $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkglibdir)/$$p; \
-	    stub=`echo $$p|sed -e "s/.*\(stub\).*/\1/"`; \
-	    if test "x$$stub" = "xstub"; then \
-		echo " $(RANLIB_STUB) $(DESTDIR)$(pkglibdir)/$$p"; \
-		$(RANLIB_STUB) $(DESTDIR)$(pkglibdir)/$$p; \
-	    else \
-		echo " $(RANLIB) $(DESTDIR)$(pkglibdir)/$$p"; \
-		$(RANLIB) $(DESTDIR)$(pkglibdir)/$$p; \
-	    fi; \
-	    ext=`echo $$p|sed -e "s/.*\.//"`; \
-	    if test "x$$ext" = "xdll"; then \
-		lib=`basename $$p|sed -e 's/.[^.]*$$//'`.lib; \
-		if test -f $$lib; then \
-		    echo " $(INSTALL_DATA) $$lib $(DESTDIR)$(pkglibdir)/$$lib"; \
-	            $(INSTALL_DATA) $$lib $(DESTDIR)$(pkglibdir)/$$lib; \
-		fi; \
-	    fi; \
-	  fi; \
-	done
-	@list='$(PKG_TCL_SOURCES)'; for p in $$list; do \
-	  if test -f $(srcdir)/$$p; then \
-	    destp=`basename $$p`; \
-	    echo " Install $$destp $(DESTDIR)$(pkglibdir)/$$destp"; \
-	    $(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(pkglibdir)/$$destp; \
-	  fi; \
-	done
-	@if test "x$(SHARED_BUILD)" = "x1"; then \
-	    echo " Install pkgIndex.tcl $(DESTDIR)$(pkglibdir)"; \
-	    $(INSTALL_DATA) pkgIndex.tcl $(DESTDIR)$(pkglibdir); \
-	fi
-
-#========================================================================
-# Install binary executables (e.g. .exe files and dependent .dll files)
-# This is for files that must go in the bin directory (located next to
-# wish and tclsh), like dependent .dll files on Windows.
-#
-# You should not have to modify this target, except to define bin_BINARIES
-# above if necessary.
-#========================================================================
-
-install-bin-binaries: binaries
-	@mkdir -p $(DESTDIR)$(bindir)
-	@list='$(bin_BINARIES)'; for p in $$list; do \
-	  if test -f $$p; then \
-	    echo " $(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/$$p"; \
-	    $(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/$$p; \
-	  fi; \
-	done
-
-.SUFFIXES: .c .$(OBJEXT)
-
-Makefile: $(srcdir)/Makefile.in  $(top_builddir)/config.status
-	cd $(top_builddir) \
-	  && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
-
-uninstall-binaries:
-	list='$(lib_BINARIES)'; for p in $$list; do \
-	  rm -f $(DESTDIR)$(pkglibdir)/$$p; \
-	done
-	list='$(PKG_TCL_SOURCES)'; for p in $$list; do \
-	  p=`basename $$p`; \
-	  rm -f $(DESTDIR)$(pkglibdir)/$$p; \
-	done
-	list='$(bin_BINARIES)'; for p in $$list; do \
-	  rm -f $(DESTDIR)$(bindir)/$$p; \
-	done
-
-.PHONY: all binaries clean depend distclean doc install libraries test
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:

autoconf/tea/README

@@ -1,36 +0,0 @@
-This is the SQLite extension for Tcl using the Tcl Extension
-Architecture (TEA).  For additional information on SQLite see
-
-        http://www.sqlite.org/
-
-
-UNIX BUILD
-==========
-
-Building under most UNIX systems is easy, just run the configure script
-and then run make. For more information about the build process, see
-the tcl/unix/README file in the Tcl src dist. The following minimal
-example will install the extension in the /opt/tcl directory.
-
-	$ cd sqlite-*-tea
-	$ ./configure --prefix=/opt/tcl
-	$ make
-	$ make install
-
-WINDOWS BUILD
-=============
-
-The recommended method to build extensions under windows is to use the
-Msys + Mingw build process. This provides a Unix-style build while
-generating native Windows binaries. Using the Msys + Mingw build tools
-means that you can use the same configure script as per the Unix build
-to create a Makefile. See the tcl/win/README file for the URL of
-the Msys + Mingw download.
-
-If you have VC++ then you may wish to use the files in the win
-subdirectory and build the extension using just VC++. These files have
-been designed to be as generic as possible but will require some
-additional maintenance by the project developer to synchronise with
-the TEA configure.in and Makefile.in files. Instructions for using the
-VC++ makefile are written in the first part of the Makefile.vc
-file.

autoconf/tea/aclocal.m4

@@ -1,9 +0,0 @@
-#
-# Include the TEA standard macro set
-#
-
-builtin(include,tclconfig/tcl.m4)
-
-#
-# Add here whatever m4 macros you want to define for your package
-#

autoconf/tea/configure.ac

@@ -1,201 +0,0 @@
-#!/bin/bash -norc
-dnl	This file is an input file used by the GNU "autoconf" program to
-dnl	generate the file "configure", which is run during Tcl installation
-dnl	to configure the system for the local environment.
-#
-# RCS: @(#) $Id: configure.in,v 1.43 2005/07/26 19:17:05 mdejong Exp $
-
-#-----------------------------------------------------------------------
-# Sample configure.in for Tcl Extensions.  The only places you should
-# need to modify this file are marked by the string __CHANGE__
-#-----------------------------------------------------------------------
-
-#-----------------------------------------------------------------------
-# __CHANGE__
-# Set your package name and version numbers here.
-#
-# This initializes the environment with PACKAGE_NAME and PACKAGE_VERSION
-# set as provided.  These will also be added as -D defs in your Makefile
-# so you can encode the package version directly into the source files.
-#-----------------------------------------------------------------------
-
-AC_INIT([sqlite], [3.32.0])
-
-#--------------------------------------------------------------------
-# Call TEA_INIT as the first TEA_ macro to set up initial vars.
-# This will define a ${TEA_PLATFORM} variable == "unix" or "windows"
-# as well as PKG_LIB_FILE and PKG_STUB_LIB_FILE.
-#--------------------------------------------------------------------
-
-TEA_INIT([3.9])
-
-AC_CONFIG_AUX_DIR(tclconfig)
-
-#--------------------------------------------------------------------
-# Load the tclConfig.sh file
-#--------------------------------------------------------------------
-
-TEA_PATH_TCLCONFIG
-TEA_LOAD_TCLCONFIG
-
-#--------------------------------------------------------------------
-# Load the tkConfig.sh file if necessary (Tk extension)
-#--------------------------------------------------------------------
-
-#TEA_PATH_TKCONFIG
-#TEA_LOAD_TKCONFIG
-
-#-----------------------------------------------------------------------
-# Handle the --prefix=... option by defaulting to what Tcl gave.
-# Must be called after TEA_LOAD_TCLCONFIG and before TEA_SETUP_COMPILER.
-#-----------------------------------------------------------------------
-
-TEA_PREFIX
-
-#-----------------------------------------------------------------------
-# Standard compiler checks.
-# This sets up CC by using the CC env var, or looks for gcc otherwise.
-# This also calls AC_PROG_CC, AC_PROG_INSTALL and a few others to create
-# the basic setup necessary to compile executables.
-#-----------------------------------------------------------------------
-
-TEA_SETUP_COMPILER
-
-#-----------------------------------------------------------------------
-# __CHANGE__
-# Specify the C source files to compile in TEA_ADD_SOURCES,
-# public headers that need to be installed in TEA_ADD_HEADERS,
-# stub library C source files to compile in TEA_ADD_STUB_SOURCES,
-# and runtime Tcl library files in TEA_ADD_TCL_SOURCES.
-# This defines PKG(_STUB)_SOURCES, PKG(_STUB)_OBJECTS, PKG_HEADERS
-# and PKG_TCL_SOURCES.
-#-----------------------------------------------------------------------
-
-TEA_ADD_SOURCES([tclsqlite3.c])
-TEA_ADD_HEADERS([])
-TEA_ADD_INCLUDES([-I\"`\${CYGPATH} \${srcdir}/generic`\"])
-TEA_ADD_LIBS([])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_FTS3=1])
-TEA_ADD_CFLAGS([-DSQLITE_3_SUFFIX_ONLY=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_RTREE=1])
-TEA_ADD_STUB_SOURCES([])
-TEA_ADD_TCL_SOURCES([])
-
-#--------------------------------------------------------------------
-# The --with-system-sqlite causes the TCL bindings to SQLite to use
-# the system shared library for SQLite rather than statically linking
-# against its own private copy.  This is dangerous and leads to
-# undersirable dependences and is not recommended.
-# Patchs from rmax.
-#--------------------------------------------------------------------
-AC_ARG_WITH([system-sqlite],
- [AC_HELP_STRING([--with-system-sqlite],
-   [use a system-supplied libsqlite3 instead of the bundled one])],
- [], [with_system_sqlite=no])
-if test x$with_system_sqlite != xno; then
- AC_CHECK_HEADER([sqlite3.h],
-   [AC_CHECK_LIB([sqlite3],[sqlite3_initialize],
-     [AC_DEFINE(USE_SYSTEM_SQLITE)
-      LIBS="$LIBS -lsqlite3"])])
-fi
-
-#--------------------------------------------------------------------
-# __CHANGE__
-# Choose which headers you need.  Extension authors should try very
-# hard to only rely on the Tcl public header files.  Internal headers
-# contain private data structures and are subject to change without
-# notice.
-# This MUST be called after TEA_LOAD_TCLCONFIG / TEA_LOAD_TKCONFIG
-#--------------------------------------------------------------------
-
-TEA_PUBLIC_TCL_HEADERS
-#TEA_PRIVATE_TCL_HEADERS
-
-#TEA_PUBLIC_TK_HEADERS
-#TEA_PRIVATE_TK_HEADERS
-#TEA_PATH_X
-
-#--------------------------------------------------------------------
-# Check whether --enable-threads or --disable-threads was given.
-# This auto-enables if Tcl was compiled threaded.
-#--------------------------------------------------------------------
-
-TEA_ENABLE_THREADS
-if test "${TCL_THREADS}" = "1" ; then
-    AC_DEFINE(SQLITE_THREADSAFE, 1, [Trigger sqlite threadsafe build])
-    # Not automatically added by Tcl because its assumed Tcl links to them,
-    # but it may not if it isn't really a threaded build.
-    TEA_ADD_LIBS([$THREADS_LIBS])
-else
-    AC_DEFINE(SQLITE_THREADSAFE, 0, [Trigger sqlite non-threadsafe build])
-fi
-
-#--------------------------------------------------------------------
-# The statement below defines a collection of symbols related to
-# building as a shared library instead of a static library.
-#--------------------------------------------------------------------
-
-TEA_ENABLE_SHARED
-
-#--------------------------------------------------------------------
-# This macro figures out what flags to use with the compiler/linker
-# when building shared/static debug/optimized objects.  This information
-# can be taken from the tclConfig.sh file, but this figures it all out.
-#--------------------------------------------------------------------
-
-TEA_CONFIG_CFLAGS
-
-#--------------------------------------------------------------------
-# Set the default compiler switches based on the --enable-symbols option.
-#--------------------------------------------------------------------
-
-TEA_ENABLE_SYMBOLS
-
-#--------------------------------------------------------------------
-# Everyone should be linking against the Tcl stub library.  If you
-# can't for some reason, remove this definition.  If you aren't using
-# stubs, you also need to modify the SHLIB_LD_LIBS setting below to
-# link against the non-stubbed Tcl library.  Add Tk too if necessary.
-#--------------------------------------------------------------------
-
-AC_DEFINE(USE_TCL_STUBS, 1, [Use Tcl stubs])
-#AC_DEFINE(USE_TK_STUBS, 1, [Use Tk stubs])
-
-
-#--------------------------------------------------------------------
-# Redefine fdatasync as fsync on systems that lack fdatasync
-#--------------------------------------------------------------------
-#
-#AC_CHECK_FUNC(fdatasync, , AC_DEFINE(fdatasync, fsync))
-# Check for library functions that SQLite can optionally use.
-AC_CHECK_FUNCS([fdatasync usleep fullfsync localtime_r gmtime_r])
-
-AC_FUNC_STRERROR_R
-
-
-#--------------------------------------------------------------------
-# This macro generates a line to use when building a library.  It
-# depends on values set by the TEA_ENABLE_SHARED, TEA_ENABLE_SYMBOLS,
-# and TEA_LOAD_TCLCONFIG macros above.
-#--------------------------------------------------------------------
-
-TEA_MAKE_LIB
-
-#--------------------------------------------------------------------
-# Determine the name of the tclsh and/or wish executables in the
-# Tcl and Tk build directories or the location they were installed
-# into. These paths are used to support running test cases only,
-# the Makefile should not be making use of these paths to generate
-# a pkgIndex.tcl file or anything else at extension build time.
-#--------------------------------------------------------------------
-
-TEA_PROG_TCLSH
-#TEA_PROG_WISH
-
-#--------------------------------------------------------------------
-# Finally, substitute all of the various values into the Makefile.
-# You may alternatively have a special pkgIndex.tcl.in or other files
-# which require substituting th AC variables in.  Include these here.
-#--------------------------------------------------------------------
-
-AC_OUTPUT([Makefile pkgIndex.tcl])

autoconf/tea/doc/sqlite3.n

@@ -1,15 +0,0 @@
-.TH sqlite3 n 4.1 "Tcl-Extensions"
-.HS sqlite3 tcl
-.BS
-.SH NAME
-sqlite3 \- an interface to the SQLite3 database engine
-.SH SYNOPSIS
-\fBsqlite3\fI command_name ?filename?\fR
-.br
-.SH DESCRIPTION
-SQLite3 is a self-contains, zero-configuration, transactional SQL database
-engine.  This extension provides an easy to use interface for accessing
-SQLite database files from Tcl.
-.PP
-For full documentation see \fIhttp://www.sqlite.org/\fR and
-in particular \fIhttp://www.sqlite.org/tclsqlite.html\fR.

autoconf/tea/license.terms

@@ -1,6 +0,0 @@
-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.

autoconf/tea/pkgIndex.tcl.in

@@ -1,7 +0,0 @@
-#
-# Tcl package index file
-#
-# Note sqlite*3* init specifically
-#
-package ifneeded sqlite3 @PACKAGE_VERSION@ \
-    [list load [file join $dir @PKG_LIB_FILE@] Sqlite3]

autoconf/tea/tclconfig/install-sh

@@ -1,528 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2011-04-20.01; # UTC
-
-# This originates from X11R5 (mit/util/scripts/install.sh), which was
-# later released in X11R6 (xc/config/util/install.sh) with the
-# following copyright and license.
-#
-# Copyright (C) 1994 X Consortium
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
-# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Except as contained in this notice, the name of the X Consortium shall not
-# be used in advertising or otherwise to promote the sale, use or other deal-
-# ings in this Software without prior written authorization from the X Consor-
-# tium.
-#
-#
-# FSF changes to this file are in the public domain.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# `make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-
-nl='
-'
-IFS=" ""	$nl"
-
-# set DOITPROG to echo to test this script
-
-# Don't use :- since 4.3BSD and earlier shells don't like it.
-doit=${DOITPROG-}
-if test -z "$doit"; then
-  doit_exec=exec
-else
-  doit_exec=$doit
-fi
-
-# Put in absolute file names if you don't have them in your path;
-# or use environment vars.
-
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
-
-posix_glob='?'
-initialize_posix_glob='
-  test "$posix_glob" != "?" || {
-    if (set -f) 2>/dev/null; then
-      posix_glob=
-    else
-      posix_glob=:
-    fi
-  }
-'
-
-posix_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-no_target_directory=
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-   or: $0 [OPTION]... SRCFILES... DIRECTORY
-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
-   or: $0 [OPTION]... -d DIRECTORIES...
-
-In the 1st form, copy SRCFILE to DSTFILE.
-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
-In the 4th, create DIRECTORIES.
-
-Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve the last data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -s            $stripprog installed files.
-  -S            $stripprog installed files.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
-
-Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-"
-
-while test $# -ne 0; do
-  case $1 in
-    -c) ;;
-
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
-
-    -g) chgrpcmd="$chgrpprog $2"
-	shift;;
-
-    --help) echo "$usage"; exit $?;;
-
-    -m) mode=$2
-	case $mode in
-	  *' '* | *'	'* | *'
-'*	  | *'*'* | *'?'* | *'['*)
-	    echo "$0: invalid mode: $mode" >&2
-	    exit 1;;
-	esac
-	shift;;
-
-    -o) chowncmd="$chownprog $2"
-	shift;;
-
-    -s) stripcmd=$stripprog;;
-
-    -S) stripcmd="$stripprog $2"
-	shift;;
-
-    -t) dst_arg=$2
-	shift;;
-
-    -T) no_target_directory=true;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --)	shift
-	break;;
-
-    -*)	echo "$0: invalid option: $1" >&2
-	exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
-  # When -d is used, all remaining arguments are directories to create.
-  # When -t is used, the destination is already specified.
-  # Otherwise, the last argument is the destination.  Remove it from $@.
-  for arg
-  do
-    if test -n "$dst_arg"; then
-      # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
-      shift # fnord
-    fi
-    shift # arg
-    dst_arg=$arg
-  done
-fi
-
-if test $# -eq 0; then
-  if test -z "$dir_arg"; then
-    echo "$0: no input file specified." >&2
-    exit 1
-  fi
-  # It's OK to call `install-sh -d' without argument.
-  # This can happen when creating conditional directories.
-  exit 0
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
-
-  # Set umask so as not to create temps with too-generous modes.
-  # However, 'strip' requires both read and write access to temps.
-  case $mode in
-    # Optimize common cases.
-    *644) cp_umask=133;;
-    *755) cp_umask=22;;
-
-    *[0-7])
-      if test -z "$stripcmd"; then
-	u_plus_rw=
-      else
-	u_plus_rw='% 200'
-      fi
-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
-    *)
-      if test -z "$stripcmd"; then
-	u_plus_rw=
-      else
-	u_plus_rw=,u+rw
-      fi
-      cp_umask=$mode$u_plus_rw;;
-  esac
-fi
-
-for src
-do
-  # Protect names starting with `-'.
-  case $src in
-    -*) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-  else
-
-    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
-    # might cause directories to be created, which would be especially bad
-    # if $src (and thus $dsttmp) contains '*'.
-    if test ! -f "$src" && test ! -d "$src"; then
-      echo "$0: $src does not exist." >&2
-      exit 1
-    fi
-
-    if test -z "$dst_arg"; then
-      echo "$0: no destination specified." >&2
-      exit 1
-    fi
-
-    dst=$dst_arg
-    # Protect names starting with `-'.
-    case $dst in
-      -*) dst=./$dst;;
-    esac
-
-    # If destination is a directory, append the input filename; won't work
-    # if double slashes aren't ignored.
-    if test -d "$dst"; then
-      if test -n "$no_target_directory"; then
-	echo "$0: $dst_arg: Is a directory" >&2
-	exit 1
-      fi
-      dstdir=$dst
-      dst=$dstdir/`basename "$src"`
-      dstdir_status=0
-    else
-      # Prefer dirname, but fall back on a substitute if dirname fails.
-      dstdir=`
-	(dirname "$dst") 2>/dev/null ||
-	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	     X"$dst" : 'X\(//\)[^/]' \| \
-	     X"$dst" : 'X\(//\)$' \| \
-	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
-	echo X"$dst" |
-	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-		   s//\1/
-		   q
-		 }
-		 /^X\(\/\/\)[^/].*/{
-		   s//\1/
-		   q
-		 }
-		 /^X\(\/\/\)$/{
-		   s//\1/
-		   q
-		 }
-		 /^X\(\/\).*/{
-		   s//\1/
-		   q
-		 }
-		 s/.*/./; q'
-      `
-
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-	# Create intermediate dirs using mode 755 as modified by the umask.
-	# This is like FreeBSD 'install' as of 1997-10-28.
-	umask=`umask`
-	case $stripcmd.$umask in
-	  # Optimize common cases.
-	  *[2367][2367]) mkdir_umask=$umask;;
-	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
-
-	  *[0-7])
-	    mkdir_umask=`expr $umask + 22 \
-	      - $umask % 100 % 40 + $umask % 20 \
-	      - $umask % 10 % 4 + $umask % 2
-	    `;;
-	  *) mkdir_umask=$umask,go-w;;
-	esac
-
-	# With -d, create the new directory with the user-specified mode.
-	# Otherwise, rely on $mkdir_umask.
-	if test -n "$dir_arg"; then
-	  mkdir_mode=-m$mode
-	else
-	  mkdir_mode=
-	fi
-
-	posix_mkdir=false
-	case $umask in
-	  *[123567][0-7][0-7])
-	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
-	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
-	    ;;
-	  *)
-	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
-
-	    if (umask $mkdir_umask &&
-		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
-	    then
-	      if test -z "$dir_arg" || {
-		   # Check for POSIX incompatibilities with -m.
-		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-		   # other-writeable bit of parent directory when it shouldn't.
-		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
-		   case $ls_ld_tmpdir in
-		     d????-?r-*) different_mode=700;;
-		     d????-?--*) different_mode=755;;
-		     *) false;;
-		   esac &&
-		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
-		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
-		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-		   }
-		 }
-	      then posix_mkdir=:
-	      fi
-	      rmdir "$tmpdir/d" "$tmpdir"
-	    else
-	      # Remove any dirs left behind by ancient mkdir implementations.
-	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
-	    fi
-	    trap '' 0;;
-	esac;;
-    esac
-
-    if
-      $posix_mkdir && (
-	umask $mkdir_umask &&
-	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # The umask is ridiculous, or mkdir does not conform to POSIX,
-      # or it failed possibly due to a race condition.  Create the
-      # directory the slow way, step by step, checking for races as we go.
-
-      case $dstdir in
-	/*) prefix='/';;
-	-*) prefix='./';;
-	*)  prefix='';;
-      esac
-
-      eval "$initialize_posix_glob"
-
-      oIFS=$IFS
-      IFS=/
-      $posix_glob set -f
-      set fnord $dstdir
-      shift
-      $posix_glob set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-	test -z "$d" && continue
-
-	prefix=$prefix$d
-	if test -d "$prefix"; then
-	  prefixes=
-	else
-	  if $posix_mkdir; then
-	    (umask=$mkdir_umask &&
-	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-	    # Don't fail if two instances are running concurrently.
-	    test -d "$prefix" || exit 1
-	  else
-	    case $prefix in
-	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-	      *) qprefix=$prefix;;
-	    esac
-	    prefixes="$prefixes '$qprefix'"
-	  fi
-	fi
-	prefix=$prefix/
-      done
-
-      if test -n "$prefixes"; then
-	# Don't fail if two instances are running concurrently.
-	(umask $mkdir_umask &&
-	 eval "\$doit_exec \$mkdirprog $prefixes") ||
-	  test -d "$dstdir" || exit 1
-	obsolete_mkdir_used=true
-      fi
-    fi
-  fi
-
-  if test -n "$dir_arg"; then
-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
-  else
-
-    # Make a couple of temp file names in the proper directory.
-    dsttmp=$dstdir/_inst.$$_
-    rmtmp=$dstdir/_rm.$$_
-
-    # Trap to clean up those temp files at exit.
-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
-
-    # Copy the file name to the temp name.
-    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
-
-    # and set any options; do chmod last to preserve setuid bits.
-    #
-    # If any of these fail, we abort the whole thing.  If we want to
-    # ignore errors from any of these, just make sure not to ignore
-    # errors from the above "$doit $cpprog $src $dsttmp" command.
-    #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
-
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&
-
-       eval "$initialize_posix_glob" &&
-       $posix_glob set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       $posix_glob set +f &&
-
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
-
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-	# Now remove or move aside any old file at destination location.
-	# We try this two ways since rm can't unlink itself on some
-	# systems and the destination file might be busy for other
-	# reasons.  In this case, the final cleanup might fail but the new
-	# file should still install successfully.
-	{
-	  test ! -f "$dst" ||
-	  $doit $rmcmd -f "$dst" 2>/dev/null ||
-	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
-	  } ||
-	  { echo "$0: cannot unlink or rename $dst" >&2
-	    (exit 1); exit 1
-	  }
-	} &&
-
-	# Now rename the file to the real destination.
-	$doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
-
-    trap '' 0
-  fi
-done
-
-# Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
-# time-stamp-end: "; # UTC"
-# End:

autoconf/tea/win/makefile.vc

@@ -1,419 +0,0 @@
-# makefile.vc --                                               -*- Makefile -*-
-#
-# Microsoft Visual C++ makefile for use with nmake.exe v1.62+ (VC++ 5.0+)
-#
-# This makefile is based upon the Tcl 8.4 Makefile.vc and modified to 
-# make it suitable as a general package makefile. Look for the word EDIT
-# which marks sections that may need modification. As a minumum you will
-# need to change the PROJECT, DOTVERSION and DLLOBJS variables to values
-# relevant to your package.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-# 
-# Copyright (c) 1995-1996 Sun Microsystems, Inc.
-# Copyright (c) 1998-2000 Ajuba Solutions.
-# Copyright (c) 2001 ActiveState Corporation.
-# Copyright (c) 2001-2002 David Gravereaux.
-# Copyright (c) 2003 Pat Thoyts
-#
-#-------------------------------------------------------------------------
-# RCS: @(#)$Id: makefile.vc,v 1.4 2004/07/26 08:22:05 patthoyts Exp $
-#-------------------------------------------------------------------------
-
-!if !defined(MSDEVDIR) && !defined(MSVCDIR) && !defined(VCINSTALLDIR) && !defined(MSSDK) && !defined(WINDOWSSDKDIR)
-MSG = ^
-You will need to run vcvars32.bat from Developer Studio, first, to setup^
-the environment.  Jump to this line to read the new instructions.
-!error $(MSG)
-!endif
-
-#------------------------------------------------------------------------------
-# HOW TO USE this makefile:
-#
-# 1)  It is now necessary to have %MSVCDir% set in the environment.  This is
-#     used  as a check to see if vcvars32.bat had been run prior to running
-#     nmake or during the installation of Microsoft Visual C++, MSVCDir had
-#     been set globally and the PATH adjusted.  Either way is valid.
-#
-#     You'll need to run vcvars32.bat contained in the MsDev's vc(98)/bin
-#     directory to setup the proper environment, if needed, for your current
-#     setup.  This is a needed bootstrap requirement and allows the swapping of
-#     different environments to be easier.
-#
-# 2)  To use the Platform SDK (not expressly needed), run setenv.bat after
-#     vcvars32.bat according to the instructions for it.  This can also turn on
-#     the 64-bit compiler, if your SDK has it.
-#
-# 3)  Targets are:
-#	all       -- Builds everything.
-#       <project> -- Builds the project (eg: nmake sample)
-#	test      -- Builds and runs the test suite.
-#	install   -- Installs the built binaries and libraries to $(INSTALLDIR)
-#		     in an appropriate subdirectory.
-#	clean/realclean/distclean -- varying levels of cleaning.
-#
-# 4)  Macros usable on the commandline:
-#	INSTALLDIR=<path>
-#		Sets where to install Tcl from the built binaries.
-#		C:\Progra~1\Tcl is assumed when not specified.
-#
-#	OPTS=static,msvcrt,staticpkg,threads,symbols,profile,loimpact,none
-#		Sets special options for the core.  The default is for none.
-#		Any combination of the above may be used (comma separated).
-#		'none' will over-ride everything to nothing.
-#
-#		static  =  Builds a static library of the core instead of a
-#			   dll.  The shell will be static (and large), as well.
-#		msvcrt  =  Effects the static option only to switch it from
-#			   using libcmt(d) as the C runtime [by default] to
-#			   msvcrt(d). This is useful for static embedding
-#			   support.
-#		staticpkg = Effects the static option only to switch
-#			   tclshXX.exe to have the dde and reg extension linked
-#			   inside it.
-#		threads =  Turns on full multithreading support.
-#		thrdalloc = Use the thread allocator (shared global free pool).
-#		symbols =  Adds symbols for step debugging.
-#		profile =  Adds profiling hooks.  Map file is assumed.
-#		loimpact =  Adds a flag for how NT treats the heap to keep memory
-#			   in use, low.  This is said to impact alloc performance.
-#
-#	STATS=memdbg,compdbg,none
-#		Sets optional memory and bytecode compiler debugging code added
-#		to the core.  The default is for none.  Any combination of the
-#		above may be used (comma separated).  'none' will over-ride
-#		everything to nothing.
-#
-#		memdbg   = Enables the debugging memory allocator.
-#		compdbg  = Enables byte compilation logging.
-#
-#	MACHINE=(IX86|IA64|ALPHA)
-#		Set the machine type used for the compiler, linker, and
-#		resource compiler.  This hook is needed to tell the tools
-#		when alternate platforms are requested.  IX86 is the default
-#		when not specified.
-#
-#	TMP_DIR=<path>
-#	OUT_DIR=<path>
-#		Hooks to allow the intermediate and output directories to be
-#		changed.  $(OUT_DIR) is assumed to be 
-#		$(BINROOT)\(Release|Debug) based on if symbols are requested.
-#		$(TMP_DIR) will de $(OUT_DIR)\<buildtype> by default.
-#
-#	TESTPAT=<file>
-#		Reads the tests requested to be run from this file.
-#
-#	CFG_ENCODING=encoding
-#		name of encoding for configuration information. Defaults
-#		to cp1252
-#
-# 5)  Examples:
-#
-#	Basic syntax of calling nmake looks like this:
-#	nmake [-nologo] -f makefile.vc [target|macrodef [target|macrodef] [...]]
-#
-#                        Standard (no frills)
-#       c:\tcl_src\win\>c:\progra~1\micros~1\vc98\bin\vcvars32.bat
-#       Setting environment for using Microsoft Visual C++ tools.
-#       c:\tcl_src\win\>nmake -f makefile.vc all
-#       c:\tcl_src\win\>nmake -f makefile.vc install INSTALLDIR=c:\progra~1\tcl
-#
-#                         Building for Win64
-#       c:\tcl_src\win\>c:\progra~1\micros~1\vc98\bin\vcvars32.bat
-#       Setting environment for using Microsoft Visual C++ tools.
-#       c:\tcl_src\win\>c:\progra~1\platfo~1\setenv.bat /pre64 /RETAIL
-#       Targeting Windows pre64 RETAIL
-#       c:\tcl_src\win\>nmake -f makefile.vc MACHINE=IA64
-#
-#------------------------------------------------------------------------------
-#==============================================================================
-###############################################################################
-#------------------------------------------------------------------------------
-
-!if !exist("makefile.vc")
-MSG = ^
-You must run this makefile only from the directory it is in.^
-Please `cd` to its location first.
-!error $(MSG)
-!endif
-
-#-------------------------------------------------------------------------
-# Project specific information (EDIT)
-#
-# You should edit this with the name and version of your project. This
-# information is used to generate the name of the package library and
-# it's install location.
-#
-# For example, the sample extension is  going to build sample04.dll and
-# would install it into $(INSTALLDIR)\lib\sample04
-#
-# You need to specify the object files that need to be linked into your
-# binary here.
-#
-#-------------------------------------------------------------------------
-
-PROJECT = tclsqlite3
-!include "rules.vc"
-
-# nmakehelp -V <file> <tag> will search the file for tag, skips until a
-#	number and returns all character until a character not in [0-9.ab]
-#	is read.
-
-!if [echo REM = This file is generated from Makefile.vc > versions.vc]
-!endif
-# get project version from row "AC_INIT([sqlite], [3.x.y])"
-!if [echo DOTVERSION = \>> versions.vc] \
-   && [nmakehlp -V ..\configure.ac AC_INIT >> versions.vc]
-!endif
-!include "versions.vc"
-
-VERSION         = $(DOTVERSION:.=)
-STUBPREFIX      = $(PROJECT)stub
-
-#-------------------------------------------------------------------------
-# Target names and paths ( shouldn't need changing )
-#-------------------------------------------------------------------------
-
-BINROOT		= .
-ROOT            = ..
-
-PRJIMPLIB	= $(OUT_DIR)\$(PROJECT)$(VERSION)$(SUFX).lib
-PRJLIBNAME	= $(PROJECT).$(EXT)
-PRJLIB		= $(OUT_DIR)\$(PRJLIBNAME)
-
-PRJSTUBLIBNAME	= $(STUBPREFIX)$(VERSION).lib
-PRJSTUBLIB	= $(OUT_DIR)\$(PRJSTUBLIBNAME)
-
-### Make sure we use backslash only.
-PRJ_INSTALL_DIR         = $(_INSTALLDIR)\$(PROJECT)$(DOTVERSION)
-LIB_INSTALL_DIR		= $(PRJ_INSTALL_DIR)
-BIN_INSTALL_DIR		= $(PRJ_INSTALL_DIR)
-DOC_INSTALL_DIR		= $(PRJ_INSTALL_DIR)
-SCRIPT_INSTALL_DIR	= $(PRJ_INSTALL_DIR)
-INCLUDE_INSTALL_DIR	= $(_TCLDIR)\include
-
-### The following paths CANNOT have spaces in them.
-GENERICDIR	= $(ROOT)\generic
-WINDIR		= $(ROOT)\win
-LIBDIR          = $(ROOT)\library
-DOCDIR		= $(ROOT)\doc
-TOOLSDIR	= $(ROOT)\tools
-COMPATDIR	= $(ROOT)\compat
-
-### Figure out where the primary source code file(s) is/are.
-!if exist("$(ROOT)\..\..\sqlite3.c") && exist("$(ROOT)\..\..\src\tclsqlite.c")
-SQL_INCLUDES = -I"$(ROOT)\..\.."
-SQLITE_SRCDIR = $(ROOT)\..\..
-TCLSQLITE_SRCDIR = $(ROOT)\..\..\src
-DLLOBJS = $(TMP_DIR)\sqlite3.obj $(TMP_DIR)\tclsqlite.obj
-!else
-TCLSQLITE_SRCDIR = $(ROOT)\generic
-DLLOBJS = $(TMP_DIR)\tclsqlite3.obj
-!endif
-
-#---------------------------------------------------------------------
-# Compile flags
-#---------------------------------------------------------------------
-
-!if !$(DEBUG)
-!if $(OPTIMIZING)
-### This cranks the optimization level to maximize speed
-cdebug	= -O2 -Op -Gs
-!else
-cdebug	=
-!endif
-!else if "$(MACHINE)" == "IA64"
-### Warnings are too many, can't support warnings into errors.
-cdebug	= -Z7 -Od -GZ
-!else
-cdebug	= -Z7 -WX -Od -GZ
-!endif
-
-### Declarations common to all compiler options
-cflags = -nologo -c -W3 -D_CRT_SECURE_NO_WARNINGS -YX -Fp$(TMP_DIR)^\
-
-!if $(MSVCRT)
-!if $(DEBUG)
-crt = -MDd
-!else
-crt = -MD
-!endif
-!else
-!if $(DEBUG)
-crt = -MTd
-!else
-crt = -MT
-!endif
-!endif
-
-INCLUDES	= $(SQL_INCLUDES) $(TCL_INCLUDES) -I"$(WINDIR)" \
-                  -I"$(GENERICDIR)" -I"$(ROOT)\.."
-BASE_CLFAGS	= $(cflags) $(cdebug) $(crt) $(INCLUDES) \
-                  -DSQLITE_3_SUFFIX_ONLY=1 -DSQLITE_ENABLE_RTREE=1 \
-                  -DSQLITE_ENABLE_FTS3=1 -DSQLITE_OMIT_DEPRECATED=1
-CON_CFLAGS	= $(cflags) $(cdebug) $(crt) -DCONSOLE -DSQLITE_ENABLE_FTS3=1
-TCL_CFLAGS	= -DBUILD_sqlite -DUSE_TCL_STUBS \
-                  -DPACKAGE_VERSION="\"$(DOTVERSION)\"" $(BASE_CLFAGS) \
-                  $(OPTDEFINES)
-
-#---------------------------------------------------------------------
-# Link flags
-#---------------------------------------------------------------------
-
-!if $(DEBUG)
-ldebug	= -debug:full -debugtype:cv
-!else
-ldebug	= -release -opt:ref -opt:icf,3
-!endif
-
-### Declarations common to all linker options
-lflags	= -nologo -machine:$(MACHINE) $(ldebug)
-
-!if $(PROFILE)
-lflags	= $(lflags) -profile
-!endif
-
-!if $(ALIGN98_HACK) && !$(STATIC_BUILD)
-### Align sections for PE size savings.
-lflags	= $(lflags) -opt:nowin98
-!else if !$(ALIGN98_HACK) && $(STATIC_BUILD)
-### Align sections for speed in loading by choosing the virtual page size.
-lflags	= $(lflags) -align:4096
-!endif
-
-!if $(LOIMPACT)
-lflags	= $(lflags) -ws:aggressive
-!endif
-
-dlllflags = $(lflags) -dll
-conlflags = $(lflags) -subsystem:console
-guilflags = $(lflags) -subsystem:windows
-baselibs   = $(TCLSTUBLIB)
-
-#---------------------------------------------------------------------
-# TclTest flags
-#---------------------------------------------------------------------
-
-!IF "$(TESTPAT)" != ""
-TESTFLAGS = $(TESTFLAGS) -file $(TESTPAT)
-!ENDIF
-
-#---------------------------------------------------------------------
-# Project specific targets (EDIT)
-#---------------------------------------------------------------------
-
-all:	    setup $(PROJECT)
-$(PROJECT): setup $(PRJLIB)
-install:    install-binaries install-libraries install-docs
-
-# Tests need to ensure we load the right dll file we
-# have to handle the output differently on Win9x.
-#
-!if "$(OS)" == "Windows_NT"  || "$(MSVCDIR)" == "IDE"
-test: setup $(PROJECT)
-        set TCL_LIBRARY=$(ROOT)/library
-        $(TCLSH) <<
-load $(PRJLIB:\=/)
-cd "$(ROOT)/tests"
-set argv "$(TESTFLAGS)"
-source all.tcl
-<<
-!else
-test: setup $(PROJECT)
-        echo Please wait while the test results are collected
-        set TCL_LIBRARY=$(ROOT)/library
-        $(TCLSH) << >tests.log
-load $(PRJLIB:\=/)
-cd "$(ROOT)/tests"
-set argv "$(TESTFLAGS)"
-source all.tcl
-<<
-        type tests.log | more
-!endif
-
-setup:
-	@if not exist $(OUT_DIR)\nul mkdir $(OUT_DIR)
-	@if not exist $(TMP_DIR)\nul mkdir $(TMP_DIR)
-
-$(PRJLIB): $(DLLOBJS)
-	$(link32) $(dlllflags) -out:$@ $(baselibs) @<<
-$**
-<<
-	-@del $*.exp
-
-$(PRJSTUBLIB): $(PRJSTUBOBJS)
-	$(lib32) -nologo -out:$@ $(PRJSTUBOBJS)
-
-#---------------------------------------------------------------------
-# Implicit rules
-#---------------------------------------------------------------------
-
-$(TMP_DIR)\sqlite3.obj:		$(SQLITE_SRCDIR)\sqlite3.c
-	$(cc32) $(TCL_CFLAGS) -DBUILD_$(PROJECT) -Fo$(TMP_DIR)\ \
-		-c $(SQLITE_SRCDIR)\sqlite3.c
-
-$(TMP_DIR)\tclsqlite.obj:	$(TCLSQLITE_SRCDIR)\tclsqlite.c
-	$(cc32) $(TCL_CFLAGS) -DBUILD_$(PROJECT) -Fo$(TMP_DIR)\ \
-		-c $(TCLSQLITE_SRCDIR)\tclsqlite.c
-
-$(TMP_DIR)\tclsqlite3.obj:	$(TCLSQLITE_SRCDIR)\tclsqlite3.c
-	$(cc32) $(TCL_CFLAGS) -DBUILD_$(PROJECT) -Fo$(TMP_DIR)\ \
-		-c $(TCLSQLITE_SRCDIR)\tclsqlite3.c
-
-{$(WINDIR)}.rc{$(TMP_DIR)}.res:
-	$(rc32) -fo $@ -r -i "$(GENERICDIR)" -D__WIN32__ \
-!if $(DEBUG)
-	-d DEBUG \
-!endif
-!if $(TCL_THREADS)
-	-d TCL_THREADS \
-!endif
-!if $(STATIC_BUILD)
-	-d STATIC_BUILD \
-!endif
-	$<
-
-.SUFFIXES:
-.SUFFIXES:.c .rc
-
-#---------------------------------------------------------------------
-# Installation. (EDIT)
-#
-# You may need to modify this section to reflect the final distribution
-# of your files and possibly to generate documentation.
-#
-#---------------------------------------------------------------------
-
-install-binaries:
-	@echo Installing binaries to '$(SCRIPT_INSTALL_DIR)'
-	@if not exist "$(SCRIPT_INSTALL_DIR)" mkdir "$(SCRIPT_INSTALL_DIR)"
-	@$(CPY) $(PRJLIB) "$(SCRIPT_INSTALL_DIR)" >NUL
-
-install-libraries:
-        @echo Installing libraries to '$(SCRIPT_INSTALL_DIR)'
-        @if exist $(LIBDIR) $(CPY) $(LIBDIR)\*.tcl "$(SCRIPT_INSTALL_DIR)"
-        @echo Installing package index in '$(SCRIPT_INSTALL_DIR)'
-        @type << >"$(SCRIPT_INSTALL_DIR)\pkgIndex.tcl"
-package ifneeded $(PROJECT) $(DOTVERSION) \
-    [list load [file join $$dir $(PRJLIBNAME)] sqlite3]
-<<
-
-install-docs:
-	@echo Installing documentation files to '$(DOC_INSTALL_DIR)'
-	@if exist $(DOCDIR) $(CPY) $(DOCDIR)\*.n "$(DOC_INSTALL_DIR)"
-
-#---------------------------------------------------------------------
-# Clean up
-#---------------------------------------------------------------------
-
-clean:
-	@if exist $(TMP_DIR)\nul $(RMDIR) $(TMP_DIR)
-	@if exist $(WINDIR)\version.vc del $(WINDIR)\version.vc
-
-realclean: clean
-	@if exist $(OUT_DIR)\nul $(RMDIR) $(OUT_DIR)
-
-distclean: realclean
-	@if exist $(WINDIR)\nmakehlp.exe del $(WINDIR)\nmakehlp.exe
-	@if exist $(WINDIR)\nmakehlp.obj del $(WINDIR)\nmakehlp.obj

autoconf/tea/win/nmakehlp.c

@@ -1,694 +0,0 @@
-/*
- * ----------------------------------------------------------------------------
- * nmakehlp.c --
- *
- *	This is used to fix limitations within nmake and the environment.
- *
- * Copyright (c) 2002 by David Gravereaux.
- * Copyright (c) 2006 by Pat Thoyts
- *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- * ----------------------------------------------------------------------------
- */
-
-#define _CRT_SECURE_NO_DEPRECATE
-#include <windows.h>
-#define NO_SHLWAPI_GDI
-#define NO_SHLWAPI_STREAM
-#define NO_SHLWAPI_REG
-#include <shlwapi.h>
-#pragma comment (lib, "user32.lib")
-#pragma comment (lib, "kernel32.lib")
-#pragma comment (lib, "shlwapi.lib")
-#include <stdio.h>
-#include <math.h>
-
-/*
- * This library is required for x64 builds with _some_ versions of MSVC
- */
-#if defined(_M_IA64) || defined(_M_AMD64)
-#if _MSC_VER >= 1400 && _MSC_VER < 1500
-#pragma comment(lib, "bufferoverflowU")
-#endif
-#endif
-
-/* ISO hack for dumb VC++ */
-#ifdef _MSC_VER
-#define   snprintf	_snprintf
-#endif
-
-
-
-/* protos */
-
-static int CheckForCompilerFeature(const char *option);
-static int CheckForLinkerFeature(const char *option);
-static int IsIn(const char *string, const char *substring);
-static int SubstituteFile(const char *substs, const char *filename);
-static int QualifyPath(const char *path);
-static const char *GetVersionFromFile(const char *filename, const char *match);
-static DWORD WINAPI ReadFromPipe(LPVOID args);
-
-/* globals */
-
-#define CHUNK	25
-#define STATICBUFFERSIZE    1000
-typedef struct {
-    HANDLE pipe;
-    char buffer[STATICBUFFERSIZE];
-} pipeinfo;
-
-pipeinfo Out = {INVALID_HANDLE_VALUE, '\0'};
-pipeinfo Err = {INVALID_HANDLE_VALUE, '\0'};
-
-/*
- * exitcodes: 0 == no, 1 == yes, 2 == error
- */
-
-int
-main(
-    int argc,
-    char *argv[])
-{
-    char msg[300];
-    DWORD dwWritten;
-    int chars;
-
-    /*
-     * Make sure children (cl.exe and link.exe) are kept quiet.
-     */
-
-    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
-
-    /*
-     * Make sure the compiler and linker aren't effected by the outside world.
-     */
-
-    SetEnvironmentVariable("CL", "");
-    SetEnvironmentVariable("LINK", "");
-
-    if (argc > 1 && *argv[1] == '-') {
-	switch (*(argv[1]+1)) {
-	case 'c':
-	    if (argc != 3) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-		        "usage: %s -c <compiler option>\n"
-			"Tests for whether cl.exe supports an option\n"
-			"exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-			&dwWritten, NULL);
-		return 2;
-	    }
-	    return CheckForCompilerFeature(argv[2]);
-	case 'l':
-	    if (argc != 3) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-	       		"usage: %s -l <linker option>\n"
-			"Tests for whether link.exe supports an option\n"
-			"exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-			&dwWritten, NULL);
-		return 2;
-	    }
-	    return CheckForLinkerFeature(argv[2]);
-	case 'f':
-	    if (argc == 2) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-			"usage: %s -f <string> <substring>\n"
-			"Find a substring within another\n"
-			"exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-			&dwWritten, NULL);
-		return 2;
-	    } else if (argc == 3) {
-		/*
-		 * If the string is blank, there is no match.
-		 */
-
-		return 0;
-	    } else {
-		return IsIn(argv[2], argv[3]);
-	    }
-	case 's':
-	    if (argc == 2) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-			"usage: %s -s <substitutions file> <file>\n"
-			"Perform a set of string map type substutitions on a file\n"
-			"exitcodes: 0\n",
-			argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-			&dwWritten, NULL);
-		return 2;
-	    }
-	    return SubstituteFile(argv[2], argv[3]);
-	case 'V':
-	    if (argc != 4) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-		    "usage: %s -V filename matchstring\n"
-		    "Extract a version from a file:\n"
-		    "eg: pkgIndex.tcl \"package ifneeded http\"",
-		    argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-		    &dwWritten, NULL);
-		return 0;
-	    }
-	    printf("%s\n", GetVersionFromFile(argv[2], argv[3]));
-	    return 0;
-	case 'Q':
-	    if (argc != 3) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-		    "usage: %s -Q path\n"
-		    "Emit the fully qualified path\n"
-		    "exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-		    &dwWritten, NULL);
-		return 2;
-	    }
-	    return QualifyPath(argv[2]);
-	}
-    }
-    chars = snprintf(msg, sizeof(msg) - 1,
-	    "usage: %s -c|-f|-l|-Q|-s|-V ...\n"
-	    "This is a little helper app to equalize shell differences between WinNT and\n"
-	    "Win9x and get nmake.exe to accomplish its job.\n",
-	    argv[0]);
-    WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars, &dwWritten, NULL);
-    return 2;
-}
-
-static int
-CheckForCompilerFeature(
-    const char *option)
-{
-    STARTUPINFO si;
-    PROCESS_INFORMATION pi;
-    SECURITY_ATTRIBUTES sa;
-    DWORD threadID;
-    char msg[300];
-    BOOL ok;
-    HANDLE hProcess, h, pipeThreads[2];
-    char cmdline[100];
-
-    hProcess = GetCurrentProcess();
-
-    ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
-    ZeroMemory(&si, sizeof(STARTUPINFO));
-    si.cb = sizeof(STARTUPINFO);
-    si.dwFlags   = STARTF_USESTDHANDLES;
-    si.hStdInput = INVALID_HANDLE_VALUE;
-
-    ZeroMemory(&sa, sizeof(SECURITY_ATTRIBUTES));
-    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
-    sa.lpSecurityDescriptor = NULL;
-    sa.bInheritHandle = FALSE;
-
-    /*
-     * Create a non-inheritible pipe.
-     */
-
-    CreatePipe(&Out.pipe, &h, &sa, 0);
-
-    /*
-     * Dupe the write side, make it inheritible, and close the original.
-     */
-
-    DuplicateHandle(hProcess, h, hProcess, &si.hStdOutput, 0, TRUE,
-	    DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
-
-    /*
-     * Same as above, but for the error side.
-     */
-
-    CreatePipe(&Err.pipe, &h, &sa, 0);
-    DuplicateHandle(hProcess, h, hProcess, &si.hStdError, 0, TRUE,
-	    DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
-
-    /*
-     * Base command line.
-     */
-
-    lstrcpy(cmdline, "cl.exe -nologo -c -TC -Zs -X -Fp.\\_junk.pch ");
-
-    /*
-     * Append our option for testing
-     */
-
-    lstrcat(cmdline, option);
-
-    /*
-     * Filename to compile, which exists, but is nothing and empty.
-     */
-
-    lstrcat(cmdline, " .\\nul");
-
-    ok = CreateProcess(
-	    NULL,	    /* Module name. */
-	    cmdline,	    /* Command line. */
-	    NULL,	    /* Process handle not inheritable. */
-	    NULL,	    /* Thread handle not inheritable. */
-	    TRUE,	    /* yes, inherit handles. */
-	    DETACHED_PROCESS, /* No console for you. */
-	    NULL,	    /* Use parent's environment block. */
-	    NULL,	    /* Use parent's starting directory. */
-	    &si,	    /* Pointer to STARTUPINFO structure. */
-	    &pi);	    /* Pointer to PROCESS_INFORMATION structure. */
-
-    if (!ok) {
-	DWORD err = GetLastError();
-	int chars = snprintf(msg, sizeof(msg) - 1,
-		"Tried to launch: \"%s\", but got error [%u]: ", cmdline, err);
-
-	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS|
-		FORMAT_MESSAGE_MAX_WIDTH_MASK, 0L, err, 0, (LPVOID)&msg[chars],
-		(300-chars), 0);
-	WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, lstrlen(msg), &err,NULL);
-	return 2;
-    }
-
-    /*
-     * Close our references to the write handles that have now been inherited.
-     */
-
-    CloseHandle(si.hStdOutput);
-    CloseHandle(si.hStdError);
-
-    WaitForInputIdle(pi.hProcess, 5000);
-    CloseHandle(pi.hThread);
-
-    /*
-     * Start the pipe reader threads.
-     */
-
-    pipeThreads[0] = CreateThread(NULL, 0, ReadFromPipe, &Out, 0, &threadID);
-    pipeThreads[1] = CreateThread(NULL, 0, ReadFromPipe, &Err, 0, &threadID);
-
-    /*
-     * Block waiting for the process to end.
-     */
-
-    WaitForSingleObject(pi.hProcess, INFINITE);
-    CloseHandle(pi.hProcess);
-
-    /*
-     * Wait for our pipe to get done reading, should it be a little slow.
-     */
-
-    WaitForMultipleObjects(2, pipeThreads, TRUE, 500);
-    CloseHandle(pipeThreads[0]);
-    CloseHandle(pipeThreads[1]);
-
-    /*
-     * Look for the commandline warning code in both streams.
-     *  - in MSVC 6 & 7 we get D4002, in MSVC 8 we get D9002.
-     */
-
-    return !(strstr(Out.buffer, "D4002") != NULL
-             || strstr(Err.buffer, "D4002") != NULL
-             || strstr(Out.buffer, "D9002") != NULL
-             || strstr(Err.buffer, "D9002") != NULL
-             || strstr(Out.buffer, "D2021") != NULL
-             || strstr(Err.buffer, "D2021") != NULL);
-}
-
-static int
-CheckForLinkerFeature(
-    const char *option)
-{
-    STARTUPINFO si;
-    PROCESS_INFORMATION pi;
-    SECURITY_ATTRIBUTES sa;
-    DWORD threadID;
-    char msg[300];
-    BOOL ok;
-    HANDLE hProcess, h, pipeThreads[2];
-    char cmdline[100];
-
-    hProcess = GetCurrentProcess();
-
-    ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
-    ZeroMemory(&si, sizeof(STARTUPINFO));
-    si.cb = sizeof(STARTUPINFO);
-    si.dwFlags   = STARTF_USESTDHANDLES;
-    si.hStdInput = INVALID_HANDLE_VALUE;
-
-    ZeroMemory(&sa, sizeof(SECURITY_ATTRIBUTES));
-    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
-    sa.lpSecurityDescriptor = NULL;
-    sa.bInheritHandle = TRUE;
-
-    /*
-     * Create a non-inheritible pipe.
-     */
-
-    CreatePipe(&Out.pipe, &h, &sa, 0);
-
-    /*
-     * Dupe the write side, make it inheritible, and close the original.
-     */
-
-    DuplicateHandle(hProcess, h, hProcess, &si.hStdOutput, 0, TRUE,
-	    DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
-
-    /*
-     * Same as above, but for the error side.
-     */
-
-    CreatePipe(&Err.pipe, &h, &sa, 0);
-    DuplicateHandle(hProcess, h, hProcess, &si.hStdError, 0, TRUE,
-	    DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
-
-    /*
-     * Base command line.
-     */
-
-    lstrcpy(cmdline, "link.exe -nologo ");
-
-    /*
-     * Append our option for testing.
-     */
-
-    lstrcat(cmdline, option);
-
-    ok = CreateProcess(
-	    NULL,	    /* Module name. */
-	    cmdline,	    /* Command line. */
-	    NULL,	    /* Process handle not inheritable. */
-	    NULL,	    /* Thread handle not inheritable. */
-	    TRUE,	    /* yes, inherit handles. */
-	    DETACHED_PROCESS, /* No console for you. */
-	    NULL,	    /* Use parent's environment block. */
-	    NULL,	    /* Use parent's starting directory. */
-	    &si,	    /* Pointer to STARTUPINFO structure. */
-	    &pi);	    /* Pointer to PROCESS_INFORMATION structure. */
-
-    if (!ok) {
-	DWORD err = GetLastError();
-	int chars = snprintf(msg, sizeof(msg) - 1,
-		"Tried to launch: \"%s\", but got error [%u]: ", cmdline, err);
-
-	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS|
-		FORMAT_MESSAGE_MAX_WIDTH_MASK, 0L, err, 0, (LPVOID)&msg[chars],
-		(300-chars), 0);
-	WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, lstrlen(msg), &err,NULL);
-	return 2;
-    }
-
-    /*
-     * Close our references to the write handles that have now been inherited.
-     */
-
-    CloseHandle(si.hStdOutput);
-    CloseHandle(si.hStdError);
-
-    WaitForInputIdle(pi.hProcess, 5000);
-    CloseHandle(pi.hThread);
-
-    /*
-     * Start the pipe reader threads.
-     */
-
-    pipeThreads[0] = CreateThread(NULL, 0, ReadFromPipe, &Out, 0, &threadID);
-    pipeThreads[1] = CreateThread(NULL, 0, ReadFromPipe, &Err, 0, &threadID);
-
-    /*
-     * Block waiting for the process to end.
-     */
-
-    WaitForSingleObject(pi.hProcess, INFINITE);
-    CloseHandle(pi.hProcess);
-
-    /*
-     * Wait for our pipe to get done reading, should it be a little slow.
-     */
-
-    WaitForMultipleObjects(2, pipeThreads, TRUE, 500);
-    CloseHandle(pipeThreads[0]);
-    CloseHandle(pipeThreads[1]);
-
-    /*
-     * Look for the commandline warning code in the stderr stream.
-     */
-
-    return !(strstr(Out.buffer, "LNK1117") != NULL ||
-	    strstr(Err.buffer, "LNK1117") != NULL ||
-	    strstr(Out.buffer, "LNK4044") != NULL ||
-	    strstr(Err.buffer, "LNK4044") != NULL);
-}
-
-static DWORD WINAPI
-ReadFromPipe(
-    LPVOID args)
-{
-    pipeinfo *pi = (pipeinfo *) args;
-    char *lastBuf = pi->buffer;
-    DWORD dwRead;
-    BOOL ok;
-
-  again:
-    if (lastBuf - pi->buffer + CHUNK > STATICBUFFERSIZE) {
-	CloseHandle(pi->pipe);
-	return (DWORD)-1;
-    }
-    ok = ReadFile(pi->pipe, lastBuf, CHUNK, &dwRead, 0L);
-    if (!ok || dwRead == 0) {
-	CloseHandle(pi->pipe);
-	return 0;
-    }
-    lastBuf += dwRead;
-    goto again;
-
-    return 0;  /* makes the compiler happy */
-}
-
-static int
-IsIn(
-    const char *string,
-    const char *substring)
-{
-    return (strstr(string, substring) != NULL);
-}
-
-/*
- * GetVersionFromFile --
- * 	Looks for a match string in a file and then returns the version
- * 	following the match where a version is anything acceptable to
- * 	package provide or package ifneeded.
- */
-
-static const char *
-GetVersionFromFile(
-    const char *filename,
-    const char *match)
-{
-    size_t cbBuffer = 100;
-    static char szBuffer[100];
-    char *szResult = NULL;
-    FILE *fp = fopen(filename, "rt");
-
-    if (fp != NULL) {
-	/*
-	 * Read data until we see our match string.
-	 */
-
-	while (fgets(szBuffer, cbBuffer, fp) != NULL) {
-	    LPSTR p, q;
-
-	    p = strstr(szBuffer, match);
-	    if (p != NULL) {
-		/*
-		 * Skip to first digit.
-		 */
-
-		while (*p && !isdigit(*p)) {
-		    ++p;
-		}
-
-		/*
-		 * Find ending whitespace.
-		 */
-
-		q = p;
-		while (*q && (isalnum(*q) || *q == '.')) {
-		    ++q;
-		}
-
-		memcpy(szBuffer, p, q - p);
-		szBuffer[q-p] = 0;
-		szResult = szBuffer;
-		break;
-	    }
-	}
-	fclose(fp);
-    }
-    return szResult;
-}
-
-/*
- * List helpers for the SubstituteFile function
- */
-
-typedef struct list_item_t {
-    struct list_item_t *nextPtr;
-    char * key;
-    char * value;
-} list_item_t;
-
-/* insert a list item into the list (list may be null) */
-static list_item_t *
-list_insert(list_item_t **listPtrPtr, const char *key, const char *value)
-{
-    list_item_t *itemPtr = malloc(sizeof(list_item_t));
-    if (itemPtr) {
-	itemPtr->key = strdup(key);
-	itemPtr->value = strdup(value);
-	itemPtr->nextPtr = NULL;
-
-	while(*listPtrPtr) {
-	    listPtrPtr = &(*listPtrPtr)->nextPtr;
-	}
-	*listPtrPtr = itemPtr;
-    }
-    return itemPtr;
-}
-
-static void
-list_free(list_item_t **listPtrPtr)
-{
-    list_item_t *tmpPtr, *listPtr = *listPtrPtr;
-    while (listPtr) {
-	tmpPtr = listPtr;
-	listPtr = listPtr->nextPtr;
-	free(tmpPtr->key);
-	free(tmpPtr->value);
-	free(tmpPtr);
-    }
-}
-
-/*
- * SubstituteFile --
- *	As windows doesn't provide anything useful like sed and it's unreliable
- *	to use the tclsh you are building against (consider x-platform builds -
- *	eg compiling AMD64 target from IX86) we provide a simple substitution
- *	option here to handle autoconf style substitutions.
- *	The substitution file is whitespace and line delimited. The file should
- *	consist of lines matching the regular expression:
- *	  \s*\S+\s+\S*$
- *
- *	Usage is something like:
- *	  nmakehlp -S << $** > $@
- *        @PACKAGE_NAME@ $(PACKAGE_NAME)
- *        @PACKAGE_VERSION@ $(PACKAGE_VERSION)
- *        <<
- */
-
-static int
-SubstituteFile(
-    const char *substitutions,
-    const char *filename)
-{
-    size_t cbBuffer = 1024;
-    static char szBuffer[1024], szCopy[1024];
-    char *szResult = NULL;
-    list_item_t *substPtr = NULL;
-    FILE *fp, *sp;
-
-    fp = fopen(filename, "rt");
-    if (fp != NULL) {
-
-	/*
-	 * Build a list of substutitions from the first filename
-	 */
-
-	sp = fopen(substitutions, "rt");
-	if (sp != NULL) {
-	    while (fgets(szBuffer, cbBuffer, sp) != NULL) {
-		unsigned char *ks, *ke, *vs, *ve;
-		ks = (unsigned char*)szBuffer;
-		while (ks && *ks && isspace(*ks)) ++ks;
-		ke = ks;
-		while (ke && *ke && !isspace(*ke)) ++ke;
-		vs = ke;
-		while (vs && *vs && isspace(*vs)) ++vs;
-		ve = vs;
-		while (ve && *ve && !(*ve == '\r' || *ve == '\n')) ++ve;
-		*ke = 0, *ve = 0;
-		list_insert(&substPtr, (char*)ks, (char*)vs);
-	    }
-	    fclose(sp);
-	}
-
-	/* debug: dump the list */
-#ifdef _DEBUG
-	{
-	    int n = 0;
-	    list_item_t *p = NULL;
-	    for (p = substPtr; p != NULL; p = p->nextPtr, ++n) {
-		fprintf(stderr, "% 3d '%s' => '%s'\n", n, p->key, p->value);
-	    }
-	}
-#endif
-	
-	/*
-	 * Run the substitutions over each line of the input
-	 */
-	
-	while (fgets(szBuffer, cbBuffer, fp) != NULL) {
-	    list_item_t *p = NULL;
-	    for (p = substPtr; p != NULL; p = p->nextPtr) {
-		char *m = strstr(szBuffer, p->key);
-		if (m) {
-		    char *cp, *op, *sp;
-		    cp = szCopy;
-		    op = szBuffer;
-		    while (op != m) *cp++ = *op++;
-		    sp = p->value;
-		    while (sp && *sp) *cp++ = *sp++;
-		    op += strlen(p->key);
-		    while (*op) *cp++ = *op++;
-		    *cp = 0;
-		    memcpy(szBuffer, szCopy, sizeof(szCopy));
-		}
-	    }
-	    printf(szBuffer);
-	}
-	
-	list_free(&substPtr);
-    }
-    fclose(fp);
-    return 0;
-}
-
-/*
- * QualifyPath --
- *
- *	This composes the current working directory with a provided path
- *	and returns the fully qualified and normalized path.
- *	Mostly needed to setup paths for testing.
- */
-
-static int
-QualifyPath(
-    const char *szPath)
-{
-    char szCwd[MAX_PATH + 1];
-    char szTmp[MAX_PATH + 1];
-    char *p;
-    GetCurrentDirectory(MAX_PATH, szCwd);
-    while ((p = strchr(szPath, '/')) && *p)
-	*p = '\\';
-    PathCombine(szTmp, szCwd, szPath);
-    PathCanonicalize(szCwd, szTmp);
-    printf("%s\n", szCwd);
-    return 0;
-}
-
-/*
- * Local variables:
- *   mode: c
- *   c-basic-offset: 4
- *   fill-column: 78
- *   indent-tabs-mode: t
- *   tab-width: 8
- * End:
- */

autoconf/tea/win/rules.vc

@@ -1,711 +0,0 @@
-#------------------------------------------------------------------------------
-# rules.vc --
-#
-#	Microsoft Visual C++ makefile include for decoding the commandline
-#	macros.  This file does not need editing to build Tcl.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# Copyright (c) 2001-2003 David Gravereaux.
-# Copyright (c) 2003-2008 Patrick Thoyts
-#------------------------------------------------------------------------------
-
-!ifndef _RULES_VC
-_RULES_VC = 1
-
-cc32		= $(CC)   # built-in default.
-link32		= link
-lib32		= lib
-rc32		= $(RC)   # built-in default.
-
-!ifndef INSTALLDIR
-### Assume the normal default.
-_INSTALLDIR	= C:\Program Files\Tcl
-!else
-### Fix the path separators.
-_INSTALLDIR	= $(INSTALLDIR:/=\)
-!endif
-
-#----------------------------------------------------------
-# Set the proper copy method to avoid overwrite questions
-# to the user when copying files and selecting the right
-# "delete all" method.
-#----------------------------------------------------------
-
-!if "$(OS)" == "Windows_NT"
-RMDIR	= rmdir /S /Q
-ERRNULL  = 2>NUL
-!if ![ver | find "4.0" > nul]
-CPY	= echo y | xcopy /i >NUL
-COPY	= copy >NUL
-!else
-CPY	= xcopy /i /y >NUL
-COPY	= copy /y >NUL
-!endif
-!else # "$(OS)" != "Windows_NT"
-CPY	= xcopy /i >_JUNK.OUT # On Win98 NUL does not work here.
-COPY	= copy >_JUNK.OUT # On Win98 NUL does not work here.
-RMDIR	= deltree /Y
-NULL    = \NUL # Used in testing directory existence
-ERRNULL = >NUL # Win9x shell cannot redirect stderr
-!endif
-MKDIR   = mkdir
-
-#------------------------------------------------------------------------------
-# Determine the host and target architectures and compiler version.
-#------------------------------------------------------------------------------
-
-_HASH=^#
-_VC_MANIFEST_EMBED_EXE=
-_VC_MANIFEST_EMBED_DLL=
-VCVER=0
-!if ![echo VCVERSION=_MSC_VER > vercl.x] \
-    && ![echo $(_HASH)if defined(_M_IX86) >> vercl.x] \
-    && ![echo ARCH=IX86 >> vercl.x] \
-    && ![echo $(_HASH)elif defined(_M_AMD64) >> vercl.x] \
-    && ![echo ARCH=AMD64 >> vercl.x] \
-    && ![echo $(_HASH)endif >> vercl.x] \
-    && ![cl -nologo -TC -P vercl.x $(ERRNULL)]
-!include vercl.i
-!if ![echo VCVER= ^\> vercl.vc] \
-    && ![set /a $(VCVERSION) / 100 - 6 >> vercl.vc]
-!include vercl.vc
-!endif
-!endif
-!if ![del $(ERRNUL) /q/f vercl.x vercl.i vercl.vc]
-!endif
-
-!if ![reg query HKLM\Hardware\Description\System\CentralProcessor\0 /v Identifier | findstr /i x86]
-NATIVE_ARCH=IX86
-!else
-NATIVE_ARCH=AMD64
-!endif
-
-# Since MSVC8 we must deal with manifest resources.
-!if $(VCVERSION) >= 1400
-_VC_MANIFEST_EMBED_EXE=if exist $@.manifest mt -nologo -manifest $@.manifest -outputresource:$@;1
-_VC_MANIFEST_EMBED_DLL=if exist $@.manifest mt -nologo -manifest $@.manifest -outputresource:$@;2
-!endif
-
-!ifndef MACHINE
-MACHINE=$(ARCH)
-!endif
-
-!ifndef CFG_ENCODING
-CFG_ENCODING	= \"cp1252\"
-!endif
-
-!message ===============================================================================
-
-#----------------------------------------------------------
-# build the helper app we need to overcome nmake's limiting
-# environment.
-#----------------------------------------------------------
-
-!if !exist(nmakehlp.exe)
-!if [$(cc32) -nologo nmakehlp.c -link -subsystem:console > nul]
-!endif
-!endif
-
-#----------------------------------------------------------
-# Test for compiler features
-#----------------------------------------------------------
-
-### test for optimizations
-!if [nmakehlp -c -Ot]
-!message *** Compiler has 'Optimizations'
-OPTIMIZING	= 1
-!else
-!message *** Compiler does not have 'Optimizations'
-OPTIMIZING	= 0
-!endif
-
-OPTIMIZATIONS   =
-
-!if [nmakehlp -c -Ot]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -Ot
-!endif
-
-!if [nmakehlp -c -Oi]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -Oi
-!endif
-
-!if [nmakehlp -c -Op]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -Op
-!endif
-
-!if [nmakehlp -c -fp:strict]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -fp:strict
-!endif
-
-!if [nmakehlp -c -Gs]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -Gs
-!endif
-
-!if [nmakehlp -c -GS]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -GS
-!endif
-
-!if [nmakehlp -c -GL]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -GL
-!endif
-
-DEBUGFLAGS     =
-
-!if [nmakehlp -c -RTC1]
-DEBUGFLAGS     = $(DEBUGFLAGS) -RTC1
-!elseif [nmakehlp -c -GZ]
-DEBUGFLAGS     = $(DEBUGFLAGS) -GZ
-!endif
-
-COMPILERFLAGS  =-W3 -DUNICODE -D_UNICODE
-
-# In v13 -GL and -YX are incompatible.
-!if [nmakehlp -c -YX]
-!if ![nmakehlp -c -GL]
-OPTIMIZATIONS  = $(OPTIMIZATIONS) -YX
-!endif
-!endif
-
-!if "$(MACHINE)" == "IX86"
-### test for pentium errata
-!if [nmakehlp -c -QI0f]
-!message *** Compiler has 'Pentium 0x0f fix'
-COMPILERFLAGS  = $(COMPILERFLAGS) -QI0f
-!else
-!message *** Compiler does not have 'Pentium 0x0f fix'
-!endif
-!endif
-
-!if "$(MACHINE)" == "IA64"
-### test for Itanium errata
-!if [nmakehlp -c -QIA64_Bx]
-!message *** Compiler has 'B-stepping errata workarounds'
-COMPILERFLAGS   = $(COMPILERFLAGS) -QIA64_Bx
-!else
-!message *** Compiler does not have 'B-stepping errata workarounds'
-!endif
-!endif
-
-!if "$(MACHINE)" == "IX86"
-### test for -align:4096, when align:512 will do.
-!if [nmakehlp -l -opt:nowin98]
-!message *** Linker has 'Win98 alignment problem'
-ALIGN98_HACK	= 1
-!else
-!message *** Linker does not have 'Win98 alignment problem'
-ALIGN98_HACK	= 0
-!endif
-!else
-ALIGN98_HACK	= 0
-!endif
-
-LINKERFLAGS     =
-
-!if [nmakehlp -l -ltcg]
-LINKERFLAGS     =-ltcg
-!endif
-
-#----------------------------------------------------------
-# Decode the options requested.
-#----------------------------------------------------------
-
-!if "$(OPTS)" == "" || [nmakehlp -f "$(OPTS)" "none"]
-STATIC_BUILD	= 0
-TCL_THREADS	= 1
-DEBUG		= 0
-SYMBOLS		= 0
-PROFILE		= 0
-PGO		= 0
-MSVCRT		= 0
-LOIMPACT	= 0
-TCL_USE_STATIC_PACKAGES	= 0
-USE_THREAD_ALLOC = 1
-UNCHECKED	= 0
-!else
-!if [nmakehlp -f $(OPTS) "static"]
-!message *** Doing static
-STATIC_BUILD	= 1
-!else
-STATIC_BUILD	= 0
-!endif
-!if [nmakehlp -f $(OPTS) "msvcrt"]
-!message *** Doing msvcrt
-MSVCRT		= 1
-!else
-MSVCRT		= 0
-!endif
-!if [nmakehlp -f $(OPTS) "staticpkg"]
-!message *** Doing staticpkg
-TCL_USE_STATIC_PACKAGES	= 1
-!else
-TCL_USE_STATIC_PACKAGES	= 0
-!endif
-!if [nmakehlp -f $(OPTS) "nothreads"]
-!message *** Compile explicitly for non-threaded tcl
-TCL_THREADS	= 0
-!else
-TCL_THREADS	= 1
-USE_THREAD_ALLOC= 1
-!endif
-!if [nmakehlp -f $(OPTS) "symbols"]
-!message *** Doing symbols
-DEBUG		= 1
-!else
-DEBUG		= 0
-!endif
-!if [nmakehlp -f $(OPTS) "pdbs"]
-!message *** Doing pdbs
-SYMBOLS		= 1
-!else
-SYMBOLS		= 0
-!endif
-!if [nmakehlp -f $(OPTS) "profile"]
-!message *** Doing profile
-PROFILE		= 1
-!else
-PROFILE		= 0
-!endif
-!if [nmakehlp -f $(OPTS) "pgi"]
-!message *** Doing profile guided optimization instrumentation
-PGO		= 1
-!elseif [nmakehlp -f $(OPTS) "pgo"]
-!message *** Doing profile guided optimization
-PGO		= 2
-!else
-PGO		= 0
-!endif
-!if [nmakehlp -f $(OPTS) "loimpact"]
-!message *** Doing loimpact
-LOIMPACT	= 1
-!else
-LOIMPACT	= 0
-!endif
-!if [nmakehlp -f $(OPTS) "thrdalloc"]
-!message *** Doing thrdalloc
-USE_THREAD_ALLOC = 1
-!endif
-!if [nmakehlp -f $(OPTS) "tclalloc"]
-!message *** Doing tclalloc
-USE_THREAD_ALLOC = 0
-!endif
-!if [nmakehlp -f $(OPTS) "unchecked"]
-!message *** Doing unchecked
-UNCHECKED = 1
-!else
-UNCHECKED = 0
-!endif
-!endif
-
-
-!if !$(STATIC_BUILD)
-# Make sure we don't build overly fat DLLs.
-MSVCRT		= 1
-# We shouldn't statically put the extensions inside the shell when dynamic.
-TCL_USE_STATIC_PACKAGES = 0
-!endif
-
-
-#----------------------------------------------------------
-# Figure-out how to name our intermediate and output directories.
-# We wouldn't want different builds to use the same .obj files
-# by accident.
-#----------------------------------------------------------
-
-#----------------------------------------
-# Naming convention:
-#   t = full thread support.
-#   s = static library (as opposed to an
-#	import library)
-#   g = linked to the debug enabled C
-#	run-time.
-#   x = special static build when it
-#	links to the dynamic C run-time.
-#----------------------------------------
-SUFX	    = tsgx
-
-!if $(DEBUG)
-BUILDDIRTOP = Debug
-!else
-BUILDDIRTOP = Release
-!endif
-
-!if "$(MACHINE)" != "IX86"
-BUILDDIRTOP =$(BUILDDIRTOP)_$(MACHINE)
-!endif
-!if $(VCVER) > 6
-BUILDDIRTOP =$(BUILDDIRTOP)_VC$(VCVER)
-!endif
-
-!if !$(DEBUG) || $(DEBUG) && $(UNCHECKED)
-SUFX	    = $(SUFX:g=)
-!endif
-
-TMP_DIRFULL = .\$(BUILDDIRTOP)\$(PROJECT)_ThreadedDynamicStaticX
-
-!if !$(STATIC_BUILD)
-TMP_DIRFULL = $(TMP_DIRFULL:Static=)
-SUFX	    = $(SUFX:s=)
-EXT	    = dll
-!if $(MSVCRT)
-TMP_DIRFULL = $(TMP_DIRFULL:X=)
-SUFX	    = $(SUFX:x=)
-!endif
-!else
-TMP_DIRFULL = $(TMP_DIRFULL:Dynamic=)
-EXT	    = lib
-!if !$(MSVCRT)
-TMP_DIRFULL = $(TMP_DIRFULL:X=)
-SUFX	    = $(SUFX:x=)
-!endif
-!endif
-
-!if !$(TCL_THREADS)
-TMP_DIRFULL = $(TMP_DIRFULL:Threaded=)
-SUFX	    = $(SUFX:t=)
-!endif
-
-!ifndef TMP_DIR
-TMP_DIR	    = $(TMP_DIRFULL)
-!ifndef OUT_DIR
-OUT_DIR	    = .\$(BUILDDIRTOP)
-!endif
-!else
-!ifndef OUT_DIR
-OUT_DIR	    = $(TMP_DIR)
-!endif
-!endif
-
-
-#----------------------------------------------------------
-# Decode the statistics requested.
-#----------------------------------------------------------
-
-!if "$(STATS)" == "" || [nmakehlp -f "$(STATS)" "none"]
-TCL_MEM_DEBUG	    = 0
-TCL_COMPILE_DEBUG   = 0
-!else
-!if [nmakehlp -f $(STATS) "memdbg"]
-!message *** Doing memdbg
-TCL_MEM_DEBUG	    = 1
-!else
-TCL_MEM_DEBUG	    = 0
-!endif
-!if [nmakehlp -f $(STATS) "compdbg"]
-!message *** Doing compdbg
-TCL_COMPILE_DEBUG   = 1
-!else
-TCL_COMPILE_DEBUG   = 0
-!endif
-!endif
-
-
-#----------------------------------------------------------
-# Decode the checks requested.
-#----------------------------------------------------------
-
-!if "$(CHECKS)" == "" || [nmakehlp -f "$(CHECKS)" "none"]
-TCL_NO_DEPRECATED	    = 0
-WARNINGS		    = -W3
-!else
-!if [nmakehlp -f $(CHECKS) "nodep"]
-!message *** Doing nodep check
-TCL_NO_DEPRECATED	    = 1
-!else
-TCL_NO_DEPRECATED	    = 0
-!endif
-!if [nmakehlp -f $(CHECKS) "fullwarn"]
-!message *** Doing full warnings check
-WARNINGS		    = -W4
-!if [nmakehlp -l -warn:3]
-LINKERFLAGS		    = $(LINKERFLAGS) -warn:3
-!endif
-!else
-WARNINGS		    = -W3
-!endif
-!if [nmakehlp -f $(CHECKS) "64bit"] && [nmakehlp -c -Wp64]
-!message *** Doing 64bit portability warnings
-WARNINGS		    = $(WARNINGS) -Wp64
-!endif
-!endif
-
-!if $(PGO) > 1
-!if [nmakehlp -l -ltcg:pgoptimize]
-LINKERFLAGS	= $(LINKERFLAGS:-ltcg=) -ltcg:pgoptimize
-!else
-MSG=^
-This compiler does not support profile guided optimization.
-!error $(MSG)
-!endif
-!elseif $(PGO) > 0
-!if [nmakehlp -l -ltcg:pginstrument]
-LINKERFLAGS	= $(LINKERFLAGS:-ltcg=) -ltcg:pginstrument
-!else
-MSG=^
-This compiler does not support profile guided optimization.
-!error $(MSG)
-!endif
-!endif
-
-#----------------------------------------------------------
-# Set our defines now armed with our options.
-#----------------------------------------------------------
-
-OPTDEFINES	= -DTCL_CFGVAL_ENCODING=$(CFG_ENCODING) -DSTDC_HEADERS
-
-!if $(TCL_MEM_DEBUG)
-OPTDEFINES	= $(OPTDEFINES) -DTCL_MEM_DEBUG
-!endif
-!if $(TCL_COMPILE_DEBUG)
-OPTDEFINES	= $(OPTDEFINES) -DTCL_COMPILE_DEBUG -DTCL_COMPILE_STATS
-!endif
-!if $(TCL_THREADS)
-OPTDEFINES	= $(OPTDEFINES) -DTCL_THREADS=1
-!if $(USE_THREAD_ALLOC)
-OPTDEFINES	= $(OPTDEFINES) -DUSE_THREAD_ALLOC=1
-!endif
-!endif
-!if $(STATIC_BUILD)
-OPTDEFINES	= $(OPTDEFINES) -DSTATIC_BUILD
-!endif
-!if $(TCL_NO_DEPRECATED)
-OPTDEFINES	= $(OPTDEFINES) -DTCL_NO_DEPRECATED
-!endif
-
-!if !$(DEBUG)
-OPTDEFINES	= $(OPTDEFINES) -DNDEBUG
-!if $(OPTIMIZING)
-OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_OPTIMIZED
-!endif
-!endif
-!if $(PROFILE)
-OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_PROFILED
-!endif
-!if "$(MACHINE)" == "IA64" || "$(MACHINE)" == "AMD64"
-OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_DO64BIT
-!endif
-!if $(VCVERSION) < 1300
-OPTDEFINES	= $(OPTDEFINES) -DNO_STRTOI64
-!endif
-
-#----------------------------------------------------------
-# Locate the Tcl headers to build against
-#----------------------------------------------------------
-
-!if "$(PROJECT)" == "tcl"
-
-_TCL_H          = ..\generic\tcl.h
-
-!else
-
-# If INSTALLDIR set to tcl root dir then reset to the lib dir.
-!if exist("$(_INSTALLDIR)\include\tcl.h")
-_INSTALLDIR=$(_INSTALLDIR)\lib
-!endif
-
-!if !defined(TCLDIR)
-!if exist("$(_INSTALLDIR)\..\include\tcl.h")
-TCLINSTALL	= 1
-_TCLDIR		= $(_INSTALLDIR)\..
-_TCL_H          = $(_INSTALLDIR)\..\include\tcl.h
-TCLDIR          = $(_INSTALLDIR)\..
-!else
-MSG=^
-Failed to find tcl.h.  Set the TCLDIR macro.
-!error $(MSG)
-!endif
-!else
-_TCLDIR	= $(TCLDIR:/=\)
-!if exist("$(_TCLDIR)\include\tcl.h")
-TCLINSTALL	= 1
-_TCL_H          = $(_TCLDIR)\include\tcl.h
-!elseif exist("$(_TCLDIR)\generic\tcl.h")
-TCLINSTALL	= 0
-_TCL_H          = $(_TCLDIR)\generic\tcl.h
-!else
-MSG =^
-Failed to find tcl.h.  The TCLDIR macro does not appear correct.
-!error $(MSG)
-!endif
-!endif
-!endif
-
-#--------------------------------------------------------------
-# Extract various version numbers from tcl headers
-# The generated file is then included in the makefile.
-#--------------------------------------------------------------
-
-!if [echo REM = This file is generated from rules.vc > versions.vc]
-!endif
-!if [echo TCL_MAJOR_VERSION = \>> versions.vc] \
-   && [nmakehlp -V "$(_TCL_H)" TCL_MAJOR_VERSION >> versions.vc]
-!endif
-!if [echo TCL_MINOR_VERSION = \>> versions.vc] \
-   && [nmakehlp -V "$(_TCL_H)" TCL_MINOR_VERSION >> versions.vc]
-!endif
-!if [echo TCL_PATCH_LEVEL = \>> versions.vc] \
-   && [nmakehlp -V "$(_TCL_H)" TCL_PATCH_LEVEL >> versions.vc]
-!endif
-
-# If building the tcl core then we need additional package versions
-!if "$(PROJECT)" == "tcl"
-!if [echo PKG_HTTP_VER = \>> versions.vc] \
-   && [nmakehlp -V ..\library\http\pkgIndex.tcl http >> versions.vc]
-!endif
-!if [echo PKG_TCLTEST_VER = \>> versions.vc] \
-   && [nmakehlp -V ..\library\tcltest\pkgIndex.tcl tcltest >> versions.vc]
-!endif
-!if [echo PKG_MSGCAT_VER = \>> versions.vc] \
-   && [nmakehlp -V ..\library\msgcat\pkgIndex.tcl msgcat >> versions.vc]
-!endif
-!if [echo PKG_PLATFORM_VER = \>> versions.vc] \
-   && [nmakehlp -V ..\library\platform\pkgIndex.tcl "platform " >> versions.vc]
-!endif
-!if [echo PKG_SHELL_VER = \>> versions.vc] \
-   && [nmakehlp -V ..\library\platform\pkgIndex.tcl "platform::shell" >> versions.vc]
-!endif
-!if [echo PKG_DDE_VER = \>> versions.vc] \
-   && [nmakehlp -V ..\library\dde\pkgIndex.tcl "dde " >> versions.vc]
-!endif
-!if [echo PKG_REG_VER =\>> versions.vc] \
-   && [nmakehlp -V ..\library\reg\pkgIndex.tcl registry >> versions.vc]
-!endif
-!endif
-
-!include versions.vc
-
-#--------------------------------------------------------------
-# Setup tcl version dependent stuff headers
-#--------------------------------------------------------------
-
-!if "$(PROJECT)" != "tcl"
-
-TCL_VERSION	= $(TCL_MAJOR_VERSION)$(TCL_MINOR_VERSION)
-
-!if $(TCL_VERSION) < 81
-TCL_DOES_STUBS	= 0
-!else
-TCL_DOES_STUBS	= 1
-!endif
-
-!if $(TCLINSTALL)
-TCLSH		= "$(_TCLDIR)\bin\tclsh$(TCL_VERSION)$(SUFX).exe"
-!if !exist($(TCLSH)) && $(TCL_THREADS)
-TCLSH           = "$(_TCLDIR)\bin\tclsh$(TCL_VERSION)t$(SUFX).exe"
-!endif
-TCLSTUBLIB	= "$(_TCLDIR)\lib\tclstub$(TCL_VERSION).lib"
-TCLIMPLIB	= "$(_TCLDIR)\lib\tcl$(TCL_VERSION)$(SUFX).lib"
-TCL_LIBRARY	= $(_TCLDIR)\lib
-TCLREGLIB	= "$(_TCLDIR)\lib\tclreg13$(SUFX:t=).lib"
-TCLDDELIB	= "$(_TCLDIR)\lib\tcldde14$(SUFX:t=).lib"
-COFFBASE	= \must\have\tcl\sources\to\build\this\target
-TCLTOOLSDIR	= \must\have\tcl\sources\to\build\this\target
-TCL_INCLUDES    = -I"$(_TCLDIR)\include"
-!else
-TCLSH		= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclsh$(TCL_VERSION)$(SUFX).exe"
-!if !exist($(TCLSH)) && $(TCL_THREADS)
-TCLSH		= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclsh$(TCL_VERSION)t$(SUFX).exe"
-!endif
-TCLSTUBLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclstub$(TCL_VERSION).lib"
-TCLIMPLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tcl$(TCL_VERSION)$(SUFX).lib"
-TCL_LIBRARY	= $(_TCLDIR)\library
-TCLREGLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclreg13$(SUFX:t=).lib"
-TCLDDELIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tcldde14$(SUFX:t=).lib"
-COFFBASE	= "$(_TCLDIR)\win\coffbase.txt"
-TCLTOOLSDIR	= $(_TCLDIR)\tools
-TCL_INCLUDES	= -I"$(_TCLDIR)\generic" -I"$(_TCLDIR)\win"
-!endif
-
-!endif
-
-#-------------------------------------------------------------------------
-# Locate the Tk headers to build against
-#-------------------------------------------------------------------------
-
-!if "$(PROJECT)" == "tk"
-_TK_H          = ..\generic\tk.h
-_INSTALLDIR    = $(_INSTALLDIR)\..
-!endif
-
-!ifdef PROJECT_REQUIRES_TK
-!if !defined(TKDIR)
-!if exist("$(_INSTALLDIR)\..\include\tk.h")
-TKINSTALL      = 1
-_TKDIR         = $(_INSTALLDIR)\..
-_TK_H          = $(_TKDIR)\include\tk.h
-TKDIR          = $(_TKDIR)
-!elseif exist("$(_TCLDIR)\include\tk.h")
-TKINSTALL      = 1
-_TKDIR         = $(_TCLDIR)
-_TK_H          = $(_TKDIR)\include\tk.h
-TKDIR          = $(_TKDIR)
-!endif
-!else
-_TKDIR = $(TKDIR:/=\)
-!if exist("$(_TKDIR)\include\tk.h")
-TKINSTALL      = 1
-_TK_H          = $(_TKDIR)\include\tk.h
-!elseif exist("$(_TKDIR)\generic\tk.h")
-TKINSTALL      = 0
-_TK_H          = $(_TKDIR)\generic\tk.h
-!else
-MSG =^
-Failed to find tk.h. The TKDIR macro does not appear correct.
-!error $(MSG)
-!endif
-!endif
-!endif
-
-#-------------------------------------------------------------------------
-# Extract Tk version numbers
-#-------------------------------------------------------------------------
-
-!if defined(PROJECT_REQUIRES_TK) || "$(PROJECT)" == "tk"
-
-!if [echo TK_MAJOR_VERSION = \>> versions.vc] \
-   && [nmakehlp -V $(_TK_H) TK_MAJOR_VERSION >> versions.vc]
-!endif
-!if [echo TK_MINOR_VERSION = \>> versions.vc] \
-   && [nmakehlp -V $(_TK_H) TK_MINOR_VERSION >> versions.vc]
-!endif
-!if [echo TK_PATCH_LEVEL = \>> versions.vc] \
-   && [nmakehlp -V $(_TK_H) TK_PATCH_LEVEL >> versions.vc]
-!endif
-
-!include versions.vc
-
-TK_DOTVERSION	= $(TK_MAJOR_VERSION).$(TK_MINOR_VERSION)
-TK_VERSION	= $(TK_MAJOR_VERSION)$(TK_MINOR_VERSION)
-
-!if "$(PROJECT)" != "tk"
-!if $(TKINSTALL)
-WISH		= "$(_TKDIR)\bin\wish$(TK_VERSION)$(SUFX).exe"
-TKSTUBLIB	= "$(_TKDIR)\lib\tkstub$(TK_VERSION).lib"
-TKIMPLIB	= "$(_TKDIR)\lib\tk$(TK_VERSION)$(SUFX).lib"
-TK_INCLUDES     = -I"$(_TKDIR)\include"
-!else
-WISH		= "$(_TKDIR)\win\$(BUILDDIRTOP)\wish$(TCL_VERSION)$(SUFX).exe"
-TKSTUBLIB	= "$(_TKDIR)\win\$(BUILDDIRTOP)\tkstub$(TCL_VERSION).lib"
-TKIMPLIB	= "$(_TKDIR)\win\$(BUILDDIRTOP)\tk$(TCL_VERSION)$(SUFX).lib"
-TK_INCLUDES     = -I"$(_TKDIR)\generic" -I"$(_TKDIR)\win" -I"$(_TKDIR)\xlib"
-!endif
-!endif
-
-!endif
-
-#----------------------------------------------------------
-# Display stats being used.
-#----------------------------------------------------------
-
-!message *** Intermediate directory will be '$(TMP_DIR)'
-!message *** Output directory will be '$(OUT_DIR)'
-!message *** Suffix for binaries will be '$(SUFX)'
-!message *** Optional defines are '$(OPTDEFINES)'
-!message *** Compiler version $(VCVER). Target machine is $(MACHINE)
-!message *** Host architecture is $(NATIVE_ARCH)
-!message *** Compiler options '$(COMPILERFLAGS) $(OPTIMIZATIONS) $(DEBUGFLAGS) $(WARNINGS)'
-!message *** Link options '$(LINKERFLAGS)'
-
-!endif
-

config.h.in

@@ -27,45 +27,21 @@
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
-/* Define to 1 if you have the `isnan' function. */
-#undef HAVE_ISNAN
-
 /* Define to 1 if you have the `localtime_r' function. */
 #undef HAVE_LOCALTIME_R
 
 /* Define to 1 if you have the `localtime_s' function. */
 #undef HAVE_LOCALTIME_S
 
-/* Define to 1 if you have the <malloc.h> header file. */
-#undef HAVE_MALLOC_H
-
-/* Define to 1 if you have the `malloc_usable_size' function. */
-#undef HAVE_MALLOC_USABLE_SIZE
-
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
-/* Define to 1 if you have the pread() function. */
-#undef HAVE_PREAD
-
-/* Define to 1 if you have the pread64() function. */
-#undef HAVE_PREAD64
-
-/* Define to 1 if you have the pwrite() function. */
-#undef HAVE_PWRITE
-
-/* Define to 1 if you have the pwrite64() function. */
-#undef HAVE_PWRITE64
-
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
 
 /* Define to 1 if you have the <stdlib.h> header file. */
 #undef HAVE_STDLIB_H
 
-/* Define to 1 if you have the strchrnul() function */
-#undef HAVE_STRCHRNUL
-
 /* Define to 1 if you have the <strings.h> header file. */
 #undef HAVE_STRINGS_H
 
@@ -99,9 +75,6 @@
 /* Define to 1 if you have the `usleep' function. */
 #undef HAVE_USLEEP
 
-/* Define to 1 if you have the utime() library function. */
-#undef HAVE_UTIME
-
 /* Define to the sub-directory in which libtool stores uninstalled libraries.
    */
 #undef LT_OBJDIR

configure.ac

@@ -69,6 +69,19 @@
 #        The filename extension for executables on the
 #        target platform.  "" for Unix and ".exe" for windows.
 #
+# The generated configure script will make an attempt to guess
+# at all of the above parameters.  You can override any of
+# the guesses by setting the environment variable named
+# "config_AAAA" where "AAAA" is the name of the parameter
+# described above.  (Exception: srcdir cannot be set this way.)
+# If you have a file that sets one or more of these environment
+# variables, you can invoke configure as follows:
+#
+#           configure --with-hints=FILE
+#
+# where FILE is the name of the file that sets the environment
+# variables.  FILE should be an absolute pathname.
+#
 # This configure.in file is easy to reuse on other projects.  Just
 # change the argument to AC_INIT().  And disable any features that
 # you don't need (for example BLT) by erasing or commenting out
@@ -85,11 +98,17 @@ AC_MSG_ERROR([configure script is out of date:
 please regen with autoconf])
 fi
 
+dnl Put the RCS revision string after AC_INIT so that it will also
+dnl show in in configure.
+# The following RCS revision string applies to configure.in
+# $Revision: 1.56 $
+
 #########
 # Programs needed
 #
 AC_PROG_LIBTOOL
 AC_PROG_INSTALL
+AC_PROG_AWK
 
 #########
 # Enable large file support (if special flags are necessary)
@@ -103,12 +122,12 @@ AC_CHECK_TYPES([int8_t, int16_t, int32_t, int64_t, intptr_t, uint8_t,
 
 #########
 # Check for needed/wanted headers
-AC_CHECK_HEADERS([sys/types.h stdlib.h stdint.h inttypes.h malloc.h])
+AC_CHECK_HEADERS([sys/types.h stdlib.h stdint.h inttypes.h])
 
 #########
 # Figure out whether or not we have these functions
 #
-AC_CHECK_FUNCS([fdatasync gmtime_r isnan localtime_r localtime_s malloc_usable_size strchrnul usleep utime pread pread64 pwrite pwrite64])
+AC_CHECK_FUNCS([usleep fdatasync localtime_r gmtime_r localtime_s])
 
 #########
 # By default, we use the amalgamation (this may be changed below...)
@@ -120,7 +139,7 @@ USE_AMALGAMATION=1
 # if not, then we fall back to plain tclsh.
 # TODO: try other versions before falling back?
 # 
-AC_CHECK_PROGS(TCLSH_CMD, [tclsh8.7 tclsh8.6 tclsh8.5 tclsh], none)
+AC_CHECK_PROGS(TCLSH_CMD, [tclsh8.4 tclsh], none)
 if test "$TCLSH_CMD" = "none"; then
   # If we can't find a local tclsh, then building the amalgamation will fail.
   # We act as though --disable-amalgamation has been used.
@@ -161,6 +180,41 @@ VERSION_NUMBER=[`cat $srcdir/VERSION \
 AC_MSG_NOTICE(Version number set to $VERSION_NUMBER)
 AC_SUBST(VERSION_NUMBER)
 
+#########
+# Check to see if the --with-hints=FILE option is used.  If there is none,
+# then check for a files named "$host.hints" and ../$hosts.hints where
+# $host is the hostname of the build system.  If still no hints are
+# found, try looking in $system.hints and ../$system.hints where
+# $system is the result of uname -s.
+#
+AC_ARG_WITH(hints,
+  AC_HELP_STRING([--with-hints=FILE],[Read configuration options from FILE]),
+  hints=$withval)
+if test "$hints" = ""; then
+  host=`hostname | sed 's/\..*//'`
+  if test -r $host.hints; then
+    hints=$host.hints
+  else
+     if test -r ../$host.hints; then
+       hints=../$host.hints
+     fi
+  fi
+fi
+if test "$hints" = ""; then
+  sys=`uname -s`
+  if test -r $sys.hints; then
+    hints=$sys.hints
+  else
+     if test -r ../$sys.hints; then
+       hints=../$sys.hints
+     fi
+  fi
+fi
+if test "$hints" != ""; then
+  AC_MSG_RESULT(reading hints from $hints)
+  . $hints
+fi
+
 #########
 # Locate a compiler for the build machine.  This compiler should
 # generate command-line programs that run on the build machine.
@@ -182,7 +236,7 @@ AC_SUBST(BUILD_CC)
 # Do we want to support multithreaded use of sqlite
 #
 AC_ARG_ENABLE(threadsafe, 
-AC_HELP_STRING([--disable-threadsafe],[Disable mutexing]))
+AC_HELP_STRING([--enable-threadsafe],[Support threadsafe operation]),,enable_threadsafe=yes)
 AC_MSG_CHECKING([whether to support threadsafe operation])
 if test "$enable_threadsafe" = "no"; then
   SQLITE_THREADSAFE=0
@@ -195,9 +249,43 @@ AC_SUBST(SQLITE_THREADSAFE)
 
 if test "$SQLITE_THREADSAFE" = "1"; then
   AC_SEARCH_LIBS(pthread_create, pthread)
-  AC_SEARCH_LIBS(pthread_mutexattr_init, pthread)
 fi
 
+##########
+# Do we want to allow a connection created in one thread to be used
+# in another thread.  This does not work on many Linux systems (ex: RedHat 9)
+# due to bugs in the threading implementations.  This is thus off by default.
+#
+AC_ARG_ENABLE(cross-thread-connections, 
+AC_HELP_STRING([--enable-cross-thread-connections],[Allow connection sharing across threads]),,enable_xthreadconnect=no)
+AC_MSG_CHECKING([whether to allow connections to be shared across threads])
+if test "$enable_xthreadconnect" = "no"; then
+  XTHREADCONNECT=''
+  AC_MSG_RESULT([no])
+else
+  XTHREADCONNECT='-DSQLITE_ALLOW_XTHREAD_CONNECT=1'
+  AC_MSG_RESULT([yes])
+fi
+AC_SUBST(XTHREADCONNECT)
+
+##########
+# Do we want to set threadsOverrideEachOthersLocks variable to be 1 (true) by
+# default. Normally, a test at runtime is performed to determine the
+# appropriate value of this variable. Use this option only if you're sure that
+# threads can safely override each others locks in all runtime situations.
+#
+AC_ARG_ENABLE(threads-override-locks, 
+AC_HELP_STRING([--enable-threads-override-locks],[Threads can override each others locks]),,enable_threads_override_locks=no)
+AC_MSG_CHECKING([whether threads can override each others locks])
+if test "$enable_threads_override_locks" = "no"; then
+  THREADSOVERRIDELOCKS='-1'
+  AC_MSG_RESULT([no])
+else
+  THREADSOVERRIDELOCKS='1'
+  AC_MSG_RESULT([yes])
+fi
+AC_SUBST(THREADSOVERRIDELOCKS)
+
 ##########
 # Do we want to support release
 #
@@ -270,18 +358,28 @@ else
   TARGET_EXEEXT=$config_TARGET_EXEEXT
 fi
 if test "$TARGET_EXEEXT" = ".exe"; then
-  SQLITE_OS_UNIX=0
-  SQLITE_OS_WIN=1
-  CFLAGS="$CFLAGS -DSQLITE_OS_WIN=1"
+  if test $OS2_SHELL ; then
+    SQLITE_OS_UNIX=0
+    SQLITE_OS_WIN=0
+    SQLITE_OS_OS2=1
+    CFLAGS="$CFLAGS -DSQLITE_OS_OS2=1"
+  else
+    SQLITE_OS_UNIX=0
+    SQLITE_OS_WIN=1
+    SQLITE_OS_OS2=0
+    CFLAGS="$CFLAGS -DSQLITE_OS_WIN=1"
+  fi
 else
   SQLITE_OS_UNIX=1
   SQLITE_OS_WIN=0
+  SQLITE_OS_OS2=0
   CFLAGS="$CFLAGS -DSQLITE_OS_UNIX=1"
 fi
 
 AC_SUBST(BUILD_EXEEXT)
 AC_SUBST(SQLITE_OS_UNIX)
 AC_SUBST(SQLITE_OS_WIN)
+AC_SUBST(SQLITE_OS_OS2)
 AC_SUBST(TARGET_EXEEXT)
 
 ##########
@@ -308,44 +406,14 @@ if test "${use_tcl}" = "yes" ; then
     fi
 
     # Start autosearch by asking tclsh
-    if test x"${ac_cv_c_tclconfig}" = x ; then
-      if test x"$cross_compiling" = xno; then
-        for i in `echo 'puts stdout $auto_path' | ${TCLSH_CMD}`
-        do
-          if test -f "$i/tclConfig.sh" ; then
-            ac_cv_c_tclconfig="$i"
-            break
-          fi
-        done
-      fi
-    fi
-
-    # On ubuntu 14.10, $auto_path on tclsh is not quite correct.
-    # So try again after applying corrections.
-    if test x"${ac_cv_c_tclconfig}" = x ; then
-      if test x"$cross_compiling" = xno; then
-        for i in `echo 'puts stdout $auto_path' | ${TCLSH_CMD} | sed 's,/tcltk/tcl,/tcl,g'`
-        do
-          if test -f "$i/tclConfig.sh" ; then
-            ac_cv_c_tclconfig="$i"
-            break
-          fi
-        done
-      fi
-    fi
-
-    # Recent versions of Xcode on Macs hid the tclConfig.sh file
-    # in a strange place.
-    if test x"${ac_cv_c_tclconfig}" = x ; then
-      if test x"$cross_compiling" = xno; then
-        for i in /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX*.sdk/usr/lib
-        do
-          if test -f "$i/tclConfig.sh" ; then
-            ac_cv_c_tclconfig="$i"
-            break
-          fi
-        done
-      fi
+    if test x"$cross_compiling" = xno; then
+      for i in `echo 'puts stdout $auto_path' | ${TCLSH_CMD}`
+      do
+        if test -f "$i/tclConfig.sh" ; then
+          ac_cv_c_tclconfig="$i"
+          break
+        fi
+      done
     fi
 
     # then check for a private Tcl installation
@@ -449,6 +517,7 @@ if test "${use_tcl}" = "yes" ; then
     AC_SUBST(TCL_VERSION)
     AC_SUBST(TCL_BIN_DIR)
     AC_SUBST(TCL_SRC_DIR)
+    AC_SUBST(TCL_LIBS)
     AC_SUBST(TCL_INCLUDE_SPEC)
     
     AC_SUBST(TCL_LIB_FILE)
@@ -458,7 +527,6 @@ if test "${use_tcl}" = "yes" ; then
     AC_SUBST(TCL_STUB_LIB_FILE)
     AC_SUBST(TCL_STUB_LIB_FLAG)
     AC_SUBST(TCL_STUB_LIB_SPEC)
-    AC_SUBST(TCL_SHLIB_SUFFIX)
   fi
 fi
 if test "${use_tcl}" = "no" ; then
@@ -475,24 +543,11 @@ AC_SUBST(HAVE_TCL)
 TARGET_READLINE_LIBS=""
 TARGET_READLINE_INC=""
 TARGET_HAVE_READLINE=0
-TARGET_HAVE_EDITLINE=0
-AC_ARG_ENABLE([editline],
-	[AC_HELP_STRING([--enable-editline],[enable BSD editline support])],
-	[with_editline=$enableval],
-	[with_editline=auto])
 AC_ARG_ENABLE([readline],
-	[AC_HELP_STRING([--disable-readline],[disable readline support])],
+	[AC_HELP_STRING([--disable-readline],[disable readline support [default=detect]])],
 	[with_readline=$enableval],
 	[with_readline=auto])
 
-if test x"$with_editline" != xno; then
-        sLIBS=$LIBS
-        LIBS=""
-	TARGET_HAVE_EDITLINE=1
-	AC_SEARCH_LIBS(readline,edit,[with_readline=no],[TARGET_HAVE_EDITLINE=0])
-        TARGET_READLINE_LIBS=$LIBS
-        LIBS=$sLIBS
-fi
 if test x"$with_readline" != xno; then
 	found="yes"
 
@@ -547,7 +602,6 @@ fi
 AC_SUBST(TARGET_READLINE_LIBS)
 AC_SUBST(TARGET_READLINE_INC)
 AC_SUBST(TARGET_HAVE_READLINE)
-AC_SUBST(TARGET_HAVE_EDITLINE)
 
 ##########
 # Figure out what C libraries are required to compile programs
@@ -557,9 +611,10 @@ AC_SEARCH_LIBS(fdatasync, [rt])
 
 #########
 # check for debug enabled
-AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug],[enable debugging & verbose explain]))
-if test "${enable_debug}" = "yes" ; then
-  TARGET_DEBUG="-DSQLITE_DEBUG=1 -DSQLITE_ENABLE_SELECTTRACE -DSQLITE_ENABLE_WHERETRACE -O0"
+AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug],[enable debugging & verbose explain]),
+      [use_debug=$enableval],[use_debug=no])
+if test "${use_debug}" = "yes" ; then
+  TARGET_DEBUG="-DSQLITE_DEBUG=1"
 else
   TARGET_DEBUG="-DNDEBUG"
 fi
@@ -568,122 +623,26 @@ AC_SUBST(TARGET_DEBUG)
 #########
 # See whether we should use the amalgamation to build
 AC_ARG_ENABLE(amalgamation, AC_HELP_STRING([--disable-amalgamation],
-      [Disable the amalgamation and instead build all files separately]))
-if test "${enable_amalgamation}" == "no" ; then
+      [Disable the amalgamation and instead build all files separately]),
+      [use_amalgamation=$enableval],[use_amalgamation=yes])
+if test "${use_amalgamation}" != "yes" ; then
   USE_AMALGAMATION=0
 fi
 AC_SUBST(USE_AMALGAMATION)
 
-#########
-# Look for zlib.  Only needed by extensions and by the sqlite3.exe shell
-AC_CHECK_HEADERS(zlib.h)
-AC_SEARCH_LIBS(deflate, z, [HAVE_ZLIB="-DSQLITE_HAVE_ZLIB=1"], [HAVE_ZLIB=""])
-AC_SUBST(HAVE_ZLIB)
-
 #########
 # See whether we should allow loadable extensions
-AC_ARG_ENABLE(load-extension, AC_HELP_STRING([--disable-load-extension],
-      [Disable loading of external extensions]),,[enable_load_extension=yes])
-if test "${enable_load_extension}" = "yes" ; then
+AC_ARG_ENABLE(load-extension, AC_HELP_STRING([--enable-load-extension],
+      [Enable loading of external extensions]),
+      [use_loadextension=$enableval],[use_loadextension=no])
+if test "${use_loadextension}" = "yes" ; then
   OPT_FEATURE_FLAGS=""
-  AC_SEARCH_LIBS(dlopen, dl)
 else
   OPT_FEATURE_FLAGS="-DSQLITE_OMIT_LOAD_EXTENSION=1"
 fi
 
-##########
-# Do we want to support memsys3 and/or memsys5
-#
-AC_ARG_ENABLE(memsys5, 
-  AC_HELP_STRING([--enable-memsys5],[Enable MEMSYS5]))
-AC_MSG_CHECKING([whether to support MEMSYS5])
-if test "${enable_memsys5}" = "yes"; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_MEMSYS5"
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-AC_ARG_ENABLE(memsys3, 
-  AC_HELP_STRING([--enable-memsys3],[Enable MEMSYS3]))
-AC_MSG_CHECKING([whether to support MEMSYS3])
-if test "${enable_memsys3}" = "yes" -a "${enable_memsys5}" = "no"; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_MEMSYS3"
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-########
-# The --enable-extensions argument is short-hand to enable
-# multiple extensions.
-AC_ARG_ENABLE(all, AC_HELP_STRING([--enable-all],
-      [Enable FTS4, FTS5, Geopoly, JSON, RTree, Sessions]))
-
 #########
-# See whether we should enable Full Text Search extensions
-AC_ARG_ENABLE(fts3, AC_HELP_STRING([--enable-fts3],
-      [Enable the FTS3 extension]))
-if test "${enable_fts3}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_FTS3"
-fi
-AC_ARG_ENABLE(fts4, AC_HELP_STRING([--enable-fts4],
-      [Enable the FTS4 extension]))
-if test "${enable_fts4}" = "yes" -o "${enable_all}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_FTS4"
-  AC_SEARCH_LIBS([log],[m])
-fi
-AC_ARG_ENABLE(fts5, AC_HELP_STRING([--enable-fts5],
-      [Enable the FTS5 extension]))
-if test "${enable_fts5}" = "yes" -o "${enable_all}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_FTS5"
-  AC_SEARCH_LIBS([log],[m])
-fi
-
-#########
-# See whether we should enable JSON1
-AC_ARG_ENABLE(json1, AC_HELP_STRING([--enable-json1],[Enable the JSON1 extension]))
-if test "${enable_json1}" = "yes" -o "${enable_all}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_JSON1"
-fi
-
-#########
-# See whether we should enable the LIMIT clause on UPDATE and DELETE
-# statements.
-AC_ARG_ENABLE(update-limit, AC_HELP_STRING([--enable-update-limit],
-      [Enable the UPDATE/DELETE LIMIT clause]))
-if test "${enable_udlimit}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT"
-fi
-
-#########
-# See whether we should enable GEOPOLY
-AC_ARG_ENABLE(geopoly, AC_HELP_STRING([--enable-geopoly],
-      [Enable the GEOPOLY extension]),
-      [enable_geopoly=yes],[enable_geopoly=no])
-if test "${enable_geopoly}" = "yes" -o "${enable_all}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_GEOPOLY"
-  enable_rtree=yes
-fi
-
-#########
-# See whether we should enable RTREE
-AC_ARG_ENABLE(rtree, AC_HELP_STRING([--enable-rtree],
-      [Enable the RTREE extension]))
-if test "${enable_rtree}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_RTREE"
-fi
-
-#########
-# See whether we should enable the SESSION extension
-AC_ARG_ENABLE(session, AC_HELP_STRING([--enable-session],
-      [Enable the SESSION extension]))
-if test "${enable_session}" = "yes" -o "${enable_all}" = "yes" ; then
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_SESSION"
-  OPT_FEATURE_FLAGS="${OPT_FEATURE_FLAGS} -DSQLITE_ENABLE_PREUPDATE_HOOK"
-fi
-
-#########
-# attempt to duplicate any OMITS and ENABLES into the ${OPT_FEATURE_FLAGS} parameter
+# attempt to duplicate any OMITS and ENABLES into the $(OPT_FEATURE_FLAGS) parameter
 for option in $CFLAGS $CPPFLAGS
 do
   case $option in
@@ -736,7 +695,8 @@ BUILD_CFLAGS=$ac_temp_BUILD_CFLAGS
 #########
 # See whether we should use GCOV
 AC_ARG_ENABLE(gcov, AC_HELP_STRING([--enable-gcov],
-      [Enable coverage testing using gcov]))
+      [Enable coverage testing using gcov]),
+      [use_gcov=$enableval],[use_gcov=no])
 if test "${use_gcov}" = "yes" ; then
   USE_GCOV=1
 else

doc/F2FS.txt

@@ -1,87 +0,0 @@
-
-SQLite's OS layer contains the following definitions used in F2FS related
-calls:
-
-#define F2FS_IOCTL_MAGIC        0xf5
-#define F2FS_IOC_START_ATOMIC_WRITE     _IO(F2FS_IOCTL_MAGIC, 1)
-#define F2FS_IOC_COMMIT_ATOMIC_WRITE    _IO(F2FS_IOCTL_MAGIC, 2)
-#define F2FS_IOC_START_VOLATILE_WRITE   _IO(F2FS_IOCTL_MAGIC, 3)
-#define F2FS_IOC_ABORT_VOLATILE_WRITE   _IO(F2FS_IOCTL_MAGIC, 5)
-#define F2FS_IOC_GET_FEATURES           _IOR(F2FS_IOCTL_MAGIC, 12, u32)
-#define F2FS_FEATURE_ATOMIC_WRITE       0x0004
-
-After opening a database file on Linux (including Android), SQLite determines
-whether or not a file supports F2FS atomic commits as follows:
-
-  u32 flags = 0;
-  rc = ioctl(fd, F2FS_IOC_GET_FEATURES, &flags);
-  if( rc==0 && (flags & F2FS_FEATURE_ATOMIC_WRITE) ){
-    /* File supports F2FS atomic commits */
-  }else{
-    /* File does NOT support F2FS atomic commits */
-  }
-
-where "fd" is the file-descriptor open on the database file.
-
-Usually, when writing to a database file that supports atomic commits, SQLite
-accumulates the entire transaction in heap memory, deferring all writes to the
-db file until the transaction is committed.
-
-When it is time to commit a transaction on a file that supports atomic
-commits, SQLite does:
-
-  /* Take an F_WRLCK lock on the database file. This prevents any other
-  ** SQLite clients from reading or writing the file until the lock
-  ** is released.  */
-  rc = fcntl(fd, F_SETLK, ...);
-  if( rc!=0 ) goto failed;
-
-  rc = ioctl(fd, F2FS_IOC_START_ATOMIC_WRITE);
-  if( rc!=0 ) goto fallback_to_legacy_journal_commit;
-
-  foreach (dirty page){
-    rc = write(fd, ...dirty page...);
-    if( rc!=0 ){
-      ioctl(fd, F2FS_IOC_ABORT_VOLATILE_WRITE);
-      goto fallback_to_legacy_journal_commit;
-    }
-  }
-
-  rc = ioctl(fd, F2FS_IOC_COMMIT_ATOMIC_WRITE);
-  if( rc!=0 ){
-    ioctl(fd, F2FS_IOC_ABORT_VOLATILE_WRITE);
-    goto fallback_to_legacy_journal_commit;
-  }
-
-  /* If we get there, the transaction has been successfully 
-  ** committed to persistent storage. The following call
-  ** relinquishes the F_WRLCK lock.  */
-  fcntl(fd, F_SETLK, ...);
-
-Assumptions:
-
-1. After either of the F2FS_IOC_ABORT_VOLATILE_WRITE calls return,
-   the database file is in the state that it was in before
-   F2FS_IOC_START_ATOMIC_WRITE was invoked. Even if the ioctl()
-   fails - we're ignoring the return code.
-
-   This is true regardless of the type of error that occurred in
-   ioctl() or write().
-
-2. If the system fails before the F2FS_IOC_COMMIT_ATOMIC_WRITE is
-   completed, then following a reboot the database file is in the
-   state that it was in before F2FS_IOC_START_ATOMIC_WRITE was invoked.
-   Or, if the write was commited right before the system failed, in a 
-   state indicating that all write() calls were successfully committed
-   to persistent storage before the failure occurred.
-
-3. If the process crashes before the F2FS_IOC_COMMIT_ATOMIC_WRITE is
-   completed then the file is automatically restored to the state that
-   it was in before F2FS_IOC_START_ATOMIC_WRITE was called. This occurs
-   before the posix advisory lock is automatically dropped - there is
-   no chance that another client will be able to read the file in a
-   half-committed state before the rollback operation occurs.
-
-
-
-

doc/pager-invariants.txt

@@ -1,76 +0,0 @@
- *** Throughout this document, a page is deemed to have been synced
-     automatically as soon as it is written when PRAGMA synchronous=OFF.
-     Otherwise, the page is not synced until the xSync method of the VFS
-     is called successfully on the file containing the page.
-
- *** Definition:  A page of the database file is said to be "overwriteable" if
-     one or more of the following are true about the page:
- 
-     (a)  The original content of the page as it was at the beginning of
-          the transaction has been written into the rollback journal and
-          synced.
- 
-     (b)  The page was a freelist leaf page at the start of the transaction.
- 
-     (c)  The page number is greater than the largest page that existed in
-          the database file at the start of the transaction.
- 
- (1) A page of the database file is never overwritten unless one of the
-     following are true:
- 
-     (a) The page and all other pages on the same sector are overwriteable.
- 
-     (b) The atomic page write optimization is enabled, and the entire
-         transaction other than the update of the transaction sequence
-         number consists of a single page change.
- 
- (2) The content of a page written into the rollback journal exactly matches
-     both the content in the database when the rollback journal was written
-     and the content in the database at the beginning of the current
-     transaction.
- 
- (3) Writes to the database file are an integer multiple of the page size
-     in length and are aligned to a page boundary.
- 
- (4) Reads from the database file are either aligned on a page boundary and
-     an integer multiple of the page size in length or are taken from the
-     first 100 bytes of the database file.
- 
- (5) All writes to the database file are synced prior to the rollback journal
-     being deleted, truncated, or zeroed.
- 
- (6) If a master journal file is used, then all writes to the database file
-     are synced prior to the master journal being deleted.
- 
- *** Definition: Two databases (or the same database at two points it time)
-     are said to be "logically equivalent" if they give the same answer to
-     all queries.  Note in particular the content of freelist leaf
-     pages can be changed arbitarily without effecting the logical equivalence
-     of the database.
- 
- (7) At any time, if any subset, including the empty set and the total set,
-     of the unsynced changes to a rollback journal are removed and the 
-     journal is rolled back, the resulting database file will be logical
-     equivalent to the database file at the beginning of the transaction.
- 
- (8) When a transaction is rolled back, the xTruncate method of the VFS
-     is called to restore the database file to the same size it was at
-     the beginning of the transaction.  (In some VFSes, the xTruncate
-     method is a no-op, but that does not change the fact the SQLite will
-     invoke it.)
- 
- (9) Whenever the database file is modified, at least one bit in the range
-     of bytes from 24 through 39 inclusive will be changed prior to releasing
-     the EXCLUSIVE lock.
-
-(10) The pattern of bits in bytes 24 through 39 shall not repeat in less
-     than one billion transactions.
-
-(11) A database file is well-formed at the beginning and at the conclusion
-     of every transaction.
-
-(12) An EXCLUSIVE lock must be held on the database file before making
-     any changes to the database file.
-
-(13) A SHARED lock must be held on the database file before reading any
-     content out of the database file.

doc/trusted-schema.md

@@ -1,142 +0,0 @@
-# The new-security-options branch
-
-## The problem that the [new-security-options](/timeline?r=new-security-options) branch tries to solve
-
-An attacker might modify the schema of an SQLite database by adding
-structures that cause code to run when some other application opens and
-reads the database.  For example, the attacker might replace a table
-definition with a view.  Or the attacker might add triggers to tables
-or views, or add new CHECK constraints or generated columns or indexes
-with expressions in the index list or in the WHERE clause.  If the
-added features invoke SQL functions or virtual tables with side effects,
-that might cause harm to the system if run by a high-privilege victim.
-Or, the added features might exfiltrate information if the database is
-read by a high-privilege victim.
-
-The changes in this branch strive to make it easier for high-privilege
-applications to safely read SQLite database files that might have been
-maliciously corrupted by an attacker.
-
-## Overview of changes in [new-security-options](/timeline?r=new-security-options)
-
-The basic idea is to tag every SQL function and virtual table with one
-of three risk levels:
-
-  1.  Innocuous
-  2.  Normal
-  3.  Direct-Only
-
-Innocuous functions/vtabs are safe and can be used at any time.
-Direct-only elements, in contrast, might have cause side-effects and
-should only be used from top-level SQL, not from within triggers or views nor
-in elements of the schema such as CHECK constraint, DEFAULT values, 
-generated columns, index expressions, or in the WHERE clause of a 
-partial index that are potentially under the control of an attacker.
-Normal elements behave like Innocuous if TRUSTED\_SCHEMA=on
-and behave like direct-only if TRUSTED\_SCHEMA=off.
-
-Application-defined functions and virtual tables go in as Normal unless
-the application takes deliberate steps to change the risk level.
-
-For backwards compatibility, the default is TRUSTED\_SCHEMA=on.  Documentation
-will be updated to recommend applications turn TRUSTED\_SCHEMA to off.
-
-An innocuous function or virtual table is one that can only read content
-from the database file in which it resides, and can only alter the database
-in which it resides.  Most SQL functions are innocuous.  For example, there
-is no harm in an attacker running the abs() function.
-
-Direct-only elements that have side-effects that go outside the database file
-in which it lives, or return information from outside of the database file.
-Examples of direct-only elements include:
-
-  1.  The fts3\_tokenizer() function
-  2.  The writefile() function
-  3.  The readfile() function
-  4.  The zipvfs virtual table
-  5.  The csv virtual table
-
-We do not want an attacker to be able to add these kinds of things to
-the database schema and possibly trick a high-privilege application 
-from performing any of these actions.  Therefore, functions and vtabs
-with side-effects are marked as Direct-Only.
-
-Legacy applications might add other risky functions or vtabs.  Those will
-go in as "Normal" by default.  For optimal security, we want those risky
-app-defined functions and vtabs to be direct-only, but making that the
-default might break some legacy applications.  Hence, all app-defined
-functions and vtabs go in as Normal, but the application can switch them
-over to "Direct-Only" behavior using a single pragma.
-
-The restrictions on the use of functions and virtual tables do not apply
-to TEMP.  A TEMP VIEW or a TEMP TRIGGER can use any valid SQL function
-or virtual table.  The idea is that TEMP views and triggers must be
-directly created by the application and are thus under the control of the
-application.  TEMP views and triggers cannot be created by an attacker who
-corrupts the schema of a persistent database file.  Hence TEMP views and
-triggers are safe.
-
-## Specific changes
-
-  1.  New sqlite3\_db\_config() option SQLITE\_DBCONFIG\_TRUSTED\_SCHEMA for
-      turning TRUSTED\_SCHEMA on and off.  It defaults to ON.
-
-  2.  Compile-time option -DSQLITE\_TRUSTED\_SCHEMA=0 causes the default
-      TRUSTED\_SCHEMA setting to be off.
-
-  3.  New pragma "PRAGMA trusted\_schema=(ON\|OFF);".  This provides access
-      to the TRUSTED_SCHEMA setting for application coded using scripting
-      languages or other secondary languages where they are unable to make
-      calls to sqlite3\_db\_config().
-
-  4.  New options for the "enc" parameter to sqlite3\_create\_function() and
-      its kin:
-      <ol type="a">
-      <li>  _SQLITE\_INNOCUOUS_  &rarr; tags the new functions as Innocuous
-      <li>  _SQLITE\_DIRECTONLY_ &rarr; tags the new functions as Direct-Only
-      </ol>
-
-  5.  New options to sqlite3\_vtab\_config():
-      <ol type="a">
-      <li>  _SQLITE\_VTAB\_INNOCUOUS_   &rarr; tags the vtab as Innocuous
-      <li>  _SQLITE\_VTAB\_DIRECTONLY_  &rarr; tags the vtab as Direct-Only
-      </ol>
-
-  6.  Change many of the functions and virtual tables in the SQLite source
-      tree to use one of the tags above.
-
-  7.  Enhanced PRAGMA function\_list and virtual-table "pragma\_function\_list"
-      with additional columns.  The columns now are:
-      <ul>
-      <li> _name_      &rarr;  Name of the function
-      <li> _builtin_   &rarr;  1 for built-in functions.  0 otherwise.
-      <li> _type_      &rarr;  's'=Scalar, 'a'=Aggregate, 'w'=Window
-      <li> _enc_       &rarr;  'utf8', 'utf16le', or 'utf16be'
-      <li> _narg_      &rarr;  number of argument
-      <li> _flags_     &rarr;  Bitmask of SQLITE\_INNOCUOUS, SQLITE\_DIRECTONLY,
-                               SQLITE\_DETERMINISTIC, SQLITE\_SUBTYPE, and
-                               SQLITE\_FUNC\_INTERNAL flags.
-      </ul>
-      <p>The last four columns are new.
-
-  8.  The function\_list PRAGMA now also shows all entries for each function.
-      So, for example, if a function can take either 2 or 3 arguments,
-      there are separate rows for the 2-argument and 3-argument versions of
-      the function.
-
-## Additional Notes
-
-The function_list enhancements allow the application to query the set
-of SQL functions that meet various criteria.  For example, to see all
-SQL functions that are never allowed to be used in the schema or in
-trigger or views:
-
-~~~
-    SELECT DISTINCT name FROM pragma_function_list
-     WHERE (flags & 0x80000)!=0
-     ORDER BY name;
-~~~
-
-Doing the same is not possible for virtual tables, as a virtual table
-might be Innocuous, Normal, or Direct-Only depending on the arguments
-passed into the xConnect method.

doc/vfs-shm.txt

@@ -1,130 +0,0 @@
-The 5 states of an historical rollback lock as implemented by the
-xLock, xUnlock, and xCheckReservedLock methods of the sqlite3_io_methods
-objec are:
-
-   UNLOCKED
-   SHARED
-   RESERVED
-   PENDING
-   EXCLUSIVE
-
-The wal-index file has a similar locking hierarchy implemented using
-the xShmLock method of the sqlite3_vfs object, but with 7
-states.  Each connection to a wal-index file must be in one of
-the following 7 states:
-
-   UNLOCKED
-   READ
-   READ_FULL
-   WRITE
-   PENDING
-   CHECKPOINT
-   RECOVER
-
-These roughly correspond to the 5 states of a rollback lock except
-that SHARED is split out into 2 states: READ and READ_FULL and
-there is an extra RECOVER state used for wal-index reconstruction.
-
-The meanings of the various wal-index locking states is as follows:
-
-   UNLOCKED    - The wal-index is not in use.
-
-   READ        - Some prefix of the wal-index is being read. Additional
-                 wal-index information can be appended at any time.  The
-                 newly appended content will be ignored by the holder of
-                 the READ lock.
-
-   READ_FULL   - The entire wal-index is being read.  No new information
-                 can be added to the wal-index.  The holder of a READ_FULL
-                 lock promises never to read pages from the database file
-                 that are available anywhere in the wal-index.
-
-   WRITE       - It is OK to append to the wal-index file and to adjust
-                 the header to indicate the new "last valid frame".
-
-   PENDING     - Waiting on all READ locks to clear so that a
-                 CHECKPOINT lock can be acquired.
-
-   CHECKPOINT  - It is OK to write any WAL data into the database file
-                 and zero the last valid frame field of the wal-index
-                 header.  The wal-index file itself may not be changed
-                 other than to zero the last valid frame field in the
-                 header.
-
-   RECOVER     - Held during wal-index recovery.  Used to prevent a
-                 race if multiple clients try to recover a wal-index at
-                 the same time.
-   
-
-A particular lock manager implementation may coalesce one or more of 
-the wal-index locking states, though with a reduction in concurrency.
-For example, an implemention might implement only exclusive locking,
-in which case all states would be equivalent to CHECKPOINT, meaning that 
-only one reader or one writer or one checkpointer could be active at a 
-time.  Or, an implementation might combine READ and READ_FULL into 
-a single state equivalent to READ, meaning that a writer could
-coexist with a reader, but no reader or writers could coexist with a
-checkpointer.
-
-The lock manager must obey the following rules:
-
-(1)  A READ cannot coexist with CHECKPOINT.
-(2)  A READ_FULL cannot coexist with WRITE.
-(3)  None of WRITE, PENDING, CHECKPOINT, or RECOVER can coexist.
-
-The SQLite core will obey the next set of rules.  These rules are
-assertions on the behavior of the SQLite core which might be verified
-during testing using an instrumented lock manager.
-
-(5)  No part of the wal-index will be read without holding either some
-     kind of SHM lock or an EXCLUSIVE lock on the original database.
-     The original database is the file named in the 2nd parameter to
-     the xShmOpen method.
-
-(6)  A holder of a READ_FULL will never read any page of the database
-     file that is contained anywhere in the wal-index.
-
-(7)  No part of the wal-index other than the header will be written nor
-     will the size of the wal-index grow without holding a WRITE or
-     an EXCLUSIVE on the original database file.
-
-(8)  The wal-index header will not be written without holding one of
-     WRITE, CHECKPOINT, or RECOVER on the wal-index or an EXCLUSIVE on
-     the original database files.
-
-(9)  A CHECKPOINT or RECOVER must be held on the wal-index, or an
-     EXCLUSIVE on the original database file, in order to reset the 
-     last valid frame counter in the header of the wal-index back to zero.
-
-(10) A WRITE can only increase the last valid frame pointer in the header.
-
-The SQLite core will only ever send requests for UNLOCK, READ, WRITE,
-CHECKPOINT, or RECOVER to the lock manager.   The SQLite core will never
-request a READ_FULL or PENDING lock though the lock manager may deliver
-those locking states in response to READ and CHECKPOINT requests,
-respectively, if and only if the requested READ or CHECKPOINT cannot
-be delivered.
-
-The following are the allowed lock transitions:
-
-       Original-State     Request         New-State
-       --------------     ----------      ----------
-(11a)  UNLOCK             READ            READ
-(11b)  UNLOCK             READ            READ_FULL
-(11c)  UNLOCK             CHECKPOINT      PENDING
-(11d)  UNLOCK             CHECKPOINT      CHECKPOINT
-(11e)  READ               UNLOCK          UNLOCK
-(11f)  READ               WRITE           WRITE
-(11g)  READ               RECOVER         RECOVER
-(11h)  READ_FULL          UNLOCK          UNLOCK
-(11i)  READ_FULL          WRITE           WRITE
-(11j)  READ_FULL          RECOVER         RECOVER
-(11k)  WRITE              READ            READ
-(11l)  PENDING            UNLOCK          UNLOCK
-(11m)  PENDING            CHECKPOINT      CHECKPOINT
-(11n)  CHECKPOINT         UNLOCK          UNLOCK
-(11o)  RECOVER            READ            READ
-
-These 15 transitions are all that needs to be supported.  The lock
-manager implementation can assert that fact.  The other 27 possible
-transitions among the 7 locking states will never occur.

ext/README.md

@@ -1,8 +0,0 @@
-## Loadable Extensions
-
-Various [loadable extensions](https://www.sqlite.org/loadext.html) for
-SQLite are found in subfolders.
-
-Most subfolders are dedicated to a single loadable extension (for
-example FTS5, or RTREE).  But the misc/ subfolder contains a collection
-of smaller single-file extensions.

ext/README.txt

@@ -0,0 +1,2 @@
+Version loadable extensions to SQLite are found in subfolders
+of this folder.

ext/async/README.txt

@@ -1,10 +1,3 @@
-NOTE (2012-11-29):
-
-The functionality implemented by this extension has been superseded
-by WAL-mode.  This module is no longer supported or maintained.  The
-code is retained for historical reference only.
-
-------------------------------------------------------------------------------
 
 Normally, when SQLite writes to a database file, it waits until the write
 operation is finished before returning control to the calling application.
@@ -168,3 +161,4 @@ the database, eliminating the bottleneck.
 
   The functionality required of each of the above functions is described
   in comments in sqlite3async.c.
+

ext/async/sqlite3async.c

@@ -667,7 +667,7 @@ static int asyncRead(
 ){
   AsyncFileData *p = ((AsyncFile *)pFile)->pData;
   int rc = SQLITE_OK;
-  sqlite3_int64 filesize = 0;
+  sqlite3_int64 filesize;
   sqlite3_file *pBase = p->pBaseRead;
   sqlite3_int64 iAmt64 = (sqlite3_int64)iAmt;
 
@@ -690,7 +690,7 @@ static int asyncRead(
     }
     nRead = MIN(filesize - iOffset, iAmt64);
     if( nRead>0 ){
-      rc = pBase->pMethods->xRead(pBase, zOut, (int)nRead, iOffset);
+      rc = pBase->pMethods->xRead(pBase, zOut, nRead, iOffset);
       ASYNC_TRACE(("READ %s %d bytes at %d\n", p->zName, nRead, iOffset));
     }
   }
@@ -717,11 +717,9 @@ static int asyncRead(
         if( iBeginIn<0 ) iBeginIn = 0;
         if( iBeginOut<0 ) iBeginOut = 0;
 
-        filesize = MAX(filesize, pWrite->iOffset+nByte64);
-
         nCopy = MIN(nByte64-iBeginIn, iAmt64-iBeginOut);
         if( nCopy>0 ){
-          memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], (size_t)nCopy);
+          memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], nCopy);
           ASYNC_TRACE(("OVERREAD %d bytes at %d\n", nCopy, iBeginOut+iOffset));
         }
       }
@@ -730,9 +728,6 @@ static int asyncRead(
 
 asyncread_out:
   async_mutex_leave(ASYNC_MUTEX_QUEUE);
-  if( rc==SQLITE_OK && filesize<(iOffset+iAmt) ){
-    rc = SQLITE_IOERR_SHORT_READ;
-  }
   return rc;
 }
 
@@ -944,7 +939,7 @@ static int asyncFileControl(sqlite3_file *id, int op, void *pArg){
       return SQLITE_OK;
     }
   }
-  return SQLITE_NOTFOUND;
+  return SQLITE_ERROR;
 }
 
 /* 
@@ -1044,18 +1039,15 @@ static int asyncOpen(
   char *z;
   int isAsyncOpen = doAsynchronousOpen(flags);
 
-  /* If zName is NULL, then the upper layer is requesting an anonymous file.
-  ** Otherwise, allocate enough space to make a copy of the file name (along
-  ** with the second nul-terminator byte required by xOpen).
-  */
+  /* If zName is NULL, then the upper layer is requesting an anonymous file */
   if( zName ){
-    nName = (int)strlen(zName);
+    nName = (int)strlen(zName)+1;
   }
 
   nByte = (
     sizeof(AsyncFileData) +        /* AsyncFileData structure */
     2 * pVfs->szOsFile +           /* AsyncFileData.pBaseRead and pBaseWrite */
-    nName + 2                      /* AsyncFileData.zName */
+    nName                          /* AsyncFileData.zName */
   ); 
   z = sqlite3_malloc(nByte);
   if( !z ){
@@ -1146,6 +1138,7 @@ static int asyncOpen(
   async_mutex_leave(ASYNC_MUTEX_LOCK);
 
   if( rc==SQLITE_OK ){
+    incrOpenFileCount();
     pData->pLock = pLock;
   }
 
@@ -1162,10 +1155,7 @@ static int asyncOpen(
   }
   if( rc!=SQLITE_OK ){
     p->pMethod = 0;
-  }else{
-    incrOpenFileCount();
   }
-
   return rc;
 }
 
@@ -1241,8 +1231,8 @@ static int asyncFullPathname(
   */
   if( rc==SQLITE_OK ){
     int i, j;
+    int n = nPathOut;
     char *z = zPathOut;
-    int n = (int)strlen(z);
     while( n>1 && z[n-1]=='/' ){ n--; }
     for(i=j=0; i<n; i++){
       if( z[i]=='/' ){
@@ -1510,7 +1500,6 @@ static void asyncWriterThread(void){
       case ASYNC_DELETE:
         ASYNC_TRACE(("DELETE %s\n", p->zBuf));
         rc = pVfs->xDelete(pVfs, p->zBuf, (int)p->iOffset);
-        if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
         break;
 
       case ASYNC_OPENEXCLUSIVE: {
@@ -1636,7 +1625,6 @@ void sqlite3async_run(void){
 ** Control/configure the asynchronous IO system.
 */
 int sqlite3async_control(int op, ...){
-  int rc = SQLITE_OK;
   va_list ap;
   va_start(ap, op);
   switch( op ){
@@ -1646,8 +1634,7 @@ int sqlite3async_control(int op, ...){
        && eWhen!=SQLITEASYNC_HALT_NOW
        && eWhen!=SQLITEASYNC_HALT_IDLE
       ){
-        rc = SQLITE_MISUSE;
-        break;
+        return SQLITE_MISUSE;
       }
       async.eHalt = eWhen;
       async_mutex_enter(ASYNC_MUTEX_QUEUE);
@@ -1659,8 +1646,7 @@ int sqlite3async_control(int op, ...){
     case SQLITEASYNC_DELAY: {
       int iDelay = va_arg(ap, int);
       if( iDelay<0 ){
-        rc = SQLITE_MISUSE;
-        break;
+        return SQLITE_MISUSE;
       }
       async.ioDelay = iDelay;
       break;
@@ -1671,8 +1657,7 @@ int sqlite3async_control(int op, ...){
       async_mutex_enter(ASYNC_MUTEX_QUEUE);
       if( async.nFile || async.pQueueFirst ){
         async_mutex_leave(ASYNC_MUTEX_QUEUE);
-        rc = SQLITE_MISUSE;
-        break;
+        return SQLITE_MISUSE;
       }
       async.bLockFiles = bLock;
       async_mutex_leave(ASYNC_MUTEX_QUEUE);
@@ -1696,11 +1681,9 @@ int sqlite3async_control(int op, ...){
     }
 
     default:
-      rc = SQLITE_ERROR;
-      break;
+      return SQLITE_ERROR;
   }
-  va_end(ap);
-  return rc;
+  return SQLITE_OK;
 }
 
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO) */

ext/async/sqlite3async.h

@@ -75,7 +75,7 @@ int sqlite3async_initialize(const char *zParent, int isDefault);
 ** On win32 platforms, this function also releases the small number of 
 ** critical section and event objects created by sqlite3async_initialize().
 */ 
-void sqlite3async_shutdown(void);
+void sqlite3async_shutdown();
 
 /*
 ** This function may only be called when the asynchronous IO VFS is 
@@ -94,7 +94,7 @@ void sqlite3async_shutdown(void);
 ** If multiple simultaneous calls are made to sqlite3async_run() from two
 ** or more threads, then the calls are serialized internally.
 */
-void sqlite3async_run(void);
+void sqlite3async_run();
 
 /*
 ** This function may only be called when the asynchronous IO VFS is 

ext/csv/csv.c

@@ -0,0 +1,670 @@
+/*
+** 2009 March 26
+**
+** 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.
+**
+*************************************************************************
+** This file contains code for implementations of the CSV
+** algorithms packaged as an SQLite virtual table module.
+*/
+#if defined(_WIN32) || defined(WIN32)
+/* This needs to come before any includes for MSVC compiler */
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_CSV)
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+#ifndef SQLITE_CORE
+  #include "sqlite3ext.h"
+  SQLITE_EXTENSION_INIT1
+#else
+  #include "sqlite3.h"
+#endif
+
+
+#define UNUSED_PARAMETER(x) (void)(x)
+
+
+/* 
+** The CSV virtual-table types.
+*/
+typedef struct CSV CSV;
+typedef struct CSVCursor CSVCursor;
+
+
+/* 
+** An CSV virtual-table object.
+*/
+struct CSV {
+  sqlite3_vtab base;           /* Must be first */
+  sqlite3 *db;                 /* Host database connection */
+  char *zDb;                   /* Name of database containing CSV table */
+  char *zName;                 /* Name of CSV table */ 
+  char *zFile;                 /* Name of CSV file */ 
+  int nBusy;                   /* Current number of users of this structure */
+  FILE *f;                     /* File pointer for source CSV file */
+  long offsetFirstRow;         /* ftell position of first row */
+  int eof;                     /* True when at end of file */
+  int maxRow;                  /* Size of zRow buffer */
+  char *zRow;                  /* Buffer for current CSV row */
+  char cDelim;                 /* Character to use for delimiting columns */
+  int nCol;                    /* Number of columns in current row */
+  int maxCol;                  /* Size of aCols array */
+  char **aCols;                /* Array of parsed columns */
+};
+
+
+/* 
+** An CSV cursor object.
+*/
+struct CSVCursor {
+  sqlite3_vtab_cursor base;    /* Must be first */
+  long csvpos;                 /* ftell position of current zRow */
+};
+
+
+/*
+** Forward declarations.
+*/
+static int csvNext( sqlite3_vtab_cursor* pVtabCursor );
+static int csvInit(
+  sqlite3 *db,                        /* Database connection */
+  void *pAux,                         /* Unused */
+  int argc, const char *const*argv,   /* Parameters to CREATE TABLE statement */
+  sqlite3_vtab **ppVtab,              /* OUT: New virtual table */
+  char **pzErr,                       /* OUT: Error message, if any */
+  int isCreate                        /* True for xCreate, false for xConnect */
+);
+static void csvReference( CSV *pCSV );
+static int csvRelease( CSV *pCSV );
+
+
+/* 
+** Abstract out file io routines for porting 
+*/
+static FILE *csv_open( CSV *pCSV ){
+  return fopen( pCSV->zFile, "rb" );
+}
+static void csv_close( CSV *pCSV ){
+  if( pCSV->f ) fclose( pCSV->f );
+}
+static int csv_seek( CSV *pCSV, long pos ){
+  return fseek( pCSV->f, pos, SEEK_SET );
+}
+static long csv_tell( CSV *pCSV ){
+  return ftell( pCSV->f );
+}
+
+
+/*
+** This routine reads a line of text from FILE in, stores
+** the text in memory obtained from malloc() and returns a pointer
+** to the text.  NULL is returned at end of file, or if malloc()
+** fails.
+**
+** The interface is like "readline" but no command-line editing
+** is done.
+**
+** This code was modified from existing code in shell.c of the sqlite3 CLI.
+*/
+static char *csv_getline( CSV *pCSV ){
+  int n = 0;
+  int bEol = 0;
+  int bShrink = 0;
+
+  /* allocate initial row buffer */
+  if( pCSV->maxRow < 1 ){
+    pCSV->zRow = sqlite3_malloc( 100 );
+    if( pCSV->zRow ){
+      pCSV->maxRow = 100;
+    }
+  }
+  if( !pCSV->zRow ) return 0;
+
+  /* read until eol */
+  while( !bEol ){
+    /* grow row buffer as needed */
+    if( n+100>pCSV->maxRow ){
+      int newSize = pCSV->maxRow*2 + 100;
+      char *p = sqlite3_realloc(pCSV->zRow, newSize);
+      if( !p ) return 0;
+      pCSV->maxRow = newSize;
+      pCSV->zRow = p;
+      bShrink = -1;
+    }
+    if( fgets(&pCSV->zRow[n], pCSV->maxRow-n, pCSV->f)==0 ){
+      if( n==0 ){
+        break;
+      }
+      pCSV->zRow[n] = '\0';
+      bEol = -1;
+      break;
+    }
+    /* look for line delimiter */
+    while( pCSV->zRow[n] ){ n++; }
+    if( (n>0) && ((pCSV->zRow[n-1]=='\n') || (pCSV->zRow[n-1]=='\r')) ){
+      pCSV->zRow[n-1] = '\n'; /* uniform line ending */
+      pCSV->zRow[n] = '\0';
+      bEol = -1;
+    }
+  }
+  if( bShrink ){ 
+    pCSV->zRow = realloc( pCSV->zRow, n+1 ); 
+    pCSV->maxRow = n+1;
+  }
+  return bEol ? pCSV->zRow : 0;
+}
+
+
+/* 
+** CSV virtual table module xCreate method.
+*/
+static int csvCreate(
+  sqlite3* db, 
+  void *pAux,
+  int argc, 
+  const char *const *argv,
+  sqlite3_vtab **ppVtab, 
+  char **pzErr 
+){
+  return csvInit( db, pAux, argc, argv, ppVtab, pzErr, 1 );
+}
+
+
+/* 
+** CSV virtual table module xConnect method.
+*/
+static int csvConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  return csvInit(db, pAux, argc, argv, ppVtab, pzErr, 0);
+}
+
+
+/*
+** CSV virtual table module xBestIndex method.
+*/
+static int csvBestIndex( sqlite3_vtab *pVtab, sqlite3_index_info* info )
+{
+  UNUSED_PARAMETER(pVtab);
+  UNUSED_PARAMETER(info);
+
+  /* TBD */
+
+  return SQLITE_OK;
+}
+
+
+/* 
+** CSV virtual table module xDisconnect method.
+*/
+static int csvDisconnect( sqlite3_vtab *pVtab ){
+  return csvRelease( (CSV *)pVtab );
+}
+
+
+/* 
+** CSV virtual table module xDestroy method.
+*/
+static int csvDestroy( sqlite3_vtab *pVtab ){
+  return csvDisconnect( pVtab );
+}
+
+
+/* 
+** CSV virtual table module xOpen method.
+*/
+static int csvOpen( sqlite3_vtab *pVtab, sqlite3_vtab_cursor **ppVtabCursor ){
+  int rc = SQLITE_NOMEM;
+  CSVCursor *pCsr;
+
+  /* create a new cursor object */
+  pCsr = (CSVCursor *)sqlite3_malloc(sizeof(CSVCursor));
+  if( pCsr ){
+    memset(pCsr, 0, sizeof(CSVCursor));
+    pCsr->base.pVtab = pVtab;
+    rc = SQLITE_OK;
+  }
+  *ppVtabCursor = (sqlite3_vtab_cursor *)pCsr;
+
+  return rc;
+}
+
+
+/* 
+** CSV virtual table module xClose method.
+*/
+static int csvClose( sqlite3_vtab_cursor *pVtabCursor ){
+  CSVCursor *pCsr = (CSVCursor *)pVtabCursor;
+
+  sqlite3_free(pCsr);
+
+  return SQLITE_OK;
+}
+
+
+/* 
+** CSV virtual table module xFilter method.
+*/
+static int csvFilter(
+  sqlite3_vtab_cursor *pVtabCursor, 
+  int idxNum, const char *idxStr,
+  int argc, sqlite3_value **argv
+){
+  CSV *pCSV = (CSV *)pVtabCursor->pVtab;
+  int rc;
+
+  UNUSED_PARAMETER(idxNum);
+  UNUSED_PARAMETER(idxStr);
+  UNUSED_PARAMETER(argc);
+  UNUSED_PARAMETER(argv);
+
+  csvReference( pCSV );
+
+  /* seek back to start of first zRow */
+  pCSV->eof = 0;
+  csv_seek( pCSV, pCSV->offsetFirstRow );
+  /* read and parse next line */
+  rc = csvNext( pVtabCursor );
+
+  csvRelease( pCSV );
+
+  return rc;
+}
+
+
+/* 
+** CSV virtual table module xNext method.
+*/
+static int csvNext( sqlite3_vtab_cursor* pVtabCursor ){
+  CSV *pCSV = (CSV *)pVtabCursor->pVtab;
+  CSVCursor *pCsr = (CSVCursor *)pVtabCursor;
+  int nCol = 0;
+  char *s;
+  char zDelims[3] = ",\n";
+  char cDelim; /* char that delimited current col */
+
+  if( pCSV->eof ){
+    return SQLITE_ERROR;
+  }
+
+  /* update the cursor */
+  pCsr->csvpos = csv_tell( pCSV );
+
+  /* read the next row of data */
+  s = csv_getline( pCSV );
+  if( !s ){
+    /* and error or eof occured */
+    pCSV->eof = -1;
+    return SQLITE_OK;
+  }
+
+  /* allocate initial space for the column pointers */
+  if( pCSV->maxCol < 1 ){
+    /* take a guess */
+    int maxCol = (int)(strlen(pCSV->zRow) / 5 + 1);
+    pCSV->aCols = (char **)sqlite3_malloc( sizeof(char*) * maxCol );
+    if( pCSV->aCols ){
+      pCSV->maxCol = maxCol;
+    }
+  }
+  if( !pCSV->aCols ) return SQLITE_NOMEM;
+
+  /* add custom delim character */
+  zDelims[0] = pCSV->cDelim;
+
+  /* parse the zRow into individual columns */
+  do{
+    /* if it begins with a quote, assume it's a quoted col */
+    if( *s=='\"' ){
+      s++;  /* skip quote */
+      pCSV->aCols[nCol] = s; /* save pointer for this col */
+      /* TBD: handle escaped quotes "" */
+      /* find closing quote */
+      s = strchr(s, '\"');
+      if( !s ){
+        /* no closing quote */
+        pCSV->eof = -1;
+        return SQLITE_ERROR;
+      }
+      *s = '\0'; /* null terminate this col */
+      /* fall through and look for following ",\n" */
+      s++;
+    }else{
+      pCSV->aCols[nCol] = s; /* save pointer for this col */
+    }
+    s = strpbrk(s, zDelims);
+    if( !s ){
+      /* no col delimiter */
+      pCSV->eof = -1;
+      return SQLITE_ERROR;
+    }
+    cDelim = *s;
+    /* null terminate the column by overwriting the delimiter */
+    *s = '\0';
+    nCol++;
+    /* if end of zRow, stop parsing cols */
+    if( cDelim == '\n' ) break;
+    /* move to start of next col */
+    s++; /* skip delimiter */
+
+    if(nCol >= pCSV->maxCol ){
+      /* we need to grow our col pointer array */
+      char **p = (char **)sqlite3_realloc( pCSV->aCols, sizeof(char*) * (nCol+5) );
+      if( !p ){
+        /* out of memory */
+        return SQLITE_ERROR;
+      }
+      pCSV->maxCol = nCol + 5;
+      pCSV->aCols = p;
+    }
+
+  }while( *s );
+
+  pCSV->nCol = nCol;
+  return SQLITE_OK;
+}
+
+
+/*
+** CSV virtual table module xEof method.
+**
+** Return non-zero if the cursor does not currently point to a valid 
+** record (i.e if the scan has finished), or zero otherwise.
+*/
+static int csvEof( sqlite3_vtab_cursor *pVtabCursor )
+{
+  CSV *pCSV = (CSV *)pVtabCursor->pVtab;
+
+  return pCSV->eof;
+}
+
+
+/* 
+** CSV virtual table module xColumn method.
+*/
+static int csvColumn(sqlite3_vtab_cursor *pVtabCursor, sqlite3_context *ctx, int i){
+  CSV *pCSV = (CSV *)pVtabCursor->pVtab;
+
+  if( i<0 || i>=pCSV->nCol ){
+    sqlite3_result_null( ctx );
+  }else{
+    char *col = pCSV->aCols[i];
+    if( !col ){
+      sqlite3_result_null( ctx );
+    }else{
+      sqlite3_result_text( ctx, col, -1, SQLITE_TRANSIENT );
+    }
+  }
+
+  return SQLITE_OK;
+}
+
+
+/* 
+** CSV virtual table module xRowid method.
+** We probably should store a hidden table
+** mapping rowid's to csvpos.
+*/
+static int csvRowid( sqlite3_vtab_cursor* pVtabCursor, sqlite3_int64 *pRowid ){
+  CSVCursor *pCsr = (CSVCursor *)pVtabCursor;
+
+  *pRowid = pCsr->csvpos;
+
+  return SQLITE_OK;
+}
+
+
+static sqlite3_module csvModule = {
+  0,                        /* iVersion */
+  csvCreate,                /* xCreate - create a table */
+  csvConnect,               /* xConnect - connect to an existing table */
+  csvBestIndex,             /* xBestIndex - Determine search strategy */
+  csvDisconnect,            /* xDisconnect - Disconnect from a table */
+  csvDestroy,               /* xDestroy - Drop a table */
+  csvOpen,                  /* xOpen - open a cursor */
+  csvClose,                 /* xClose - close a cursor */
+  csvFilter,                /* xFilter - configure scan constraints */
+  csvNext,                  /* xNext - advance a cursor */
+  csvEof,                   /* xEof */
+  csvColumn,                /* xColumn - read data */
+  csvRowid,                 /* xRowid - read data */
+  0,                        /* xUpdate - write data */
+  0,                        /* xBegin - begin transaction */
+  0,                        /* xSync - sync transaction */
+  0,                        /* xCommit - commit transaction */
+  0,                        /* xRollback - rollback transaction */
+  0,                        /* xFindFunction - function overloading */
+  0                         /* xRename - rename the table */
+};
+
+
+/*
+** Increment the CSV reference count.
+*/
+static void csvReference( CSV *pCSV ){
+  pCSV->nBusy++;
+}
+
+
+/*
+** Decrement the CSV reference count. When the reference count reaches
+** zero the structure is deleted.
+*/
+static int csvRelease( CSV *pCSV ){
+  pCSV->nBusy--;
+  if( pCSV->nBusy<1 ){
+
+    /* finalize any prepared statements here */
+
+    csv_close( pCSV );
+    if( pCSV->zRow ) sqlite3_free( pCSV->zRow );
+    if( pCSV->aCols ) sqlite3_free( pCSV->aCols );
+    sqlite3_free( pCSV );
+  }
+  return 0;
+}
+
+
+/* 
+** This function is the implementation of both the xConnect and xCreate
+** methods of the CSV virtual table.
+**
+**   argv[0]   -> module name
+**   argv[1]   -> database name
+**   argv[2]   -> table name
+**   argv[3]   -> csv file name
+**   argv[4]   -> custom delimiter
+**   argv[5]   -> optional:  use header row for column names
+*/
+static int csvInit(
+  sqlite3 *db,                        /* Database connection */
+  void *pAux,                         /* Unused */
+  int argc, const char *const*argv,   /* Parameters to CREATE TABLE statement */
+  sqlite3_vtab **ppVtab,              /* OUT: New virtual table */
+  char **pzErr,                       /* OUT: Error message, if any */
+  int isCreate                        /* True for xCreate, false for xConnect */
+){
+  int rc = SQLITE_OK;
+  int i;
+  CSV *pCSV;
+  char *zSql;
+  char cDelim = ',';       /* Default col delimiter */
+  int bUseHeaderRow = 0;   /* Default to not use zRow headers */
+  size_t nDb;              /* Length of string argv[1] */
+  size_t nName;            /* Length of string argv[2] */
+  size_t nFile;            /* Length of string argv[3] */
+  CSVCursor csvCsr;        /* Used for calling csvNext */
+
+  const char *aErrMsg[] = {
+    0,                                                    /* 0 */
+    "No CSV file specified",                              /* 1 */
+    "Error opening CSV file: '%s'",                       /* 2 */
+    "No columns found",                                   /* 3 */
+    "No column name found",                               /* 4 */
+    "Out of memory",                                      /* 5 */
+  };
+
+  UNUSED_PARAMETER(pAux);
+  UNUSED_PARAMETER(isCreate);
+
+  if( argc < 4 ){
+    *pzErr = sqlite3_mprintf("%s", aErrMsg[1]);
+    return SQLITE_ERROR;
+  }
+
+  /* allocate space for the virtual table object */
+  nDb = strlen(argv[1]);
+  nName = strlen(argv[2]);
+  nFile = strlen(argv[3]);
+  pCSV = (CSV *)sqlite3_malloc( (int)(sizeof(CSV)+nDb+nName+nFile+3) );
+  if( !pCSV ){
+    /* out of memory */
+    *pzErr = sqlite3_mprintf("%s", aErrMsg[5]);
+    return SQLITE_NOMEM;
+  }
+
+  /* intialize virtual table object */
+  memset(pCSV, 0, sizeof(CSV)+nDb+nName+nFile+3);
+  pCSV->nBusy = 1;
+  pCSV->base.pModule = &csvModule;
+  pCSV->cDelim = cDelim;
+  pCSV->zDb = (char *)&pCSV[1];
+  pCSV->zName = &pCSV->zDb[nDb+1];
+  pCSV->zFile = &pCSV->zName[nName+1];
+  memcpy(pCSV->zDb, argv[1], nDb);
+  memcpy(pCSV->zName, argv[2], nName);
+
+  /* pull out name of csv file (remove quotes) */
+  if( argv[3][0] == '\'' ){
+    memcpy( pCSV->zFile, argv[3]+1, nFile-2 );
+    pCSV->zFile[nFile-2] = '\0';
+  }else{
+    memcpy( pCSV->zFile, argv[3], nFile );
+  }
+
+  /* if a custom delimiter specified, pull it out */
+  if( argc > 4 ){
+    if( argv[4][0] == '\'' ){
+      pCSV->cDelim = argv[4][1];
+    }else{
+      pCSV->cDelim = argv[4][0];
+    }
+  }
+
+  /* should the header zRow be used */
+  if( argc > 5 ){
+    if( !strcmp(argv[5], "USE_HEADER_ROW") ){
+      bUseHeaderRow = -1;
+    }
+  }
+
+  /* open the source csv file */
+  pCSV->f = csv_open( pCSV );
+  if( !pCSV->f ){
+    *pzErr = sqlite3_mprintf(aErrMsg[2], pCSV->zFile);
+    csvRelease( pCSV );
+    return SQLITE_ERROR;
+  }
+
+  /* Read first zRow to obtain column names/number */
+  csvCsr.base.pVtab = (sqlite3_vtab *)pCSV;
+  rc = csvNext( (sqlite3_vtab_cursor *)&csvCsr );
+  if( (SQLITE_OK!=rc) || (pCSV->nCol<=0) ){
+    *pzErr = sqlite3_mprintf("%s", aErrMsg[3]);
+    csvRelease( pCSV );
+    return SQLITE_ERROR;
+  }
+  if( bUseHeaderRow ){
+    pCSV->offsetFirstRow = csv_tell( pCSV );
+  }
+
+  /* Create the underlying relational database schema. If
+  ** that is successful, call sqlite3_declare_vtab() to configure
+  ** the csv table schema.
+  */
+  zSql = sqlite3_mprintf("CREATE TABLE x(");
+  for(i=0; zSql && i<pCSV->nCol; i++){
+    const char *zTail = (i+1<pCSV->nCol) ? ", " : ");";
+    char *zTmp = zSql;
+    if( bUseHeaderRow ){
+      const char *zCol = pCSV->aCols[i];
+      if( !zCol ){
+        *pzErr = sqlite3_mprintf("%s", aErrMsg[4]);
+        sqlite3_free(zSql);
+        csvRelease( pCSV );
+        return SQLITE_ERROR;
+      }
+      zSql = sqlite3_mprintf("%s%s%s", zTmp, zCol, zTail);
+    }else{
+      zSql = sqlite3_mprintf("%scol%d%s", zTmp, i+1, zTail);
+    }
+    sqlite3_free(zTmp);
+  }
+  if( !zSql ){
+    *pzErr = sqlite3_mprintf("%s", aErrMsg[5]);
+    csvRelease( pCSV );
+    return SQLITE_NOMEM;
+  }
+
+  rc = sqlite3_declare_vtab( db, zSql );
+  sqlite3_free(zSql);
+  if( SQLITE_OK != rc ){
+    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
+    csvRelease( pCSV );
+    return SQLITE_ERROR;
+  }
+
+  *ppVtab = (sqlite3_vtab *)pCSV;
+  *pzErr  = NULL;
+  return SQLITE_OK;
+}
+
+
+/*
+** Register the CSV module with database handle db. This creates the
+** virtual table module "csv".
+*/
+int sqlite3CsvInit(sqlite3 *db){
+  int rc = SQLITE_OK;
+
+  if( rc==SQLITE_OK ){
+    void *c = (void *)NULL;
+    rc = sqlite3_create_module_v2(db, "csv", &csvModule, c, 0);
+  }
+
+  return rc;
+}
+
+
+#if !SQLITE_CORE
+/*
+** Support auto-extension loading.
+*/
+int sqlite3_extension_init(
+  sqlite3 *db,
+  char **pzErrMsg,
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi)
+  return sqlite3CsvInit(db);
+}
+#endif
+
+
+#endif

ext/csv/csv.h

@@ -0,0 +1,28 @@
+/*
+** 2009 March 26
+**
+** 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.
+**
+******************************************************************************
+**
+** This header file is used by programs that want to link against the
+** CSV Virtual Table extention.
+**
+** All it does is declare the sqlite3CsvInit() interface.
+*/
+#include "sqlite3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+int sqlite3CsvInit(sqlite3 *db);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */

ext/csv/csv1.test

@@ -0,0 +1,253 @@
+# 2009 Nov 11
+#
+# 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.
+#
+#***********************************************************************
+#
+# The focus of this file is testing the csv extension.
+#
+# $Id: csv1.test,v 1.7 2009/07/17 16:54:48 shaneh Exp $
+#
+
+if {![info exists testdir]} {
+  set testdir [file join [file dirname $argv0] .. .. test]
+}
+source $testdir/tester.tcl
+
+# Test plan:
+#
+#   csv-1.*: Creating/destroying csv tables.
+#   csv-2.*: Linear scans of csv data.
+#   csv-3.*: Test renaming an csv table.
+#   csv-4.*: CREATE errors
+#
+
+ifcapable !csv {
+  finish_test
+  return
+}
+
+# This file is delimited by ',' and has quoted fields.
+set test1csv [file join [file dirname [info script]] test1.csv]
+# This file is delimited by '|' and has quoted fields.
+set test2csv [file join [file dirname [info script]] test2.csv]
+# This file is delimited by '|'.  It does NOT have quoted fields.
+set test3csv [file join [file dirname [info script]] test3.csv]
+
+#----------------------------------------------------------------------------
+# Test cases csv-1.* test CREATE and DROP table statements.
+#
+
+# Test creating and dropping an csv table with a header row.
+#
+do_test csv-1.1.1 {
+  execsql " CREATE VIRTUAL TABLE t1 USING csv('$test1csv', ',', USE_HEADER_ROW) "
+} {}
+do_test csv-1.1.2 {
+  execsql { SELECT name FROM sqlite_master ORDER BY name }
+} {t1}
+do_test csv-1.1.3 {
+  execsql { 
+    DROP TABLE t1; 
+    SELECT name FROM sqlite_master ORDER BY name;
+  }
+} {}
+
+# Test creating and dropping an csv table without a header row.
+#
+do_test csv-1.2.1 {
+  execsql " CREATE VIRTUAL TABLE t1 USING csv('$test1csv', ',') "
+} {}
+do_test csv-1.2.2 {
+  execsql { SELECT name FROM sqlite_master ORDER BY name }
+} {t1}
+do_test csv-1.2.3 {
+  execsql { 
+    DROP TABLE t1; 
+    SELECT name FROM sqlite_master ORDER BY name;
+  }
+} {}
+
+# Test creating and dropping an csv table without a header row
+# and with the default delimiter ','.
+#
+do_test csv-1.3.1 {
+  execsql " CREATE VIRTUAL TABLE t1 USING csv('$test1csv') "
+} {}
+do_test csv-1.3.2 {
+  execsql { SELECT name FROM sqlite_master ORDER BY name }
+} {t1}
+do_test csv-1.3.3 {
+  execsql { 
+    DROP TABLE t1; 
+    SELECT name FROM sqlite_master ORDER BY name;
+  }
+} {}
+
+# Test creating and dropping an csv table without a header row
+# and with the custom delimiter '|'.
+#
+do_test csv-1.4.1 {
+  execsql " CREATE VIRTUAL TABLE t1 USING csv('$test2csv', '|') "
+} {}
+do_test csv-1.4.2 {
+  execsql { SELECT name FROM sqlite_master ORDER BY name }
+} {t1}
+do_test csv-1.4.3 {
+  execsql { 
+    DROP TABLE t1; 
+    SELECT name FROM sqlite_master ORDER BY name;
+  }
+} {}
+
+#----------------------------------------------------------------------------
+# Test cases csv-2.* test linear scans of csv table data. 
+#
+do_test csv-2.1.1 {
+  execsql " CREATE VIRTUAL TABLE t1 USING csv('$test1csv', ',', USE_HEADER_ROW) "
+} {}
+do_test csv-2.1.2 {
+  execsql { 
+    SELECT * FROM t1;
+  }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-2.1.3 {
+  execsql { 
+    SELECT * FROM t1 WHERE colA='a';
+  }
+} {a b c a b c a b {c .. z} a b c,d}
+
+do_test csv-2.2.1 {
+  execsql " CREATE VIRTUAL TABLE t2 USING csv('$test1csv', ',') "
+} {}
+do_test csv-2.2.2 {
+  execsql { 
+    SELECT * FROM t2;
+  }
+} {colA colB colC 1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-2.2.3 {
+  execsql { 
+    SELECT * FROM t2 WHERE col1='a';
+  }
+} {a b c a b c a b {c .. z} a b c,d}
+
+# Test scanning with the custom delimiter '|'.
+#
+do_test csv-2.3.1 {
+  execsql " CREATE VIRTUAL TABLE t3 USING csv('$test2csv', '|') "
+} {}
+do_test csv-2.3.2 {
+  execsql { 
+    SELECT * FROM t3;
+  }
+} {colA colB colC 1 2 3 a b c a b c a b {c .. z} a b c|d}
+do_test csv-2.3.3 {
+  execsql { 
+    SELECT * FROM t3 WHERE col1='a';
+  }
+} {a b c a b c a b {c .. z} a b c|d}
+
+# Test scanning with the custom delimiter ';'.  The test file
+# uses | for a delimiter, so everything should be treated as
+# a single column.
+#
+do_test csv-2.4.1 {
+  execsql " CREATE VIRTUAL TABLE t4 USING csv('$test3csv', ';') "
+} {}
+do_test csv-2.4.2 {
+  execsql { 
+    SELECT * FROM t4;
+  }
+} {colA|colB|colC 1|2|3 a|b|c {a|b|c .. z} a|b|c|d}
+do_test csv-2.4.3 {
+  execsql { 
+    SELECT * FROM t4 WHERE col1 LIKE 'a%';
+  }
+} {a|b|c {a|b|c .. z} a|b|c|d}
+
+# Test rowid column.
+#
+do_test csv-2.5.1 {
+  execsql { 
+    SELECT rowid FROM t1;
+  }
+} {21 27 33 41 58}
+do_test csv-2.5.2 {
+  execsql { 
+    SELECT rowid FROM t1 WHERE colA='a';
+  }
+} {27 33 41 58}
+
+# Clean-up.
+#
+do_test csv-2.6.1 {
+  execsql { 
+    DROP TABLE t1; 
+    DROP TABLE t2; 
+    DROP TABLE t3; 
+    DROP TABLE t4; 
+  }
+} {}
+
+#----------------------------------------------------------------------------
+# Test cases csv-3.* test rename operations.
+#
+do_test csv-3.1.1 {
+  execsql " CREATE VIRTUAL TABLE t1 USING csv('$test1csv', ',', USE_HEADER_ROW) "
+  execsql " CREATE VIRTUAL TABLE t2 USING csv('$test1csv', ',', USE_HEADER_ROW) "
+} {}
+do_test csv-3.1.2 {
+  catchsql { ALTER TABLE t2 RENAME TO t1 }
+} {1 {there is already another table or index with this name: t1}}
+do_test csv-3.1.3 {
+  execsql { 
+    DROP TABLE t1; 
+    ALTER TABLE t2 RENAME TO t1 
+  }
+} {}
+do_test csv-3.1.4 {
+  execsql { ALTER TABLE t1 RENAME TO t5 }
+  execsql { SELECT * FROM t5 }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-3.1.5 {
+  db close
+  sqlite3 db test.db
+  execsql { SELECT * FROM t5 }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-3.1.6 {
+  execsql { ALTER TABLE t5 RENAME TO 'raisara "one"'''}
+  execsql { SELECT * FROM "raisara ""one""'" }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-3.1.7 {
+  execsql { SELECT * FROM 'raisara "one"''' }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-3.1.8 {
+  execsql { ALTER TABLE "raisara ""one""'" RENAME TO "abc 123" }
+  execsql { SELECT * FROM "abc 123" }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+do_test csv-3.1.9 {
+  db close
+  sqlite3 db test.db
+  execsql { SELECT * FROM "abc 123" }
+} {1 2 3 a b c a b c a b {c .. z} a b c,d}
+
+#----------------------------------------------------------------------------
+# Test cases csv-4.* test CREATE errors
+#
+
+# Test creating and dropping an csv table with a header row.
+#
+do_test csv-4.1.1 {
+  catchsql " CREATE VIRTUAL TABLE t1 USING csv() "
+} {1 {No CSV file specified}}
+do_test csv-4.1.2 {
+  catchsql " CREATE VIRTUAL TABLE t1 USING csv('foo') "
+} {1 {Error opening CSV file: 'foo'}}
+do_test csv-4.1.3 {
+  catchsql " CREATE VIRTUAL TABLE t1 USING csv(foo foo) "
+} {1 {Error opening CSV file: 'foo foo'}}

ext/csv/test1.csv

@@ -0,0 +1,6 @@
+"colA","colB","colC"
+1,2,3
+a,b,c
+a,"b",c
+"a","b","c .. z"
+"a","b","c,d"

ext/csv/test2.csv

@@ -0,0 +1,6 @@
+"colA"|"colB"|"colC"
+1|2|3
+a|b|c
+a|"b"|c
+"a"|"b"|"c .. z"
+"a"|"b"|"c|d"

ext/csv/test3.csv

@@ -0,0 +1,5 @@
+colA|colB|colC
+1|2|3
+a|b|c
+a|b|c .. z
+a|b|c|d

ext/expert/README.md

@@ -1,83 +0,0 @@
-## SQLite Expert Extension
-
-This folder contains code for a simple system to propose useful indexes
-given a database and a set of SQL queries. It works as follows:
-
-  1. The user database schema is copied to a temporary database.
-
-  1. All SQL queries are prepared against the temporary database.
-     Information regarding the WHERE and ORDER BY clauses, and other query
-     features that affect index selection are recorded.
-
-  1. The information gathered in step 2 is used to create candidate 
-     indexes - indexes that the planner might have made use of in the previous
-     step, had they been available.
-
-  1. A subset of the data in the user database is used to generate statistics
-     for all existing indexes and the candidate indexes generated in step 3
-     above.
-
-  1. The SQL queries are prepared a second time. If the planner uses any
-     of the indexes created in step 3, they are recommended to the user.
-
-# C API
-
-The SQLite expert C API is defined in sqlite3expert.h. Most uses will proceed
-as follows:
-
-  1. An sqlite3expert object is created by calling **sqlite3\_expert\_new()**.
-     A database handle opened by the user is passed as an argument.
-
-  1. The sqlite3expert object is configured with one or more SQL statements
-     by making one or more calls to **sqlite3\_expert\_sql()**. Each call may
-     specify a single SQL statement, or multiple statements separated by
-     semi-colons.
-  
-  1. Optionally, the **sqlite3\_expert\_config()** API may be used to 
-     configure the size of the data subset used to generate index statistics.
-     Using a smaller subset of the data can speed up the analysis.
-
-  1. **sqlite3\_expert\_analyze()** is called to run the analysis.
-
-  1. One or more calls are made to **sqlite3\_expert\_report()** to extract
-     components of the results of the analysis.
-
-  1. **sqlite3\_expert\_destroy()** is called to free all resources.
-
-Refer to comments in sqlite3expert.h for further details.
-
-# sqlite3_expert application
-
-The file "expert.c" contains the code for a command line application that
-uses the API described above. It can be compiled with (for example):
-
-<pre>
-  gcc -O2 sqlite3.c expert.c sqlite3expert.c -o sqlite3_expert
-</pre>
-
-Assuming the database is named "test.db", it can then be run to analyze a
-single query:
-
-<pre>
-  ./sqlite3_expert -sql &lt;sql-query&gt; test.db
-</pre>
-
-Or an entire text file worth of queries with:
-
-<pre>
-  ./sqlite3_expert -file &lt;text-file&gt; test.db
-</pre>
-
-By default, sqlite3\_expert generates index statistics using all the data in
-the user database. For a large database, this may be prohibitively time
-consuming. The "-sample" option may be used to configure sqlite3\_expert to
-generate statistics based on an integer percentage of the user database as
-follows:
-
-<pre>
-  # Generate statistics based on 25% of the user database rows:
-  ./sqlite3_expert -sample 25 -sql &lt;sql-query&gt; test.db
-
-  # Do not generate any statistics at all:
-  ./sqlite3_expert -sample 0 -sql &lt;sql-query&gt; test.db
-</pre>

ext/expert/expert.c

@@ -1,156 +0,0 @@
-/*
-** 2017 April 07
-**
-** 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.
-**
-*************************************************************************
-*/
-
-
-#include <sqlite3.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "sqlite3expert.h"
-
-
-static void option_requires_argument(const char *zOpt){
-  fprintf(stderr, "Option requires an argument: %s\n", zOpt);
-  exit(-3);
-}
-
-static int option_integer_arg(const char *zVal){
-  return atoi(zVal);
-}
-
-static void usage(char **argv){
-  fprintf(stderr, "\n");
-  fprintf(stderr, "Usage %s ?OPTIONS? DATABASE\n", argv[0]);
-  fprintf(stderr, "\n");
-  fprintf(stderr, "Options are:\n");
-  fprintf(stderr, "  -sql SQL   (analyze SQL statements passed as argument)\n");
-  fprintf(stderr, "  -file FILE (read SQL statements from file FILE)\n");
-  fprintf(stderr, "  -verbose LEVEL (integer verbosity level. default 1)\n");
-  fprintf(stderr, "  -sample PERCENT (percent of db to sample. default 100)\n");
-  exit(-1);
-}
-
-static int readSqlFromFile(sqlite3expert *p, const char *zFile, char **pzErr){
-  FILE *in = fopen(zFile, "rb");
-  long nIn;
-  size_t nRead;
-  char *pBuf;
-  int rc;
-  if( in==0 ){
-    *pzErr = sqlite3_mprintf("failed to open file %s\n", zFile);
-    return SQLITE_ERROR;
-  }
-  fseek(in, 0, SEEK_END);
-  nIn = ftell(in);
-  rewind(in);
-  pBuf = sqlite3_malloc64( nIn+1 );
-  nRead = fread(pBuf, nIn, 1, in);
-  fclose(in);
-  if( nRead!=1 ){
-    sqlite3_free(pBuf);
-    *pzErr = sqlite3_mprintf("failed to read file %s\n", zFile);
-    return SQLITE_ERROR;
-  }
-  pBuf[nIn] = 0;
-  rc = sqlite3_expert_sql(p, pBuf, pzErr);
-  sqlite3_free(pBuf);
-  return rc;
-}
-
-int main(int argc, char **argv){
-  const char *zDb;
-  int rc = 0;
-  char *zErr = 0;
-  int i;
-  int iVerbose = 1;               /* -verbose option */
-
-  sqlite3 *db = 0;
-  sqlite3expert *p = 0;
-
-  if( argc<2 ) usage(argv);
-  zDb = argv[argc-1];
-  if( zDb[0]=='-' ) usage(argv);
-  rc = sqlite3_open(zDb, &db);
-  if( rc!=SQLITE_OK ){
-    fprintf(stderr, "Cannot open db file: %s - %s\n", zDb, sqlite3_errmsg(db));
-    exit(-2);
-  }
-
-  p = sqlite3_expert_new(db, &zErr);
-  if( p==0 ){
-    fprintf(stderr, "Cannot run analysis: %s\n", zErr);
-    rc = 1;
-  }else{
-    for(i=1; i<(argc-1); i++){
-      char *zArg = argv[i];
-      int nArg;
-      if( zArg[0]=='-' && zArg[1]=='-' && zArg[2]!=0 ) zArg++;
-      nArg = (int)strlen(zArg);
-      if( nArg>=2 && 0==sqlite3_strnicmp(zArg, "-file", nArg) ){
-        if( ++i==(argc-1) ) option_requires_argument("-file");
-        rc = readSqlFromFile(p, argv[i], &zErr);
-      }
-
-      else if( nArg>=3 && 0==sqlite3_strnicmp(zArg, "-sql", nArg) ){
-        if( ++i==(argc-1) ) option_requires_argument("-sql");
-        rc = sqlite3_expert_sql(p, argv[i], &zErr);
-      }
-
-      else if( nArg>=3 && 0==sqlite3_strnicmp(zArg, "-sample", nArg) ){
-        int iSample;
-        if( ++i==(argc-1) ) option_requires_argument("-sample");
-        iSample = option_integer_arg(argv[i]);
-        sqlite3_expert_config(p, EXPERT_CONFIG_SAMPLE, iSample);
-      }
-
-      else if( nArg>=2 && 0==sqlite3_strnicmp(zArg, "-verbose", nArg) ){
-        if( ++i==(argc-1) ) option_requires_argument("-verbose");
-        iVerbose = option_integer_arg(argv[i]);
-      }
-
-      else{
-        usage(argv);
-      }
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_expert_analyze(p, &zErr);
-  }
-
-  if( rc==SQLITE_OK ){
-    int nQuery = sqlite3_expert_count(p);
-    if( iVerbose>0 ){
-      const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
-      fprintf(stdout, "-- Candidates -------------------------------\n");
-      fprintf(stdout, "%s\n", zCand);
-    }
-    for(i=0; i<nQuery; i++){
-      const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
-      const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
-      const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
-      if( zIdx==0 ) zIdx = "(no new indexes)\n";
-      if( iVerbose>0 ){
-        fprintf(stdout, "-- Query %d ----------------------------------\n",i+1);
-        fprintf(stdout, "%s\n\n", zSql);
-      }
-      fprintf(stdout, "%s\n%s\n", zIdx, zEQP);
-    }
-  }else{
-    fprintf(stderr, "Error: %s\n", zErr ? zErr : "?");
-  }
-
-  sqlite3_expert_destroy(p);
-  sqlite3_free(zErr);
-  return rc;
-}

ext/expert/expert1.test

@@ -1,393 +0,0 @@
-# 2009 Nov 11
-#
-# 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.
-#
-#***********************************************************************
-#
-# The focus of this file is testing the CLI shell tool. Specifically,
-# the ".recommend" command.
-#
-#
-
-# Test plan:
-#
-#
-if {![info exists testdir]} {
-  set testdir [file join [file dirname [info script]] .. .. test]
-}
-source $testdir/tester.tcl
-set testprefix expert1
-
-if {[info commands sqlite3_expert_new]==""} {
-  finish_test
-  return
-}
-
-set CLI [test_binary_name sqlite3]
-set CMD [test_binary_name sqlite3_expert]
-
-proc squish {txt} {
-  regsub -all {[[:space:]]+} $txt { }
-}
-
-proc do_setup_rec_test {tn setup sql res} {
-  reset_db
-  if {[info exists ::set_main_db_name]} {
-    dbconfig_maindbname_icecube db
-  }
-  db eval $setup
-  uplevel [list do_rec_test $tn $sql $res]
-}
-
-foreach {tn setup} {
-  1 {
-    if {![file executable $CMD]} { continue }
-
-    proc do_rec_test {tn sql res} {
-      set res [squish [string trim $res]]
-      set tst [subst -nocommands { 
-        squish [string trim [exec $::CMD -verbose 0 -sql {$sql;} test.db]]
-      }]
-      uplevel [list do_test $tn $tst $res]
-    }
-  }
-  2 {
-    if {[info commands sqlite3_expert_new]==""} { continue }
-
-    proc do_rec_test {tn sql res} {
-      set expert [sqlite3_expert_new db]
-      $expert sql $sql
-      $expert analyze
-
-      set result [list]
-      for {set i 0} {$i < [$expert count]} {incr i} {
-        set idx [string trim [$expert report $i indexes]]
-        if {$idx==""} {set idx "(no new indexes)"}
-        lappend result $idx
-        lappend result [string trim [$expert report $i plan]]
-      }
-
-      $expert destroy
-
-      set tst [subst -nocommands {set {} [squish [join {$result}]]}]
-      uplevel [list do_test $tn $tst [string trim [squish $res]]]
-    }
-  }
-  3 {
-    if {[info commands sqlite3_expert_new]==""} { continue }
-    set ::set_main_db_name 1
-  }
-  4 {
-    if {![file executable $CLI]} { continue }
-
-    proc do_rec_test {tn sql res} {
-      set res [squish [string trim $res]]
-      set tst [subst -nocommands { 
-        squish [string trim [exec $::CLI test.db ".expert" {$sql;}]]
-      }]
-      uplevel [list do_test $tn $tst $res]
-    }
-  }
-} {
-
-  eval $setup
-
-
-do_setup_rec_test $tn.1 { CREATE TABLE t1(a, b, c) } {
-  SELECT * FROM t1
-} {
-  (no new indexes)
-  SCAN TABLE t1
-}
-
-do_setup_rec_test $tn.2 {
-  CREATE TABLE t1(a, b, c);
-} {
-  SELECT * FROM t1 WHERE b>?;
-} {
-  CREATE INDEX t1_idx_00000062 ON t1(b);
-  SEARCH TABLE t1 USING INDEX t1_idx_00000062 (b>?)
-}
-
-do_setup_rec_test $tn.3 {
-  CREATE TABLE t1(a, b, c);
-} {
-  SELECT * FROM t1 WHERE b COLLATE nocase BETWEEN ? AND ?
-} {
-  CREATE INDEX t1_idx_3e094c27 ON t1(b COLLATE NOCASE);
-  SEARCH TABLE t1 USING INDEX t1_idx_3e094c27 (b>? AND b<?)
-}
-
-do_setup_rec_test $tn.4 {
-  CREATE TABLE t1(a, b, c);
-} {
-  SELECT a FROM t1 ORDER BY b;
-} {
-  CREATE INDEX t1_idx_00000062 ON t1(b);
-  SCAN TABLE t1 USING INDEX t1_idx_00000062
-}
-
-do_setup_rec_test $tn.5 {
-  CREATE TABLE t1(a, b, c);
-} {
-  SELECT a FROM t1 WHERE a=? ORDER BY b;
-} {
-  CREATE INDEX t1_idx_000123a7 ON t1(a, b);
-  SEARCH TABLE t1 USING COVERING INDEX t1_idx_000123a7 (a=?)
-}
-
-if 0 {
-do_setup_rec_test $tn.6 {
-  CREATE TABLE t1(a, b, c);
-} {
-  SELECT min(a) FROM t1
-} {
-  CREATE INDEX t1_idx_00000061 ON t1(a);
-  SEARCH TABLE t1 USING COVERING INDEX t1_idx_00000061
-}
-}
-
-do_setup_rec_test $tn.7 {
-  CREATE TABLE t1(a, b, c);
-} {
-  SELECT * FROM t1 ORDER BY a, b, c;
-} {
-  CREATE INDEX t1_idx_033e95fe ON t1(a, b, c);
-  SCAN TABLE t1 USING COVERING INDEX t1_idx_033e95fe
-}
-
-#do_setup_rec_test $tn.1.8 {
-#  CREATE TABLE t1(a, b, c);
-#} {
-#  SELECT * FROM t1 ORDER BY a ASC, b COLLATE nocase DESC, c ASC;
-#} {
-#  CREATE INDEX t1_idx_5be6e222 ON t1(a, b COLLATE NOCASE DESC, c);
-#  0|0|0|SCAN TABLE t1 USING COVERING INDEX t1_idx_5be6e222
-#}
-
-do_setup_rec_test $tn.8.1 {
-  CREATE TABLE t1(a COLLATE NOCase, b, c);
-} {
-  SELECT * FROM t1 WHERE a=?
-} {
-  CREATE INDEX t1_idx_00000061 ON t1(a);
-  SEARCH TABLE t1 USING INDEX t1_idx_00000061 (a=?)
-}
-do_setup_rec_test $tn.8.2 {
-  CREATE TABLE t1(a, b COLLATE nocase, c);
-} {
-  SELECT * FROM t1 ORDER BY a ASC, b DESC, c ASC;
-} {
-  CREATE INDEX t1_idx_5cb97285 ON t1(a, b DESC, c);
-  SCAN TABLE t1 USING COVERING INDEX t1_idx_5cb97285
-}
-
-
-# Tables with names that require quotes.
-#
-do_setup_rec_test $tn.9.1 {
-  CREATE TABLE "t t"(a, b, c);
-} {
-  SELECT * FROM "t t" WHERE a=?
-} {
-  CREATE INDEX 't t_idx_00000061' ON 't t'(a);
-  SEARCH TABLE t t USING INDEX t t_idx_00000061 (a=?) 
-}
-
-do_setup_rec_test $tn.9.2 {
-  CREATE TABLE "t t"(a, b, c);
-} {
-  SELECT * FROM "t t" WHERE b BETWEEN ? AND ?
-} {
-  CREATE INDEX 't t_idx_00000062' ON 't t'(b);
-  SEARCH TABLE t t USING INDEX t t_idx_00000062 (b>? AND b<?)
-}
-
-# Columns with names that require quotes.
-#
-do_setup_rec_test $tn.10.1 {
-  CREATE TABLE t3(a, "b b", c);
-} {
-  SELECT * FROM t3 WHERE "b b" = ?
-} {
-  CREATE INDEX t3_idx_00050c52 ON t3('b b');
-  SEARCH TABLE t3 USING INDEX t3_idx_00050c52 (b b=?)
-}
-
-do_setup_rec_test $tn.10.2 {
-  CREATE TABLE t3(a, "b b", c);
-} {
-  SELECT * FROM t3 ORDER BY "b b"
-} {
-  CREATE INDEX t3_idx_00050c52 ON t3('b b');
-  SCAN TABLE t3 USING INDEX t3_idx_00050c52
-}
-
-# Transitive constraints
-#
-do_setup_rec_test $tn.11.1 {
-  CREATE TABLE t5(a, b);
-  CREATE TABLE t6(c, d);
-} {
-  SELECT * FROM t5, t6 WHERE a=? AND b=c AND c=?
-} {
-  CREATE INDEX t5_idx_000123a7 ON t5(a, b);
-  CREATE INDEX t6_idx_00000063 ON t6(c);
-  SEARCH TABLE t6 USING INDEX t6_idx_00000063 (c=?) 
-  SEARCH TABLE t5 USING COVERING INDEX t5_idx_000123a7 (a=? AND b=?)
-}
-
-# OR terms.
-#
-do_setup_rec_test $tn.12.1 {
-  CREATE TABLE t7(a, b);
-} {
-  SELECT * FROM t7 WHERE a=? OR b=?
-} {
-  CREATE INDEX t7_idx_00000062 ON t7(b);
-  CREATE INDEX t7_idx_00000061 ON t7(a);
-  MULTI-INDEX OR
-    INDEX 1
-      SEARCH TABLE t7 USING INDEX t7_idx_00000061 (a=?) 
-    INDEX 2
-      SEARCH TABLE t7 USING INDEX t7_idx_00000062 (b=?)
-}
-
-# rowid terms.
-#
-do_setup_rec_test $tn.13.1 {
-  CREATE TABLE t8(a, b);
-} {
-  SELECT * FROM t8 WHERE rowid=?
-} {
-  (no new indexes)
-  SEARCH TABLE t8 USING INTEGER PRIMARY KEY (rowid=?)
-}
-do_setup_rec_test $tn.13.2 {
-  CREATE TABLE t8(a, b);
-} {
-  SELECT * FROM t8 ORDER BY rowid
-} {
-  (no new indexes)
-  SCAN TABLE t8
-}
-do_setup_rec_test $tn.13.3 {
-  CREATE TABLE t8(a, b);
-} {
-  SELECT * FROM t8 WHERE a=? ORDER BY rowid
-} {
-  CREATE INDEX t8_idx_00000061 ON t8(a); 
-  SEARCH TABLE t8 USING INDEX t8_idx_00000061 (a=?)
-}
-
-# Triggers
-#
-do_setup_rec_test $tn.14 {
-  CREATE TABLE t9(a, b, c);
-  CREATE TABLE t10(a, b, c);
-  CREATE TRIGGER t9t AFTER INSERT ON t9 BEGIN
-    UPDATE t10 SET a=new.a WHERE b = new.b;
-  END;
-} {
-  INSERT INTO t9 VALUES(?, ?, ?);
-} {
-  CREATE INDEX t10_idx_00000062 ON t10(b); 
-  SEARCH TABLE t10 USING INDEX t10_idx_00000062 (b=?)
-}
-
-do_setup_rec_test $tn.15 {
-  CREATE TABLE t1(a, b);
-  CREATE TABLE t2(c, d);
-
-  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<100)
-  INSERT INTO t1 SELECT (i-1)/50, (i-1)/20 FROM s;
-
-  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<100)
-  INSERT INTO t2 SELECT (i-1)/20, (i-1)/5 FROM s;
-} {
-  SELECT * FROM t2, t1 WHERE b=? AND d=? AND t2.rowid=t1.rowid
-} {
-  CREATE INDEX t2_idx_00000064 ON t2(d);
-  SEARCH TABLE t2 USING INDEX t2_idx_00000064 (d=?) 
-  SEARCH TABLE t1 USING INTEGER PRIMARY KEY (rowid=?)
-}
-
-do_setup_rec_test $tn.16 {
-  CREATE TABLE t1(a, b);
-} {
-  SELECT * FROM t1 WHERE b IS NOT NULL;
-} {
-  (no new indexes)
-  SCAN TABLE t1
-}
-
-}
-
-proc do_candidates_test {tn sql res} {
-  set res [squish [string trim $res]]
-
-  set expert [sqlite3_expert_new db]
-  $expert sql $sql
-  $expert analyze
-
-  set candidates [squish [string trim [$expert report 0 candidates]]]
-  $expert destroy
-
-  uplevel [list do_test $tn [list set {} $candidates] $res]
-}
-
-
-reset_db
-do_execsql_test 5.0 {
-  CREATE TABLE t1(a, b);
-  CREATE TABLE t2(c, d);
-
-  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<100)
-  INSERT INTO t1 SELECT (i-1)/50, (i-1)/20 FROM s;
-
-  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<100)
-  INSERT INTO t2 SELECT (i-1)/20, (i-1)/5 FROM s;
-}
-do_candidates_test 5.1 {
-  SELECT * FROM t1,t2 WHERE (b=? OR a=?) AND (c=? OR d=?)
-} {
-  CREATE INDEX t1_idx_00000062 ON t1(b); -- stat1: 100 20 
-  CREATE INDEX t1_idx_00000061 ON t1(a); -- stat1: 100 50 
-  CREATE INDEX t2_idx_00000063 ON t2(c); -- stat1: 100 20 
-  CREATE INDEX t2_idx_00000064 ON t2(d); -- stat1: 100 5
-}
-
-do_candidates_test 5.2 {
-  SELECT * FROM t1,t2 WHERE a=? AND b=? AND c=? AND d=?
-} {
-  CREATE INDEX t1_idx_000123a7 ON t1(a, b); -- stat1: 100 50 17
-  CREATE INDEX t2_idx_0001295b ON t2(c, d); -- stat1: 100 20 5
-}
-
-do_execsql_test 5.3 {
-  CREATE INDEX t1_idx_00000061 ON t1(a); -- stat1: 100 50 
-  CREATE INDEX t1_idx_00000062 ON t1(b); -- stat1: 100 20 
-  CREATE INDEX t1_idx_000123a7 ON t1(a, b); -- stat1: 100 50 16
-
-  CREATE INDEX t2_idx_00000063 ON t2(c); -- stat1: 100 20 
-  CREATE INDEX t2_idx_00000064 ON t2(d); -- stat1: 100 5
-  CREATE INDEX t2_idx_0001295b ON t2(c, d); -- stat1: 100 20 5
-
-  ANALYZE;
-  SELECT * FROM sqlite_stat1 ORDER BY 1, 2;
-} {
-  t1 t1_idx_00000061 {100 50} 
-  t1 t1_idx_00000062 {100 20}
-  t1 t1_idx_000123a7 {100 50 17}
-  t2 t2_idx_00000063 {100 20} 
-  t2 t2_idx_00000064 {100 5} 
-  t2 t2_idx_0001295b {100 20 5}
-}
-
-
-finish_test

ext/expert/sqlite3expert.h

@@ -1,168 +0,0 @@
-/*
-** 2017 April 07
-**
-** 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.
-**
-*************************************************************************
-*/
-#if !defined(SQLITEEXPERT_H)
-#define SQLITEEXPERT_H 1
-#include "sqlite3.h"
-
-typedef struct sqlite3expert sqlite3expert;
-
-/*
-** Create a new sqlite3expert object.
-**
-** If successful, a pointer to the new object is returned and (*pzErr) set
-** to NULL. Or, if an error occurs, NULL is returned and (*pzErr) set to
-** an English-language error message. In this case it is the responsibility
-** of the caller to eventually free the error message buffer using
-** sqlite3_free().
-*/
-sqlite3expert *sqlite3_expert_new(sqlite3 *db, char **pzErr);
-
-/*
-** Configure an sqlite3expert object.
-**
-** EXPERT_CONFIG_SAMPLE:
-**   By default, sqlite3_expert_analyze() generates sqlite_stat1 data for
-**   each candidate index. This involves scanning and sorting the entire
-**   contents of each user database table once for each candidate index
-**   associated with the table. For large databases, this can be 
-**   prohibitively slow. This option allows the sqlite3expert object to
-**   be configured so that sqlite_stat1 data is instead generated based on a
-**   subset of each table, or so that no sqlite_stat1 data is used at all.
-**
-**   A single integer argument is passed to this option. If the value is less
-**   than or equal to zero, then no sqlite_stat1 data is generated or used by
-**   the analysis - indexes are recommended based on the database schema only.
-**   Or, if the value is 100 or greater, complete sqlite_stat1 data is
-**   generated for each candidate index (this is the default). Finally, if the
-**   value falls between 0 and 100, then it represents the percentage of user
-**   table rows that should be considered when generating sqlite_stat1 data.
-**
-**   Examples:
-**
-**     // Do not generate any sqlite_stat1 data
-**     sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 0);
-**
-**     // Generate sqlite_stat1 data based on 10% of the rows in each table.
-**     sqlite3_expert_config(pExpert, EXPERT_CONFIG_SAMPLE, 10);
-*/
-int sqlite3_expert_config(sqlite3expert *p, int op, ...);
-
-#define EXPERT_CONFIG_SAMPLE 1    /* int */
-
-/*
-** Specify zero or more SQL statements to be included in the analysis.
-**
-** Buffer zSql must contain zero or more complete SQL statements. This
-** function parses all statements contained in the buffer and adds them
-** to the internal list of statements to analyze. If successful, SQLITE_OK
-** is returned and (*pzErr) set to NULL. Or, if an error occurs - for example
-** due to a error in the SQL - an SQLite error code is returned and (*pzErr)
-** may be set to point to an English language error message. In this case
-** the caller is responsible for eventually freeing the error message buffer
-** using sqlite3_free().
-**
-** If an error does occur while processing one of the statements in the
-** buffer passed as the second argument, none of the statements in the
-** buffer are added to the analysis.
-**
-** This function must be called before sqlite3_expert_analyze(). If a call
-** to this function is made on an sqlite3expert object that has already
-** been passed to sqlite3_expert_analyze() SQLITE_MISUSE is returned
-** immediately and no statements are added to the analysis.
-*/
-int sqlite3_expert_sql(
-  sqlite3expert *p,               /* From a successful sqlite3_expert_new() */
-  const char *zSql,               /* SQL statement(s) to add */
-  char **pzErr                    /* OUT: Error message (if any) */
-);
-
-
-/*
-** This function is called after the sqlite3expert object has been configured
-** with all SQL statements using sqlite3_expert_sql() to actually perform
-** the analysis. Once this function has been called, it is not possible to
-** add further SQL statements to the analysis.
-**
-** If successful, SQLITE_OK is returned and (*pzErr) is set to NULL. Or, if
-** an error occurs, an SQLite error code is returned and (*pzErr) set to 
-** point to a buffer containing an English language error message. In this
-** case it is the responsibility of the caller to eventually free the buffer
-** using sqlite3_free().
-**
-** If an error does occur within this function, the sqlite3expert object
-** is no longer useful for any purpose. At that point it is no longer
-** possible to add further SQL statements to the object or to re-attempt
-** the analysis. The sqlite3expert object must still be freed using a call
-** sqlite3_expert_destroy().
-*/
-int sqlite3_expert_analyze(sqlite3expert *p, char **pzErr);
-
-/*
-** Return the total number of statements loaded using sqlite3_expert_sql().
-** The total number of SQL statements may be different from the total number
-** to calls to sqlite3_expert_sql().
-*/
-int sqlite3_expert_count(sqlite3expert*);
-
-/*
-** Return a component of the report.
-**
-** This function is called after sqlite3_expert_analyze() to extract the
-** results of the analysis. Each call to this function returns either a
-** NULL pointer or a pointer to a buffer containing a nul-terminated string.
-** The value passed as the third argument must be one of the EXPERT_REPORT_*
-** #define constants defined below.
-**
-** For some EXPERT_REPORT_* parameters, the buffer returned contains 
-** information relating to a specific SQL statement. In these cases that
-** SQL statement is identified by the value passed as the second argument.
-** SQL statements are numbered from 0 in the order in which they are parsed.
-** If an out-of-range value (less than zero or equal to or greater than the
-** value returned by sqlite3_expert_count()) is passed as the second argument
-** along with such an EXPERT_REPORT_* parameter, NULL is always returned.
-**
-** EXPERT_REPORT_SQL:
-**   Return the text of SQL statement iStmt.
-**
-** EXPERT_REPORT_INDEXES:
-**   Return a buffer containing the CREATE INDEX statements for all recommended
-**   indexes for statement iStmt. If there are no new recommeded indexes, NULL 
-**   is returned.
-**
-** EXPERT_REPORT_PLAN:
-**   Return a buffer containing the EXPLAIN QUERY PLAN output for SQL query
-**   iStmt after the proposed indexes have been added to the database schema.
-**
-** EXPERT_REPORT_CANDIDATES:
-**   Return a pointer to a buffer containing the CREATE INDEX statements 
-**   for all indexes that were tested (for all SQL statements). The iStmt
-**   parameter is ignored for EXPERT_REPORT_CANDIDATES calls.
-*/
-const char *sqlite3_expert_report(sqlite3expert*, int iStmt, int eReport);
-
-/*
-** Values for the third argument passed to sqlite3_expert_report().
-*/
-#define EXPERT_REPORT_SQL        1
-#define EXPERT_REPORT_INDEXES    2
-#define EXPERT_REPORT_PLAN       3
-#define EXPERT_REPORT_CANDIDATES 4
-
-/*
-** Free an (sqlite3expert*) handle and all associated resources. There 
-** should be one call to this function for each successful call to 
-** sqlite3-expert_new().
-*/
-void sqlite3_expert_destroy(sqlite3expert*);
-
-#endif  /* !defined(SQLITEEXPERT_H) */

ext/expert/test_expert.c

@@ -1,220 +0,0 @@
-/*
-** 2017 April 07
-**
-** 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.
-**
-*************************************************************************
-*/
-
-#if defined(SQLITE_TEST)
-
-#include "sqlite3expert.h"
-#include <assert.h>
-#include <string.h>
-
-#if defined(INCLUDE_SQLITE_TCL_H)
-#  include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#  ifndef SQLITE_TCLAPI
-#    define SQLITE_TCLAPI
-#  endif
-#endif
-
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-
-/*
-** Extract an sqlite3* db handle from the object passed as the second
-** argument. If successful, set *pDb to point to the db handle and return
-** TCL_OK. Otherwise, return TCL_ERROR.
-*/
-static int dbHandleFromObj(Tcl_Interp *interp, Tcl_Obj *pObj, sqlite3 **pDb){
-  Tcl_CmdInfo info;
-  if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(pObj), &info) ){
-    Tcl_AppendResult(interp, "no such handle: ", Tcl_GetString(pObj), 0);
-    return TCL_ERROR;
-  }
-
-  *pDb = *(sqlite3 **)info.objClientData;
-  return TCL_OK;
-}
-
-
-/*
-** Tclcmd:  $expert sql SQL
-**          $expert analyze
-**          $expert count
-**          $expert report STMT EREPORT
-**          $expert destroy
-*/
-static int SQLITE_TCLAPI testExpertCmd(
-  void *clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  sqlite3expert *pExpert = (sqlite3expert*)clientData;
-  struct Subcmd {
-    const char *zSub;
-    int nArg;
-    const char *zMsg;
-  } aSub[] = {
-    { "sql",       1, "TABLE",        }, /* 0 */
-    { "analyze",   0, "",             }, /* 1 */
-    { "count",     0, "",             }, /* 2 */
-    { "report",    2, "STMT EREPORT", }, /* 3 */
-    { "destroy",   0, "",             }, /* 4 */
-    { 0 }
-  };
-  int iSub;
-  int rc = TCL_OK;
-  char *zErr = 0;
-
-  if( objc<2 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
-    return TCL_ERROR;
-  }
-  rc = Tcl_GetIndexFromObjStruct(interp, 
-      objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iSub
-  );
-  if( rc!=TCL_OK ) return rc;
-  if( objc!=2+aSub[iSub].nArg ){
-    Tcl_WrongNumArgs(interp, 2, objv, aSub[iSub].zMsg);
-    return TCL_ERROR;
-  }
-
-  switch( iSub ){
-    case 0: {      /* sql */
-      char *zArg = Tcl_GetString(objv[2]);
-      rc = sqlite3_expert_sql(pExpert, zArg, &zErr);
-      break;
-    }
-
-    case 1: {      /* analyze */
-      rc = sqlite3_expert_analyze(pExpert, &zErr);
-      break;
-    }
-
-    case 2: {      /* count */
-      int n = sqlite3_expert_count(pExpert);
-      Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
-      break;
-    }
-
-    case 3: {      /* report */
-      const char *aEnum[] = {
-        "sql", "indexes", "plan", "candidates", 0
-      };
-      int iEnum;
-      int iStmt;
-      const char *zReport;
-
-      if( Tcl_GetIntFromObj(interp, objv[2], &iStmt) 
-       || Tcl_GetIndexFromObj(interp, objv[3], aEnum, "report", 0, &iEnum)
-      ){
-        return TCL_ERROR;
-      }
-
-      assert( EXPERT_REPORT_SQL==1 );
-      assert( EXPERT_REPORT_INDEXES==2 );
-      assert( EXPERT_REPORT_PLAN==3 );
-      assert( EXPERT_REPORT_CANDIDATES==4 );
-      zReport = sqlite3_expert_report(pExpert, iStmt, 1+iEnum);
-      Tcl_SetObjResult(interp, Tcl_NewStringObj(zReport, -1));
-      break;
-    }
-
-    default:       /* destroy */
-      assert( iSub==4 );     
-      Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
-      break;
-  }
-
-  if( rc!=TCL_OK ){
-    if( zErr ){
-      Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1));
-    }else{
-      extern const char *sqlite3ErrName(int);
-      Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
-    }
-  }
-  sqlite3_free(zErr);
-  return rc;
-}
-
-static void SQLITE_TCLAPI testExpertDel(void *clientData){
-  sqlite3expert *pExpert = (sqlite3expert*)clientData;
-  sqlite3_expert_destroy(pExpert);
-}
-
-/*
-** sqlite3_expert_new DB
-*/
-static int SQLITE_TCLAPI test_sqlite3_expert_new(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  static int iCmd = 0;
-  sqlite3 *db;
-  char *zCmd = 0;
-  char *zErr = 0;
-  sqlite3expert *pExpert;
-  int rc = TCL_OK;
-
-  if( objc!=2 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "DB");
-    return TCL_ERROR;
-  }
-  if( dbHandleFromObj(interp, objv[1], &db) ){
-    return TCL_ERROR;
-  }
-
-  zCmd = sqlite3_mprintf("sqlite3expert%d", ++iCmd);
-  if( zCmd==0 ){
-    Tcl_AppendResult(interp, "out of memory", (char*)0);
-    return TCL_ERROR;
-  }
-
-  pExpert = sqlite3_expert_new(db, &zErr);
-  if( pExpert==0 ){
-    Tcl_AppendResult(interp, zErr, (char*)0);
-    rc = TCL_ERROR;
-  }else{
-    void *p = (void*)pExpert;
-    Tcl_CreateObjCommand(interp, zCmd, testExpertCmd, p, testExpertDel);
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(zCmd, -1));
-  }
-
-  sqlite3_free(zCmd);
-  sqlite3_free(zErr);
-  return rc;
-}
-
-#endif  /* ifndef SQLITE_OMIT_VIRTUALTABLE */
-
-int TestExpert_Init(Tcl_Interp *interp){
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  struct Cmd {
-    const char *zCmd;
-    Tcl_ObjCmdProc *xProc;
-  } aCmd[] = {
-    { "sqlite3_expert_new", test_sqlite3_expert_new },
-  };
-  int i;
-
-  for(i=0; i<sizeof(aCmd)/sizeof(struct Cmd); i++){
-    struct Cmd *p = &aCmd[i];
-    Tcl_CreateObjCommand(interp, p->zCmd, p->xProc, 0, 0);
-  }
-#endif
-  return TCL_OK;
-}
-
-#endif

ext/fts1/ft_hash.h

@@ -9,7 +9,7 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** This is the header file for the generic hash-table implementation
+** This is the header file for the generic hash-table implemenation
 ** used in SQLite.  We've modified it slightly to serve as a standalone
 ** hash table implementation for the full-text indexing module.
 **

ext/fts1/fts1.c

@@ -205,13 +205,13 @@ static int getVarint32(const char *p, int *pi){
 */
 /* TODO(shess) Is __isascii() a portable version of (c&0x80)==0? */
 static int safe_isspace(char c){
-  return (c&0x80)==0 ? isspace((unsigned char)c) : 0;
+  return (c&0x80)==0 ? isspace(c) : 0;
 }
 static int safe_tolower(char c){
-  return (c&0x80)==0 ? tolower((unsigned char)c) : c;
+  return (c&0x80)==0 ? tolower(c) : c;
 }
 static int safe_isalnum(char c){
-  return (c&0x80)==0 ? isalnum((unsigned char)c) : 0;
+  return (c&0x80)==0 ? isalnum(c) : 0;
 }
 
 typedef enum DocListType {
@@ -3335,11 +3335,8 @@ int sqlite3Fts1Init(sqlite3 *db){
 }
 
 #if !SQLITE_CORE
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-int sqlite3_fts1_init(sqlite3 *db, char **pzErrMsg,
-                      const sqlite3_api_routines *pApi){
+int sqlite3_extension_init(sqlite3 *db, char **pzErrMsg,
+                           const sqlite3_api_routines *pApi){
   SQLITE_EXTENSION_INIT2(pApi)
   return sqlite3Fts1Init(db);
 }

ext/fts1/fts1_hash.h

@@ -9,7 +9,7 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** This is the header file for the generic hash-table implementation
+** This is the header file for the generic hash-table implemenation
 ** used in SQLite.  We've modified it slightly to serve as a standalone
 ** hash table implementation for the full-text indexing module.
 **

ext/fts1/fulltext.c

@@ -852,14 +852,8 @@ static void fulltext_vtab_destroy(fulltext_vtab *v){
 ** argv[3] - tokenizer name (optional, a sensible default is provided)
 ** argv[4..] - passed to tokenizer (optional based on tokenizer)
 **/
-static int fulltextConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc,
-  const char * const *argv,
-  sqlite3_vtab **ppVTab,
-  char **pzErr
-){
+static int fulltextConnect(sqlite3 *db, void *pAux, int argc, char **argv,
+                           sqlite3_vtab **ppVTab){
   int rc;
   fulltext_vtab *v;
   sqlite3_tokenizer_module *m = NULL;
@@ -904,14 +898,8 @@ static int fulltextConnect(
   return SQLITE_OK;
 }
 
-static int fulltextCreate(
-  sqlite3 *db,
-  void *pAux,
-  int argc,
-  const char * const *argv,
-  sqlite3_vtab **ppVTab,
-  char **pzErr
-){
+static int fulltextCreate(sqlite3 *db, void *pAux, int argc, char **argv,
+                          sqlite3_vtab **ppVTab){
   int rc;
   assert( argc>=3 );
 
@@ -946,7 +934,7 @@ static int fulltextCreate(
     "create index %_index on %_term(term, first)");
   if( rc!=SQLITE_OK ) return rc;
 
-  return fulltextConnect(db, pAux, argc, argv, ppVTab, pzErr);
+  return fulltextConnect(db, pAux, argc, argv, ppVTab);
 }
 
 /* Decide how to handle an SQL query.
@@ -1500,11 +1488,8 @@ int fulltext_init(sqlite3 *db){
 }
 
 #if !SQLITE_CORE
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-int sqlite3_fulltext_init(sqlite3 *db, char **pzErrMsg,
-                          const sqlite3_api_routines *pApi){
+int sqlite3_extension_init(sqlite3 *db, char **pzErrMsg,
+                           const sqlite3_api_routines *pApi){
  SQLITE_EXTENSION_INIT2(pApi)
  return fulltext_init(db);
 }

ext/fts1/simple_tokenizer.c

@@ -138,7 +138,7 @@ static int simpleNext(
         ** case-insensitivity.
         */
         char ch = c->pCurrent[ii];
-        c->zToken[ii] = (unsigned char)ch<0x80 ? tolower((unsigned char)ch):ch;
+        c->zToken[ii] = (unsigned char)ch<0x80 ? tolower(ch) : ch;
       }
       c->zToken[n] = '\0';
       *ppToken = c->zToken;

ext/fts2/fts2.c

@@ -306,6 +306,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
+
 #include "fts2.h"
 #include "fts2_hash.h"
 #include "fts2_tokenizer.h"
@@ -343,13 +345,13 @@ SQLITE_EXTENSION_INIT1
 */
 /* TODO(shess) Is __isascii() a portable version of (c&0x80)==0? */
 static int safe_isspace(char c){
-  return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f';
+  return (c&0x80)==0 ? isspace(c) : 0;
 }
 static int safe_tolower(char c){
-  return (c>='A' && c<='Z') ? (c - 'A' + 'a') : c;
+  return (c&0x80)==0 ? tolower(c) : c;
 }
 static int safe_isalnum(char c){
-  return (c>='0' && c<='9') || (c>='A' && c<='Z') || (c>='a' && c<='z');
+  return (c&0x80)==0 ? isalnum(c) : 0;
 }
 
 typedef enum DocListType {
@@ -5051,7 +5053,7 @@ static int leavesReaderAtEnd(LeavesReader *pReader){
 ** modification to control flow all over the place, though, so for now
 ** just punt.
 **
-** Note the current system assumes that segment merges will run to
+** Note the the current system assumes that segment merges will run to
 ** completion, which is why this particular probably hasn't arisen in
 ** this case.  Probably a brittle assumption.
 */
@@ -6779,7 +6781,7 @@ void sqlite3Fts2IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
 int sqlite3Fts2InitHashTable(sqlite3 *, fts2Hash *, const char *);
 
 /*
-** Initialize the fts2 extension. If this extension is built as part
+** Initialise the fts2 extension. If this extension is built as part
 ** of the sqlite library, then this function is called directly by
 ** SQLite. If fts2 is built as a dynamically loadable extension, this
 ** function is called by the sqlite3_extension_init() entry point.
@@ -6797,7 +6799,7 @@ int sqlite3Fts2Init(sqlite3 *db){
   sqlite3Fts2IcuTokenizerModule(&pIcu);
 #endif
 
-  /* Allocate and initialize the hash-table used to store tokenizers. */
+  /* Allocate and initialise the hash-table used to store tokenizers. */
   pHash = sqlite3_malloc(sizeof(fts2Hash));
   if( !pHash ){
     rc = SQLITE_NOMEM;
@@ -6844,10 +6846,7 @@ int sqlite3Fts2Init(sqlite3 *db){
 }
 
 #if !SQLITE_CORE
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-int sqlite3_fts2_init(
+int sqlite3_extension_init(
   sqlite3 *db, 
   char **pzErrMsg,
   const sqlite3_api_routines *pApi

ext/fts2/fts2_hash.c

@@ -30,8 +30,6 @@
 #include <string.h>
 
 #include "sqlite3.h"
-#include "sqlite3ext.h"
-SQLITE_EXTENSION_INIT3
 #include "fts2_hash.h"
 
 /*

ext/fts2/fts2_hash.h

@@ -9,7 +9,7 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** This is the header file for the generic hash-table implementation
+** This is the header file for the generic hash-table implemenation
 ** used in SQLite.  We've modified it slightly to serve as a standalone
 ** hash table implementation for the full-text indexing module.
 **

ext/fts2/fts2_icu.c

@@ -118,7 +118,7 @@ static int icuOpen(
   nChar = nInput+1;
   pCsr = (IcuCursor *)sqlite3_malloc(
       sizeof(IcuCursor) +                /* IcuCursor */
-      ((nChar+3)&~3) * sizeof(UChar) +   /* IcuCursor.aChar[] */
+      nChar * sizeof(UChar) +            /* IcuCursor.aChar[] */
       (nChar+1) * sizeof(int)            /* IcuCursor.aOffset[] */
   );
   if( !pCsr ){
@@ -126,7 +126,7 @@ static int icuOpen(
   }
   memset(pCsr, 0, sizeof(IcuCursor));
   pCsr->aChar = (UChar *)&pCsr[1];
-  pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3];
+  pCsr->aOffset = (int *)&pCsr->aChar[nChar];
 
   pCsr->aOffset[iOut] = iInput;
   U8_NEXT(zInput, iInput, nInput, c); 

ext/fts2/fts2_porter.c

@@ -29,10 +29,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
 
-#include "sqlite3.h"
-#include "sqlite3ext.h"
-SQLITE_EXTENSION_INIT3
 #include "fts2_tokenizer.h"
 
 /*

ext/fts2/fts2_tokenizer.c

@@ -28,7 +28,7 @@
 
 #include "sqlite3.h"
 #include "sqlite3ext.h"
-SQLITE_EXTENSION_INIT3
+SQLITE_EXTENSION_INIT1
 
 #include "fts2_hash.h"
 #include "fts2_tokenizer.h"
@@ -99,11 +99,7 @@ static void scalarFunc(
 
 #ifdef SQLITE_TEST
 
-#if defined(INCLUDE_SQLITE_TCL_H)
-#  include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#endif
+#include <tcl.h>
 #include <string.h>
 
 /*
@@ -323,7 +319,7 @@ static void intTestFunc(
 /*
 ** Set up SQL objects in database db used to access the contents of
 ** the hash table pointed to by argument pHash. The hash table must
-** been initialized to use string keys, and to take a private copy 
+** been initialised to use string keys, and to take a private copy 
 ** of the key when a value is inserted. i.e. by a call similar to:
 **
 **    sqlite3Fts2HashInit(pHash, FTS2_HASH_STRING, 1);

ext/fts2/fts2_tokenizer.h

@@ -70,7 +70,7 @@ struct sqlite3_tokenizer_module {
   ** This method should return either SQLITE_OK (0), or an SQLite error 
   ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
   ** to point at the newly created tokenizer structure. The generic
-  ** sqlite3_tokenizer.pModule variable should not be initialized by
+  ** sqlite3_tokenizer.pModule variable should not be initialised by
   ** this callback. The caller will do so.
   */
   int (*xCreate)(

ext/fts2/fts2_tokenizer1.c

@@ -29,10 +29,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
 
-#include "sqlite3.h"
-#include "sqlite3ext.h"
-SQLITE_EXTENSION_INIT3
 #include "fts2_tokenizer.h"
 
 typedef struct simple_tokenizer {
@@ -91,8 +89,7 @@ static int simpleCreate(
     /* Mark non-alphanumeric ASCII characters as delimiters */
     int i;
     for(i=1; i<0x80; i++){
-      t->delim[i] = !((i>='0' && i<='9') || (i>='A' && i<='Z') ||
-                      (i>='a' && i<='z'));
+      t->delim[i] = !isalnum(i);
     }
   }
 
@@ -194,7 +191,7 @@ static int simpleNext(
         ** case-insensitivity.
         */
         unsigned char ch = p[iStartOffset+i];
-        c->pToken[i] = (ch>='A' && ch<='Z') ? (ch - 'A' + 'a') : ch;
+        c->pToken[i] = ch<0x80 ? tolower(ch) : ch;
       }
       *ppToken = c->pToken;
       *pnBytes = n;

ext/fts3/README.content

@@ -1,178 +0,0 @@
-
-FTS4 CONTENT OPTION
-
-  Normally, in order to create a full-text index on a dataset, the FTS4 
-  module stores a copy of all indexed documents in a specially created 
-  database table.
-
-  As of SQLite version 3.7.9, FTS4 supports a new option - "content" -
-  designed to extend FTS4 to support the creation of full-text indexes where:
-
-    * The indexed documents are not stored within the SQLite database 
-      at all (a "contentless" FTS4 table), or
-
-    * The indexed documents are stored in a database table created and
-      managed by the user (an "external content" FTS4 table).
-
-  Because the indexed documents themselves are usually much larger than 
-  the full-text index, the content option can sometimes be used to achieve 
-  significant space savings.
-
-CONTENTLESS FTS4 TABLES
-
-  In order to create an FTS4 table that does not store a copy of the indexed
-  documents at all, the content option should be set to an empty string.
-  For example, the following SQL creates such an FTS4 table with three
-  columns - "a", "b", and "c":
-
-    CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);
-
-  Data can be inserted into such an FTS4 table using an INSERT statements.
-  However, unlike ordinary FTS4 tables, the user must supply an explicit
-  integer docid value. For example:
-
-    -- This statement is Ok:
-    INSERT INTO t1(docid, a, b, c) VALUES(1, 'a b c', 'd e f', 'g h i');
-
-    -- This statement causes an error, as no docid value has been provided:
-    INSERT INTO t1(a, b, c) VALUES('j k l', 'm n o', 'p q r');
-
-  It is not possible to UPDATE or DELETE a row stored in a contentless FTS4
-  table. Attempting to do so is an error.
-
-  Contentless FTS4 tables also support SELECT statements. However, it is
-  an error to attempt to retrieve the value of any table column other than
-  the docid column. The auxiliary function matchinfo() may be used, but
-  snippet() and offsets() may not. For example:
-
-    -- The following statements are Ok:
-    SELECT docid FROM t1 WHERE t1 MATCH 'xxx';
-    SELECT docid FROM t1 WHERE a MATCH 'xxx';
-    SELECT matchinfo(t1) FROM t1 WHERE t1 MATCH 'xxx';
-
-    -- The following statements all cause errors, as the value of columns
-    -- other than docid are required to evaluate them.
-    SELECT * FROM t1;
-    SELECT a, b FROM t1 WHERE t1 MATCH 'xxx';
-    SELECT docid FROM t1 WHERE a LIKE 'xxx%';
-    SELECT snippet(t1) FROM t1 WHERE t1 MATCH 'xxx';
-
-  Errors related to attempting to retrieve column values other than docid
-  are runtime errors that occur within sqlite3_step(). In some cases, for
-  example if the MATCH expression in a SELECT query matches zero rows, there
-  may be no error at all even if a statement does refer to column values 
-  other than docid.
-
-EXTERNAL CONTENT FTS4 TABLES
-
-  An "external content" FTS4 table is similar to a contentless table, except
-  that if evaluation of a query requires the value of a column other than 
-  docid, FTS4 attempts to retrieve that value from a table (or view, or 
-  virtual table) nominated by the user (hereafter referred to as the "content
-  table"). The FTS4 module never writes to the content table, and writing
-  to the content table does not affect the full-text index. It is the
-  responsibility of the user to ensure that the content table and the 
-  full-text index are consistent.
-
-  An external content FTS4 table is created by setting the content option
-  to the name of a table (or view, or virtual table) that may be queried by
-  FTS4 to retrieve column values when required. If the nominated table does
-  not exist, then an external content table behaves in the same way as
-  a contentless table. For example:
-
-    CREATE TABLE t2(id INTEGER PRIMARY KEY, a, b, c);
-    CREATE VIRTUAL TABLE t3 USING fts4(content="t2", a, c);
-
-  Assuming the nominated table does exist, then its columns must be the same 
-  as or a superset of those defined for the FTS table.
-
-  When a users query on the FTS table requires a column value other than
-  docid, FTS attempts to read this value from the corresponding column of
-  the row in the content table with a rowid value equal to the current FTS
-  docid. Or, if such a row cannot be found in the content table, a NULL
-  value is used instead. For example:
-
-    CREATE TABLE t2(id INTEGER PRIMARY KEY, a, b, c, d);
-    CREATE VIRTUAL TABLE t3 USING fts4(content="t2", b, c);
-  
-    INSERT INTO t2 VALUES(2, 'a b', 'c d', 'e f');
-    INSERT INTO t2 VALUES(3, 'g h', 'i j', 'k l');
-    INSERT INTO t3(docid, b, c) SELECT id, b, c FROM t2;
-
-    -- The following query returns a single row with two columns containing
-    -- the text values "i j" and "k l".
-    --
-    -- The query uses the full-text index to discover that the MATCH 
-    -- term matches the row with docid=3. It then retrieves the values
-    -- of columns b and c from the row with rowid=3 in the content table
-    -- to return.
-    --
-    SELECT * FROM t3 WHERE t3 MATCH 'k';
-
-    -- Following the UPDATE, the query still returns a single row, this
-    -- time containing the text values "xxx" and "yyy". This is because the
-    -- full-text index still indicates that the row with docid=3 matches
-    -- the FTS4 query 'k', even though the documents stored in the content
-    -- table have been modified.
-    --
-    UPDATE t2 SET b = 'xxx', c = 'yyy' WHERE rowid = 3;
-    SELECT * FROM t3 WHERE t3 MATCH 'k';
-
-    -- Following the DELETE below, the query returns one row containing two
-    -- NULL values. NULL values are returned because FTS is unable to find
-    -- a row with rowid=3 within the content table.
-    --
-    DELETE FROM t2;
-    SELECT * FROM t3 WHERE t3 MATCH 'k';
-
-  When a row is deleted from an external content FTS4 table, FTS4 needs to
-  retrieve the column values of the row being deleted from the content table.
-  This is so that FTS4 can update the full-text index entries for each token
-  that occurs within the deleted row to indicate that that row has been 
-  deleted. If the content table row cannot be found, or if it contains values
-  inconsistent with the contents of the FTS index, the results can be difficult
-  to predict. The FTS index may be left containing entries corresponding to the
-  deleted row, which can lead to seemingly nonsensical results being returned
-  by subsequent SELECT queries. The same applies when a row is updated, as
-  internally an UPDATE is the same as a DELETE followed by an INSERT.
-  
-  Instead of writing separately to the full-text index and the content table,
-  some users may wish to use database triggers to keep the full-text index
-  up to date with respect to the set of documents stored in the content table.
-  For example, using the tables from earlier examples:
-
-    CREATE TRIGGER t2_bu BEFORE UPDATE ON t2 BEGIN
-      DELETE FROM t3 WHERE docid=old.rowid;
-    END;
-    CREATE TRIGGER t2_bd BEFORE DELETE ON t2 BEGIN
-      DELETE FROM t3 WHERE docid=old.rowid;
-    END;
-
-    CREATE TRIGGER t2_bu AFTER UPDATE ON t2 BEGIN
-      INSERT INTO t3(docid, b, c) VALUES(new.rowid, new.b, new.c);
-    END;
-    CREATE TRIGGER t2_bd AFTER INSERT ON t2 BEGIN
-      INSERT INTO t3(docid, b, c) VALUES(new.rowid, new.b, new.c);
-    END;
-
-  The DELETE trigger must be fired before the actual delete takes place
-  on the content table. This is so that FTS4 can still retrieve the original
-  values in order to update the full-text index. And the INSERT trigger must
-  be fired after the new row is inserted, so as to handle the case where the
-  rowid is assigned automatically within the system. The UPDATE trigger must
-  be split into two parts, one fired before and one after the update of the
-  content table, for the same reasons.
-
-  FTS4 features a special command similar to the 'optimize' command that
-  deletes the entire full-text index and rebuilds it based on the current
-  set of documents in the content table. Assuming again that "t3" is the
-  name of the external content FTS4 table, the command is:
-
-    INSERT INTO t3(t3) VALUES('rebuild');
-
-  This command may also be used with ordinary FTS4 tables, although it may
-  only be useful if the full-text index has somehow become corrupt. It is an
-  error to attempt to rebuild the full-text index maintained by a contentless
-  FTS4 table.
-
-

ext/fts3/README.tokenizers

@@ -11,7 +11,7 @@
     );
 
   The built-in tokenizers (valid values to pass as <tokenizer name>) are
-  "simple", "porter" and "unicode".
+  "simple" and "porter".
 
   <tokenizer-args> should consist of zero or more white-space separated
   arguments to pass to the selected tokenizer implementation. The 
@@ -52,10 +52,8 @@
 
   SECURITY: If the fts3 extension is used in an environment where potentially
     malicious users may execute arbitrary SQL (i.e. gears), they should be
-    prevented from invoking the fts3_tokenizer() function.  The
-    fts3_tokenizer() function is disabled by default. It is only enabled
-    by SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER. Do not enable it in
-    security sensitive environments.
+    prevented from invoking the fts3_tokenizer() function, possibly using the
+    authorisation callback.
 
   See "Sample code" below for an example of calling the fts3_tokenizer()
   function from C code.

ext/fts3/fts3Int.h

@@ -1,650 +0,0 @@
-/*
-** 2009 Nov 12
-**
-** 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.
-**
-******************************************************************************
-**
-*/
-#ifndef _FTSINT_H
-#define _FTSINT_H
-
-#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 
-# define NDEBUG 1
-#endif
-
-/* FTS3/FTS4 require virtual tables */
-#ifdef SQLITE_OMIT_VIRTUALTABLE
-# undef SQLITE_ENABLE_FTS3
-# undef SQLITE_ENABLE_FTS4
-#endif
-
-/*
-** FTS4 is really an extension for FTS3.  It is enabled using the
-** SQLITE_ENABLE_FTS3 macro.  But to avoid confusion we also all
-** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3.
-*/
-#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
-# define SQLITE_ENABLE_FTS3
-#endif
-
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
-
-/* If not building as part of the core, include sqlite3ext.h. */
-#ifndef SQLITE_CORE
-# include "sqlite3ext.h" 
-SQLITE_EXTENSION_INIT3
-#endif
-
-#include "sqlite3.h"
-#include "fts3_tokenizer.h"
-#include "fts3_hash.h"
-
-/*
-** This constant determines the maximum depth of an FTS expression tree
-** that the library will create and use. FTS uses recursion to perform 
-** various operations on the query tree, so the disadvantage of a large
-** limit is that it may allow very large queries to use large amounts
-** of stack space (perhaps causing a stack overflow).
-*/
-#ifndef SQLITE_FTS3_MAX_EXPR_DEPTH
-# define SQLITE_FTS3_MAX_EXPR_DEPTH 12
-#endif
-
-
-/*
-** This constant controls how often segments are merged. Once there are
-** FTS3_MERGE_COUNT segments of level N, they are merged into a single
-** segment of level N+1.
-*/
-#define FTS3_MERGE_COUNT 16
-
-/*
-** This is the maximum amount of data (in bytes) to store in the 
-** Fts3Table.pendingTerms hash table. Normally, the hash table is
-** populated as documents are inserted/updated/deleted in a transaction
-** and used to create a new segment when the transaction is committed.
-** However if this limit is reached midway through a transaction, a new 
-** segment is created and the hash table cleared immediately.
-*/
-#define FTS3_MAX_PENDING_DATA (1*1024*1024)
-
-/*
-** Macro to return the number of elements in an array. SQLite has a
-** similar macro called ArraySize(). Use a different name to avoid
-** a collision when building an amalgamation with built-in FTS3.
-*/
-#define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0])))
-
-
-#ifndef MIN
-# define MIN(x,y) ((x)<(y)?(x):(y))
-#endif
-#ifndef MAX
-# define MAX(x,y) ((x)>(y)?(x):(y))
-#endif
-
-/*
-** Maximum length of a varint encoded integer. The varint format is different
-** from that used by SQLite, so the maximum length is 10, not 9.
-*/
-#define FTS3_VARINT_MAX 10
-
-#define FTS3_BUFFER_PADDING 8
-
-/*
-** FTS4 virtual tables may maintain multiple indexes - one index of all terms
-** in the document set and zero or more prefix indexes. All indexes are stored
-** as one or more b+-trees in the %_segments and %_segdir tables. 
-**
-** It is possible to determine which index a b+-tree belongs to based on the
-** value stored in the "%_segdir.level" column. Given this value L, the index
-** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with
-** level values between 0 and 1023 (inclusive) belong to index 0, all levels
-** between 1024 and 2047 to index 1, and so on.
-**
-** It is considered impossible for an index to use more than 1024 levels. In 
-** theory though this may happen, but only after at least 
-** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables.
-*/
-#define FTS3_SEGDIR_MAXLEVEL      1024
-#define FTS3_SEGDIR_MAXLEVEL_STR "1024"
-
-/*
-** The testcase() macro is only used by the amalgamation.  If undefined,
-** make it a no-op.
-*/
-#ifndef testcase
-# define testcase(X)
-#endif
-
-/*
-** Terminator values for position-lists and column-lists.
-*/
-#define POS_COLUMN  (1)     /* Column-list terminator */
-#define POS_END     (0)     /* Position-list terminator */ 
-
-/*
-** The assert_fts3_nc() macro is similar to the assert() macro, except that it
-** is used for assert() conditions that are true only if it can be 
-** guranteed that the database is not corrupt.
-*/
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-extern int sqlite3_fts3_may_be_corrupt;
-# define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x))
-#else
-# define assert_fts3_nc(x) assert(x)
-#endif
-
-/*
-** This section provides definitions to allow the
-** FTS3 extension to be compiled outside of the 
-** amalgamation.
-*/
-#ifndef SQLITE_AMALGAMATION
-/*
-** Macros indicating that conditional expressions are always true or
-** false.
-*/
-#ifdef SQLITE_COVERAGE_TEST
-# define ALWAYS(x) (1)
-# define NEVER(X)  (0)
-#elif defined(SQLITE_DEBUG)
-# define ALWAYS(x) sqlite3Fts3Always((x)!=0)
-# define NEVER(x) sqlite3Fts3Never((x)!=0)
-int sqlite3Fts3Always(int b);
-int sqlite3Fts3Never(int b);
-#else
-# define ALWAYS(x) (x)
-# define NEVER(x)  (x)
-#endif
-
-/*
-** Internal types used by SQLite.
-*/
-typedef unsigned char u8;         /* 1-byte (or larger) unsigned integer */
-typedef short int i16;            /* 2-byte (or larger) signed integer */
-typedef unsigned int u32;         /* 4-byte unsigned integer */
-typedef sqlite3_uint64 u64;       /* 8-byte unsigned integer */
-typedef sqlite3_int64 i64;        /* 8-byte signed integer */
-
-/*
-** Macro used to suppress compiler warnings for unused parameters.
-*/
-#define UNUSED_PARAMETER(x) (void)(x)
-
-/*
-** Activate assert() only if SQLITE_TEST is enabled.
-*/
-#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 
-# define NDEBUG 1
-#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(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
-# define TESTONLY(X)  X
-#else
-# define TESTONLY(X)
-#endif
-
-#define LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))
-#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
-
-#endif /* SQLITE_AMALGAMATION */
-
-#ifdef SQLITE_DEBUG
-int sqlite3Fts3Corrupt(void);
-# define FTS_CORRUPT_VTAB sqlite3Fts3Corrupt()
-#else
-# define FTS_CORRUPT_VTAB SQLITE_CORRUPT_VTAB
-#endif
-
-typedef struct Fts3Table Fts3Table;
-typedef struct Fts3Cursor Fts3Cursor;
-typedef struct Fts3Expr Fts3Expr;
-typedef struct Fts3Phrase Fts3Phrase;
-typedef struct Fts3PhraseToken Fts3PhraseToken;
-
-typedef struct Fts3Doclist Fts3Doclist;
-typedef struct Fts3SegFilter Fts3SegFilter;
-typedef struct Fts3DeferredToken Fts3DeferredToken;
-typedef struct Fts3SegReader Fts3SegReader;
-typedef struct Fts3MultiSegReader Fts3MultiSegReader;
-
-typedef struct MatchinfoBuffer MatchinfoBuffer;
-
-/*
-** A connection to a fulltext index is an instance of the following
-** structure. The xCreate and xConnect methods create an instance
-** of this structure and xDestroy and xDisconnect free that instance.
-** All other methods receive a pointer to the structure as one of their
-** arguments.
-*/
-struct Fts3Table {
-  sqlite3_vtab base;              /* Base class used by SQLite core */
-  sqlite3 *db;                    /* The database connection */
-  const char *zDb;                /* logical database name */
-  const char *zName;              /* virtual table name */
-  int nColumn;                    /* number of named columns in virtual table */
-  char **azColumn;                /* column names.  malloced */
-  u8 *abNotindexed;               /* True for 'notindexed' columns */
-  sqlite3_tokenizer *pTokenizer;  /* tokenizer for inserts and queries */
-  char *zContentTbl;              /* content=xxx option, or NULL */
-  char *zLanguageid;              /* languageid=xxx option, or NULL */
-  int nAutoincrmerge;             /* Value configured by 'automerge' */
-  u32 nLeafAdd;                   /* Number of leaf blocks added this trans */
-  int bLock;                      /* Used to prevent recursive content= tbls */
-
-  /* Precompiled statements used by the implementation. Each of these 
-  ** statements is run and reset within a single virtual table API call. 
-  */
-  sqlite3_stmt *aStmt[40];
-  sqlite3_stmt *pSeekStmt;        /* Cache for fts3CursorSeekStmt() */
-
-  char *zReadExprlist;
-  char *zWriteExprlist;
-
-  int nNodeSize;                  /* Soft limit for node size */
-  u8 bFts4;                       /* True for FTS4, false for FTS3 */
-  u8 bHasStat;                    /* True if %_stat table exists (2==unknown) */
-  u8 bHasDocsize;                 /* True if %_docsize table exists */
-  u8 bDescIdx;                    /* True if doclists are in reverse order */
-  u8 bIgnoreSavepoint;            /* True to ignore xSavepoint invocations */
-  int nPgsz;                      /* Page size for host database */
-  char *zSegmentsTbl;             /* Name of %_segments table */
-  sqlite3_blob *pSegments;        /* Blob handle open on %_segments table */
-
-  /* 
-  ** The following array of hash tables is used to buffer pending index 
-  ** updates during transactions. All pending updates buffered at any one
-  ** time must share a common language-id (see the FTS4 langid= feature).
-  ** The current language id is stored in variable iPrevLangid.
-  **
-  ** A single FTS4 table may have multiple full-text indexes. For each index
-  ** there is an entry in the aIndex[] array. Index 0 is an index of all the
-  ** terms that appear in the document set. Each subsequent index in aIndex[]
-  ** is an index of prefixes of a specific length.
-  **
-  ** Variable nPendingData contains an estimate the memory consumed by the 
-  ** pending data structures, including hash table overhead, but not including
-  ** malloc overhead.  When nPendingData exceeds nMaxPendingData, all hash
-  ** tables are flushed to disk. Variable iPrevDocid is the docid of the most 
-  ** recently inserted record.
-  */
-  int nIndex;                     /* Size of aIndex[] */
-  struct Fts3Index {
-    int nPrefix;                  /* Prefix length (0 for main terms index) */
-    Fts3Hash hPending;            /* Pending terms table for this index */
-  } *aIndex;
-  int nMaxPendingData;            /* Max pending data before flush to disk */
-  int nPendingData;               /* Current bytes of pending data */
-  sqlite_int64 iPrevDocid;        /* Docid of most recently inserted document */
-  int iPrevLangid;                /* Langid of recently inserted document */
-  int bPrevDelete;                /* True if last operation was a delete */
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
-  /* State variables used for validating that the transaction control
-  ** methods of the virtual table are called at appropriate times.  These
-  ** values do not contribute to FTS functionality; they are used for
-  ** verifying the operation of the SQLite core.
-  */
-  int inTransaction;     /* True after xBegin but before xCommit/xRollback */
-  int mxSavepoint;       /* Largest valid xSavepoint integer */
-#endif
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-  /* True to disable the incremental doclist optimization. This is controled
-  ** by special insert command 'test-no-incr-doclist'.  */
-  int bNoIncrDoclist;
-
-  /* Number of segments in a level */
-  int nMergeCount;
-#endif
-};
-
-/* Macro to find the number of segments to merge */
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-# define MergeCount(P) ((P)->nMergeCount)
-#else
-# define MergeCount(P) FTS3_MERGE_COUNT
-#endif
-
-/*
-** When the core wants to read from the virtual table, it creates a
-** virtual table cursor (an instance of the following structure) using
-** the xOpen method. Cursors are destroyed using the xClose method.
-*/
-struct Fts3Cursor {
-  sqlite3_vtab_cursor base;       /* Base class used by SQLite core */
-  i16 eSearch;                    /* Search strategy (see below) */
-  u8 isEof;                       /* True if at End Of Results */
-  u8 isRequireSeek;               /* True if must seek pStmt to %_content row */
-  u8 bSeekStmt;                   /* True if pStmt is a seek */
-  sqlite3_stmt *pStmt;            /* Prepared statement in use by the cursor */
-  Fts3Expr *pExpr;                /* Parsed MATCH query string */
-  int iLangid;                    /* Language being queried for */
-  int nPhrase;                    /* Number of matchable phrases in query */
-  Fts3DeferredToken *pDeferred;   /* Deferred search tokens, if any */
-  sqlite3_int64 iPrevId;          /* Previous id read from aDoclist */
-  char *pNextId;                  /* Pointer into the body of aDoclist */
-  char *aDoclist;                 /* List of docids for full-text queries */
-  int nDoclist;                   /* Size of buffer at aDoclist */
-  u8 bDesc;                       /* True to sort in descending order */
-  int eEvalmode;                  /* An FTS3_EVAL_XX constant */
-  int nRowAvg;                    /* Average size of database rows, in pages */
-  sqlite3_int64 nDoc;             /* Documents in table */
-  i64 iMinDocid;                  /* Minimum docid to return */
-  i64 iMaxDocid;                  /* Maximum docid to return */
-  int isMatchinfoNeeded;          /* True when aMatchinfo[] needs filling in */
-  MatchinfoBuffer *pMIBuffer;     /* Buffer for matchinfo data */
-};
-
-#define FTS3_EVAL_FILTER    0
-#define FTS3_EVAL_NEXT      1
-#define FTS3_EVAL_MATCHINFO 2
-
-/*
-** The Fts3Cursor.eSearch member is always set to one of the following.
-** Actualy, Fts3Cursor.eSearch can be greater than or equal to
-** FTS3_FULLTEXT_SEARCH.  If so, then Fts3Cursor.eSearch - 2 is the index
-** of the column to be searched.  For example, in
-**
-**     CREATE VIRTUAL TABLE ex1 USING fts3(a,b,c,d);
-**     SELECT docid FROM ex1 WHERE b MATCH 'one two three';
-** 
-** Because the LHS of the MATCH operator is 2nd column "b",
-** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1.  (+0 for a,
-** +1 for b, +2 for c, +3 for d.)  If the LHS of MATCH were "ex1" 
-** indicating that all columns should be searched,
-** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
-*/
-#define FTS3_FULLSCAN_SEARCH 0    /* Linear scan of %_content table */
-#define FTS3_DOCID_SEARCH    1    /* Lookup by rowid on %_content table */
-#define FTS3_FULLTEXT_SEARCH 2    /* Full-text index search */
-
-/*
-** The lower 16-bits of the sqlite3_index_info.idxNum value set by
-** the xBestIndex() method contains the Fts3Cursor.eSearch value described
-** above. The upper 16-bits contain a combination of the following
-** bits, used to describe extra constraints on full-text searches.
-*/
-#define FTS3_HAVE_LANGID    0x00010000      /* languageid=? */
-#define FTS3_HAVE_DOCID_GE  0x00020000      /* docid>=? */
-#define FTS3_HAVE_DOCID_LE  0x00040000      /* docid<=? */
-
-struct Fts3Doclist {
-  char *aAll;                    /* Array containing doclist (or NULL) */
-  int nAll;                      /* Size of a[] in bytes */
-  char *pNextDocid;              /* Pointer to next docid */
-
-  sqlite3_int64 iDocid;          /* Current docid (if pList!=0) */
-  int bFreeList;                 /* True if pList should be sqlite3_free()d */
-  char *pList;                   /* Pointer to position list following iDocid */
-  int nList;                     /* Length of position list */
-};
-
-/*
-** A "phrase" is a sequence of one or more tokens that must match in
-** sequence.  A single token is the base case and the most common case.
-** For a sequence of tokens contained in double-quotes (i.e. "one two three")
-** nToken will be the number of tokens in the string.
-*/
-struct Fts3PhraseToken {
-  char *z;                        /* Text of the token */
-  int n;                          /* Number of bytes in buffer z */
-  int isPrefix;                   /* True if token ends with a "*" character */
-  int bFirst;                     /* True if token must appear at position 0 */
-
-  /* Variables above this point are populated when the expression is
-  ** parsed (by code in fts3_expr.c). Below this point the variables are
-  ** used when evaluating the expression. */
-  Fts3DeferredToken *pDeferred;   /* Deferred token object for this token */
-  Fts3MultiSegReader *pSegcsr;    /* Segment-reader for this token */
-};
-
-struct Fts3Phrase {
-  /* Cache of doclist for this phrase. */
-  Fts3Doclist doclist;
-  int bIncr;                 /* True if doclist is loaded incrementally */
-  int iDoclistToken;
-
-  /* Used by sqlite3Fts3EvalPhrasePoslist() if this is a descendent of an
-  ** OR condition.  */
-  char *pOrPoslist;
-  i64 iOrDocid;
-
-  /* Variables below this point are populated by fts3_expr.c when parsing 
-  ** a MATCH expression. Everything above is part of the evaluation phase. 
-  */
-  int nToken;                /* Number of tokens in the phrase */
-  int iColumn;               /* Index of column this phrase must match */
-  Fts3PhraseToken aToken[1]; /* One entry for each token in the phrase */
-};
-
-/*
-** A tree of these objects forms the RHS of a MATCH operator.
-**
-** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist 
-** points to a malloced buffer, size nDoclist bytes, containing the results 
-** of this phrase query in FTS3 doclist format. As usual, the initial 
-** "Length" field found in doclists stored on disk is omitted from this 
-** buffer.
-**
-** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global
-** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
-** where nCol is the number of columns in the queried FTS table. The array
-** is populated as follows:
-**
-**   aMI[iCol*3 + 0] = Undefined
-**   aMI[iCol*3 + 1] = Number of occurrences
-**   aMI[iCol*3 + 2] = Number of rows containing at least one instance
-**
-** The aMI array is allocated using sqlite3_malloc(). It should be freed 
-** when the expression node is.
-*/
-struct Fts3Expr {
-  int eType;                 /* One of the FTSQUERY_XXX values defined below */
-  int nNear;                 /* Valid if eType==FTSQUERY_NEAR */
-  Fts3Expr *pParent;         /* pParent->pLeft==this or pParent->pRight==this */
-  Fts3Expr *pLeft;           /* Left operand */
-  Fts3Expr *pRight;          /* Right operand */
-  Fts3Phrase *pPhrase;       /* Valid if eType==FTSQUERY_PHRASE */
-
-  /* The following are used by the fts3_eval.c module. */
-  sqlite3_int64 iDocid;      /* Current docid */
-  u8 bEof;                   /* True this expression is at EOF already */
-  u8 bStart;                 /* True if iDocid is valid */
-  u8 bDeferred;              /* True if this expression is entirely deferred */
-
-  /* The following are used by the fts3_snippet.c module. */
-  int iPhrase;               /* Index of this phrase in matchinfo() results */
-  u32 *aMI;                  /* See above */
-};
-
-/*
-** Candidate values for Fts3Query.eType. Note that the order of the first
-** four values is in order of precedence when parsing expressions. For 
-** example, the following:
-**
-**   "a OR b AND c NOT d NEAR e"
-**
-** is equivalent to:
-**
-**   "a OR (b AND (c NOT (d NEAR e)))"
-*/
-#define FTSQUERY_NEAR   1
-#define FTSQUERY_NOT    2
-#define FTSQUERY_AND    3
-#define FTSQUERY_OR     4
-#define FTSQUERY_PHRASE 5
-
-
-/* fts3_write.c */
-int sqlite3Fts3UpdateMethod(sqlite3_vtab*,int,sqlite3_value**,sqlite3_int64*);
-int sqlite3Fts3PendingTermsFlush(Fts3Table *);
-void sqlite3Fts3PendingTermsClear(Fts3Table *);
-int sqlite3Fts3Optimize(Fts3Table *);
-int sqlite3Fts3SegReaderNew(int, int, sqlite3_int64,
-  sqlite3_int64, sqlite3_int64, const char *, int, Fts3SegReader**);
-int sqlite3Fts3SegReaderPending(
-  Fts3Table*,int,const char*,int,int,Fts3SegReader**);
-void sqlite3Fts3SegReaderFree(Fts3SegReader *);
-int sqlite3Fts3AllSegdirs(Fts3Table*, int, int, int, sqlite3_stmt **);
-int sqlite3Fts3ReadBlock(Fts3Table*, sqlite3_int64, char **, int*, int*);
-
-int sqlite3Fts3SelectDoctotal(Fts3Table *, sqlite3_stmt **);
-int sqlite3Fts3SelectDocsize(Fts3Table *, sqlite3_int64, sqlite3_stmt **);
-
-#ifndef SQLITE_DISABLE_FTS4_DEFERRED
-void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *);
-int sqlite3Fts3DeferToken(Fts3Cursor *, Fts3PhraseToken *, int);
-int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *);
-void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *);
-int sqlite3Fts3DeferredTokenList(Fts3DeferredToken *, char **, int *);
-#else
-# define sqlite3Fts3FreeDeferredTokens(x)
-# define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
-# define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK
-# define sqlite3Fts3FreeDeferredDoclists(x)
-# define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
-#endif
-
-void sqlite3Fts3SegmentsClose(Fts3Table *);
-int sqlite3Fts3MaxLevel(Fts3Table *, int *);
-
-/* Special values interpreted by sqlite3SegReaderCursor() */
-#define FTS3_SEGCURSOR_PENDING        -1
-#define FTS3_SEGCURSOR_ALL            -2
-
-int sqlite3Fts3SegReaderStart(Fts3Table*, Fts3MultiSegReader*, Fts3SegFilter*);
-int sqlite3Fts3SegReaderStep(Fts3Table *, Fts3MultiSegReader *);
-void sqlite3Fts3SegReaderFinish(Fts3MultiSegReader *);
-
-int sqlite3Fts3SegReaderCursor(Fts3Table *, 
-    int, int, int, const char *, int, int, int, Fts3MultiSegReader *);
-
-/* Flags allowed as part of the 4th argument to SegmentReaderIterate() */
-#define FTS3_SEGMENT_REQUIRE_POS   0x00000001
-#define FTS3_SEGMENT_IGNORE_EMPTY  0x00000002
-#define FTS3_SEGMENT_COLUMN_FILTER 0x00000004
-#define FTS3_SEGMENT_PREFIX        0x00000008
-#define FTS3_SEGMENT_SCAN          0x00000010
-#define FTS3_SEGMENT_FIRST         0x00000020
-
-/* Type passed as 4th argument to SegmentReaderIterate() */
-struct Fts3SegFilter {
-  const char *zTerm;
-  int nTerm;
-  int iCol;
-  int flags;
-};
-
-struct Fts3MultiSegReader {
-  /* Used internally by sqlite3Fts3SegReaderXXX() calls */
-  Fts3SegReader **apSegment;      /* Array of Fts3SegReader objects */
-  int nSegment;                   /* Size of apSegment array */
-  int nAdvance;                   /* How many seg-readers to advance */
-  Fts3SegFilter *pFilter;         /* Pointer to filter object */
-  char *aBuffer;                  /* Buffer to merge doclists in */
-  int nBuffer;                    /* Allocated size of aBuffer[] in bytes */
-
-  int iColFilter;                 /* If >=0, filter for this column */
-  int bRestart;
-
-  /* Used by fts3.c only. */
-  int nCost;                      /* Cost of running iterator */
-  int bLookup;                    /* True if a lookup of a single entry. */
-
-  /* Output values. Valid only after Fts3SegReaderStep() returns SQLITE_ROW. */
-  char *zTerm;                    /* Pointer to term buffer */
-  int nTerm;                      /* Size of zTerm in bytes */
-  char *aDoclist;                 /* Pointer to doclist buffer */
-  int nDoclist;                   /* Size of aDoclist[] in bytes */
-};
-
-int sqlite3Fts3Incrmerge(Fts3Table*,int,int);
-
-#define fts3GetVarint32(p, piVal) (                                           \
-  (*(u8*)(p)&0x80) ? sqlite3Fts3GetVarint32(p, piVal) : (*piVal=*(u8*)(p), 1) \
-)
-
-/* fts3.c */
-void sqlite3Fts3ErrMsg(char**,const char*,...);
-int sqlite3Fts3PutVarint(char *, sqlite3_int64);
-int sqlite3Fts3GetVarint(const char *, sqlite_int64 *);
-int sqlite3Fts3GetVarintU(const char *, sqlite_uint64 *);
-int sqlite3Fts3GetVarintBounded(const char*,const char*,sqlite3_int64*);
-int sqlite3Fts3GetVarint32(const char *, int *);
-int sqlite3Fts3VarintLen(sqlite3_uint64);
-void sqlite3Fts3Dequote(char *);
-void sqlite3Fts3DoclistPrev(int,char*,int,char**,sqlite3_int64*,int*,u8*);
-int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *);
-int sqlite3Fts3FirstFilter(sqlite3_int64, char *, int, char *);
-void sqlite3Fts3CreateStatTable(int*, Fts3Table*);
-int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc);
-int sqlite3Fts3ReadInt(const char *z, int *pnOut);
-
-/* fts3_tokenizer.c */
-const char *sqlite3Fts3NextToken(const char *, int *);
-int sqlite3Fts3InitHashTable(sqlite3 *, Fts3Hash *, const char *);
-int sqlite3Fts3InitTokenizer(Fts3Hash *pHash, const char *, 
-    sqlite3_tokenizer **, char **
-);
-int sqlite3Fts3IsIdChar(char);
-
-/* fts3_snippet.c */
-void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*);
-void sqlite3Fts3Snippet(sqlite3_context *, Fts3Cursor *, const char *,
-  const char *, const char *, int, int
-);
-void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *, const char *);
-void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p);
-
-/* fts3_expr.c */
-int sqlite3Fts3ExprParse(sqlite3_tokenizer *, int,
-  char **, int, int, int, const char *, int, Fts3Expr **, char **
-);
-void sqlite3Fts3ExprFree(Fts3Expr *);
-#ifdef SQLITE_TEST
-int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*);
-int sqlite3Fts3InitTerm(sqlite3 *db);
-#endif
-
-int sqlite3Fts3OpenTokenizer(sqlite3_tokenizer *, int, const char *, int,
-  sqlite3_tokenizer_cursor **
-);
-
-/* fts3_aux.c */
-int sqlite3Fts3InitAux(sqlite3 *db);
-
-void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *);
-
-int sqlite3Fts3MsrIncrStart(
-    Fts3Table*, Fts3MultiSegReader*, int, const char*, int);
-int sqlite3Fts3MsrIncrNext(
-    Fts3Table *, Fts3MultiSegReader *, sqlite3_int64 *, char **, int *);
-int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **); 
-int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *);
-int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
-
-/* fts3_tokenize_vtab.c */
-int sqlite3Fts3InitTok(sqlite3*, Fts3Hash *);
-
-/* fts3_unicode2.c (functions generated by parsing unicode text files) */
-#ifndef SQLITE_DISABLE_FTS3_UNICODE
-int sqlite3FtsUnicodeFold(int, int);
-int sqlite3FtsUnicodeIsalnum(int);
-int sqlite3FtsUnicodeIsdiacritic(int);
-#endif
-
-#endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */
-#endif /* _FTSINT_H */

ext/fts3/fts3_aux.c

@@ -1,551 +0,0 @@
-/*
-** 2011 Jan 27
-**
-** 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.
-**
-******************************************************************************
-**
-*/
-#include "fts3Int.h"
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
-
-#include <string.h>
-#include <assert.h>
-
-typedef struct Fts3auxTable Fts3auxTable;
-typedef struct Fts3auxCursor Fts3auxCursor;
-
-struct Fts3auxTable {
-  sqlite3_vtab base;              /* Base class used by SQLite core */
-  Fts3Table *pFts3Tab;
-};
-
-struct Fts3auxCursor {
-  sqlite3_vtab_cursor base;       /* Base class used by SQLite core */
-  Fts3MultiSegReader csr;        /* Must be right after "base" */
-  Fts3SegFilter filter;
-  char *zStop;
-  int nStop;                      /* Byte-length of string zStop */
-  int iLangid;                    /* Language id to query */
-  int isEof;                      /* True if cursor is at EOF */
-  sqlite3_int64 iRowid;           /* Current rowid */
-
-  int iCol;                       /* Current value of 'col' column */
-  int nStat;                      /* Size of aStat[] array */
-  struct Fts3auxColstats {
-    sqlite3_int64 nDoc;           /* 'documents' values for current csr row */
-    sqlite3_int64 nOcc;           /* 'occurrences' values for current csr row */
-  } *aStat;
-};
-
-/*
-** Schema of the terms table.
-*/
-#define FTS3_AUX_SCHEMA \
-  "CREATE TABLE x(term, col, documents, occurrences, languageid HIDDEN)"
-
-/*
-** This function does all the work for both the xConnect and xCreate methods.
-** These tables have no persistent representation of their own, so xConnect
-** and xCreate are identical operations.
-*/
-static int fts3auxConnectMethod(
-  sqlite3 *db,                    /* Database connection */
-  void *pUnused,                  /* Unused */
-  int argc,                       /* Number of elements in argv array */
-  const char * const *argv,       /* xCreate/xConnect argument array */
-  sqlite3_vtab **ppVtab,          /* OUT: New sqlite3_vtab object */
-  char **pzErr                    /* OUT: sqlite3_malloc'd error message */
-){
-  char const *zDb;                /* Name of database (e.g. "main") */
-  char const *zFts3;              /* Name of fts3 table */
-  int nDb;                        /* Result of strlen(zDb) */
-  int nFts3;                      /* Result of strlen(zFts3) */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate here */
-  int rc;                         /* value returned by declare_vtab() */
-  Fts3auxTable *p;                /* Virtual table object to return */
-
-  UNUSED_PARAMETER(pUnused);
-
-  /* The user should invoke this in one of two forms:
-  **
-  **     CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table);
-  **     CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table-db, fts4-table);
-  */
-  if( argc!=4 && argc!=5 ) goto bad_args;
-
-  zDb = argv[1]; 
-  nDb = (int)strlen(zDb);
-  if( argc==5 ){
-    if( nDb==4 && 0==sqlite3_strnicmp("temp", zDb, 4) ){
-      zDb = argv[3]; 
-      nDb = (int)strlen(zDb);
-      zFts3 = argv[4];
-    }else{
-      goto bad_args;
-    }
-  }else{
-    zFts3 = argv[3];
-  }
-  nFts3 = (int)strlen(zFts3);
-
-  rc = sqlite3_declare_vtab(db, FTS3_AUX_SCHEMA);
-  if( rc!=SQLITE_OK ) return rc;
-
-  nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
-  p = (Fts3auxTable *)sqlite3_malloc64(nByte);
-  if( !p ) return SQLITE_NOMEM;
-  memset(p, 0, nByte);
-
-  p->pFts3Tab = (Fts3Table *)&p[1];
-  p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
-  p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
-  p->pFts3Tab->db = db;
-  p->pFts3Tab->nIndex = 1;
-
-  memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
-  memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
-  sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
-
-  *ppVtab = (sqlite3_vtab *)p;
-  return SQLITE_OK;
-
- bad_args:
-  sqlite3Fts3ErrMsg(pzErr, "invalid arguments to fts4aux constructor");
-  return SQLITE_ERROR;
-}
-
-/*
-** This function does the work for both the xDisconnect and xDestroy methods.
-** These tables have no persistent representation of their own, so xDisconnect
-** and xDestroy are identical operations.
-*/
-static int fts3auxDisconnectMethod(sqlite3_vtab *pVtab){
-  Fts3auxTable *p = (Fts3auxTable *)pVtab;
-  Fts3Table *pFts3 = p->pFts3Tab;
-  int i;
-
-  /* Free any prepared statements held */
-  for(i=0; i<SizeofArray(pFts3->aStmt); i++){
-    sqlite3_finalize(pFts3->aStmt[i]);
-  }
-  sqlite3_free(pFts3->zSegmentsTbl);
-  sqlite3_free(p);
-  return SQLITE_OK;
-}
-
-#define FTS4AUX_EQ_CONSTRAINT 1
-#define FTS4AUX_GE_CONSTRAINT 2
-#define FTS4AUX_LE_CONSTRAINT 4
-
-/*
-** xBestIndex - Analyze a WHERE and ORDER BY clause.
-*/
-static int fts3auxBestIndexMethod(
-  sqlite3_vtab *pVTab, 
-  sqlite3_index_info *pInfo
-){
-  int i;
-  int iEq = -1;
-  int iGe = -1;
-  int iLe = -1;
-  int iLangid = -1;
-  int iNext = 1;                  /* Next free argvIndex value */
-
-  UNUSED_PARAMETER(pVTab);
-
-  /* This vtab delivers always results in "ORDER BY term ASC" order. */
-  if( pInfo->nOrderBy==1 
-   && pInfo->aOrderBy[0].iColumn==0 
-   && pInfo->aOrderBy[0].desc==0
-  ){
-    pInfo->orderByConsumed = 1;
-  }
-
-  /* Search for equality and range constraints on the "term" column. 
-  ** And equality constraints on the hidden "languageid" column. */
-  for(i=0; i<pInfo->nConstraint; i++){
-    if( pInfo->aConstraint[i].usable ){
-      int op = pInfo->aConstraint[i].op;
-      int iCol = pInfo->aConstraint[i].iColumn;
-
-      if( iCol==0 ){
-        if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iEq = i;
-        if( op==SQLITE_INDEX_CONSTRAINT_LT ) iLe = i;
-        if( op==SQLITE_INDEX_CONSTRAINT_LE ) iLe = i;
-        if( op==SQLITE_INDEX_CONSTRAINT_GT ) iGe = i;
-        if( op==SQLITE_INDEX_CONSTRAINT_GE ) iGe = i;
-      }
-      if( iCol==4 ){
-        if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iLangid = i;
-      }
-    }
-  }
-
-  if( iEq>=0 ){
-    pInfo->idxNum = FTS4AUX_EQ_CONSTRAINT;
-    pInfo->aConstraintUsage[iEq].argvIndex = iNext++;
-    pInfo->estimatedCost = 5;
-  }else{
-    pInfo->idxNum = 0;
-    pInfo->estimatedCost = 20000;
-    if( iGe>=0 ){
-      pInfo->idxNum += FTS4AUX_GE_CONSTRAINT;
-      pInfo->aConstraintUsage[iGe].argvIndex = iNext++;
-      pInfo->estimatedCost /= 2;
-    }
-    if( iLe>=0 ){
-      pInfo->idxNum += FTS4AUX_LE_CONSTRAINT;
-      pInfo->aConstraintUsage[iLe].argvIndex = iNext++;
-      pInfo->estimatedCost /= 2;
-    }
-  }
-  if( iLangid>=0 ){
-    pInfo->aConstraintUsage[iLangid].argvIndex = iNext++;
-    pInfo->estimatedCost--;
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** xOpen - Open a cursor.
-*/
-static int fts3auxOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
-  Fts3auxCursor *pCsr;            /* Pointer to cursor object to return */
-
-  UNUSED_PARAMETER(pVTab);
-
-  pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor));
-  if( !pCsr ) return SQLITE_NOMEM;
-  memset(pCsr, 0, sizeof(Fts3auxCursor));
-
-  *ppCsr = (sqlite3_vtab_cursor *)pCsr;
-  return SQLITE_OK;
-}
-
-/*
-** xClose - Close a cursor.
-*/
-static int fts3auxCloseMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
-  Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
-
-  sqlite3Fts3SegmentsClose(pFts3);
-  sqlite3Fts3SegReaderFinish(&pCsr->csr);
-  sqlite3_free((void *)pCsr->filter.zTerm);
-  sqlite3_free(pCsr->zStop);
-  sqlite3_free(pCsr->aStat);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){
-  if( nSize>pCsr->nStat ){
-    struct Fts3auxColstats *aNew;
-    aNew = (struct Fts3auxColstats *)sqlite3_realloc64(pCsr->aStat, 
-        sizeof(struct Fts3auxColstats) * nSize
-    );
-    if( aNew==0 ) return SQLITE_NOMEM;
-    memset(&aNew[pCsr->nStat], 0, 
-        sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)
-    );
-    pCsr->aStat = aNew;
-    pCsr->nStat = nSize;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** xNext - Advance the cursor to the next row, if any.
-*/
-static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
-  Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
-  int rc;
-
-  /* Increment our pretend rowid value. */
-  pCsr->iRowid++;
-
-  for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
-    if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
-  }
-
-  rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr);
-  if( rc==SQLITE_ROW ){
-    int i = 0;
-    int nDoclist = pCsr->csr.nDoclist;
-    char *aDoclist = pCsr->csr.aDoclist;
-    int iCol;
-
-    int eState = 0;
-
-    if( pCsr->zStop ){
-      int n = (pCsr->nStop<pCsr->csr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm;
-      int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
-      if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){
-        pCsr->isEof = 1;
-        return SQLITE_OK;
-      }
-    }
-
-    if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM;
-    memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
-    iCol = 0;
-
-    while( i<nDoclist ){
-      sqlite3_int64 v = 0;
-
-      i += sqlite3Fts3GetVarint(&aDoclist[i], &v);
-      switch( eState ){
-        /* State 0. In this state the integer just read was a docid. */
-        case 0:
-          pCsr->aStat[0].nDoc++;
-          eState = 1;
-          iCol = 0;
-          break;
-
-        /* State 1. In this state we are expecting either a 1, indicating
-        ** that the following integer will be a column number, or the
-        ** start of a position list for column 0.  
-        ** 
-        ** The only difference between state 1 and state 2 is that if the
-        ** integer encountered in state 1 is not 0 or 1, then we need to
-        ** increment the column 0 "nDoc" count for this term.
-        */
-        case 1:
-          assert( iCol==0 );
-          if( v>1 ){
-            pCsr->aStat[1].nDoc++;
-          }
-          eState = 2;
-          /* fall through */
-
-        case 2:
-          if( v==0 ){       /* 0x00. Next integer will be a docid. */
-            eState = 0;
-          }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
-            eState = 3;
-          }else{            /* 2 or greater. A position. */
-            pCsr->aStat[iCol+1].nOcc++;
-            pCsr->aStat[0].nOcc++;
-          }
-          break;
-
-        /* State 3. The integer just read is a column number. */
-        default: assert( eState==3 );
-          iCol = (int)v;
-          if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
-          pCsr->aStat[iCol+1].nDoc++;
-          eState = 2;
-          break;
-      }
-    }
-
-    pCsr->iCol = 0;
-    rc = SQLITE_OK;
-  }else{
-    pCsr->isEof = 1;
-  }
-  return rc;
-}
-
-/*
-** xFilter - Initialize a cursor to point at the start of its data.
-*/
-static int fts3auxFilterMethod(
-  sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
-  int idxNum,                     /* Strategy index */
-  const char *idxStr,             /* Unused */
-  int nVal,                       /* Number of elements in apVal */
-  sqlite3_value **apVal           /* Arguments for the indexing scheme */
-){
-  Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
-  Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
-  int rc;
-  int isScan = 0;
-  int iLangVal = 0;               /* Language id to query */
-
-  int iEq = -1;                   /* Index of term=? value in apVal */
-  int iGe = -1;                   /* Index of term>=? value in apVal */
-  int iLe = -1;                   /* Index of term<=? value in apVal */
-  int iLangid = -1;               /* Index of languageid=? value in apVal */
-  int iNext = 0;
-
-  UNUSED_PARAMETER(nVal);
-  UNUSED_PARAMETER(idxStr);
-
-  assert( idxStr==0 );
-  assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0
-       || idxNum==FTS4AUX_LE_CONSTRAINT || idxNum==FTS4AUX_GE_CONSTRAINT
-       || idxNum==(FTS4AUX_LE_CONSTRAINT|FTS4AUX_GE_CONSTRAINT)
-  );
-
-  if( idxNum==FTS4AUX_EQ_CONSTRAINT ){
-    iEq = iNext++;
-  }else{
-    isScan = 1;
-    if( idxNum & FTS4AUX_GE_CONSTRAINT ){
-      iGe = iNext++;
-    }
-    if( idxNum & FTS4AUX_LE_CONSTRAINT ){
-      iLe = iNext++;
-    }
-  }
-  if( iNext<nVal ){
-    iLangid = iNext++;
-  }
-
-  /* In case this cursor is being reused, close and zero it. */
-  testcase(pCsr->filter.zTerm);
-  sqlite3Fts3SegReaderFinish(&pCsr->csr);
-  sqlite3_free((void *)pCsr->filter.zTerm);
-  sqlite3_free(pCsr->aStat);
-  memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
-
-  pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
-  if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
-
-  if( iEq>=0 || iGe>=0 ){
-    const unsigned char *zStr = sqlite3_value_text(apVal[0]);
-    assert( (iEq==0 && iGe==-1) || (iEq==-1 && iGe==0) );
-    if( zStr ){
-      pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
-      if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
-      pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm);
-    }
-  }
-
-  if( iLe>=0 ){
-    pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe]));
-    if( pCsr->zStop==0 ) return SQLITE_NOMEM;
-    pCsr->nStop = (int)strlen(pCsr->zStop);
-  }
-  
-  if( iLangid>=0 ){
-    iLangVal = sqlite3_value_int(apVal[iLangid]);
-
-    /* If the user specified a negative value for the languageid, use zero
-    ** instead. This works, as the "languageid=?" constraint will also
-    ** be tested by the VDBE layer. The test will always be false (since
-    ** this module will not return a row with a negative languageid), and
-    ** so the overall query will return zero rows.  */
-    if( iLangVal<0 ) iLangVal = 0;
-  }
-  pCsr->iLangid = iLangVal;
-
-  rc = sqlite3Fts3SegReaderCursor(pFts3, iLangVal, 0, FTS3_SEGCURSOR_ALL,
-      pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
-  );
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
-  }
-
-  if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
-  return rc;
-}
-
-/*
-** xEof - Return true if the cursor is at EOF, or false otherwise.
-*/
-static int fts3auxEofMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
-  return pCsr->isEof;
-}
-
-/*
-** xColumn - Return a column value.
-*/
-static int fts3auxColumnMethod(
-  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
-  sqlite3_context *pCtx,          /* Context for sqlite3_result_xxx() calls */
-  int iCol                        /* Index of column to read value from */
-){
-  Fts3auxCursor *p = (Fts3auxCursor *)pCursor;
-
-  assert( p->isEof==0 );
-  switch( iCol ){
-    case 0: /* term */
-      sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
-      break;
-
-    case 1: /* col */
-      if( p->iCol ){
-        sqlite3_result_int(pCtx, p->iCol-1);
-      }else{
-        sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC);
-      }
-      break;
-
-    case 2: /* documents */
-      sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
-      break;
-
-    case 3: /* occurrences */
-      sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
-      break;
-
-    default: /* languageid */
-      assert( iCol==4 );
-      sqlite3_result_int(pCtx, p->iLangid);
-      break;
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** xRowid - Return the current rowid for the cursor.
-*/
-static int fts3auxRowidMethod(
-  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
-  sqlite_int64 *pRowid            /* OUT: Rowid value */
-){
-  Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
-  *pRowid = pCsr->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Register the fts3aux module with database connection db. Return SQLITE_OK
-** if successful or an error code if sqlite3_create_module() fails.
-*/
-int sqlite3Fts3InitAux(sqlite3 *db){
-  static const sqlite3_module fts3aux_module = {
-     0,                           /* iVersion      */
-     fts3auxConnectMethod,        /* xCreate       */
-     fts3auxConnectMethod,        /* xConnect      */
-     fts3auxBestIndexMethod,      /* xBestIndex    */
-     fts3auxDisconnectMethod,     /* xDisconnect   */
-     fts3auxDisconnectMethod,     /* xDestroy      */
-     fts3auxOpenMethod,           /* xOpen         */
-     fts3auxCloseMethod,          /* xClose        */
-     fts3auxFilterMethod,         /* xFilter       */
-     fts3auxNextMethod,           /* xNext         */
-     fts3auxEofMethod,            /* xEof          */
-     fts3auxColumnMethod,         /* xColumn       */
-     fts3auxRowidMethod,          /* xRowid        */
-     0,                           /* xUpdate       */
-     0,                           /* xBegin        */
-     0,                           /* xSync         */
-     0,                           /* xCommit       */
-     0,                           /* xRollback     */
-     0,                           /* xFindFunction */
-     0,                           /* xRename       */
-     0,                           /* xSavepoint    */
-     0,                           /* xRelease      */
-     0,                           /* xRollbackTo   */
-     0                            /* xShadowName   */
-  };
-  int rc;                         /* Return code */
-
-  rc = sqlite3_create_module(db, "fts4aux", &fts3aux_module, 0);
-  return rc;
-}
-
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */

ext/fts3/fts3_expr.h

@@ -0,0 +1,96 @@
+/*
+** 2008 Nov 28
+**
+** 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.
+**
+******************************************************************************
+**
+*/
+
+#include "fts3_tokenizer.h"
+#include "sqlite3.h"
+
+/*
+** The following describes the syntax supported by the fts3 MATCH
+** operator in a similar format to that used by the lemon parser
+** generator. This module does not use actually lemon, it uses a
+** custom parser.
+**
+**   query ::= andexpr (OR andexpr)*.
+**
+**   andexpr ::= notexpr (AND? notexpr)*.
+**
+**   notexpr ::= nearexpr (NOT nearexpr|-TOKEN)*.
+**   notexpr ::= LP query RP.
+**
+**   nearexpr ::= phrase (NEAR distance_opt nearexpr)*.
+**
+**   distance_opt ::= .
+**   distance_opt ::= / INTEGER.
+**
+**   phrase ::= TOKEN.
+**   phrase ::= COLUMN:TOKEN.
+**   phrase ::= "TOKEN TOKEN TOKEN...".
+*/
+
+typedef struct Fts3Expr Fts3Expr;
+typedef struct Fts3Phrase Fts3Phrase;
+
+/*
+** A "phrase" is a sequence of one or more tokens that must match in
+** sequence.  A single token is the base case and the most common case.
+** For a sequence of tokens contained in "...", nToken will be the number
+** of tokens in the string.
+*/
+struct Fts3Phrase {
+  int nToken;          /* Number of tokens in the phrase */
+  int iColumn;         /* Index of column this phrase must match */
+  int isNot;           /* Phrase prefixed by unary not (-) operator */
+  struct PhraseToken {
+    char *z;              /* Text of the token */
+    int n;                /* Number of bytes in buffer pointed to by z */
+    int isPrefix;         /* True if token ends in with a "*" character */
+  } aToken[1];         /* One entry for each token in the phrase */
+};
+
+/*
+** A tree of these objects forms the RHS of a MATCH operator.
+*/
+struct Fts3Expr {
+  int eType;                 /* One of the FTSQUERY_XXX values defined below */
+  int nNear;                 /* Valid if eType==FTSQUERY_NEAR */
+  Fts3Expr *pParent;         /* pParent->pLeft==this or pParent->pRight==this */
+  Fts3Expr *pLeft;           /* Left operand */
+  Fts3Expr *pRight;          /* Right operand */
+  Fts3Phrase *pPhrase;       /* Valid if eType==FTSQUERY_PHRASE */
+};
+
+int sqlite3Fts3ExprParse(sqlite3_tokenizer *, char **, int, int, 
+                         const char *, int, Fts3Expr **);
+void sqlite3Fts3ExprFree(Fts3Expr *);
+
+/*
+** Candidate values for Fts3Query.eType. Note that the order of the first
+** four values is in order of precedence when parsing expressions. For 
+** example, the following:
+**
+**   "a OR b AND c NOT d NEAR e"
+**
+** is equivalent to:
+**
+**   "a OR (b AND (c NOT (d NEAR e)))"
+*/
+#define FTSQUERY_NEAR   1
+#define FTSQUERY_NOT    2
+#define FTSQUERY_AND    3
+#define FTSQUERY_OR     4
+#define FTSQUERY_PHRASE 5
+
+#ifdef SQLITE_TEST
+void sqlite3Fts3ExprInitTestInterface(sqlite3 *db);
+#endif

ext/fts3/fts3_hash.c

@@ -23,20 +23,20 @@
 **     * The FTS3 module is being built into the core of
 **       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
 */
-#include "fts3Int.h"
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "sqlite3.h"
 #include "fts3_hash.h"
 
 /*
 ** Malloc and Free functions
 */
-static void *fts3HashMalloc(sqlite3_int64 n){
-  void *p = sqlite3_malloc64(n);
+static void *fts3HashMalloc(int n){
+  void *p = sqlite3_malloc(n);
   if( p ){
     memset(p, 0, n);
   }
@@ -56,7 +56,7 @@ static void fts3HashFree(void *p){
 ** true if the hash table should make its own private copy of keys and
 ** false if it should just use the supplied pointer.
 */
-void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
+void sqlite3Fts3HashInit(fts3Hash *pNew, int keyClass, int copyKey){
   assert( pNew!=0 );
   assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
   pNew->keyClass = keyClass;
@@ -71,8 +71,8 @@ void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
 ** Call this routine to delete a hash table or to reset a hash table
 ** to the empty state.
 */
-void sqlite3Fts3HashClear(Fts3Hash *pH){
-  Fts3HashElem *elem;         /* For looping over all elements of the table */
+void sqlite3Fts3HashClear(fts3Hash *pH){
+  fts3HashElem *elem;         /* For looping over all elements of the table */
 
   assert( pH!=0 );
   elem = pH->first;
@@ -81,7 +81,7 @@ void sqlite3Fts3HashClear(Fts3Hash *pH){
   pH->ht = 0;
   pH->htsize = 0;
   while( elem ){
-    Fts3HashElem *next_elem = elem->next;
+    fts3HashElem *next_elem = elem->next;
     if( pH->copyKey && elem->pKey ){
       fts3HashFree(elem->pKey);
     }
@@ -96,13 +96,13 @@ void sqlite3Fts3HashClear(Fts3Hash *pH){
 */
 static int fts3StrHash(const void *pKey, int nKey){
   const char *z = (const char *)pKey;
-  unsigned h = 0;
+  int h = 0;
   if( nKey<=0 ) nKey = (int) strlen(z);
   while( nKey > 0  ){
     h = (h<<3) ^ h ^ *z++;
     nKey--;
   }
-  return (int)(h & 0x7fffffff);
+  return h & 0x7fffffff;
 }
 static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
   if( n1!=n2 ) return 1;
@@ -164,11 +164,11 @@ static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){
 /* Link an element into the hash table
 */
 static void fts3HashInsertElement(
-  Fts3Hash *pH,            /* The complete hash table */
+  fts3Hash *pH,            /* The complete hash table */
   struct _fts3ht *pEntry,  /* The entry into which pNew is inserted */
-  Fts3HashElem *pNew       /* The element to be inserted */
+  fts3HashElem *pNew       /* The element to be inserted */
 ){
-  Fts3HashElem *pHead;     /* First element already in pEntry */
+  fts3HashElem *pHead;     /* First element already in pEntry */
   pHead = pEntry->chain;
   if( pHead ){
     pNew->next = pHead;
@@ -190,17 +190,15 @@ static void fts3HashInsertElement(
 /* Resize the hash table so that it cantains "new_size" buckets.
 ** "new_size" must be a power of 2.  The hash table might fail 
 ** to resize if sqliteMalloc() fails.
-**
-** Return non-zero if a memory allocation error occurs.
 */
-static int fts3Rehash(Fts3Hash *pH, int new_size){
+static void fts3Rehash(fts3Hash *pH, int new_size){
   struct _fts3ht *new_ht;          /* The new hash table */
-  Fts3HashElem *elem, *next_elem;  /* For looping over existing elements */
+  fts3HashElem *elem, *next_elem;  /* For looping over existing elements */
   int (*xHash)(const void*,int);   /* The hash function */
 
   assert( (new_size & (new_size-1))==0 );
   new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) );
-  if( new_ht==0 ) return 1;
+  if( new_ht==0 ) return;
   fts3HashFree(pH->ht);
   pH->ht = new_ht;
   pH->htsize = new_size;
@@ -210,20 +208,19 @@ static int fts3Rehash(Fts3Hash *pH, int new_size){
     next_elem = elem->next;
     fts3HashInsertElement(pH, &new_ht[h], elem);
   }
-  return 0;
 }
 
 /* This function (for internal use only) locates an element in an
 ** hash table that matches the given key.  The hash for this key has
 ** already been computed and is passed as the 4th parameter.
 */
-static Fts3HashElem *fts3FindElementByHash(
-  const Fts3Hash *pH, /* The pH to be searched */
+static fts3HashElem *fts3FindElementByHash(
+  const fts3Hash *pH, /* The pH to be searched */
   const void *pKey,   /* The key we are searching for */
   int nKey,
   int h               /* The hash for this key. */
 ){
-  Fts3HashElem *elem;            /* Used to loop thru the element list */
+  fts3HashElem *elem;            /* Used to loop thru the element list */
   int count;                     /* Number of elements left to test */
   int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
 
@@ -246,8 +243,8 @@ static Fts3HashElem *fts3FindElementByHash(
 ** element and a hash on the element's key.
 */
 static void fts3RemoveElementByHash(
-  Fts3Hash *pH,         /* The pH containing "elem" */
-  Fts3HashElem* elem,   /* The element to be removed from the pH */
+  fts3Hash *pH,         /* The pH containing "elem" */
+  fts3HashElem* elem,   /* The element to be removed from the pH */
   int h                 /* Hash value for the element */
 ){
   struct _fts3ht *pEntry;
@@ -279,12 +276,13 @@ static void fts3RemoveElementByHash(
   }
 }
 
-Fts3HashElem *sqlite3Fts3HashFindElem(
-  const Fts3Hash *pH, 
-  const void *pKey, 
-  int nKey
-){
-  int h;                          /* A hash on key */
+/* Attempt to locate an element of the hash table pH with a key
+** that matches pKey,nKey.  Return the data for this element if it is
+** found, or NULL if there is no match.
+*/
+void *sqlite3Fts3HashFind(const fts3Hash *pH, const void *pKey, int nKey){
+  int h;                 /* A hash on key */
+  fts3HashElem *elem;    /* The element that matches key */
   int (*xHash)(const void*,int);  /* The hash function */
 
   if( pH==0 || pH->ht==0 ) return 0;
@@ -292,19 +290,8 @@ Fts3HashElem *sqlite3Fts3HashFindElem(
   assert( xHash!=0 );
   h = (*xHash)(pKey,nKey);
   assert( (pH->htsize & (pH->htsize-1))==0 );
-  return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
-}
-
-/* 
-** Attempt to locate an element of the hash table pH with a key
-** that matches pKey,nKey.  Return the data for this element if it is
-** found, or NULL if there is no match.
-*/
-void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
-  Fts3HashElem *pElem;            /* The element that matches key (if any) */
-
-  pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
-  return pElem ? pElem->data : 0;
+  elem = fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
+  return elem ? elem->data : 0;
 }
 
 /* Insert an element into the hash table pH.  The key is pKey,nKey
@@ -323,15 +310,15 @@ void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
 ** element corresponding to "key" is removed from the hash table.
 */
 void *sqlite3Fts3HashInsert(
-  Fts3Hash *pH,        /* The hash table to insert into */
+  fts3Hash *pH,        /* The hash table to insert into */
   const void *pKey,    /* The key */
   int nKey,            /* Number of bytes in the key */
   void *data           /* The data */
 ){
   int hraw;                 /* Raw hash value of the key */
   int h;                    /* the hash of the key modulo hash table size */
-  Fts3HashElem *elem;       /* Used to loop thru the element list */
-  Fts3HashElem *new_elem;   /* New element added to the pH */
+  fts3HashElem *elem;       /* Used to loop thru the element list */
+  fts3HashElem *new_elem;   /* New element added to the pH */
   int (*xHash)(const void*,int);  /* The hash function */
 
   assert( pH!=0 );
@@ -351,14 +338,14 @@ void *sqlite3Fts3HashInsert(
     return old_data;
   }
   if( data==0 ) return 0;
-  if( (pH->htsize==0 && fts3Rehash(pH,8))
-   || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2))
-  ){
-    pH->count = 0;
-    return data;
+  if( pH->htsize==0 ){
+    fts3Rehash(pH,8);
+    if( pH->htsize==0 ){
+      pH->count = 0;
+      return data;
+    }
   }
-  assert( pH->htsize>0 );
-  new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) );
+  new_elem = (fts3HashElem*)fts3HashMalloc( sizeof(fts3HashElem) );
   if( new_elem==0 ) return data;
   if( pH->copyKey && pKey!=0 ){
     new_elem->pKey = fts3HashMalloc( nKey );
@@ -372,6 +359,9 @@ void *sqlite3Fts3HashInsert(
   }
   new_elem->nKey = nKey;
   pH->count++;
+  if( pH->count > pH->htsize ){
+    fts3Rehash(pH,pH->htsize*2);
+  }
   assert( pH->htsize>0 );
   assert( (pH->htsize & (pH->htsize-1))==0 );
   h = hraw & (pH->htsize-1);

ext/fts3/fts3_hash.h

@@ -9,7 +9,7 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** This is the header file for the generic hash-table implementation
+** This is the header file for the generic hash-table implemenation
 ** used in SQLite.  We've modified it slightly to serve as a standalone
 ** hash table implementation for the full-text indexing module.
 **
@@ -18,8 +18,8 @@
 #define _FTS3_HASH_H_
 
 /* Forward declarations of structures. */
-typedef struct Fts3Hash Fts3Hash;
-typedef struct Fts3HashElem Fts3HashElem;
+typedef struct fts3Hash fts3Hash;
+typedef struct fts3HashElem fts3HashElem;
 
 /* A complete hash table is an instance of the following structure.
 ** The internals of this structure are intended to be opaque -- client
@@ -29,15 +29,15 @@ typedef struct Fts3HashElem Fts3HashElem;
 ** accessing this structure are really macros, so we can't really make
 ** this structure opaque.
 */
-struct Fts3Hash {
+struct fts3Hash {
   char keyClass;          /* HASH_INT, _POINTER, _STRING, _BINARY */
   char copyKey;           /* True if copy of key made on insert */
   int count;              /* Number of entries in this table */
-  Fts3HashElem *first;    /* The first element of the array */
+  fts3HashElem *first;    /* The first element of the array */
   int htsize;             /* Number of buckets in the hash table */
   struct _fts3ht {        /* the hash table */
     int count;               /* Number of entries with this hash */
-    Fts3HashElem *chain;     /* Pointer to first entry with this hash */
+    fts3HashElem *chain;     /* Pointer to first entry with this hash */
   } *ht;
 };
 
@@ -47,8 +47,8 @@ struct Fts3Hash {
 ** Again, this structure is intended to be opaque, but it can't really
 ** be opaque because it is used by macros.
 */
-struct Fts3HashElem {
-  Fts3HashElem *next, *prev; /* Next and previous elements in the table */
+struct fts3HashElem {
+  fts3HashElem *next, *prev; /* Next and previous elements in the table */
   void *data;                /* Data associated with this element */
   void *pKey; int nKey;      /* Key associated with this element */
 };
@@ -71,27 +71,25 @@ struct Fts3HashElem {
 /*
 ** Access routines.  To delete, insert a NULL pointer.
 */
-void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
-void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
-void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
-void sqlite3Fts3HashClear(Fts3Hash*);
-Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int);
+void sqlite3Fts3HashInit(fts3Hash*, int keytype, int copyKey);
+void *sqlite3Fts3HashInsert(fts3Hash*, const void *pKey, int nKey, void *pData);
+void *sqlite3Fts3HashFind(const fts3Hash*, const void *pKey, int nKey);
+void sqlite3Fts3HashClear(fts3Hash*);
 
 /*
 ** Shorthand for the functions above
 */
-#define fts3HashInit     sqlite3Fts3HashInit
-#define fts3HashInsert   sqlite3Fts3HashInsert
-#define fts3HashFind     sqlite3Fts3HashFind
-#define fts3HashClear    sqlite3Fts3HashClear
-#define fts3HashFindElem sqlite3Fts3HashFindElem
+#define fts3HashInit   sqlite3Fts3HashInit
+#define fts3HashInsert sqlite3Fts3HashInsert
+#define fts3HashFind   sqlite3Fts3HashFind
+#define fts3HashClear  sqlite3Fts3HashClear
 
 /*
 ** Macros for looping over all elements of a hash table.  The idiom is
 ** like this:
 **
-**   Fts3Hash h;
-**   Fts3HashElem *p;
+**   fts3Hash h;
+**   fts3HashElem *p;
 **   ...
 **   for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){
 **     SomeStructure *pData = fts3HashData(p);

ext/fts3/fts3_icu.c

@@ -10,8 +10,10 @@
 **
 *************************************************************************
 ** This file implements a tokenizer for fts3 based on the ICU library.
+** 
+** $Id: fts3_icu.c,v 1.3 2008/09/01 18:34:20 danielk1977 Exp $
 */
-#include "fts3Int.h"
+
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
 #ifdef SQLITE_ENABLE_ICU
 
@@ -60,7 +62,7 @@ static int icuCreate(
   if( argc>0 ){
     n = strlen(argv[0])+1;
   }
-  p = (IcuTokenizer *)sqlite3_malloc64(sizeof(IcuTokenizer)+n);
+  p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n);
   if( !p ){
     return SQLITE_NOMEM;
   }
@@ -110,16 +112,13 @@ static int icuOpen(
 
   *ppCursor = 0;
 
-  if( zInput==0 ){
-    nInput = 0;
-    zInput = "";
-  }else if( nInput<0 ){
+  if( nInput<0 ){
     nInput = strlen(zInput);
   }
   nChar = nInput+1;
-  pCsr = (IcuCursor *)sqlite3_malloc64(
+  pCsr = (IcuCursor *)sqlite3_malloc(
       sizeof(IcuCursor) +                /* IcuCursor */
-      ((nChar+3)&~3) * sizeof(UChar) +   /* IcuCursor.aChar[] */
+      nChar * sizeof(UChar) +            /* IcuCursor.aChar[] */
       (nChar+1) * sizeof(int)            /* IcuCursor.aOffset[] */
   );
   if( !pCsr ){
@@ -127,7 +126,7 @@ static int icuOpen(
   }
   memset(pCsr, 0, sizeof(IcuCursor));
   pCsr->aChar = (UChar *)&pCsr[1];
-  pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3];
+  pCsr->aOffset = (int *)&pCsr->aChar[nChar];
 
   pCsr->aOffset[iOut] = iInput;
   U8_NEXT(zInput, iInput, nInput, c); 
@@ -199,7 +198,7 @@ static int icuNext(
 
     while( iStart<iEnd ){
       int iWhite = iStart;
-      U16_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
+      U8_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
       if( u_isspace(c) ){
         iStart = iWhite;
       }else{
@@ -240,13 +239,12 @@ static int icuNext(
 ** The set of routines that implement the simple tokenizer
 */
 static const sqlite3_tokenizer_module icuTokenizerModule = {
-  0,                           /* iVersion    */
-  icuCreate,                   /* xCreate     */
-  icuDestroy,                  /* xCreate     */
-  icuOpen,                     /* xOpen       */
-  icuClose,                    /* xClose      */
-  icuNext,                     /* xNext       */
-  0,                           /* xLanguageid */
+  0,                           /* iVersion */
+  icuCreate,                   /* xCreate  */
+  icuDestroy,                  /* xCreate  */
+  icuOpen,                     /* xOpen    */
+  icuClose,                    /* xClose   */
+  icuNext,                     /* xNext    */
 };
 
 /*

ext/fts3/fts3_porter.c

@@ -22,13 +22,14 @@
 **     * The FTS3 module is being built into the core of
 **       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
 */
-#include "fts3Int.h"
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
 
+
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
 
 #include "fts3_tokenizer.h"
 
@@ -40,7 +41,7 @@ typedef struct porter_tokenizer {
 } porter_tokenizer;
 
 /*
-** Class derived from sqlite3_tokenizer_cursor
+** Class derived from sqlit3_tokenizer_cursor
 */
 typedef struct porter_tokenizer_cursor {
   sqlite3_tokenizer_cursor base;
@@ -53,6 +54,10 @@ typedef struct porter_tokenizer_cursor {
 } porter_tokenizer_cursor;
 
 
+/* Forward declaration */
+static const sqlite3_tokenizer_module porterTokenizerModule;
+
+
 /*
 ** Create a new tokenizer instance.
 */
@@ -61,10 +66,6 @@ static int porterCreate(
   sqlite3_tokenizer **ppTokenizer
 ){
   porter_tokenizer *t;
-
-  UNUSED_PARAMETER(argc);
-  UNUSED_PARAMETER(argv);
-
   t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t));
   if( t==NULL ) return SQLITE_NOMEM;
   memset(t, 0, sizeof(*t));
@@ -93,8 +94,6 @@ static int porterOpen(
 ){
   porter_tokenizer_cursor *c;
 
-  UNUSED_PARAMETER(pTokenizer);
-
   c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
   if( c==NULL ) return SQLITE_NOMEM;
 
@@ -183,7 +182,7 @@ static int isVowel(const char *z){
 ** by a consonant.
 **
 ** In this routine z[] is in reverse order.  So we are really looking
-** for an instance of a consonant followed by a vowel.
+** for an instance of of a consonant followed by a vowel.
 */
 static int m_gt_0(const char *z){
   while( isVowel(z) ){ z++; }
@@ -235,7 +234,7 @@ static int hasVowel(const char *z){
 ** the first two characters of z[].
 */
 static int doubleConsonant(const char *z){
-  return isConsonant(z) && z[0]==z[1];
+  return isConsonant(z) && z[0]==z[1] && isConsonant(z+1);
 }
 
 /*
@@ -248,10 +247,10 @@ static int doubleConsonant(const char *z){
 */
 static int star_oh(const char *z){
   return
-    isConsonant(z) &&
+    z[0]!=0 && isConsonant(z) &&
     z[0]!='w' && z[0]!='x' && z[0]!='y' &&
-    isVowel(z+1) &&
-    isConsonant(z+2);
+    z[1]!=0 && isVowel(z+1) &&
+    z[2]!=0 && isConsonant(z+2);
 }
 
 /*
@@ -295,7 +294,7 @@ static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
   int i, mx, j;
   int hasDigit = 0;
   for(i=0; i<nIn; i++){
-    char c = zIn[i];
+    int c = zIn[i];
     if( c>='A' && c<='Z' ){
       zOut[i] = c - 'A' + 'a';
     }else{
@@ -339,17 +338,17 @@ static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
 ** no chance of overflowing the zOut buffer.
 */
 static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
-  int i, j;
+  int i, j, c;
   char zReverse[28];
   char *z, *z2;
-  if( nIn<3 || nIn>=(int)sizeof(zReverse)-7 ){
+  if( nIn<3 || nIn>=sizeof(zReverse)-7 ){
     /* The word is too big or too small for the porter stemmer.
     ** Fallback to the copy stemmer */
     copy_stemmer(zIn, nIn, zOut, pnOut);
     return;
   }
   for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
-    char c = zIn[i];
+    c = zIn[i];
     if( c>='A' && c<='Z' ){
       zReverse[j] = c + 'a' - 'A';
     }else if( c>='a' && c<='z' ){
@@ -403,14 +402,12 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
   /* Step 2 */
   switch( z[1] ){
    case 'a':
-     if( !stem(&z, "lanoita", "ate", m_gt_0) ){
-       stem(&z, "lanoit", "tion", m_gt_0);
-     }
+     stem(&z, "lanoita", "ate", m_gt_0) ||
+     stem(&z, "lanoit", "tion", m_gt_0);
      break;
    case 'c':
-     if( !stem(&z, "icne", "ence", m_gt_0) ){
-       stem(&z, "icna", "ance", m_gt_0);
-     }
+     stem(&z, "icne", "ence", m_gt_0) ||
+     stem(&z, "icna", "ance", m_gt_0);
      break;
    case 'e':
      stem(&z, "rezi", "ize", m_gt_0);
@@ -419,54 +416,43 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
      stem(&z, "igol", "log", m_gt_0);
      break;
    case 'l':
-     if( !stem(&z, "ilb", "ble", m_gt_0) 
-      && !stem(&z, "illa", "al", m_gt_0)
-      && !stem(&z, "iltne", "ent", m_gt_0)
-      && !stem(&z, "ile", "e", m_gt_0)
-     ){
-       stem(&z, "ilsuo", "ous", m_gt_0);
-     }
+     stem(&z, "ilb", "ble", m_gt_0) ||
+     stem(&z, "illa", "al", m_gt_0) ||
+     stem(&z, "iltne", "ent", m_gt_0) ||
+     stem(&z, "ile", "e", m_gt_0) ||
+     stem(&z, "ilsuo", "ous", m_gt_0);
      break;
    case 'o':
-     if( !stem(&z, "noitazi", "ize", m_gt_0)
-      && !stem(&z, "noita", "ate", m_gt_0)
-     ){
-       stem(&z, "rota", "ate", m_gt_0);
-     }
+     stem(&z, "noitazi", "ize", m_gt_0) ||
+     stem(&z, "noita", "ate", m_gt_0) ||
+     stem(&z, "rota", "ate", m_gt_0);
      break;
    case 's':
-     if( !stem(&z, "msila", "al", m_gt_0)
-      && !stem(&z, "ssenevi", "ive", m_gt_0)
-      && !stem(&z, "ssenluf", "ful", m_gt_0)
-     ){
-       stem(&z, "ssensuo", "ous", m_gt_0);
-     }
+     stem(&z, "msila", "al", m_gt_0) ||
+     stem(&z, "ssenevi", "ive", m_gt_0) ||
+     stem(&z, "ssenluf", "ful", m_gt_0) ||
+     stem(&z, "ssensuo", "ous", m_gt_0);
      break;
    case 't':
-     if( !stem(&z, "itila", "al", m_gt_0)
-      && !stem(&z, "itivi", "ive", m_gt_0)
-     ){
-       stem(&z, "itilib", "ble", m_gt_0);
-     }
+     stem(&z, "itila", "al", m_gt_0) ||
+     stem(&z, "itivi", "ive", m_gt_0) ||
+     stem(&z, "itilib", "ble", m_gt_0);
      break;
   }
 
   /* Step 3 */
   switch( z[0] ){
    case 'e':
-     if( !stem(&z, "etaci", "ic", m_gt_0)
-      && !stem(&z, "evita", "", m_gt_0)
-     ){
-       stem(&z, "ezila", "al", m_gt_0);
-     }
+     stem(&z, "etaci", "ic", m_gt_0) ||
+     stem(&z, "evita", "", m_gt_0)   ||
+     stem(&z, "ezila", "al", m_gt_0);
      break;
    case 'i':
      stem(&z, "itici", "ic", m_gt_0);
      break;
    case 'l':
-     if( !stem(&z, "laci", "ic", m_gt_0) ){
-       stem(&z, "luf", "", m_gt_0);
-     }
+     stem(&z, "laci", "ic", m_gt_0) ||
+     stem(&z, "luf", "", m_gt_0);
      break;
    case 's':
      stem(&z, "ssen", "", m_gt_0);
@@ -507,11 +493,9 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
            z += 3;
          }
        }else if( z[2]=='e' ){
-         if( !stem(&z, "tneme", "", m_gt_1)
-          && !stem(&z, "tnem", "", m_gt_1)
-         ){
-           stem(&z, "tne", "", m_gt_1);
-         }
+         stem(&z, "tneme", "", m_gt_1) ||
+         stem(&z, "tnem", "", m_gt_1) ||
+         stem(&z, "tne", "", m_gt_1);
        }
      }
      break;
@@ -530,9 +514,8 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
      }
      break;
    case 't':
-     if( !stem(&z, "eta", "", m_gt_1) ){
-       stem(&z, "iti", "", m_gt_1);
-     }
+     stem(&z, "eta", "", m_gt_1) ||
+     stem(&z, "iti", "", m_gt_1);
      break;
    case 'u':
      if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
@@ -564,7 +547,7 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
   /* z[] is now the stemmed word in reverse order.  Flip it back
   ** around into forward order and return.
   */
-  *pnOut = i = (int)strlen(z);
+  *pnOut = i = strlen(z);
   zOut[i] = 0;
   while( *z ){
     zOut[--i] = *(z++);
@@ -619,11 +602,9 @@ static int porterNext(
     if( c->iOffset>iStartOffset ){
       int n = c->iOffset-iStartOffset;
       if( n>c->nAllocated ){
-        char *pNew;
         c->nAllocated = n+20;
-        pNew = sqlite3_realloc(c->zToken, c->nAllocated);
-        if( !pNew ) return SQLITE_NOMEM;
-        c->zToken = pNew;
+        c->zToken = sqlite3_realloc(c->zToken, c->nAllocated);
+        if( c->zToken==NULL ) return SQLITE_NOMEM;
       }
       porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
       *pzToken = c->zToken;
@@ -646,7 +627,6 @@ static const sqlite3_tokenizer_module porterTokenizerModule = {
   porterOpen,
   porterClose,
   porterNext,
-  0
 };
 
 /*

ext/fts3/fts3_term.c

@@ -1,374 +0,0 @@
-/*
-** 2011 Jan 27
-**
-** 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.
-**
-******************************************************************************
-**
-** This file is not part of the production FTS code. It is only used for
-** testing. It contains a virtual table implementation that provides direct 
-** access to the full-text index of an FTS table. 
-*/
-
-#include "fts3Int.h"
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
-#ifdef SQLITE_TEST
-
-#include <string.h>
-#include <assert.h>
-#include <stdlib.h>
-
-typedef struct Fts3termTable Fts3termTable;
-typedef struct Fts3termCursor Fts3termCursor;
-
-struct Fts3termTable {
-  sqlite3_vtab base;              /* Base class used by SQLite core */
-  int iIndex;                     /* Index for Fts3Table.aIndex[] */
-  Fts3Table *pFts3Tab;
-};
-
-struct Fts3termCursor {
-  sqlite3_vtab_cursor base;       /* Base class used by SQLite core */
-  Fts3MultiSegReader csr;        /* Must be right after "base" */
-  Fts3SegFilter filter;
-
-  int isEof;                      /* True if cursor is at EOF */
-  char *pNext;
-
-  sqlite3_int64 iRowid;           /* Current 'rowid' value */
-  sqlite3_int64 iDocid;           /* Current 'docid' value */
-  int iCol;                       /* Current 'col' value */
-  int iPos;                       /* Current 'pos' value */
-};
-
-/*
-** Schema of the terms table.
-*/
-#define FTS3_TERMS_SCHEMA "CREATE TABLE x(term, docid, col, pos)"
-
-/*
-** This function does all the work for both the xConnect and xCreate methods.
-** These tables have no persistent representation of their own, so xConnect
-** and xCreate are identical operations.
-*/
-static int fts3termConnectMethod(
-  sqlite3 *db,                    /* Database connection */
-  void *pCtx,                     /* Non-zero for an fts4prefix table */
-  int argc,                       /* Number of elements in argv array */
-  const char * const *argv,       /* xCreate/xConnect argument array */
-  sqlite3_vtab **ppVtab,          /* OUT: New sqlite3_vtab object */
-  char **pzErr                    /* OUT: sqlite3_malloc'd error message */
-){
-  char const *zDb;                /* Name of database (e.g. "main") */
-  char const *zFts3;              /* Name of fts3 table */
-  int nDb;                        /* Result of strlen(zDb) */
-  int nFts3;                      /* Result of strlen(zFts3) */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate here */
-  int rc;                         /* value returned by declare_vtab() */
-  Fts3termTable *p;               /* Virtual table object to return */
-  int iIndex = 0;
-
-  UNUSED_PARAMETER(pCtx);
-  if( argc==5 ){
-    iIndex = atoi(argv[4]);
-    argc--;
-  }
-
-  /* The user should specify a single argument - the name of an fts3 table. */
-  if( argc!=4 ){
-    sqlite3Fts3ErrMsg(pzErr,
-        "wrong number of arguments to fts4term constructor"
-    );
-    return SQLITE_ERROR;
-  }
-
-  zDb = argv[1]; 
-  nDb = (int)strlen(zDb);
-  zFts3 = argv[3];
-  nFts3 = (int)strlen(zFts3);
-
-  rc = sqlite3_declare_vtab(db, FTS3_TERMS_SCHEMA);
-  if( rc!=SQLITE_OK ) return rc;
-
-  nByte = sizeof(Fts3termTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
-  p = (Fts3termTable *)sqlite3_malloc64(nByte);
-  if( !p ) return SQLITE_NOMEM;
-  memset(p, 0, (size_t)nByte);
-
-  p->pFts3Tab = (Fts3Table *)&p[1];
-  p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
-  p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
-  p->pFts3Tab->db = db;
-  p->pFts3Tab->nIndex = iIndex+1;
-  p->iIndex = iIndex;
-
-  memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
-  memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
-  sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
-
-  *ppVtab = (sqlite3_vtab *)p;
-  return SQLITE_OK;
-}
-
-/*
-** This function does the work for both the xDisconnect and xDestroy methods.
-** These tables have no persistent representation of their own, so xDisconnect
-** and xDestroy are identical operations.
-*/
-static int fts3termDisconnectMethod(sqlite3_vtab *pVtab){
-  Fts3termTable *p = (Fts3termTable *)pVtab;
-  Fts3Table *pFts3 = p->pFts3Tab;
-  int i;
-
-  /* Free any prepared statements held */
-  for(i=0; i<SizeofArray(pFts3->aStmt); i++){
-    sqlite3_finalize(pFts3->aStmt[i]);
-  }
-  sqlite3_free(pFts3->zSegmentsTbl);
-  sqlite3_free(p);
-  return SQLITE_OK;
-}
-
-#define FTS4AUX_EQ_CONSTRAINT 1
-#define FTS4AUX_GE_CONSTRAINT 2
-#define FTS4AUX_LE_CONSTRAINT 4
-
-/*
-** xBestIndex - Analyze a WHERE and ORDER BY clause.
-*/
-static int fts3termBestIndexMethod(
-  sqlite3_vtab *pVTab, 
-  sqlite3_index_info *pInfo
-){
-  UNUSED_PARAMETER(pVTab);
-
-  /* This vtab naturally does "ORDER BY term, docid, col, pos".  */
-  if( pInfo->nOrderBy ){
-    int i;
-    for(i=0; i<pInfo->nOrderBy; i++){
-      if( pInfo->aOrderBy[i].iColumn!=i || pInfo->aOrderBy[i].desc ) break;
-    }
-    if( i==pInfo->nOrderBy ){
-      pInfo->orderByConsumed = 1;
-    }
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** xOpen - Open a cursor.
-*/
-static int fts3termOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
-  Fts3termCursor *pCsr;            /* Pointer to cursor object to return */
-
-  UNUSED_PARAMETER(pVTab);
-
-  pCsr = (Fts3termCursor *)sqlite3_malloc(sizeof(Fts3termCursor));
-  if( !pCsr ) return SQLITE_NOMEM;
-  memset(pCsr, 0, sizeof(Fts3termCursor));
-
-  *ppCsr = (sqlite3_vtab_cursor *)pCsr;
-  return SQLITE_OK;
-}
-
-/*
-** xClose - Close a cursor.
-*/
-static int fts3termCloseMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3Table *pFts3 = ((Fts3termTable *)pCursor->pVtab)->pFts3Tab;
-  Fts3termCursor *pCsr = (Fts3termCursor *)pCursor;
-
-  sqlite3Fts3SegmentsClose(pFts3);
-  sqlite3Fts3SegReaderFinish(&pCsr->csr);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-/*
-** xNext - Advance the cursor to the next row, if any.
-*/
-static int fts3termNextMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3termCursor *pCsr = (Fts3termCursor *)pCursor;
-  Fts3Table *pFts3 = ((Fts3termTable *)pCursor->pVtab)->pFts3Tab;
-  int rc;
-  sqlite3_int64 v;
-
-  /* Increment our pretend rowid value. */
-  pCsr->iRowid++;
-
-  /* Advance to the next term in the full-text index. */
-  if( pCsr->csr.aDoclist==0 
-   || pCsr->pNext>=&pCsr->csr.aDoclist[pCsr->csr.nDoclist-1]
-  ){
-    rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr);
-    if( rc!=SQLITE_ROW ){
-      pCsr->isEof = 1;
-      return rc;
-    }
-
-    pCsr->iCol = 0;
-    pCsr->iPos = 0;
-    pCsr->iDocid = 0;
-    pCsr->pNext = pCsr->csr.aDoclist;
-
-    /* Read docid */
-    pCsr->pNext += sqlite3Fts3GetVarint(pCsr->pNext, &pCsr->iDocid);
-  }
-
-  pCsr->pNext += sqlite3Fts3GetVarint(pCsr->pNext, &v);
-  if( v==0 ){
-    pCsr->pNext += sqlite3Fts3GetVarint(pCsr->pNext, &v);
-    pCsr->iDocid += v;
-    pCsr->pNext += sqlite3Fts3GetVarint(pCsr->pNext, &v);
-    pCsr->iCol = 0;
-    pCsr->iPos = 0;
-  }
-
-  if( v==1 ){
-    pCsr->pNext += sqlite3Fts3GetVarint(pCsr->pNext, &v);
-    pCsr->iCol += (int)v;
-    pCsr->iPos = 0;
-    pCsr->pNext += sqlite3Fts3GetVarint(pCsr->pNext, &v);
-  }
-
-  pCsr->iPos += (int)(v - 2);
-
-  return SQLITE_OK;
-}
-
-/*
-** xFilter - Initialize a cursor to point at the start of its data.
-*/
-static int fts3termFilterMethod(
-  sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
-  int idxNum,                     /* Strategy index */
-  const char *idxStr,             /* Unused */
-  int nVal,                       /* Number of elements in apVal */
-  sqlite3_value **apVal           /* Arguments for the indexing scheme */
-){
-  Fts3termCursor *pCsr = (Fts3termCursor *)pCursor;
-  Fts3termTable *p = (Fts3termTable *)pCursor->pVtab;
-  Fts3Table *pFts3 = p->pFts3Tab;
-  int rc;
-
-  UNUSED_PARAMETER(nVal);
-  UNUSED_PARAMETER(idxNum);
-  UNUSED_PARAMETER(idxStr);
-  UNUSED_PARAMETER(apVal);
-
-  assert( idxStr==0 && idxNum==0 );
-
-  /* In case this cursor is being reused, close and zero it. */
-  testcase(pCsr->filter.zTerm);
-  sqlite3Fts3SegReaderFinish(&pCsr->csr);
-  memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
-
-  pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
-  pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
-
-  rc = sqlite3Fts3SegReaderCursor(pFts3, 0, p->iIndex, FTS3_SEGCURSOR_ALL,
-      pCsr->filter.zTerm, pCsr->filter.nTerm, 0, 1, &pCsr->csr
-  );
-  if( rc==SQLITE_OK ){
-    rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
-  }
-  if( rc==SQLITE_OK ){
-    rc = fts3termNextMethod(pCursor);
-  }
-  return rc;
-}
-
-/*
-** xEof - Return true if the cursor is at EOF, or false otherwise.
-*/
-static int fts3termEofMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3termCursor *pCsr = (Fts3termCursor *)pCursor;
-  return pCsr->isEof;
-}
-
-/*
-** xColumn - Return a column value.
-*/
-static int fts3termColumnMethod(
-  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
-  sqlite3_context *pCtx,          /* Context for sqlite3_result_xxx() calls */
-  int iCol                        /* Index of column to read value from */
-){
-  Fts3termCursor *p = (Fts3termCursor *)pCursor;
-
-  assert( iCol>=0 && iCol<=3 );
-  switch( iCol ){
-    case 0:
-      sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
-      break;
-    case 1:
-      sqlite3_result_int64(pCtx, p->iDocid);
-      break;
-    case 2:
-      sqlite3_result_int64(pCtx, p->iCol);
-      break;
-    default:
-      sqlite3_result_int64(pCtx, p->iPos);
-      break;
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** xRowid - Return the current rowid for the cursor.
-*/
-static int fts3termRowidMethod(
-  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
-  sqlite_int64 *pRowid            /* OUT: Rowid value */
-){
-  Fts3termCursor *pCsr = (Fts3termCursor *)pCursor;
-  *pRowid = pCsr->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Register the fts3term module with database connection db. Return SQLITE_OK
-** if successful or an error code if sqlite3_create_module() fails.
-*/
-int sqlite3Fts3InitTerm(sqlite3 *db){
-  static const sqlite3_module fts3term_module = {
-     0,                           /* iVersion      */
-     fts3termConnectMethod,       /* xCreate       */
-     fts3termConnectMethod,       /* xConnect      */
-     fts3termBestIndexMethod,     /* xBestIndex    */
-     fts3termDisconnectMethod,    /* xDisconnect   */
-     fts3termDisconnectMethod,    /* xDestroy      */
-     fts3termOpenMethod,          /* xOpen         */
-     fts3termCloseMethod,         /* xClose        */
-     fts3termFilterMethod,        /* xFilter       */
-     fts3termNextMethod,          /* xNext         */
-     fts3termEofMethod,           /* xEof          */
-     fts3termColumnMethod,        /* xColumn       */
-     fts3termRowidMethod,         /* xRowid        */
-     0,                           /* xUpdate       */
-     0,                           /* xBegin        */
-     0,                           /* xSync         */
-     0,                           /* xCommit       */
-     0,                           /* xRollback     */
-     0,                           /* xFindFunction */
-     0,                           /* xRename       */
-     0,                           /* xSavepoint    */
-     0,                           /* xRelease      */
-     0,                           /* xRollbackTo   */
-     0                            /* xShadowName   */
-  };
-  int rc;                         /* Return code */
-
-  rc = sqlite3_create_module(db, "fts4term", &fts3term_module, 0);
-  return rc;
-}
-
-#endif
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */

ext/fts3/fts3_test.c

@@ -1,621 +0,0 @@
-/*
-** 2011 Jun 13
-**
-** 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.
-**
-******************************************************************************
-**
-** This file is not part of the production FTS code. It is only used for
-** testing. It contains a Tcl command that can be used to test if a document
-** matches an FTS NEAR expression.
-**
-** As of March 2012, it also contains a version 1 tokenizer used for testing
-** that the sqlite3_tokenizer_module.xLanguage() method is invoked correctly.
-*/
-
-#if defined(INCLUDE_SQLITE_TCL_H)
-#  include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#  ifndef SQLITE_TCLAPI
-#    define SQLITE_TCLAPI
-#  endif
-#endif
-#include <string.h>
-#include <assert.h>
-
-#if defined(SQLITE_TEST)
-#if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
-
-/* Required so that the "ifdef SQLITE_ENABLE_FTS3" below works */
-#include "fts3Int.h"
-
-#define NM_MAX_TOKEN 12
-
-typedef struct NearPhrase NearPhrase;
-typedef struct NearDocument NearDocument;
-typedef struct NearToken NearToken;
-
-struct NearDocument {
-  int nToken;                     /* Length of token in bytes */
-  NearToken *aToken;              /* Token array */
-};
-
-struct NearToken {
-  int n;                          /* Length of token in bytes */
-  const char *z;                  /* Pointer to token string */
-};
-
-struct NearPhrase {
-  int nNear;                      /* Preceding NEAR value */
-  int nToken;                     /* Number of tokens in this phrase */
-  NearToken aToken[NM_MAX_TOKEN]; /* Array of tokens in this phrase */
-};
-
-static int nm_phrase_match(
-  NearPhrase *p,
-  NearToken *aToken
-){
-  int ii;
-
-  for(ii=0; ii<p->nToken; ii++){
-    NearToken *pToken = &p->aToken[ii];
-    if( pToken->n>0 && pToken->z[pToken->n-1]=='*' ){
-      if( aToken[ii].n<(pToken->n-1) ) return 0;
-      if( memcmp(aToken[ii].z, pToken->z, pToken->n-1) ) return 0;
-    }else{
-      if( aToken[ii].n!=pToken->n ) return 0;
-      if( memcmp(aToken[ii].z, pToken->z, pToken->n) ) return 0;
-    }
-  }
-
-  return 1;
-}
-
-static int nm_near_chain(
-  int iDir,                       /* Direction to iterate through aPhrase[] */
-  NearDocument *pDoc,             /* Document to match against */
-  int iPos,                       /* Position at which iPhrase was found */
-  int nPhrase,                    /* Size of phrase array */
-  NearPhrase *aPhrase,            /* Phrase array */
-  int iPhrase                     /* Index of phrase found */
-){
-  int iStart;
-  int iStop;
-  int ii;
-  int nNear;
-  int iPhrase2;
-  NearPhrase *p;
-  NearPhrase *pPrev;
-
-  assert( iDir==1 || iDir==-1 );
-
-  if( iDir==1 ){
-    if( (iPhrase+1)==nPhrase ) return 1;
-    nNear = aPhrase[iPhrase+1].nNear;
-  }else{
-    if( iPhrase==0 ) return 1;
-    nNear = aPhrase[iPhrase].nNear;
-  }
-  pPrev = &aPhrase[iPhrase];
-  iPhrase2 = iPhrase+iDir;
-  p = &aPhrase[iPhrase2];
-
-  iStart = iPos - nNear - p->nToken;
-  iStop = iPos + nNear + pPrev->nToken;
-
-  if( iStart<0 ) iStart = 0;
-  if( iStop > pDoc->nToken - p->nToken ) iStop = pDoc->nToken - p->nToken;
-
-  for(ii=iStart; ii<=iStop; ii++){
-    if( nm_phrase_match(p, &pDoc->aToken[ii]) ){
-      if( nm_near_chain(iDir, pDoc, ii, nPhrase, aPhrase, iPhrase2) ) return 1;
-    }
-  }
-
-  return 0;
-}
-
-static int nm_match_count(
-  NearDocument *pDoc,             /* Document to match against */
-  int nPhrase,                    /* Size of phrase array */
-  NearPhrase *aPhrase,            /* Phrase array */
-  int iPhrase                     /* Index of phrase to count matches for */
-){
-  int nOcc = 0;
-  int ii;
-  NearPhrase *p = &aPhrase[iPhrase];
-
-  for(ii=0; ii<(pDoc->nToken + 1 - p->nToken); ii++){
-    if( nm_phrase_match(p, &pDoc->aToken[ii]) ){
-      /* Test forward NEAR chain (i>iPhrase) */
-      if( 0==nm_near_chain(1, pDoc, ii, nPhrase, aPhrase, iPhrase) ) continue;
-
-      /* Test reverse NEAR chain (i<iPhrase) */
-      if( 0==nm_near_chain(-1, pDoc, ii, nPhrase, aPhrase, iPhrase) ) continue;
-
-      /* This is a real match. Increment the counter. */
-      nOcc++;
-    }
-  } 
-
-  return nOcc;
-}
-
-/*
-** Tclcmd: fts3_near_match DOCUMENT EXPR ?OPTIONS?
-*/
-static int SQLITE_TCLAPI fts3_near_match_cmd(
-  ClientData clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  int nTotal = 0;
-  int rc;
-  int ii;
-  int nPhrase;
-  NearPhrase *aPhrase = 0;
-  NearDocument doc = {0, 0};
-  Tcl_Obj **apDocToken;
-  Tcl_Obj *pRet;
-  Tcl_Obj *pPhrasecount = 0;
-  
-  Tcl_Obj **apExprToken;
-  int nExprToken;
-
-  UNUSED_PARAMETER(clientData);
-
-  /* Must have 3 or more arguments. */
-  if( objc<3 || (objc%2)==0 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "DOCUMENT EXPR ?OPTION VALUE?...");
-    rc = TCL_ERROR;
-    goto near_match_out;
-  }
-
-  for(ii=3; ii<objc; ii+=2){
-    enum NM_enum { NM_PHRASECOUNTS };
-    struct TestnmSubcmd {
-      char *zName;
-      enum NM_enum eOpt;
-    } aOpt[] = {
-      { "-phrasecountvar", NM_PHRASECOUNTS },
-      { 0, 0 }
-    };
-    int iOpt;
-    if( Tcl_GetIndexFromObjStruct(
-        interp, objv[ii], aOpt, sizeof(aOpt[0]), "option", 0, &iOpt) 
-    ){
-      return TCL_ERROR;
-    }
-
-    switch( aOpt[iOpt].eOpt ){
-      case NM_PHRASECOUNTS:
-        pPhrasecount = objv[ii+1];
-        break;
-    }
-  }
-
-  rc = Tcl_ListObjGetElements(interp, objv[1], &doc.nToken, &apDocToken);
-  if( rc!=TCL_OK ) goto near_match_out;
-  doc.aToken = (NearToken *)ckalloc(doc.nToken*sizeof(NearToken));
-  for(ii=0; ii<doc.nToken; ii++){
-    doc.aToken[ii].z = Tcl_GetStringFromObj(apDocToken[ii], &doc.aToken[ii].n);
-  }
-
-  rc = Tcl_ListObjGetElements(interp, objv[2], &nExprToken, &apExprToken);
-  if( rc!=TCL_OK ) goto near_match_out;
-
-  nPhrase = (nExprToken + 1) / 2;
-  aPhrase = (NearPhrase *)ckalloc(nPhrase * sizeof(NearPhrase));
-  memset(aPhrase, 0, nPhrase * sizeof(NearPhrase));
-  for(ii=0; ii<nPhrase; ii++){
-    Tcl_Obj *pPhrase = apExprToken[ii*2];
-    Tcl_Obj **apToken;
-    int nToken;
-    int jj;
-
-    rc = Tcl_ListObjGetElements(interp, pPhrase, &nToken, &apToken);
-    if( rc!=TCL_OK ) goto near_match_out;
-    if( nToken>NM_MAX_TOKEN ){
-      Tcl_AppendResult(interp, "Too many tokens in phrase", 0);
-      rc = TCL_ERROR;
-      goto near_match_out;
-    }
-    for(jj=0; jj<nToken; jj++){
-      NearToken *pT = &aPhrase[ii].aToken[jj];
-      pT->z = Tcl_GetStringFromObj(apToken[jj], &pT->n);
-    }
-    aPhrase[ii].nToken = nToken;
-  }
-  for(ii=1; ii<nPhrase; ii++){
-    Tcl_Obj *pNear = apExprToken[2*ii-1];
-    int nNear;
-    rc = Tcl_GetIntFromObj(interp, pNear, &nNear);
-    if( rc!=TCL_OK ) goto near_match_out;
-    aPhrase[ii].nNear = nNear;
-  }
-
-  pRet = Tcl_NewObj();
-  Tcl_IncrRefCount(pRet);
-  for(ii=0; ii<nPhrase; ii++){
-    int nOcc = nm_match_count(&doc, nPhrase, aPhrase, ii);
-    Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(nOcc));
-    nTotal += nOcc;
-  }
-  if( pPhrasecount ){
-    Tcl_ObjSetVar2(interp, pPhrasecount, 0, pRet, 0);
-  }
-  Tcl_DecrRefCount(pRet);
-  Tcl_SetObjResult(interp, Tcl_NewBooleanObj(nTotal>0));
-
- near_match_out: 
-  ckfree((char *)aPhrase);
-  ckfree((char *)doc.aToken);
-  return rc;
-}
-
-/*
-**   Tclcmd: fts3_configure_incr_load ?CHUNKSIZE THRESHOLD?
-**
-** Normally, FTS uses hard-coded values to determine the minimum doclist
-** size eligible for incremental loading, and the size of the chunks loaded
-** when a doclist is incrementally loaded. This command allows the built-in
-** values to be overridden for testing purposes.
-**
-** If present, the first argument is the chunksize in bytes to load doclists
-** in. The second argument is the minimum doclist size in bytes to use
-** incremental loading with.
-**
-** Whether or not the arguments are present, this command returns a list of
-** two integers - the initial chunksize and threshold when the command is
-** invoked. This can be used to restore the default behavior after running
-** tests. For example:
-**
-**    # Override incr-load settings for testing:
-**    set cfg [fts3_configure_incr_load $new_chunksize $new_threshold]
-**
-**    .... run tests ....
-**
-**    # Restore initial incr-load settings:
-**    eval fts3_configure_incr_load $cfg
-*/
-static int SQLITE_TCLAPI fts3_configure_incr_load_cmd(
-  ClientData clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-#ifdef SQLITE_ENABLE_FTS3
-  extern int test_fts3_node_chunksize;
-  extern int test_fts3_node_chunk_threshold;
-  Tcl_Obj *pRet;
-
-  if( objc!=1 && objc!=3 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "?CHUNKSIZE THRESHOLD?");
-    return TCL_ERROR;
-  }
-
-  pRet = Tcl_NewObj();
-  Tcl_IncrRefCount(pRet);
-  Tcl_ListObjAppendElement(
-      interp, pRet, Tcl_NewIntObj(test_fts3_node_chunksize));
-  Tcl_ListObjAppendElement(
-      interp, pRet, Tcl_NewIntObj(test_fts3_node_chunk_threshold));
-
-  if( objc==3 ){
-    int iArg1;
-    int iArg2;
-    if( Tcl_GetIntFromObj(interp, objv[1], &iArg1)
-     || Tcl_GetIntFromObj(interp, objv[2], &iArg2)
-    ){
-      Tcl_DecrRefCount(pRet);
-      return TCL_ERROR;
-    }
-    test_fts3_node_chunksize = iArg1;
-    test_fts3_node_chunk_threshold = iArg2;
-  }
-
-  Tcl_SetObjResult(interp, pRet);
-  Tcl_DecrRefCount(pRet);
-#endif
-  UNUSED_PARAMETER(clientData);
-  return TCL_OK;
-}
-
-#ifdef SQLITE_ENABLE_FTS3
-/**************************************************************************
-** Beginning of test tokenizer code.
-**
-** For language 0, this tokenizer is similar to the default 'simple' 
-** tokenizer. For other languages L, the following:
-**
-**   * Odd numbered languages are case-sensitive. Even numbered 
-**     languages are not.
-**
-**   * Language ids 100 or greater are considered an error.
-**
-** The implementation assumes that the input contains only ASCII characters
-** (i.e. those that may be encoded in UTF-8 using a single byte).
-*/
-typedef struct test_tokenizer {
-  sqlite3_tokenizer base;
-} test_tokenizer;
-
-typedef struct test_tokenizer_cursor {
-  sqlite3_tokenizer_cursor base;
-  const char *aInput;          /* Input being tokenized */
-  int nInput;                  /* Size of the input in bytes */
-  int iInput;                  /* Current offset in aInput */
-  int iToken;                  /* Index of next token to be returned */
-  char *aBuffer;               /* Buffer containing current token */
-  int nBuffer;                 /* Number of bytes allocated at pToken */
-  int iLangid;                 /* Configured language id */
-} test_tokenizer_cursor;
-
-static int testTokenizerCreate(
-  int argc, const char * const *argv,
-  sqlite3_tokenizer **ppTokenizer
-){
-  test_tokenizer *pNew;
-  UNUSED_PARAMETER(argc);
-  UNUSED_PARAMETER(argv);
-
-  pNew = sqlite3_malloc(sizeof(test_tokenizer));
-  if( !pNew ) return SQLITE_NOMEM;
-  memset(pNew, 0, sizeof(test_tokenizer));
-
-  *ppTokenizer = (sqlite3_tokenizer *)pNew;
-  return SQLITE_OK;
-}
-
-static int testTokenizerDestroy(sqlite3_tokenizer *pTokenizer){
-  test_tokenizer *p = (test_tokenizer *)pTokenizer;
-  sqlite3_free(p);
-  return SQLITE_OK;
-}
-
-static int testTokenizerOpen(
-  sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
-  const char *pInput, int nBytes,        /* String to be tokenized */
-  sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
-){
-  int rc = SQLITE_OK;                    /* Return code */
-  test_tokenizer_cursor *pCsr;           /* New cursor object */
-
-  UNUSED_PARAMETER(pTokenizer);
-
-  pCsr = (test_tokenizer_cursor *)sqlite3_malloc(sizeof(test_tokenizer_cursor));
-  if( pCsr==0 ){
-    rc = SQLITE_NOMEM;
-  }else{
-    memset(pCsr, 0, sizeof(test_tokenizer_cursor));
-    pCsr->aInput = pInput;
-    if( nBytes<0 ){
-      pCsr->nInput = (int)strlen(pInput);
-    }else{
-      pCsr->nInput = nBytes;
-    }
-  }
-
-  *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
-  return rc;
-}
-
-static int testTokenizerClose(sqlite3_tokenizer_cursor *pCursor){
-  test_tokenizer_cursor *pCsr = (test_tokenizer_cursor *)pCursor;
-  sqlite3_free(pCsr->aBuffer);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-static int testIsTokenChar(char c){
-  return (c>='a' && c<='z') || (c>='A' && c<='Z');
-}
-static int testTolower(char c){
-  char ret = c;
-  if( ret>='A' && ret<='Z') ret = ret - ('A'-'a');
-  return ret;
-}
-
-static int testTokenizerNext(
-  sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by testTokenizerOpen */
-  const char **ppToken,               /* OUT: *ppToken is the token text */
-  int *pnBytes,                       /* OUT: Number of bytes in token */
-  int *piStartOffset,                 /* OUT: Starting offset of token */
-  int *piEndOffset,                   /* OUT: Ending offset of token */
-  int *piPosition                     /* OUT: Position integer of token */
-){
-  test_tokenizer_cursor *pCsr = (test_tokenizer_cursor *)pCursor;
-  int rc = SQLITE_OK;
-  const char *p;
-  const char *pEnd;
-
-  p = &pCsr->aInput[pCsr->iInput];
-  pEnd = &pCsr->aInput[pCsr->nInput];
-
-  /* Skip past any white-space */
-  assert( p<=pEnd );
-  while( p<pEnd && testIsTokenChar(*p)==0 ) p++;
-
-  if( p==pEnd ){
-    rc = SQLITE_DONE;
-  }else{
-    /* Advance to the end of the token */
-    const char *pToken = p;
-    sqlite3_int64 nToken;
-    while( p<pEnd && testIsTokenChar(*p) ) p++;
-    nToken = (sqlite3_int64)(p-pToken);
-
-    /* Copy the token into the buffer */
-    if( nToken>pCsr->nBuffer ){
-      sqlite3_free(pCsr->aBuffer);
-      pCsr->aBuffer = sqlite3_malloc64(nToken);
-    }
-    if( pCsr->aBuffer==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      int i;
-
-      if( pCsr->iLangid & 0x00000001 ){
-        for(i=0; i<nToken; i++) pCsr->aBuffer[i] = pToken[i];
-      }else{
-        for(i=0; i<nToken; i++) pCsr->aBuffer[i] = (char)testTolower(pToken[i]);
-      }
-      pCsr->iToken++;
-      pCsr->iInput = (int)(p - pCsr->aInput);
-
-      *ppToken = pCsr->aBuffer;
-      *pnBytes = (int)nToken;
-      *piStartOffset = (int)(pToken - pCsr->aInput);
-      *piEndOffset = (int)(p - pCsr->aInput);
-      *piPosition = pCsr->iToken;
-    }
-  }
-
-  return rc;
-}
-
-static int testTokenizerLanguage(
-  sqlite3_tokenizer_cursor *pCursor,
-  int iLangid
-){
-  int rc = SQLITE_OK;
-  test_tokenizer_cursor *pCsr = (test_tokenizer_cursor *)pCursor;
-  pCsr->iLangid = iLangid;
-  if( pCsr->iLangid>=100 ){
-    rc = SQLITE_ERROR;
-  }
-  return rc;
-}
-#endif
-
-static int SQLITE_TCLAPI fts3_test_tokenizer_cmd(
-  ClientData clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-#ifdef SQLITE_ENABLE_FTS3
-  static const sqlite3_tokenizer_module testTokenizerModule = {
-    1,
-    testTokenizerCreate,
-    testTokenizerDestroy,
-    testTokenizerOpen,
-    testTokenizerClose,
-    testTokenizerNext,
-    testTokenizerLanguage
-  };
-  const sqlite3_tokenizer_module *pPtr = &testTokenizerModule;
-  if( objc!=1 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "");
-    return TCL_ERROR;
-  }
-  Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(
-    (const unsigned char *)&pPtr, sizeof(sqlite3_tokenizer_module *)
-  ));
-#endif
-  UNUSED_PARAMETER(clientData);
-  return TCL_OK;
-}
-
-static int SQLITE_TCLAPI fts3_test_varint_cmd(
-  ClientData clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-#ifdef SQLITE_ENABLE_FTS3
-  char aBuf[24];
-  int rc;
-  Tcl_WideInt w;
-  sqlite3_int64 w2;
-  int nByte, nByte2;
-
-  if( objc!=2 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "INTEGER");
-    return TCL_ERROR;
-  }
-
-  rc = Tcl_GetWideIntFromObj(interp, objv[1], &w);
-  if( rc!=TCL_OK ) return rc;
-
-  nByte = sqlite3Fts3PutVarint(aBuf, w);
-  nByte2 = sqlite3Fts3GetVarint(aBuf, &w2);
-  if( w!=w2 || nByte!=nByte2 ){
-    char *zErr = sqlite3_mprintf("error testing %lld", w);
-    Tcl_ResetResult(interp);
-    Tcl_AppendResult(interp, zErr, 0);
-    return TCL_ERROR;
-  }
-
-  if( w<=2147483647 && w>=0 ){
-    int i;
-    nByte2 = fts3GetVarint32(aBuf, &i);
-    if( (int)w!=i || nByte!=nByte2 ){
-      char *zErr = sqlite3_mprintf("error testing %lld (32-bit)", w);
-      Tcl_ResetResult(interp);
-      Tcl_AppendResult(interp, zErr, 0);
-      return TCL_ERROR;
-    }
-  }
-
-#endif
-  UNUSED_PARAMETER(clientData);
-  return TCL_OK;
-}
-
-/* 
-** End of tokenizer code.
-**************************************************************************/ 
-
-/*
-**      sqlite3_fts3_may_be_corrupt BOOLEAN
-**
-** Set or clear the global "may-be-corrupt" flag. Return the old value.
-*/
-static int SQLITE_TCLAPI fts3_may_be_corrupt(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  int bOld = sqlite3_fts3_may_be_corrupt;
-
-  if( objc!=2 && objc!=1 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "?BOOLEAN?");
-    return TCL_ERROR;
-  }
-  if( objc==2 ){
-    int bNew;
-    if( Tcl_GetBooleanFromObj(interp, objv[1], &bNew) ) return TCL_ERROR;
-    sqlite3_fts3_may_be_corrupt = bNew;
-  }
-
-  Tcl_SetObjResult(interp, Tcl_NewIntObj(bOld));
-  return TCL_OK;
-}
-
-int Sqlitetestfts3_Init(Tcl_Interp *interp){
-  Tcl_CreateObjCommand(interp, "fts3_near_match", fts3_near_match_cmd, 0, 0);
-  Tcl_CreateObjCommand(interp, 
-      "fts3_configure_incr_load", fts3_configure_incr_load_cmd, 0, 0
-  );
-  Tcl_CreateObjCommand(
-      interp, "fts3_test_tokenizer", fts3_test_tokenizer_cmd, 0, 0
-  );
-  Tcl_CreateObjCommand(
-      interp, "fts3_test_varint", fts3_test_varint_cmd, 0, 0
-  );
-  Tcl_CreateObjCommand(
-      interp, "sqlite3_fts3_may_be_corrupt", fts3_may_be_corrupt, 0, 0
-  );
-  return TCL_OK;
-}
-#endif                  /* SQLITE_ENABLE_FTS3 || SQLITE_ENABLE_FTS4 */
-#endif                  /* ifdef SQLITE_TEST */

ext/fts3/fts3_tokenize_vtab.c

@@ -1,455 +0,0 @@
-/*
-** 2013 Apr 22
-**
-** 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.
-**
-******************************************************************************
-**
-** This file contains code for the "fts3tokenize" virtual table module.
-** An fts3tokenize virtual table is created as follows:
-**
-**   CREATE VIRTUAL TABLE <tbl> USING fts3tokenize(
-**       <tokenizer-name>, <arg-1>, ...
-**   );
-**
-** The table created has the following schema:
-**
-**   CREATE TABLE <tbl>(input, token, start, end, position)
-**
-** When queried, the query must include a WHERE clause of type:
-**
-**   input = <string>
-**
-** The virtual table module tokenizes this <string>, using the FTS3 
-** tokenizer specified by the arguments to the CREATE VIRTUAL TABLE 
-** statement and returns one row for each token in the result. With
-** fields set as follows:
-**
-**   input:   Always set to a copy of <string>
-**   token:   A token from the input.
-**   start:   Byte offset of the token within the input <string>.
-**   end:     Byte offset of the byte immediately following the end of the
-**            token within the input string.
-**   pos:     Token offset of token within input.
-**
-*/
-#include "fts3Int.h"
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
-
-#include <string.h>
-#include <assert.h>
-
-typedef struct Fts3tokTable Fts3tokTable;
-typedef struct Fts3tokCursor Fts3tokCursor;
-
-/*
-** Virtual table structure.
-*/
-struct Fts3tokTable {
-  sqlite3_vtab base;              /* Base class used by SQLite core */
-  const sqlite3_tokenizer_module *pMod;
-  sqlite3_tokenizer *pTok;
-};
-
-/*
-** Virtual table cursor structure.
-*/
-struct Fts3tokCursor {
-  sqlite3_vtab_cursor base;       /* Base class used by SQLite core */
-  char *zInput;                   /* Input string */
-  sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */
-  int iRowid;                     /* Current 'rowid' value */
-  const char *zToken;             /* Current 'token' value */
-  int nToken;                     /* Size of zToken in bytes */
-  int iStart;                     /* Current 'start' value */
-  int iEnd;                       /* Current 'end' value */
-  int iPos;                       /* Current 'pos' value */
-};
-
-/*
-** Query FTS for the tokenizer implementation named zName.
-*/
-static int fts3tokQueryTokenizer(
-  Fts3Hash *pHash,
-  const char *zName,
-  const sqlite3_tokenizer_module **pp,
-  char **pzErr
-){
-  sqlite3_tokenizer_module *p;
-  int nName = (int)strlen(zName);
-
-  p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
-  if( !p ){
-    sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName);
-    return SQLITE_ERROR;
-  }
-
-  *pp = p;
-  return SQLITE_OK;
-}
-
-/*
-** The second argument, argv[], is an array of pointers to nul-terminated
-** strings. This function makes a copy of the array and strings into a 
-** single block of memory. It then dequotes any of the strings that appear
-** to be quoted.
-**
-** If successful, output parameter *pazDequote is set to point at the
-** array of dequoted strings and SQLITE_OK is returned. The caller is
-** responsible for eventually calling sqlite3_free() to free the array
-** in this case. Or, if an error occurs, an SQLite error code is returned.
-** The final value of *pazDequote is undefined in this case.
-*/
-static int fts3tokDequoteArray(
-  int argc,                       /* Number of elements in argv[] */
-  const char * const *argv,       /* Input array */
-  char ***pazDequote              /* Output array */
-){
-  int rc = SQLITE_OK;             /* Return code */
-  if( argc==0 ){
-    *pazDequote = 0;
-  }else{
-    int i;
-    int nByte = 0;
-    char **azDequote;
-
-    for(i=0; i<argc; i++){
-      nByte += (int)(strlen(argv[i]) + 1);
-    }
-
-    *pazDequote = azDequote = sqlite3_malloc64(sizeof(char *)*argc + nByte);
-    if( azDequote==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      char *pSpace = (char *)&azDequote[argc];
-      for(i=0; i<argc; i++){
-        int n = (int)strlen(argv[i]);
-        azDequote[i] = pSpace;
-        memcpy(pSpace, argv[i], n+1);
-        sqlite3Fts3Dequote(pSpace);
-        pSpace += (n+1);
-      }
-    }
-  }
-
-  return rc;
-}
-
-/*
-** Schema of the tokenizer table.
-*/
-#define FTS3_TOK_SCHEMA "CREATE TABLE x(input, token, start, end, position)"
-
-/*
-** This function does all the work for both the xConnect and xCreate methods.
-** These tables have no persistent representation of their own, so xConnect
-** and xCreate are identical operations.
-**
-**   argv[0]: module name
-**   argv[1]: database name 
-**   argv[2]: table name
-**   argv[3]: first argument (tokenizer name)
-*/
-static int fts3tokConnectMethod(
-  sqlite3 *db,                    /* Database connection */
-  void *pHash,                    /* Hash table of tokenizers */
-  int argc,                       /* Number of elements in argv array */
-  const char * const *argv,       /* xCreate/xConnect argument array */
-  sqlite3_vtab **ppVtab,          /* OUT: New sqlite3_vtab object */
-  char **pzErr                    /* OUT: sqlite3_malloc'd error message */
-){
-  Fts3tokTable *pTab = 0;
-  const sqlite3_tokenizer_module *pMod = 0;
-  sqlite3_tokenizer *pTok = 0;
-  int rc;
-  char **azDequote = 0;
-  int nDequote;
-
-  rc = sqlite3_declare_vtab(db, FTS3_TOK_SCHEMA);
-  if( rc!=SQLITE_OK ) return rc;
-
-  nDequote = argc-3;
-  rc = fts3tokDequoteArray(nDequote, &argv[3], &azDequote);
-
-  if( rc==SQLITE_OK ){
-    const char *zModule;
-    if( nDequote<1 ){
-      zModule = "simple";
-    }else{
-      zModule = azDequote[0];
-    }
-    rc = fts3tokQueryTokenizer((Fts3Hash*)pHash, zModule, &pMod, pzErr);
-  }
-
-  assert( (rc==SQLITE_OK)==(pMod!=0) );
-  if( rc==SQLITE_OK ){
-    const char * const *azArg = (const char * const *)&azDequote[1];
-    rc = pMod->xCreate((nDequote>1 ? nDequote-1 : 0), azArg, &pTok);
-  }
-
-  if( rc==SQLITE_OK ){
-    pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable));
-    if( pTab==0 ){
-      rc = SQLITE_NOMEM;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    memset(pTab, 0, sizeof(Fts3tokTable));
-    pTab->pMod = pMod;
-    pTab->pTok = pTok;
-    *ppVtab = &pTab->base;
-  }else{
-    if( pTok ){
-      pMod->xDestroy(pTok);
-    }
-  }
-
-  sqlite3_free(azDequote);
-  return rc;
-}
-
-/*
-** This function does the work for both the xDisconnect and xDestroy methods.
-** These tables have no persistent representation of their own, so xDisconnect
-** and xDestroy are identical operations.
-*/
-static int fts3tokDisconnectMethod(sqlite3_vtab *pVtab){
-  Fts3tokTable *pTab = (Fts3tokTable *)pVtab;
-
-  pTab->pMod->xDestroy(pTab->pTok);
-  sqlite3_free(pTab);
-  return SQLITE_OK;
-}
-
-/*
-** xBestIndex - Analyze a WHERE and ORDER BY clause.
-*/
-static int fts3tokBestIndexMethod(
-  sqlite3_vtab *pVTab, 
-  sqlite3_index_info *pInfo
-){
-  int i;
-  UNUSED_PARAMETER(pVTab);
-
-  for(i=0; i<pInfo->nConstraint; i++){
-    if( pInfo->aConstraint[i].usable 
-     && pInfo->aConstraint[i].iColumn==0 
-     && pInfo->aConstraint[i].op==SQLITE_INDEX_CONSTRAINT_EQ 
-    ){
-      pInfo->idxNum = 1;
-      pInfo->aConstraintUsage[i].argvIndex = 1;
-      pInfo->aConstraintUsage[i].omit = 1;
-      pInfo->estimatedCost = 1;
-      return SQLITE_OK;
-    }
-  }
-
-  pInfo->idxNum = 0;
-  assert( pInfo->estimatedCost>1000000.0 );
-
-  return SQLITE_OK;
-}
-
-/*
-** xOpen - Open a cursor.
-*/
-static int fts3tokOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
-  Fts3tokCursor *pCsr;
-  UNUSED_PARAMETER(pVTab);
-
-  pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor));
-  if( pCsr==0 ){
-    return SQLITE_NOMEM;
-  }
-  memset(pCsr, 0, sizeof(Fts3tokCursor));
-
-  *ppCsr = (sqlite3_vtab_cursor *)pCsr;
-  return SQLITE_OK;
-}
-
-/*
-** Reset the tokenizer cursor passed as the only argument. As if it had
-** just been returned by fts3tokOpenMethod().
-*/
-static void fts3tokResetCursor(Fts3tokCursor *pCsr){
-  if( pCsr->pCsr ){
-    Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
-    pTab->pMod->xClose(pCsr->pCsr);
-    pCsr->pCsr = 0;
-  }
-  sqlite3_free(pCsr->zInput);
-  pCsr->zInput = 0;
-  pCsr->zToken = 0;
-  pCsr->nToken = 0;
-  pCsr->iStart = 0;
-  pCsr->iEnd = 0;
-  pCsr->iPos = 0;
-  pCsr->iRowid = 0;
-}
-
-/*
-** xClose - Close a cursor.
-*/
-static int fts3tokCloseMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
-
-  fts3tokResetCursor(pCsr);
-  sqlite3_free(pCsr);
-  return SQLITE_OK;
-}
-
-/*
-** xNext - Advance the cursor to the next row, if any.
-*/
-static int fts3tokNextMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
-  Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
-  int rc;                         /* Return code */
-
-  pCsr->iRowid++;
-  rc = pTab->pMod->xNext(pCsr->pCsr,
-      &pCsr->zToken, &pCsr->nToken,
-      &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos
-  );
-
-  if( rc!=SQLITE_OK ){
-    fts3tokResetCursor(pCsr);
-    if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-  }
-
-  return rc;
-}
-
-/*
-** xFilter - Initialize a cursor to point at the start of its data.
-*/
-static int fts3tokFilterMethod(
-  sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
-  int idxNum,                     /* Strategy index */
-  const char *idxStr,             /* Unused */
-  int nVal,                       /* Number of elements in apVal */
-  sqlite3_value **apVal           /* Arguments for the indexing scheme */
-){
-  int rc = SQLITE_ERROR;
-  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
-  Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
-  UNUSED_PARAMETER(idxStr);
-  UNUSED_PARAMETER(nVal);
-
-  fts3tokResetCursor(pCsr);
-  if( idxNum==1 ){
-    const char *zByte = (const char *)sqlite3_value_text(apVal[0]);
-    int nByte = sqlite3_value_bytes(apVal[0]);
-    pCsr->zInput = sqlite3_malloc64(nByte+1);
-    if( pCsr->zInput==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte);
-      pCsr->zInput[nByte] = 0;
-      rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
-      if( rc==SQLITE_OK ){
-        pCsr->pCsr->pTokenizer = pTab->pTok;
-      }
-    }
-  }
-
-  if( rc!=SQLITE_OK ) return rc;
-  return fts3tokNextMethod(pCursor);
-}
-
-/*
-** xEof - Return true if the cursor is at EOF, or false otherwise.
-*/
-static int fts3tokEofMethod(sqlite3_vtab_cursor *pCursor){
-  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
-  return (pCsr->zToken==0);
-}
-
-/*
-** xColumn - Return a column value.
-*/
-static int fts3tokColumnMethod(
-  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
-  sqlite3_context *pCtx,          /* Context for sqlite3_result_xxx() calls */
-  int iCol                        /* Index of column to read value from */
-){
-  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
-
-  /* CREATE TABLE x(input, token, start, end, position) */
-  switch( iCol ){
-    case 0:
-      sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
-      break;
-    case 1:
-      sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
-      break;
-    case 2:
-      sqlite3_result_int(pCtx, pCsr->iStart);
-      break;
-    case 3:
-      sqlite3_result_int(pCtx, pCsr->iEnd);
-      break;
-    default:
-      assert( iCol==4 );
-      sqlite3_result_int(pCtx, pCsr->iPos);
-      break;
-  }
-  return SQLITE_OK;
-}
-
-/*
-** xRowid - Return the current rowid for the cursor.
-*/
-static int fts3tokRowidMethod(
-  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
-  sqlite_int64 *pRowid            /* OUT: Rowid value */
-){
-  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
-  *pRowid = (sqlite3_int64)pCsr->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Register the fts3tok module with database connection db. Return SQLITE_OK
-** if successful or an error code if sqlite3_create_module() fails.
-*/
-int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){
-  static const sqlite3_module fts3tok_module = {
-     0,                           /* iVersion      */
-     fts3tokConnectMethod,        /* xCreate       */
-     fts3tokConnectMethod,        /* xConnect      */
-     fts3tokBestIndexMethod,      /* xBestIndex    */
-     fts3tokDisconnectMethod,     /* xDisconnect   */
-     fts3tokDisconnectMethod,     /* xDestroy      */
-     fts3tokOpenMethod,           /* xOpen         */
-     fts3tokCloseMethod,          /* xClose        */
-     fts3tokFilterMethod,         /* xFilter       */
-     fts3tokNextMethod,           /* xNext         */
-     fts3tokEofMethod,            /* xEof          */
-     fts3tokColumnMethod,         /* xColumn       */
-     fts3tokRowidMethod,          /* xRowid        */
-     0,                           /* xUpdate       */
-     0,                           /* xBegin        */
-     0,                           /* xSync         */
-     0,                           /* xCommit       */
-     0,                           /* xRollback     */
-     0,                           /* xFindFunction */
-     0,                           /* xRename       */
-     0,                           /* xSavepoint    */
-     0,                           /* xRelease      */
-     0,                           /* xRollbackTo   */
-     0                            /* xShadowName   */
-  };
-  int rc;                         /* Return code */
-
-  rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, (void*)pHash);
-  return rc;
-}
-
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */

ext/fts3/fts3_tokenizer.c

@@ -23,23 +23,16 @@
 **     * The FTS3 module is being built into the core of
 **       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
 */
-#include "fts3Int.h"
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
 
-#include <assert.h>
-#include <string.h>
+#include "sqlite3ext.h"
+#ifndef SQLITE_CORE
+  SQLITE_EXTENSION_INIT1
+#endif
 
-/*
-** Return true if the two-argument version of fts3_tokenizer()
-** has been activated via a prior call to sqlite3_db_config(db,
-** SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
-*/
-static int fts3TokenizerEnabled(sqlite3_context *context){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  int isEnabled = 0;
-  sqlite3_db_config(db,SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,-1,&isEnabled);
-  return isEnabled;
-}
+#include "fts3_hash.h"
+#include "fts3_tokenizer.h"
+#include <assert.h>
 
 /*
 ** Implementation of the SQL scalar function for accessing the underlying 
@@ -61,44 +54,38 @@ static int fts3TokenizerEnabled(sqlite3_context *context){
 ** is a blob containing the pointer stored as the hash data corresponding
 ** to string <key-name> (after the hash-table is updated, if applicable).
 */
-static void fts3TokenizerFunc(
+static void scalarFunc(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
-  Fts3Hash *pHash;
+  fts3Hash *pHash;
   void *pPtr = 0;
   const unsigned char *zName;
   int nName;
 
   assert( argc==1 || argc==2 );
 
-  pHash = (Fts3Hash *)sqlite3_user_data(context);
+  pHash = (fts3Hash *)sqlite3_user_data(context);
 
   zName = sqlite3_value_text(argv[0]);
   nName = sqlite3_value_bytes(argv[0])+1;
 
   if( argc==2 ){
-    if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[1]) ){
-      void *pOld;
-      int n = sqlite3_value_bytes(argv[1]);
-      if( zName==0 || n!=sizeof(pPtr) ){
-        sqlite3_result_error(context, "argument type mismatch", -1);
-        return;
-      }
-      pPtr = *(void **)sqlite3_value_blob(argv[1]);
-      pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
-      if( pOld==pPtr ){
-        sqlite3_result_error(context, "out of memory", -1);
-      }
-    }else{
-      sqlite3_result_error(context, "fts3tokenize disabled", -1);
+    void *pOld;
+    int n = sqlite3_value_bytes(argv[1]);
+    if( n!=sizeof(pPtr) ){
+      sqlite3_result_error(context, "argument type mismatch", -1);
+      return;
+    }
+    pPtr = *(void **)sqlite3_value_blob(argv[1]);
+    pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
+    if( pOld==pPtr ){
+      sqlite3_result_error(context, "out of memory", -1);
       return;
     }
   }else{
-    if( zName ){
-      pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
-    }
+    pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
     if( !pPtr ){
       char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
       sqlite3_result_error(context, zErr, -1);
@@ -106,139 +93,22 @@ static void fts3TokenizerFunc(
       return;
     }
   }
-  if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[0]) ){
-    sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
-  }
+
+  sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
 }
 
-int sqlite3Fts3IsIdChar(char c){
-  static const char isFtsIdChar[] = {
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 0x */
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 1x */
-      0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
-      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
-      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
-      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
-      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
-      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
-  };
-  return (c&0x80 || isFtsIdChar[(int)(c)]);
-}
-
-const char *sqlite3Fts3NextToken(const char *zStr, int *pn){
-  const char *z1;
-  const char *z2 = 0;
-
-  /* Find the start of the next token. */
-  z1 = zStr;
-  while( z2==0 ){
-    char c = *z1;
-    switch( c ){
-      case '\0': return 0;        /* No more tokens here */
-      case '\'':
-      case '"':
-      case '`': {
-        z2 = z1;
-        while( *++z2 && (*z2!=c || *++z2==c) );
-        break;
-      }
-      case '[':
-        z2 = &z1[1];
-        while( *z2 && z2[0]!=']' ) z2++;
-        if( *z2 ) z2++;
-        break;
-
-      default:
-        if( sqlite3Fts3IsIdChar(*z1) ){
-          z2 = &z1[1];
-          while( sqlite3Fts3IsIdChar(*z2) ) z2++;
-        }else{
-          z1++;
-        }
-    }
-  }
-
-  *pn = (int)(z2-z1);
-  return z1;
-}
-
-int sqlite3Fts3InitTokenizer(
-  Fts3Hash *pHash,                /* Tokenizer hash table */
-  const char *zArg,               /* Tokenizer name */
-  sqlite3_tokenizer **ppTok,      /* OUT: Tokenizer (if applicable) */
-  char **pzErr                    /* OUT: Set to malloced error message */
-){
-  int rc;
-  char *z = (char *)zArg;
-  int n = 0;
-  char *zCopy;
-  char *zEnd;                     /* Pointer to nul-term of zCopy */
-  sqlite3_tokenizer_module *m;
-
-  zCopy = sqlite3_mprintf("%s", zArg);
-  if( !zCopy ) return SQLITE_NOMEM;
-  zEnd = &zCopy[strlen(zCopy)];
-
-  z = (char *)sqlite3Fts3NextToken(zCopy, &n);
-  if( z==0 ){
-    assert( n==0 );
-    z = zCopy;
-  }
-  z[n] = '\0';
-  sqlite3Fts3Dequote(z);
-
-  m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);
-  if( !m ){
-    sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", z);
-    rc = SQLITE_ERROR;
-  }else{
-    char const **aArg = 0;
-    int iArg = 0;
-    z = &z[n+1];
-    while( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){
-      sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
-      char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
-      if( !aNew ){
-        sqlite3_free(zCopy);
-        sqlite3_free((void *)aArg);
-        return SQLITE_NOMEM;
-      }
-      aArg = aNew;
-      aArg[iArg++] = z;
-      z[n] = '\0';
-      sqlite3Fts3Dequote(z);
-      z = &z[n+1];
-    }
-    rc = m->xCreate(iArg, aArg, ppTok);
-    assert( rc!=SQLITE_OK || *ppTok );
-    if( rc!=SQLITE_OK ){
-      sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer");
-    }else{
-      (*ppTok)->pModule = m; 
-    }
-    sqlite3_free((void *)aArg);
-  }
-
-  sqlite3_free(zCopy);
-  return rc;
-}
-
-
 #ifdef SQLITE_TEST
 
-#if defined(INCLUDE_SQLITE_TCL_H)
-#  include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#endif
+#include <tcl.h>
 #include <string.h>
 
 /*
 ** Implementation of a special SQL scalar function for testing tokenizers 
 ** designed to be used in concert with the Tcl testing framework. This
-** function must be called with two or more arguments:
+** function must be called with two arguments:
 **
-**   SELECT <function-name>(<key-name>, ..., <input-string>);
+**   SELECT <function-name>(<key-name>, <input-string>);
+**   SELECT <function-name>(<key-name>, <pointer>);
 **
 ** where <function-name> is the name passed as the second argument
 ** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer')
@@ -263,7 +133,7 @@ static void testFunc(
   int argc,
   sqlite3_value **argv
 ){
-  Fts3Hash *pHash;
+  fts3Hash *pHash;
   sqlite3_tokenizer_module *p;
   sqlite3_tokenizer *pTokenizer = 0;
   sqlite3_tokenizer_cursor *pCsr = 0;
@@ -275,53 +145,50 @@ static void testFunc(
   const char *zInput;
   int nInput;
 
-  const char *azArg[64];
+  const char *zArg = 0;
 
   const char *zToken;
-  int nToken = 0;
-  int iStart = 0;
-  int iEnd = 0;
-  int iPos = 0;
-  int i;
+  int nToken;
+  int iStart;
+  int iEnd;
+  int iPos;
 
   Tcl_Obj *pRet;
 
-  if( argc<2 ){
-    sqlite3_result_error(context, "insufficient arguments", -1);
-    return;
-  }
+  assert( argc==2 || argc==3 );
 
   nName = sqlite3_value_bytes(argv[0]);
   zName = (const char *)sqlite3_value_text(argv[0]);
   nInput = sqlite3_value_bytes(argv[argc-1]);
   zInput = (const char *)sqlite3_value_text(argv[argc-1]);
 
-  pHash = (Fts3Hash *)sqlite3_user_data(context);
+  if( argc==3 ){
+    zArg = (const char *)sqlite3_value_text(argv[1]);
+  }
+
+  pHash = (fts3Hash *)sqlite3_user_data(context);
   p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
 
   if( !p ){
-    char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName);
-    sqlite3_result_error(context, zErr2, -1);
-    sqlite3_free(zErr2);
+    char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
+    sqlite3_result_error(context, zErr, -1);
+    sqlite3_free(zErr);
     return;
   }
 
   pRet = Tcl_NewObj();
   Tcl_IncrRefCount(pRet);
 
-  for(i=1; i<argc-1; i++){
-    azArg[i-1] = (const char *)sqlite3_value_text(argv[i]);
-  }
-
-  if( SQLITE_OK!=p->xCreate(argc-2, azArg, &pTokenizer) ){
+  if( SQLITE_OK!=p->xCreate(zArg ? 1 : 0, &zArg, &pTokenizer) ){
     zErr = "error in xCreate()";
     goto finish;
   }
   pTokenizer->pModule = p;
-  if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){
+  if( SQLITE_OK!=p->xOpen(pTokenizer, zInput, nInput, &pCsr) ){
     zErr = "error in xOpen()";
     goto finish;
   }
+  pCsr->pTokenizer = pTokenizer;
 
   while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
     Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos));
@@ -371,7 +238,6 @@ int registerTokenizer(
   return sqlite3_finalize(pStmt);
 }
 
-
 static
 int queryTokenizer(
   sqlite3 *db, 
@@ -390,10 +256,8 @@ int queryTokenizer(
 
   sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
   if( SQLITE_ROW==sqlite3_step(pStmt) ){
-    if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB
-     && sqlite3_column_bytes(pStmt, 0)==sizeof(*pp)
-    ){
-      memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
+    if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
+      memcpy(pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
     }
   }
 
@@ -430,9 +294,6 @@ static void intTestFunc(
   const sqlite3_tokenizer_module *p2;
   sqlite3 *db = (sqlite3 *)sqlite3_user_data(context);
 
-  UNUSED_PARAMETER(argc);
-  UNUSED_PARAMETER(argv);
-
   /* Test the query function */
   sqlite3Fts3SimpleTokenizerModule(&p1);
   rc = queryTokenizer(db, "simple", &p2);
@@ -444,13 +305,11 @@ static void intTestFunc(
   assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
 
   /* Test the storage function */
-  if( fts3TokenizerEnabled(context) ){
-    rc = registerTokenizer(db, "nosuchtokenizer", p1);
-    assert( rc==SQLITE_OK );
-    rc = queryTokenizer(db, "nosuchtokenizer", &p2);
-    assert( rc==SQLITE_OK );
-    assert( p2==p1 );
-  }
+  rc = registerTokenizer(db, "nosuchtokenizer", p1);
+  assert( rc==SQLITE_OK );
+  rc = queryTokenizer(db, "nosuchtokenizer", &p2);
+  assert( rc==SQLITE_OK );
+  assert( p2==p1 );
 
   sqlite3_result_text(context, "ok", -1, SQLITE_STATIC);
 }
@@ -460,13 +319,13 @@ static void intTestFunc(
 /*
 ** Set up SQL objects in database db used to access the contents of
 ** the hash table pointed to by argument pHash. The hash table must
-** been initialized to use string keys, and to take a private copy 
+** been initialised to use string keys, and to take a private copy 
 ** of the key when a value is inserted. i.e. by a call similar to:
 **
 **    sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
 **
 ** This function adds a scalar function (see header comment above
-** fts3TokenizerFunc() in this file for details) and, if ENABLE_TABLE is
+** scalarFunc() in this file for details) and, if ENABLE_TABLE is
 ** defined at compilation time, a temporary virtual table (see header 
 ** comment above struct HashTableVtab) to the database schema. Both 
 ** provide read/write access to the contents of *pHash.
@@ -476,16 +335,16 @@ static void intTestFunc(
 */
 int sqlite3Fts3InitHashTable(
   sqlite3 *db, 
-  Fts3Hash *pHash, 
+  fts3Hash *pHash, 
   const char *zName
 ){
   int rc = SQLITE_OK;
   void *p = (void *)pHash;
-  const int any = SQLITE_UTF8|SQLITE_DIRECTONLY;
-
-#ifdef SQLITE_TEST
+  const int any = SQLITE_ANY;
   char *zTest = 0;
   char *zTest2 = 0;
+
+#ifdef SQLITE_TEST
   void *pdb = (void *)db;
   zTest = sqlite3_mprintf("%s_test", zName);
   zTest2 = sqlite3_mprintf("%s_internal_test", zName);
@@ -494,26 +353,18 @@ int sqlite3Fts3InitHashTable(
   }
 #endif
 
-  if( SQLITE_OK==rc ){
-    rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0);
-  }
-  if( SQLITE_OK==rc ){
-    rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0);
-  }
+  if( rc!=SQLITE_OK
+   || (rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0))
 #ifdef SQLITE_TEST
-  if( SQLITE_OK==rc ){
-    rc = sqlite3_create_function(db, zTest, -1, any, p, testFunc, 0, 0);
-  }
-  if( SQLITE_OK==rc ){
-    rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0);
-  }
+   || (rc = sqlite3_create_function(db, zTest, 2, any, p, testFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zTest, 3, any, p, testFunc, 0, 0))
+   || (rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0))
 #endif
+  );
 
-#ifdef SQLITE_TEST
   sqlite3_free(zTest);
   sqlite3_free(zTest2);
-#endif
-
   return rc;
 }
 

ext/fts3/fts3_tokenizer.h

@@ -52,7 +52,7 @@ typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor;
 struct sqlite3_tokenizer_module {
 
   /*
-  ** Structure version. Should always be set to 0 or 1.
+  ** Structure version. Should always be set to 0.
   */
   int iVersion;
 
@@ -70,7 +70,7 @@ struct sqlite3_tokenizer_module {
   ** This method should return either SQLITE_OK (0), or an SQLite error 
   ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
   ** to point at the newly created tokenizer structure. The generic
-  ** sqlite3_tokenizer.pModule variable should not be initialized by
+  ** sqlite3_tokenizer.pModule variable should not be initialised by
   ** this callback. The caller will do so.
   */
   int (*xCreate)(
@@ -133,15 +133,6 @@ struct sqlite3_tokenizer_module {
     int *piEndOffset,    /* OUT: Byte offset of end of token in input buffer */
     int *piPosition      /* OUT: Number of tokens returned before this one */
   );
-
-  /***********************************************************************
-  ** Methods below this point are only available if iVersion>=1.
-  */
-
-  /* 
-  ** Configure the language id of a tokenizer cursor.
-  */
-  int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid);
 };
 
 struct sqlite3_tokenizer {
@@ -154,8 +145,4 @@ struct sqlite3_tokenizer_cursor {
   /* Tokenizer implementations will typically add additional fields */
 };
 
-int fts3_global_term_cnt(int iTerm, int iCol);
-int fts3_term_cnt(int iTerm, int iCol);
-
-
 #endif /* _FTS3_TOKENIZER_H_ */

ext/fts3/fts3_tokenizer1.c

@@ -22,13 +22,14 @@
 **     * The FTS3 module is being built into the core of
 **       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
 */
-#include "fts3Int.h"
 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
 
+
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
 
 #include "fts3_tokenizer.h"
 
@@ -48,12 +49,12 @@ typedef struct simple_tokenizer_cursor {
 } simple_tokenizer_cursor;
 
 
+/* Forward declaration */
+static const sqlite3_tokenizer_module simpleTokenizerModule;
+
 static int simpleDelim(simple_tokenizer *t, unsigned char c){
   return c<0x80 && t->delim[c];
 }
-static int fts3_isalnum(int x){
-  return (x>='0' && x<='9') || (x>='A' && x<='Z') || (x>='a' && x<='z');
-}
 
 /*
 ** Create a new tokenizer instance.
@@ -74,7 +75,7 @@ static int simpleCreate(
   ** information on the initial create.
   */
   if( argc>1 ){
-    int i, n = (int)strlen(argv[1]);
+    int i, n = strlen(argv[1]);
     for(i=0; i<n; i++){
       unsigned char ch = argv[1][i];
       /* We explicitly don't support UTF-8 delimiters for now. */
@@ -88,7 +89,7 @@ static int simpleCreate(
     /* Mark non-alphanumeric ASCII characters as delimiters */
     int i;
     for(i=1; i<0x80; i++){
-      t->delim[i] = !fts3_isalnum(i) ? -1 : 0;
+      t->delim[i] = !isalnum(i);
     }
   }
 
@@ -117,8 +118,6 @@ static int simpleOpen(
 ){
   simple_tokenizer_cursor *c;
 
-  UNUSED_PARAMETER(pTokenizer);
-
   c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
   if( c==NULL ) return SQLITE_NOMEM;
 
@@ -183,18 +182,16 @@ static int simpleNext(
     if( c->iOffset>iStartOffset ){
       int i, n = c->iOffset-iStartOffset;
       if( n>c->nTokenAllocated ){
-        char *pNew;
         c->nTokenAllocated = n+20;
-        pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated);
-        if( !pNew ) return SQLITE_NOMEM;
-        c->pToken = pNew;
+        c->pToken = sqlite3_realloc(c->pToken, c->nTokenAllocated);
+        if( c->pToken==NULL ) return SQLITE_NOMEM;
       }
       for(i=0; i<n; i++){
         /* TODO(shess) This needs expansion to handle UTF-8
         ** case-insensitivity.
         */
         unsigned char ch = p[iStartOffset+i];
-        c->pToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch);
+        c->pToken[i] = ch<0x80 ? tolower(ch) : ch;
       }
       *ppToken = c->pToken;
       *pnBytes = n;
@@ -218,7 +215,6 @@ static const sqlite3_tokenizer_module simpleTokenizerModule = {
   simpleOpen,
   simpleClose,
   simpleNext,
-  0,
 };
 
 /*