Simplifications to the row-value IN operator logic. Do not let the query

planner accept a WhereLoop for a row-value IN operator that uses the same index column more than once. FossilOrigin-Name: d2adf61f21a3ce901a2b08199ad0de191e88ef16e097c5f7a75c95ad958eff12
Back out the fix at [ba7d5bad32ad6aac] because it does not always work and because
2025-07-07 15:40:53 +00:00 · 2025-07-07 10:54:00 +00:00 · 2025-07-07 02:18:27 +00:00 · 2025-07-04 18:32:18 +00:00 · 2025-07-04 17:20:37 +00:00 · 2025-07-04 12:25:24 +00:00
412 changed files with 14713 additions and 18127 deletions
@@ -0,0 +1 @@
+*.db
@@ -122,10 +122,13 @@ LDFLAGS.rt = @LDFLAGS_RT@
 CFLAGS.icu = @CFLAGS_ICU@
 LDFLAGS.libsqlite3.soname = @LDFLAGS_LIBSQLITE3_SONAME@
 # soname: see https://sqlite.org/src/forumpost/5a3b44f510df8ded
-LDFLAGS.libsqlite3.os-specific = @LDFLAGS_MAC_CVERSION@ @LDFLAGS_OUT_IMPLIB@
+LDFLAGS.libsqlite3.os-specific = \
+  @LDFLAGS_MAC_CVERSION@ @LDFLAGS_MAC_INSTALL_NAME@ @LDFLAGS_OUT_IMPLIB@
 # os-specific: see
 # - https://sqlite.org/forum/forumpost/9dfd5b8fd525a5d7
 # - https://sqlite.org/forum/forumpost/0c7fc097b2
+# - https://sqlite.org/forum/forumpost/5651662b8875ec0a
+
 libsqlite3.DLL.basename = @SQLITE_DLL_BASENAME@
 # DLL.basename: see https://sqlite.org/forum/forumpost/828fdfe904
 libsqlite3.out.implib = @SQLITE_OUT_IMPLIB@
@@ -135,16 +138,13 @@ ENABLE_LIB_STATIC = @ENABLE_LIB_STATIC@
 HAVE_WASI_SDK = @HAVE_WASI_SDK@
 libsqlite3.DLL.install-rules = @SQLITE_DLL_INSTALL_RULES@

-T.cc.sqlite = $(T.cc) @TARGET_DEBUG@
+# -fsanitize flags for the fuzzcheck-asap app
+CFLAGS.fuzzcheck-asan.fsanitize = @CFLAGS_ASAN_FSANITIZE@

 #
-# Define -D_HAVE_SQLITE_CONFIG_H so that the code knows it
-# can include the generated sqlite_cfg.h.
+# Intended to either be empty or be set to -g -DSQLITE_DEBUG=1.
 #
-# main.mk will fill out T.cc.sqlite with additional flags common to
-# all builds.
-#
-T.cc.sqlite += -D_HAVE_SQLITE_CONFIG_H -DBUILD_sqlite
+T.cc.TARGET_DEBUG = @TARGET_DEBUG@

 #
 # $(JIMSH) and $(CFLAGS.jimsh) are documented in main.mk.  $(JIMSH)
@@ -213,6 +213,13 @@ TCL_CONFIG_SH = @TCL_CONFIG_SH@
 #TCL_STUB_LIB_SPEC = @TCL_STUB_LIB_SPEC@
 #TCL_EXEC_PREFIX = @TCL_EXEC_PREFIX@
 #TCL_VERSION = @TCL_VERSION@
+TCL_MAJOR_VERSION = @TCL_MAJOR_VERSION@
+# ^^^ main.mk optionally uses this for determining the Tcl extension's
+# DLL name.
+TCL_EXT_DLL_BASENAME = @TCL_EXT_DLL_BASENAME@
+# ^^^ base name of the Tcl extension DLL. It varies by platform and
+# Tcl version.
+
 #
 # $(TCLLIBDIR) = where to install the tcl plugin. If this is empty, it
 # is calculated at make-time by the targets which need it but we
@@ -243,8 +250,8 @@ TSTRNNR_OPTS = @TSTRNNR_OPTS@
 CFLAGS.gcov1 = -DSQLITE_COVERAGE_TEST=1 -fprofile-arcs -ftest-coverage
 LDFLAGS.gcov1 = -lgcov
 USE_GCOV = @USE_GCOV@
-T.compile.extras = $(CFLAGS.gcov$(USE_GCOV))
-T.link.extras = $(LDFLAGS.gcov$(USE_GCOV))
+T.compile.gcov = $(CFLAGS.gcov$(USE_GCOV))
+T.link.gcov = $(LDFLAGS.gcov$(USE_GCOV))

 #
 # Vars with the AS_ prefix are specifically related to AutoSetup.
@@ -257,10 +264,15 @@ AS_AUTO_DEF = $(TOP)/auto.def
 # invoked with to produce this makefile.
 #
 AS_AUTORECONFIG = @SQLITE_AUTORECONFIG@
-
+.PHONY: reconfigure
+reconfigure:
+	$(AS_AUTORECONFIG)
 USE_AMALGAMATION ?= @USE_AMALGAMATION@
 LINK_TOOLS_DYNAMICALLY ?= @LINK_TOOLS_DYNAMICALLY@
 AMALGAMATION_GEN_FLAGS ?= --linemacros=@AMALGAMATION_LINE_MACROS@
+EXTRA_SRC ?= @AMALGAMATION_EXTRA_SRC@
+STATIC_TCLSQLITE3 = @STATIC_TCLSQLITE3@
+STATIC_CLI_SHELL = @STATIC_CLI_SHELL@

 #
 # CFLAGS for sqlite3$(T.exe)
@@ -322,13 +334,7 @@ misspell: ./custom.rws has_tclsh84
 # perform cleanup known to be relevant to (only) the autosetup-driven
 # build.
 #
-#clean-autosetup:
-#	-if [ -f ext/wasm/GNUmakefile ]; then \
-#		gmake --no-print-directory --ignore-errors -C ext/wasm clean; \
-#	fi >/dev/null 2>&1; true
-#clean: clean-autosetup
-
-distclean-autosetup:	clean
+distclean-autosetup:
 	rm -f sqlite_cfg.h config.log config.status config.defines.* Makefile sqlite3.pc
 	rm -f $(TOP)/tool/emcc.sh
 	rm -f libsqlite3*$(T.dll)
@@ -342,5 +348,4 @@ distclean: distclean-autosetup
 version-info$(T.exe): $(TOP)/tool/version-info.c Makefile sqlite3.h
 	$(T.link) $(ST_OPT) -o $@ $(TOP)/tool/version-info.c

-IS_CROSS_COMPILING = @IS_CROSS_COMPILING@
 include $(TOP)/main.mk
@@ -884,7 +884,7 @@ RCC = $(RCC) -DSQLITE_ENABLE_API_ARMOR=1
 !ENDIF

 !IF $(DEBUG)>2
-TCC = $(TCC) -DSQLITE_DEBUG=1
+TCC = $(TCC) -DSQLITE_DEBUG=1 -DSQLITE_USE_W32_FOR_CONSOLE_IO
 RCC = $(RCC) -DSQLITE_DEBUG=1
 !IF $(DYNAMIC_SHELL)==0
 TCC = $(TCC) -DSQLITE_ENABLE_WHERETRACE -DSQLITE_ENABLE_SELECTTRACE
@@ -1616,7 +1616,6 @@ TESTSRC = \
  $(TOP)\src\test_quota.c \
  $(TOP)\src\test_rtree.c \
  $(TOP)\src\test_schema.c \
-  $(TOP)\src\test_schemapool.c \
  $(TOP)\src\test_superlock.c \
  $(TOP)\src\test_syscall.c \
  $(TOP)\src\test_tclsh.c \
@@ -1624,7 +1623,6 @@ TESTSRC = \
  $(TOP)\src\test_thread.c \
  $(TOP)\src\test_vdbecov.c \
  $(TOP)\src\test_vfs.c \
-  $(TOP)\src\test_windirent.c \
  $(TOP)\src\test_window.c \
  $(TOP)\src\test_wsd.c \
  $(TOP)\ext\fts3\fts3_term.c \
@@ -1973,10 +1971,6 @@ fuzzcheck.exe:	$(FUZZCHECK_SRC) $(SQLITE3C) $(SQLITE3H)
 fuzzcheck-asan.exe:	$(FUZZCHECK_SRC) $(SQLITE3C) $(SQLITE3H)
 	$(LTLINK) $(NO_WARN) /fsanitize=address $(FUZZCHECK_OPTS) $(FUZZCHECK_SRC) $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

-run-fuzzcheck:	fuzzcheck.exe fuzzcheck-asan.exe
-	fuzzcheck --spinner $(FUZZDB)
-	fuzzcheck-asan --spinner $(FUZZDB)
-
 ossshell.exe:	$(OSSSHELL_SRC) $(SQLITE3C) $(SQLITE3H)
 	$(LTLINK) $(NO_WARN) $(FUZZCHECK_OPTS) $(OSSSHELL_SRC) $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

@@ -2400,12 +2394,11 @@ SHELL_DEP = \
    $(TOP)\ext\misc\sqlite3_stdio.h \
    $(TOP)\ext\misc\uint.c \
    $(TOP)\ext\misc\vfstrace.c \
+    $(TOP)\ext\misc\windirent.h \
    $(TOP)\ext\misc\zipfile.c \
    $(TOP)\ext\recover\dbdata.c \
    $(TOP)\ext\recover\sqlite3recover.c \
-    $(TOP)\ext\recover\sqlite3recover.h \
-    $(TOP)\src\test_windirent.c \
-    $(TOP)\src\test_windirent.h
+    $(TOP)\ext\recover\sqlite3recover.h

 # If use of zlib is enabled, add the "zipfile.c" source file.
 #
@@ -2590,10 +2583,15 @@ sqlite_tcl.h:

 testfixture.exe:	$(TESTFIXTURE_SRC) $(TESTFIXTURE_DEP) $(SQLITE3H) $(LIBRESOBJS) $(HDR) $(SQLITE_TCL_DEP)
 	$(LTLINK) -DSQLITE_NO_SYNC=1 $(TESTFIXTURE_FLAGS) \
-		-DBUILD_sqlite -I$(TCLINCDIR) \
+		-DBUILD_sqlite -I$(TCLINCDIR) -I$(TOP)\ext\misc \
 		$(TESTFIXTURE_SRC) \
 		/link $(LDFLAGS) $(LTLINKOPTS) $(TCLLIBPATHS) $(LTLIBPATHS) $(LIBRESOBJS) $(TCLLIBS) $(LTLIBS) $(TLIBS)

+# A small helper for manually running individual tests
+tf.bat: testfixture.exe Makefile.msc
+	echo @set PATH=$(LIBTCLPATH);%PATH% > $@
+	echo .\testfixture.exe %* >> $@
+
 extensiontest:	testfixture.exe testloadext.dll
 	@set PATH=$(LIBTCLPATH);$(PATH)
 	.\testfixture.exe $(TOP)\test\loadext.test $(TESTOPTS)
@@ -2674,7 +2672,14 @@ srctree-check:	$(TOP)\tool\srctree-check.tcl

 # Testing for a release
 #
-releasetest:
+releasetest: verify-source
+	$(TCLSH_CMD) $(TOP)\test\testrunner.tcl release
+
+# xdevtest is like releasetest, except that it skips the
+# dependency on verify-source so that xdevtest can be run from
+# a modified source tree.
+#
+xdevtest:	
 	$(TCLSH_CMD) $(TOP)\test\testrunner.tcl release


@@ -2845,7 +2850,9 @@ clean:
 	del /Q lsm.dll lsmtest.exe 2>NUL
 	del /Q atrc.exe changesetfuzz.exe dbtotxt.exe index_usage.exe 2>NUL
 	del /Q testloadext.dll 2>NUL
-	del /Q testfixture.exe test.db 2>NUL
+	del /Q testfixture.exe test.db tf.bat 2>NUL
+	del /Q /S testdir 2>/NUL
+	-rmdir /Q /S testdir 2>NUL
 	del /Q LogEst.exe fts3view.exe rollback-test.exe showdb.exe dbdump.exe 2>NUL
 	del /Q changeset.exe 2>NUL
 	del /Q showjournal.exe showstat4.exe showwal.exe speedtest1.exe 2>NUL
@@ -57,18 +57,18 @@ 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:

  *  Latest 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).
+     [Tarball](https://sqlite.org/src/tarball/sqlite.tar.gz),
+     [ZIP-archive](https://sqlite.org/src/zip/sqlite.zip), or
+     [SQLite-archive](https://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).
+     [Tarball](https://sqlite.org/src/tarball/sqlite.tar.gz?r=release),
+     [ZIP-archive](https://sqlite.org/src/zip/sqlite.zip?r=release), or
+     [SQLite-archive](https://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)
+     bullet.  Or browse the [timeline](https://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.
@@ -308,14 +308,14 @@ individual source file exceeds 32K lines in length.
 ## How It All Fits Together

 SQLite is modular in design.
-See the [architectural description](https://www.sqlite.org/arch.html)
+See the [architectural description](https://sqlite.org/arch.html)
 for details. Other documents that are useful in
 helping to understand how SQLite works include the
-[file format](https://www.sqlite.org/fileformat2.html) description,
-the [virtual machine](https://www.sqlite.org/opcode.html) that runs
+[file format](https://sqlite.org/fileformat2.html) description,
+the [virtual machine](https://sqlite.org/opcode.html) that runs
 prepared statements, the description of
-[how transactions work](https://www.sqlite.org/atomiccommit.html), and
-the [overview of the query planner](https://www.sqlite.org/optoverview.html).
+[how transactions work](https://sqlite.org/atomiccommit.html), and
+the [overview of the query planner](https://sqlite.org/optoverview.html).

 Decades of effort have gone into optimizing SQLite, both
 for small size and high performance.  And optimizations tend to result in
@@ -1 +1 @@
-3.50.0
+3.51.0
@@ -12,7 +12,6 @@
 #
 # JimTCL: https://jim.tcl.tk
 #
-
 use sqlite-config
 sqlite-configure canonical {
  proj-if-opt-truthy dev {
@@ -25,8 +24,9 @@ sqlite-configure canonical {
    # -------------^^^^^^^ intentionally using [get-env] instead of
    # [proj-get-env] here because [sqlite-setup-default-cflags] uses
    # [proj-get-env] and we want this to supercede that.
-    sqlite-munge-cflags
+    sqlite-munge-cflags; # straighten out -DSQLITE_ENABLE/OMIT flags
  }
+  sqlite-handle-debug      ;# must come after --dev flag check
  sqlite-check-common-bins ;# must come before [sqlite-handle-wasi-sdk]
  sqlite-handle-wasi-sdk   ;# must run relatively early, as it changes the environment
  sqlite-check-common-system-deps
@@ -41,8 +41,24 @@ sqlite-configure canonical {
  proj-define-for-opt linemacros AMALGAMATION_LINE_MACROS \
    "Use #line macros in the amalgamation:"

+  define AMALGAMATION_EXTRA_SRC \
+    [join [opt-val amalgamation-extra-src ""] " "]
+
  define LINK_TOOLS_DYNAMICALLY [proj-opt-was-provided dynlink-tools]

+  if {[set fsan [join [opt-val asan-fsanitize] ","]] in {auto ""}} {
+    set fsan address,bounds-strict
+  }
+  define CFLAGS_ASAN_FSANITIZE [proj-check-fsanitize [split $fsan ", "]]
+
  sqlite-handle-tcl
  sqlite-handle-emsdk
-}
+
+  proj-if-opt-truthy static-shells {
+    proj-opt-set static-tclsqlite3 1
+    proj-opt-set static-cli-shell 1
+  }
+  proj-define-for-opt static-tclsqlite3 STATIC_TCLSQLITE3 "Statically link tclsqlite3?"
+  proj-define-for-opt static-cli-shell STATIC_CLI_SHELL "Statically link CLI shell?"
+
+}; # sqlite-configure
@@ -50,6 +50,7 @@ CC = @CC@

 ENABLE_LIB_SHARED = @ENABLE_LIB_SHARED@
 ENABLE_LIB_STATIC = @ENABLE_LIB_STATIC@
+HAVE_WASI_SDK = @HAVE_WASI_SDK@

 CFLAGS = @CFLAGS@ @CPPFLAGS@
 #
@@ -71,11 +72,8 @@ LDFLAGS.rt = @LDFLAGS_RT@
 LDFLAGS.icu = @LDFLAGS_ICU@
 CFLAGS.icu = @CFLAGS_ICU@

-# When cross-compiling, we need to avoid the -s flag because it only
-# works on the build host's platform.
-INSTALL.strip.1 = $(INSTALL)
-INSTALL.strip.0 = $(INSTALL) -s
-INSTALL.strip   = $(INSTALL.strip.@IS_CROSS_COMPILING@)
+# INSTALL reminder: we specifically do not strip binaries,
+# as discussed in https://sqlite.org/forum/forumpost/9a67df63eda9925c.
 INSTALL.noexec  = $(INSTALL) -m 0644

 install-dir.bin = $(DESTDIR)$(bindir)
@@ -127,10 +125,8 @@ OPT_FEATURE_FLAGS = @OPT_FEATURE_FLAGS@

 LDFLAGS.libsqlite3.soname = @LDFLAGS_LIBSQLITE3_SONAME@
 # soname: see https://sqlite.org/src/forumpost/5a3b44f510df8ded
-LDFLAGS.libsqlite3.os-specific = @LDFLAGS_MAC_CVERSION@ @LDFLAGS_OUT_IMPLIB@
-# os-specific: see
-# - https://sqlite.org/forum/forumpost/9dfd5b8fd525a5d7
-# - https://sqlite.org/forum/forumpost/0c7fc097b2
+LDFLAGS.libsqlite3.os-specific = \
+  @LDFLAGS_MAC_CVERSION@ @LDFLAGS_MAC_INSTALL_NAME@ @LDFLAGS_OUT_IMPLIB@

 LDFLAGS.libsqlite3 = \
  $(LDFLAGS.rpath) $(LDFLAGS.pthread) \
@@ -195,6 +191,8 @@ install-dll-unix-generic: install-dll-out-implib
 install-dll-msys: install-dll-out-implib $(install-dir.bin)
 	$(INSTALL) $(libsqlite3.DLL) "$(install-dir.bin)"
 # ----------------------------------------------^^^ yes, bin
+# Each of {msys,mingw,cygwin} uses a different name for the DLL, but
+# that is already accounted for via $(libsqlite3.DLL).
 install-dll-mingw:  install-dll-msys
 install-dll-cygwin: install-dll-msys

@@ -220,27 +218,43 @@ install-lib-0 install-lib-:
 install-lib: install-lib-$(ENABLE_LIB_STATIC)
 install: install-lib

-
+#
 # Flags to link the shell app either directly against sqlite3.c
 # (ENABLE_STATIC_SHELL==1) or libsqlite3.so (ENABLE_STATIC_SHELL==0).
 #
 ENABLE_STATIC_SHELL = @ENABLE_STATIC_SHELL@
 sqlite3-shell-link-flags.1 = $(TOP)/sqlite3.c $(LDFLAGS.libsqlite3)
-sqlite3-shell-link-flags.0 = -L. -lsqlite3 $(LDFLAGS.zlib)
+sqlite3-shell-link-flags.0 = -L. -lsqlite3 $(LDFLAGS.zlib) $(LDFLAGS.math)
 sqlite3-shell-deps.1 = $(TOP)/sqlite3.c
 sqlite3-shell-deps.0 = $(libsqlite3.DLL)
+#
+# STATIC_CLI_SHELL = 1 to statically link sqlite3$(T.exe), else
+# 0. Requires static versions of all requisite libraries. Primarily
+# intended for use with static-friendly environments like Alpine
+# Linux.
+#
+STATIC_CLI_SHELL = @STATIC_CLI_SHELL@
+#
+# sqlite3-shell-static.flags.N = N is $(STATIC_CLI_SHELL)
+#
+sqlite3-shell-static.flags.1 = -static
+sqlite3-shell-static.flags.0 =
 sqlite3$(T.exe): $(TOP)/shell.c $(sqlite3-shell-deps.$(ENABLE_STATIC_SHELL))
 	$(CC) -o $@ \
 		$(TOP)/shell.c $(sqlite3-shell-link-flags.$(ENABLE_STATIC_SHELL)) \
+		$(sqlite3-shell-static.flags.$(STATIC_CLI_SHELL)) \
 		-I. $(OPT_FEATURE_FLAGS) $(SHELL_OPT) \
 		$(CFLAGS) $(CFLAGS.readline) $(CFLAGS.icu) \
 		$(LDFLAGS) $(LDFLAGS.readline)

-all: sqlite3$(T.exe)
+sqlite3$(T.exe)-1:
+sqlite3$(T.exe)-0: sqlite3$(T.exe)
+all: sqlite3$(T.exe)-$(HAVE_WASI_SDK)

-install-shell: sqlite3$(T.exe) $(install-dir.bin)
-	$(INSTALL.strip) sqlite3$(T.exe) "$(install-dir.bin)"
-install: install-shell
+install-shell-0: sqlite3$(T.exe) $(install-dir.bin)
+	$(INSTALL) sqlite3$(T.exe) "$(install-dir.bin)"
+install-shell-1:
+install: install-shell-$(HAVE_WASI_SDK)

 install-headers: $(TOP)/sqlite3.h $(install-dir.include)
 	$(INSTALL.noexec) $(TOP)/sqlite3.h $(TOP)/sqlite3ext.h "$(install-dir.include)"
@@ -269,15 +283,16 @@ DIST_FILES := \
  sqlite3.rc sqlite3rc.h Replace.cs \
  sqlite3.pc.in sqlite3.1

+#
 # Maintenance note: dist_name must be sqlite-$(PACKAGE_VERSION) so
 # that tool/mkautoconfamal.sh knows how to find it.
+#
 dist_name = sqlite-$(PACKAGE_VERSION)
 dist_tarball = $(dist_name).tar.gz
 dist:
 	rm -fr $(dist_name)
 	mkdir -p $(dist_name)
 	cp -rp $(DIST_FILES) $(dist_name)/.
-	rm -f $(dist_name)/tea/configure.ac.in
 	tar czf $(dist_tarball) $(dist_name)
 	rm -fr $(dist_name)
 	ls -l $(dist_tarball)
@@ -724,7 +724,7 @@ RCC = $(RCC) -DSQLITE_ENABLE_API_ARMOR=1
 !ENDIF

 !IF $(DEBUG)>2
-TCC = $(TCC) -DSQLITE_DEBUG=1
+TCC = $(TCC) -DSQLITE_DEBUG=1 -DSQLITE_USE_W32_FOR_CONSOLE_IO
 RCC = $(RCC) -DSQLITE_DEBUG=1
 !IF $(DYNAMIC_SHELL)==0
 TCC = $(TCC) -DSQLITE_ENABLE_WHERETRACE -DSQLITE_ENABLE_SELECTTRACE
@@ -90,7 +90,7 @@ 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
+with them enabled (see http://sqlite.org/compile.html). For example, the
 following will work:

  "OPTS=-DSQLITE_ENABLE_STAT4=1 -DSQLITE_OMIT_JSON=1"
@@ -5,6 +5,21 @@
 # "autoconf" bundle of the SQLite project.
 use sqlite-config
 sqlite-configure autoconf {
-  sqlite-check-common-bins
+  sqlite-handle-debug
+  sqlite-check-common-bins ;# must come before [sqlite-handle-wasi-sdk]
+  sqlite-handle-wasi-sdk   ;# must run relatively early, as it changes the environment
  sqlite-check-common-system-deps
+  proj-define-for-opt static-shell ENABLE_STATIC_SHELL \
+    "Link library statically into the CLI shell?"
+  proj-define-for-opt static-cli-shell STATIC_CLI_SHELL "Statically link CLI shell?"
+  if {![opt-bool static-shell] && [opt-bool static-cli-shell]} {
+    proj-fatal "--disable-static-shell and --static-cli-shell are mutualy exclusive"
+  }
+  if {![opt-bool shared] && ![opt-bool static-shell]} {
+    proj-opt-set shared 1
+    proj-indented-notice {
+      NOTICE: ignoring --disable-shared because --disable-static-shell
+      was specified.
+    }
+  }
 }
@@ -1,9 +1,30 @@
-This is the SQLite extension for Tcl using the Tcl Extension
-Architecture (TEA). 
+This is the SQLite extension for Tcl using something akin to
+the Tcl Extension Architecture (TEA). To build it:

----------------------- A BETTER WAY ---------------------------
+    ./configure ...flags...

-A better way to build the TCL extension for SQLite is to use the
+e.g.:
+
+    ./configure --with-tcl=/path/to/tcl/install/root
+
+or:
+
+    ./configure --with-tclsh=/path/to/tcl/install/root
+
+Run ./configure --help for the full list of flags.
+
+The configuration process will fail if tclConfig.sh cannot be found.
+
+The makefile will only honor CFLAGS and CPPFLAGS passed to the
+configure script, not those directly passed to the makefile.
+
+Then:
+
+    make test install
+
+----------------------- THE PREFERRED WAY ---------------------------
+
+The preferred way to build the TCL extension for SQLite is to use the
 canonical source code tarball.  For Unix:

    ./configure --with-tclsh=$(TCLSH)
@@ -20,24 +41,32 @@ step-by-step instructions at the links below for more information:
    https://sqlite.org/src/doc/trunk/doc/compile-for-unix.md
    https://sqlite.org/src/doc/trunk/doc/compile-for-windows.md

-The whole point of the amalgamation-autoconf tarball (in which this
-README.txt file is embedded) is to provide a means of compiling
-SQLite that does not require first installing TCL and/or "tclsh".
-The canonical Makefile in the SQLite source tree provides more
-capabilities (such as the the ability to run test cases to ensure
-that the build worked) and is better maintained.  The only
-downside of the canonical Makefile is that it requires a TCL
-installation.  But if you are wanting to build the TCL extension for
-SQLite, then presumably you already have a TCL installation.  So why
-not just use the more-capable and better-maintained canoncal Makefile?
+And info about the extension's Tcl interface can be found at:

-This TEA builder is derived from code found at
+    https://sqlite.org/tclsqlite.html
+
+The whole point of the amalgamation-autoconf tarball (in which this
+README.txt file is embedded) is to provide a means of compiling SQLite
+that does not require first installing TCL and/or "tclsh".  The
+canonical Makefile in the SQLite source tree provides more
+capabilities (such as the the ability to run test cases to ensure that
+the build worked) and is better maintained.  The only downside of the
+canonical Makefile is that it requires a TCL installation.  But if you
+are wanting to build the TCL extension for SQLite, then presumably you
+already have a TCL installation.  So why not just use the more-capable
+and better-maintained canoncal Makefile?
+
+As of version 3.50.0, this build process uses "teaish":
+
+    https://fossil.wanderinghorse.net/r/teaish
+
+which is conceptually derived from the pre-3.50 toolchain, TEA:

    http://core.tcl-lang.org/tclconfig
    http://core.tcl-lang.org/sampleextension

-The SQLite developers do not understand how it works.  It seems to
-work for us.  It might also work for you.  But we cannot promise that.
+It to works for us.  It might also work for you.  But we cannot
+promise that.

 If you want to use this TEA builder and it works for you, that's fine.
 But if you have trouble, the first thing you should do is go back
@@ -49,30 +78,17 @@ to using the canonical Makefile in the SQLite source tree.
 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.
+Building under most UNIX systems is easy, just run the configure
+script and then run make. For example:

 	$ cd sqlite-*-tea
-	$ ./configure --prefix=/opt/tcl
-	$ make
+	$ ./configure --with-tcl=/path/to/tcl/install/root
+	$ make test
 	$ 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.
+On Windows this build is known to work on Cygwin and some Msys2
+environments. We do not currently support Microsoft makefiles for
+native Windows builds.
@@ -0,0 +1,50 @@
+# -*- tcl -*-
+#
+# Unless this file is named _teaish.tester.tcl.in, you are probably
+# looking at an automatically generated/filtered copy and should
+# probably not edit it.
+#
+# This is the wrapper script invoked by teaish's "make test" recipe.
+# It gets passed 3 args:
+#
+# $1 = the DLL name, or "" if the extension has no DLL
+#
+# $2 = the "load prefix" for Tcl's [load] or empty if $1 is empty
+#
+# $3 = the /path/to/teaish/tester.tcl (test utility code)
+#
+@if TEAISH_VSATISFIES_CODE
+@TEAISH_VSATISFIES_CODE@
+@endif
+if {[llength [lindex $::argv 0]] > 0} {
+  load [file normalize [lindex $::argv 0]] [lindex $::argv 1];
+  # ----^^^^^^^ needed on Haiku when argv 0 is just a filename, else
+  # load cannot find the file.
+}
+set ::argv [lassign $argv - -]
+source -encoding utf-8 [lindex $::argv 0]; # teaish/tester.tcl
+@if TEAISH_PKGINIT_TCL
+apply {{file} {
+  set dir [file dirname $::argv0]
+  source -encoding utf-8 $file
+}} [join {@TEAISH_PKGINIT_TCL@}]
+@endif
+@if TEAISH_TM_TCL
+apply {{file} {
+  set dir [file dirname $::argv0]
+  source -encoding utf-8 $file
+}} [join {@TEAISH_TM_TCL@}]
+@endif
+@if TEAISH_TEST_TCL
+apply {{file} {
+  # Populate state for [tester.tcl::teaish-build-flag*]
+  array set ::teaish__BuildFlags @TEAISH__DEFINES_MAP@
+  set dir [file normalize [file dirname $file]]
+  #test-fail "Just testing"
+  source -encoding utf-8 $file
+}} [join {@TEAISH_TEST_TCL@}]
+@else # TEAISH_TEST_TCL
+# No $TEAISH_TEST_TCL provided, so here's a default test which simply
+# loads the extension.
+puts {Extension @TEAISH_NAME@ @TEAISH_VERSION@ successfully loaded from @TEAISH_TESTER_TCL@}
+@endif
@@ -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
-#
@@ -0,0 +1,8 @@
+#/do/not/tclsh
+# ^^^ help out editors which guess this file's content type.
+#
+# Main configure script entry point for the TEA(ish) framework.  All
+# extension-specific customization goes in teaish.tcl.in or
+# teaish.tcl.
+use teaish/core
+teaish-configure-core
@@ -0,0 +1,7 @@
+#!/bin/sh
+dir0="`dirname "$0"`"
+dirA="$dir0/../autosetup"
+# This is the case ^^^^^^^^^^^^ in the SQLite "autoconf" bundle.
+WRAPPER="$0"; export WRAPPER; exec "`"$dirA/autosetup-find-tclsh"`" \
+                                   "$dirA/autosetup" --teaish-extension-dir="$dir0" \
+                                   "$@"
@@ -1,227 +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.
-
-#-----------------------------------------------------------------------
-# Sample configure.ac 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.
-# This will also define a special symbol for Windows (BUILD_<PACKAGE_NAME>
-# so that we create the export library with the dll.
-#-----------------------------------------------------------------------
-
-AC_INIT([sqlite],[@VERSION@])
-
-#--------------------------------------------------------------------
-# 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()
-
-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 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([])
-TEA_ADD_LIBS([])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_FTS3=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_FTS4=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_FTS5=1])
-TEA_ADD_CFLAGS([-DSQLITE_3_SUFFIX_ONLY=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_RTREE=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_GEOPOLY=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_MATH_FUNCTIONS=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_DESERIALIZE=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_DBPAGE_VTAB=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_BYTECODE_VTAB=1])
-TEA_ADD_CFLAGS([-DSQLITE_ENABLE_DBSTAT_VTAB=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
-# undesirable dependences and is not recommended.
-# Patchs from rmax.
-#--------------------------------------------------------------------
-AC_ARG_WITH([system-sqlite],
- [AS_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__
-#
-# You can add more files to clean if your extension creates any extra
-# files by extending CLEANFILES.
-# Add pkgIndex.tcl if it is generated in the Makefile instead of ./configure
-# and change Makefile.in to move it from CONFIG_CLEAN_FILES to BINARIES var.
-#
-# A few miscellaneous platform-specific items:
-# TEA_ADD_* any platform specific compiler/build info here.
-#--------------------------------------------------------------------
-
-#CLEANFILES="$CLEANFILES pkgIndex.tcl"
-if test "${TEA_PLATFORM}" = "windows" ; then
-    # Ensure no empty if clauses
-    :
-    #TEA_ADD_SOURCES([win/winFile.c])
-    #TEA_ADD_INCLUDES([-I\"$(${CYGPATH} ${srcdir}/win)\"])
-else
-    # Ensure no empty else clauses
-    :
-    #TEA_ADD_SOURCES([unix/unixFile.c])
-    #TEA_ADD_LIBS([-lsuperfly])
-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
-
-#--------------------------------------------------------------------
-# 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
-
-#--------------------------------------------------------------------
-# Setup a *Config.sh.in configuration file.
-#--------------------------------------------------------------------
-
-#TEA_EXPORT_CONFIG([sample])
-#AC_SUBST(SAMPLE_VAR)
-
-#--------------------------------------------------------------------
-# Specify files to substitute AC variables in. You may alternatively
-# have a special pkgIndex.tcl.in or other files which require
-# substituting the AC variables in. Include these here.
-#--------------------------------------------------------------------
-
-AC_CONFIG_FILES([Makefile pkgIndex.tcl])
-#AC_CONFIG_FILES([sampleConfig.sh])
-
-#--------------------------------------------------------------------
-# Finally, substitute all of the various values into the files
-# specified with AC_CONFIG_FILES.
-#--------------------------------------------------------------------
-
-AC_OUTPUT
@@ -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.
@@ -1,10 +1,40 @@
 # -*- tcl -*-
-# Tcl package index file, version 1.1
+# Tcl package index file
 #
+# Unless this file is named pkgIndex.tcl.in, you are probably looking
+# at an automatically generated/filtered copy and should probably not
+# edit it.
+#
+# Adapted from https://core.tcl-lang.org/tcltls
+@if TEAISH_VSATISFIES_CODE
+@TEAISH_VSATISFIES_CODE@
+@endif
 if {[package vsatisfies [package provide Tcl] 9.0-]} {
-    package ifneeded sqlite3 @PACKAGE_VERSION@ \
-	    [list load [file join $dir @PKG_LIB_FILE9@] Sqlite3]
+  package ifneeded {@TEAISH_PKGNAME@} {@TEAISH_VERSION@} [list apply {{dir} {
+@if TEAISH_ENABLE_DLL
+    load [file join $dir {@TEAISH_DLL9@}] @TEAISH_LOAD_PREFIX@
+@endif
+@if TEAISH_PKGINIT_TCL_TAIL
+    set initScript [file join $dir {@TEAISH_PKGINIT_TCL_TAIL@}]
+    if {[file exists $initScript]} {
+      source -encoding utf-8 $initScript
+    }
+@endif
+  }} $dir]
 } else {
-    package ifneeded sqlite3 @PACKAGE_VERSION@ \
-	    [list load [file join $dir @PKG_LIB_FILE8@] Sqlite3]
+  package ifneeded {@TEAISH_PKGNAME@} {@TEAISH_VERSION@} [list apply {{dir} {
+@if TEAISH_ENABLE_DLL
+    if {[string tolower [file extension {@TEAISH_DLL8@}]] in [list .dll .dylib .so]} {
+      load [file join $dir {@TEAISH_DLL8@}] @TEAISH_LOAD_PREFIX@
+    } else {
+      load {} @TEAISH_LOAD_PREFIX@
+    }
+@endif
+@if TEAISH_PKGINIT_TCL_TAIL
+    set initScript [file join $dir {@TEAISH_PKGINIT_TCL_TAIL@}]
+    if {[file exists $initScript]} {
+      source -encoding utf-8 $initScript
+    }
+@endif
+  }} $dir]
 }
@@ -1,541 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2020-11-14.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.
-
-tab='	'
-nl='
-'
-IFS=" $tab$nl"
-
-# Set DOITPROG to "echo" to test this script.
-
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
-
-# 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_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-# Create dirs (including intermediate dirs) using mode 755.
-# This is like GNU 'install' as of coreutils 8.32 (2020).
-mkdir_umask=22
-
-backupsuffix=
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-is_target_a_directory=possibly
-
-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 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.
-  -p            pass -p to $cpprog.
-  -s            $stripprog installed files.
-  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
-  -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
-
-By default, rm is invoked with -f; when overridden with RMPROG,
-it's up to you to specify -f if you want it.
-
-If -S is not specified, no backups are attempted.
-
-Email bug reports to bug-automake@gnu.org.
-Automake home page: https://www.gnu.org/software/automake/
-"
-
-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
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
-
-    -o) chowncmd="$chownprog $2"
-        shift;;
-
-    -p) cpprog="$cpprog -p";;
-
-    -s) stripcmd=$stripprog;;
-
-    -S) backupsuffix="$2"
-        shift;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --) shift
-        break;;
-
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-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
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
-  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
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-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 problematic for 'test' and other utilities.
-  case $src in
-    -* | [=\(\)!]) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-    # Don't chown directories that already exist.
-    if test $dstdir_status = 0; then
-      chowncmd=""
-    fi
-  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
-
-    # If destination is a directory, append the input filename.
-    if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
-      fi
-      dstdir=$dst
-      dstbase=`basename "$src"`
-      case $dst in
-	*/) dst=$dst$dstbase;;
-	*)  dst=$dst/$dstbase;;
-      esac
-      dstdir_status=0
-    else
-      dstdir=`dirname "$dst"`
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  case $dstdir in
-    */) dstdirslash=$dstdir;;
-    *)  dstdirslash=$dstdir/;;
-  esac
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-        # 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
-	# The $RANDOM variable is not portable (e.g., dash).  Use it
-	# here however when possible just to lower collision chance.
-	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-
-	trap '
-	  ret=$?
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
-	  exit $ret
-	' 0
-
-	# Because "mkdir -p" follows existing symlinks and we likely work
-	# directly in world-writeable /tmp, make sure that the '$tmpdir'
-	# directory is successfully created first before we actually test
-	# 'mkdir -p'.
-	if (umask $mkdir_umask &&
-	    $mkdirprog $mkdir_mode "$tmpdir" &&
-	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/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-writable bit of parent directory when it shouldn't.
-	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-	       test_tmpdir="$tmpdir/a"
-	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
-	       case $ls_ld_tmpdir in
-		 d????-?r-*) different_mode=700;;
-		 d????-?--*) different_mode=755;;
-		 *) false;;
-	       esac &&
-	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
-		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
-		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-	       }
-	     }
-	  then posix_mkdir=:
-	  fi
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
-	else
-	  # Remove any dirs left behind by ancient mkdir implementations.
-	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
-	fi
-	trap '' 0;;
-    esac
-
-    if
-      $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # 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
-
-      oIFS=$IFS
-      IFS=/
-      set -f
-      set fnord $dstdir
-      shift
-      set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-        test X"$d" = X && 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=${dstdirslash}_inst.$$_
-    rmtmp=${dstdirslash}_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 &&
-     { test -z "$stripcmd" || {
-	 # Create $dsttmp read-write so that cp doesn't create it read-only,
-	 # which would cause strip to fail.
-	 if test -z "$doit"; then
-	   : >"$dsttmp" # No need to fork-exec 'touch'.
-	 else
-	   $doit touch "$dsttmp"
-	 fi
-       }
-     } &&
-     $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` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # If $backupsuffix is set, and the file being installed
-      # already exists, attempt a backup.  Don't worry if it fails,
-      # e.g., if mv doesn't support -f.
-      if test -n "$backupsuffix" && test -f "$dst"; then
-        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
-      fi
-
-      # 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 "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd "$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 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
@@ -0,0 +1,569 @@
+# Teaish configure script for the SQLite Tcl extension
+
+#
+# State for disparate config-time pieces.
+#
+array set sqlite__Config [proj-strip-hash-comments {
+  #
+  # The list of feature --flags which the --all flag implies. This
+  # requires special handling in a few places.
+  #
+  all-flag-enables {fts3 fts4 fts5 rtree geopoly}
+
+  # >0 if building in the canonical tree. -1=undetermined
+  is-canonical -1
+}]
+
+#
+# Set up the package info for teaish...
+#
+apply {{dir} {
+  # Figure out the version number...
+  set version ""
+  if {[file exists $dir/../VERSION]} {
+    # The canonical SQLite TEA(ish) build
+    set version [proj-file-content -trim $dir/../VERSION]
+    set ::sqlite__Config(is-canonical) 1
+    set distname sqlite-tcl
+  } elseif {[file exists $dir/generic/tclsqlite3.c]} {
+    # The copy from the teaish tree, used as a dev/test bed before
+    # updating SQLite's tree.
+    set ::sqlite__Config(is-canonical) 0
+    set fd [open $dir/generic/tclsqlite3.c rb]
+    while {[gets $fd line] >=0} {
+      if {[regexp {^#define[ ]+SQLITE_VERSION[ ]+"(3.+)"} \
+             $line - version]} {
+        set distname sqlite-teaish
+        break
+      }
+    }
+    close $fd
+  }
+
+  if {"" eq $version} {
+    proj-fatal "Cannot determine the SQLite version number"
+  }
+
+  proj-assert {$::sqlite__Config(is-canonical) > -1}
+  proj-assert {[string match 3.*.* $version]} \
+    "Unexpected SQLite version: $version"
+
+  set pragmas {}
+  if {$::sqlite__Config(is-canonical)} {
+    # Disable "make dist" in the canonical tree.  That tree is
+    # generated from several pieces and creating/testing working
+    # "dist" rules for that sub-build currently feels unnecessary. The
+    # copy in the teaish tree, though, should be able to "make dist".
+    lappend pragmas no-dist
+  } else {
+    lappend pragmas full-dist
+  }
+
+  teaish-pkginfo-set -vars {
+    -name sqlite
+    -name.pkg sqlite3
+    -version $version
+    -name.dist $distname
+    -libDir sqlite$version
+    -pragmas $pragmas
+    -src generic/tclsqlite3.c
+  }
+  # We should also have:
+  #    -vsatisfies 8.6-
+  # But at least one platform is failing this vsatisfies check
+  # for no apparent reason:
+  # https://sqlite.org/forum/forumpost/fde857fb8101a4be
+}} [teaish-get -dir]
+
+
+#
+# Must return either an empty string or a list in the form accepted by
+# autosetup's [options] function.
+#
+proc teaish-options {} {
+  # These flags and defaults mostly derive from the historical TEA
+  # build.  Some, like ICU, are taken from the canonical SQLite tree.
+  return [subst -nocommands -nobackslashes {
+    with-system-sqlite=0
+      => {Use the system-level SQLite instead of the copy in this tree.
+          Also requires use of --override-sqlite-version so that the build
+          knows what version number to associate with the system-level SQLite.}
+    override-sqlite-version:VERSION
+      => {For use with --with-system-sqlite to set the version number.}
+    threadsafe=1         => {Disable mutexing}
+    with-tempstore:=no   => {Use an in-RAM database for temporary tables: never,no,yes,always}
+    load-extension=0     => {Enable loading of external extensions}
+    math=1               => {Disable math functions}
+    json=1               => {Disable JSON functions}
+    fts3                 => {Enable the FTS3 extension}
+    fts4                 => {Enable the FTS4 extension}
+    fts5                 => {Enable the FTS5 extension}
+    update-limit         => {Enable the UPDATE/DELETE LIMIT clause}
+    geopoly              => {Enable the GEOPOLY extension}
+    rtree                => {Enable the RTREE extension}
+    session              => {Enable the SESSION extension}
+    all=1                => {Disable $::sqlite__Config(all-flag-enables)}
+    with-icu-ldflags:LDFLAGS
+      => {Enable SQLITE_ENABLE_ICU and add the given linker flags for the
+          ICU libraries. e.g. on Ubuntu systems, try '-licui18n -licuuc -licudata'.}
+    with-icu-cflags:CFLAGS
+      => {Apply extra CFLAGS/CPPFLAGS necessary for building with ICU.
+          e.g. -I/usr/local/include}
+    with-icu-config:=auto
+      => {Enable SQLITE_ENABLE_ICU. Value must be one of: auto, pkg-config,
+          /path/to/icu-config}
+    icu-collations=0
+      => {Enable SQLITE_ENABLE_ICU_COLLATIONS. Requires --with-icu-ldflags=...
+          or --with-icu-config}
+  }]
+}
+
+#
+# Gets called by tea-configure-core. Must perform any configuration
+# work needed for this extension.
+#
+proc teaish-configure {} {
+  use teaish/feature
+
+  if {[proj-opt-was-provided override-sqlite-version]} {
+    teaish-pkginfo-set -version [opt-val override-sqlite-version]
+    proj-warn "overriding sqlite version number:" [teaish-pkginfo-get -version]
+  } elseif {[proj-opt-was-provided with-system-sqlite]
+            && [opt-val with-system-sqlite] ne "0"} {
+    proj-fatal "when using --with-system-sqlite also use" \
+      "--override-sqlite-version to specify a library version number."
+  }
+
+  define CFLAGS [proj-get-env CFLAGS {-O2}]
+  sqlite-munge-cflags
+
+  #
+  # Add feature flags from legacy configure.ac which are not covered by
+  # --flags.
+  #
+  sqlite-add-feature-flag {
+    -DSQLITE_3_SUFFIX_ONLY=1
+    -DSQLITE_ENABLE_DESERIALIZE=1
+    -DSQLITE_ENABLE_DBPAGE_VTAB=1
+    -DSQLITE_ENABLE_BYTECODE_VTAB=1
+    -DSQLITE_ENABLE_DBSTAT_VTAB=1
+  }
+
+  if {[opt-bool with-system-sqlite]} {
+    msg-result "Using system-level sqlite3."
+    teaish-cflags-add -DUSE_SYSTEM_SQLITE
+    teaish-ldflags-add -lsqlite3
+  } elseif {$::sqlite__Config(is-canonical)} {
+    teaish-cflags-add -I[teaish-get -dir]/..
+  }
+
+  teaish-check-librt
+  teaish-check-libz
+  sqlite-handle-threadsafe
+  sqlite-handle-tempstore
+  sqlite-handle-load-extension
+  sqlite-handle-math
+  sqlite-handle-icu
+
+  sqlite-handle-common-feature-flags; # must be late in the process
+}; # teaish-configure
+
+define OPT_FEATURE_FLAGS {} ; # -DSQLITE_OMIT/ENABLE flags.
+#
+# Adds $args, if not empty, to OPT_FEATURE_FLAGS. This is intended only for holding
+# -DSQLITE_ENABLE/OMIT/... flags, but that is not enforced here.
+proc sqlite-add-feature-flag {args} {
+  if {"" ne $args} {
+    define-append OPT_FEATURE_FLAGS {*}$args
+  }
+}
+
+#
+# Check for log(3) in libm and die with an error if it is not
+# found. $featureName should be the feature name which requires that
+# function (it's used only in error messages). defines LDFLAGS_MATH to
+# the required linker flags (which may be empty even if the math APIs
+# are found, depending on the OS).
+proc sqlite-affirm-have-math {featureName} {
+  if {"" eq [get-define LDFLAGS_MATH ""]} {
+    if {![msg-quiet proj-check-function-in-lib log m]} {
+      user-error "Missing math APIs for $featureName"
+    }
+    set lfl [get-define lib_log ""]
+    undefine lib_log
+    if {"" ne $lfl} {
+      user-notice "Forcing requirement of $lfl for $featureName"
+    }
+    define LDFLAGS_MATH $lfl
+    teaish-ldflags-prepend $lfl
+  }
+}
+
+#
+# Handle various SQLITE_ENABLE/OMIT_... feature flags.
+proc sqlite-handle-common-feature-flags {} {
+  msg-result "Feature flags..."
+  if {![opt-bool all]} {
+    # Special handling for --disable-all
+    foreach flag $::sqlite__Config(all-flag-enables) {
+      if {![proj-opt-was-provided $flag]} {
+        proj-opt-set $flag 0
+      }
+    }
+  }
+  foreach {boolFlag featureFlag ifSetEvalThis} [proj-strip-hash-comments {
+    all         {} {
+      # The 'all' option must be first in this list.  This impl makes
+      # an effort to only apply flags which the user did not already
+      # apply, so that combinations like (--all --disable-geopoly)
+      # will indeed disable geopoly. There are corner cases where
+      # flags which depend on each other will behave in non-intuitive
+      # ways:
+      #
+      # --all --disable-rtree
+      #
+      # Will NOT disable geopoly, though geopoly depends on rtree.
+      # The --geopoly flag, though, will automatically re-enable
+      # --rtree, so --disable-rtree won't actually disable anything in
+      # that case.
+      foreach k $::sqlite__Config(all-flag-enables) {
+        if {![proj-opt-was-provided $k]} {
+          proj-opt-set $k 1
+        }
+      }
+    }
+    fts3         -DSQLITE_ENABLE_FTS3    {sqlite-affirm-have-math fts3}
+    fts4         -DSQLITE_ENABLE_FTS4    {sqlite-affirm-have-math fts4}
+    fts5         -DSQLITE_ENABLE_FTS5    {sqlite-affirm-have-math fts5}
+    geopoly      -DSQLITE_ENABLE_GEOPOLY {proj-opt-set rtree}
+    rtree        -DSQLITE_ENABLE_RTREE   {}
+    session      {-DSQLITE_ENABLE_SESSION -DSQLITE_ENABLE_PREUPDATE_HOOK} {}
+    update-limit -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT {}
+    scanstatus     -DSQLITE_ENABLE_STMT_SCANSTATUS {}
+  }] {
+    if {$boolFlag ni $::autosetup(options)} {
+      # Skip flags which are in the canonical build but not
+      # the autoconf bundle.
+      continue
+    }
+    proj-if-opt-truthy $boolFlag {
+      sqlite-add-feature-flag $featureFlag
+      if {0 != [eval $ifSetEvalThis] && "all" ne $boolFlag} {
+        msg-result "  + $boolFlag"
+      }
+    } {
+      if {"all" ne $boolFlag} {
+        msg-result "  - $boolFlag"
+      }
+    }
+  }
+  #
+  # Invert the above loop's logic for some SQLITE_OMIT_...  cases. If
+  # config option $boolFlag is false, [sqlite-add-feature-flag
+  # $featureFlag], where $featureFlag is intended to be
+  # -DSQLITE_OMIT_...
+  foreach {boolFlag featureFlag} {
+    json        -DSQLITE_OMIT_JSON
+  } {
+    if {[proj-opt-truthy $boolFlag]} {
+      msg-result "  + $boolFlag"
+    } else {
+      sqlite-add-feature-flag $featureFlag
+      msg-result "  - $boolFlag"
+    }
+  }
+
+  ##
+  # Remove duplicates from the final feature flag sets and show them
+  # to the user.
+  set oFF [get-define OPT_FEATURE_FLAGS]
+  if {"" ne $oFF} {
+    define OPT_FEATURE_FLAGS [lsort -unique $oFF]
+    msg-result "Library feature flags: [get-define OPT_FEATURE_FLAGS]"
+  }
+  if {[lsearch [get-define TARGET_DEBUG ""] -DSQLITE_DEBUG=1] > -1} {
+    msg-result "Note: this is a debug build, so performance will suffer."
+  }
+  teaish-cflags-add -define OPT_FEATURE_FLAGS
+}; # sqlite-handle-common-feature-flags
+
+#
+# If --enable-threadsafe is set, this adds -DSQLITE_THREADSAFE=1 to
+# OPT_FEATURE_FLAGS and sets LDFLAGS_PTHREAD to the linker flags
+# needed for linking pthread (possibly an empty string). If
+# --enable-threadsafe is not set, adds -DSQLITE_THREADSAFE=0 to
+# OPT_FEATURE_FLAGS and sets LDFLAGS_PTHREAD to an empty string.
+#
+# It prepends the flags to the global LDFLAGS.
+proc sqlite-handle-threadsafe {} {
+  msg-checking "Support threadsafe operation? "
+  define LDFLAGS_PTHREAD ""
+  set enable 0
+  if {[proj-opt-was-provided threadsafe]} {
+    proj-if-opt-truthy threadsafe {
+      if {[proj-check-function-in-lib pthread_create pthread]
+          && [proj-check-function-in-lib pthread_mutexattr_init pthread]} {
+        incr enable
+        set ldf [get-define lib_pthread_create]
+        define LDFLAGS_PTHREAD $ldf
+        teaish-ldflags-prepend $ldf
+        undefine lib_pthread_create
+        undefine lib_pthread_mutexattr_init
+      } else {
+        user-error "Missing required pthread libraries. Use --disable-threadsafe to disable this check."
+      }
+      # Recall that LDFLAGS_PTHREAD might be empty even if pthreads if
+      # found because it's in -lc on some platforms.
+    } {
+      msg-result "Disabled using --disable-threadsafe"
+    }
+  } else {
+    #
+    # If user does not specify --[disable-]threadsafe then select a
+    # default based on whether it looks like Tcl has threading
+    # support.
+    #
+    catch {
+      scan [exec echo {puts [tcl::pkgconfig get threaded]} | [get-define TCLSH_CMD]] \
+        %d enable
+    }
+    if {$enable} {
+      set flagName "--threadsafe"
+      set lblAbled "enabled"
+      msg-result yes
+    } else {
+      set flagName "--disable-threadsafe"
+      set lblAbled "disabled"
+      msg-result no
+    }
+    msg-result "Defaulting to ${flagName} because Tcl has threading ${lblAbled}."
+    # ^^^ We (probably) don't need to link against -lpthread in the
+    # is-enabled case. We might in the case of static linking. Unsure.
+  }
+  sqlite-add-feature-flag -DSQLITE_THREADSAFE=${enable}
+  return $enable
+}
+
+#
+# Handles the --enable-load-extension flag. Returns 1 if the support
+# is enabled, else 0. If support for that feature is not found, a
+# fatal error is triggered if --enable-load-extension is explicitly
+# provided, else a loud warning is instead emitted. If
+# --disable-load-extension is used, no check is performed.
+#
+# Makes the following environment changes:
+#
+# - defines LDFLAGS_DLOPEN to any linker flags needed for this
+#   feature.  It may legally be empty on some systems where dlopen()
+#   is in libc.
+#
+# - If the feature is not available, adds
+#   -DSQLITE_OMIT_LOAD_EXTENSION=1 to the feature flags list.
+proc sqlite-handle-load-extension {} {
+  define LDFLAGS_DLOPEN ""
+  set found 0
+  proj-if-opt-truthy load-extension {
+    set found [proj-check-function-in-lib dlopen dl]
+    if {$found} {
+      set ldf [get-define lib_dlopen]
+      define LDFLAGS_DLOPEN $ldf
+      teaish-ldflags-prepend $ldf
+      undefine lib_dlopen
+    } else {
+      if {[proj-opt-was-provided load-extension]} {
+        # Explicit --enable-load-extension: fail if not found
+        proj-indented-notice -error {
+          --enable-load-extension was provided but dlopen()
+          not found. Use --disable-load-extension to bypass this
+          check.
+        }
+      } else {
+        # It was implicitly enabled: warn if not found
+        proj-indented-notice {
+          WARNING: dlopen() not found, so loadable module support will
+          be disabled. Use --disable-load-extension to bypass this
+          check.
+        }
+      }
+    }
+  }
+  if {$found} {
+    msg-result "Loadable extension support enabled."
+  } else {
+    msg-result "Disabling loadable extension support. Use --enable-load-extension to enable them."
+    sqlite-add-feature-flag -DSQLITE_OMIT_LOAD_EXTENSION=1
+  }
+  return $found
+}
+
+#
+# ICU - International Components for Unicode
+#
+# Handles these flags:
+#
+#  --with-icu-ldflags=LDFLAGS
+#  --with-icu-cflags=CFLAGS
+#  --with-icu-config[=auto | pkg-config | /path/to/icu-config]
+#  --enable-icu-collations
+#
+# --with-icu-config values:
+#
+#   - auto: use the first one of (pkg-config, icu-config) found on the
+#     system.
+#   - pkg-config: use only pkg-config to determine flags
+#   - /path/to/icu-config: use that to determine flags
+#
+# If --with-icu-config is used as neither pkg-config nor icu-config
+# are found, fail fatally.
+#
+# If both --with-icu-ldflags and --with-icu-config are provided, they
+# are cumulative.  If neither are provided, icu-collations is not
+# honored and a warning is emitted if it is provided.
+#
+# Design note: though we could automatically enable ICU if the
+# icu-config binary or (pkg-config icu-io) are found, we specifically
+# do not. ICU is always an opt-in feature.
+proc sqlite-handle-icu {} {
+  define LDFLAGS_LIBICU [join [opt-val with-icu-ldflags ""]]
+  define CFLAGS_LIBICU [join [opt-val with-icu-cflags ""]]
+  if {[proj-opt-was-provided with-icu-config]} {
+    msg-result "Checking for ICU support..."
+    set icuConfigBin [opt-val with-icu-config]
+    set tryIcuConfigBin 1; # set to 0 if we end up using pkg-config
+    if {$icuConfigBin in {auto pkg-config}} {
+      uplevel 3 { use pkg-config }
+      if {[pkg-config-init 0] && [pkg-config icu-io]} {
+        # Maintenance reminder: historical docs say to use both of
+        # (icu-io, icu-uc). icu-uc lacks a required lib and icu-io has
+        # all of them on tested OSes.
+        set tryIcuConfigBin 0
+        define LDFLAGS_LIBICU [get-define PKG_ICU_IO_LDFLAGS]
+        define-append LDFLAGS_LIBICU [get-define PKG_ICU_IO_LIBS]
+        define CFLAGS_LIBICU [get-define PKG_ICU_IO_CFLAGS]
+      } elseif {"pkg-config" eq $icuConfigBin} {
+        proj-fatal "pkg-config cannot find package icu-io"
+      } else {
+        proj-assert {"auto" eq $icuConfigBin}
+      }
+    }
+    if {$tryIcuConfigBin} {
+      if {"auto" eq $icuConfigBin} {
+        set icuConfigBin [proj-first-bin-of \
+                            /usr/local/bin/icu-config \
+                            /usr/bin/icu-config]
+        if {"" eq $icuConfigBin} {
+          proj-indented-notice -error {
+            --with-icu-config=auto cannot find (pkg-config icu-io) or icu-config binary.
+            On Ubuntu-like systems try:
+            --with-icu-ldflags='-licui18n -licuuc -licudata'
+          }
+        }
+      }
+      if {[file-isexec $icuConfigBin]} {
+        set x [exec $icuConfigBin --ldflags]
+        if {"" eq $x} {
+          proj-indented-notice -error \
+            [subst {
+              $icuConfigBin --ldflags returned no data.
+              On Ubuntu-like systems try:
+              --with-icu-ldflags='-licui18n -licuuc -licudata'
+            }]
+        }
+        define-append LDFLAGS_LIBICU $x
+        set x [exec $icuConfigBin --cppflags]
+        define-append CFLAGS_LIBICU $x
+      } else {
+        proj-fatal "--with-icu-config=$icuConfigBin does not refer to an executable"
+      }
+    }
+  }
+  set ldflags [define LDFLAGS_LIBICU [string trim [get-define LDFLAGS_LIBICU]]]
+  set cflags [define CFLAGS_LIBICU [string trim [get-define CFLAGS_LIBICU]]]
+  if {"" ne $ldflags} {
+    sqlite-add-feature-flag -DSQLITE_ENABLE_ICU
+    msg-result "Enabling ICU support with flags: $ldflags $cflags"
+    if {[opt-bool icu-collations]} {
+      msg-result "Enabling ICU collations."
+      sqlite-add-feature-flag -DSQLITE_ENABLE_ICU_COLLATIONS
+    }
+    teaish-ldflags-prepend $ldflags
+    teaish-cflags-add $cflags
+  } elseif {[opt-bool icu-collations]} {
+    proj-warn "ignoring --enable-icu-collations because neither --with-icu-ldflags nor --with-icu-config provided any linker flags"
+  } else {
+    msg-result "ICU support is disabled."
+  }
+}; # sqlite-handle-icu
+
+
+#
+# Handles the --with-tempstore flag.
+#
+# The test fixture likes to set SQLITE_TEMP_STORE on its own, so do
+# not set that feature flag unless it was explicitly provided to the
+# configure script.
+proc sqlite-handle-tempstore {} {
+  if {[proj-opt-was-provided with-tempstore]} {
+    set ts [opt-val with-tempstore no]
+    set tsn 1
+    msg-checking "Use an in-RAM database for temporary tables? "
+    switch -exact -- $ts {
+      never  { set tsn 0 }
+      no     { set tsn 1 }
+      yes    { set tsn 2 }
+      always { set tsn 3 }
+      default {
+        user-error "Invalid --with-tempstore value '$ts'. Use one of: never, no, yes, always"
+      }
+    }
+    msg-result $ts
+    sqlite-add-feature-flag -DSQLITE_TEMP_STORE=$tsn
+  }
+}
+
+#
+# Handles the --enable-math flag.
+proc sqlite-handle-math {} {
+  proj-if-opt-truthy math {
+    if {![proj-check-function-in-lib ceil m]} {
+      user-error "Cannot find libm functions. Use --disable-math to bypass this."
+    }
+    set lfl [get-define lib_ceil]
+    undefine lib_ceil
+    define LDFLAGS_MATH $lfl
+    teaish-ldflags-prepend $lfl
+    sqlite-add-feature-flag -DSQLITE_ENABLE_MATH_FUNCTIONS
+    msg-result "Enabling math SQL functions"
+  } {
+    define LDFLAGS_MATH ""
+    msg-result "Disabling math SQL functions"
+  }
+}
+
+#
+# Move -DSQLITE_OMIT... and -DSQLITE_ENABLE... flags from CFLAGS and
+# CPPFLAGS to OPT_FEATURE_FLAGS and remove them from BUILD_CFLAGS.
+proc sqlite-munge-cflags {} {
+  # Move CFLAGS and CPPFLAGS entries matching -DSQLITE_OMIT* and
+  # -DSQLITE_ENABLE* to OPT_FEATURE_FLAGS. This behavior is derived
+  # from the pre-3.48 build.
+  #
+  # If any configure flags for features are in conflict with
+  # CFLAGS/CPPFLAGS-specified feature flags, all bets are off.  There
+  # are no guarantees about which one will take precedence.
+  foreach flagDef {CFLAGS CPPFLAGS} {
+    set tmp ""
+    foreach cf [get-define $flagDef ""] {
+      switch -glob -- $cf {
+        -DSQLITE_OMIT* -
+        -DSQLITE_ENABLE* {
+          sqlite-add-feature-flag $cf
+        }
+        default {
+          lappend tmp $cf
+        }
+      }
+    }
+    define $flagDef $tmp
+  }
+}
@@ -0,0 +1,14 @@
+test-expect 1.0-open {
+  sqlite3 db :memory:
+} {}
+
+test-assert 1.1-version-3.x {
+  [string match 3.* [db eval {select sqlite_version()}]]
+}
+
+test-expect 1.2-select {
+  db eval {select 'hi, world',1,2,3}
+} {{hi, world} 1 2 3}
+
+
+test-expect 99.0-db-close {db close} {}
@@ -1,61 +0,0 @@
-#------------------------------------------------------------- -*- makefile -*-
-#
-# Sample makefile for building Tcl extensions.
-#
-# Basic build, test and install
-#   nmake /s /nologo /f makefile.vc INSTALLDIR=c:\path\to\tcl
-#   nmake /s /nologo /f makefile.vc INSTALLDIR=c:\path\to\tcl test
-#   nmake /s /nologo /f makefile.vc INSTALLDIR=c:\path\to\tcl install
-#
-# For other build options (debug, static etc.)
-# See TIP 477 (https://core.tcl.tk/tips/doc/trunk/tip/477.md) for
-# detailed documentation.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-#------------------------------------------------------------------------------
-
-# PROJECT is sqlite, not sqlite3 to match TEA AC_INIT definition.
-# This makes the generated DLL name also consistent between the two
-# except for the "t" suffix which is the convention for nmake builds.
-PROJECT = sqlite
-PRJ_PACKAGE_TCLNAME = sqlite3
-
-!include "rules-ext.vc"
-
-PRJ_OBJS = $(TMP_DIR)\tclsqlite3.obj
-
-# Preprocessor macros specific to sqlite3.
-PRJ_DEFINES = -I"$(ROOT)\.." -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
-                  -DSQLITE_ENABLE_DBPAGE_VTAB=1 -DSQLITE_ENABLE_DBSTAT_VTAB=1 \
-                  -DSQLITE_ENABLE_FTS3_PARENTHESIS=1 -DSQLITE_ENABLE_FTS4=1 \
-                  -DSQLITE_ENABLE_FTS5=1 -DSQLITE_ENABLE_COLUMN_METADATA=1 \
-                  -DSQLITE_ENABLE_JSON1=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1 \
-                  -DSQLITE_3_SUFFIX_ONLY=1 -DSQLITE_ENABLE_RTREE=1 \
-                  -DSQLITE_UNTESTABLE=1 -DSQLITE_OMIT_LOOKASIDE=1 \
-                  -DSQLITE_SECURE_DELETE=1 -DSQLITE_SOUNDEX=1 -DSQLITE_ENABLE_GEOPOLY=1 \
-                  -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT=1 \
-                  -DSQLITE_ENABLE_MATH_FUNCTIONS=1 -DDSQLITE_USE_ALLOCA=1 \
-                  -DSQLITE_ENABLE_STAT4=1 -DSQLITE_OMIT_DEPRECATED=1 \
-                  -DSQLITE_WIN32_GETVERSIONEX=0 -DSQLITE_WIN32_NO_ANSI=1
-PRJ_DEFINES = $(PRJ_DEFINES) -I$(TMP_DIR)
-
-# Standard targets to build, install, test etc.
-!include "$(_RULESDIR)\targets.vc"
-
-# The built-in pkgindex does no suffice for our extension as
-# the PROJECT name (sqlite) is not same as init function name (Sqlite3)
-pkgindex:
-	@echo if {[package vsatisfies [package provide Tcl] 9.0-]} { > $(OUT_DIR)\pkgIndex.tcl
-	@echo package ifneeded $(PRJ_PACKAGE_TCLNAME) $(DOTVERSION) \
-	    [list load [file join $$dir $(PRJLIBNAME9)] [string totitle $(PRJ_PACKAGE_TCLNAME)]] >> $(OUT_DIR)\pkgIndex.tcl
-	@echo } else { >> $(OUT_DIR)\pkgIndex.tcl
-	@echo package ifneeded $(PRJ_PACKAGE_TCLNAME) $(DOTVERSION) \
-	    [list load [file join $$dir $(PRJLIBNAME8)] [string totitle $(PRJ_PACKAGE_TCLNAME)]] >> $(OUT_DIR)\pkgIndex.tcl
-	@echo } >> $(OUT_DIR)\pkgIndex.tcl
-
-# Install the manpage though on Windows, doubt it does much good
-install:    default-install-docs-n
-
-# Explicit dependency rules
@@ -1,815 +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>
-#ifdef _MSC_VER
-#pragma comment (lib, "user32.lib")
-#pragma comment (lib, "kernel32.lib")
-#endif
-#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(char **options, int count);
-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 int LocateDependency(const char *keyfile);
-static const char *GetVersionFromFile(const char *filename, const char *match, int numdots);
-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, ""};
-pipeinfo Err = {INVALID_HANDLE_VALUE, ""};
-
-/*
- * exitcodes: 0 == no, 1 == yes, 2 == error
- */
-
-int
-main(
-    int argc,
-    char *argv[])
-{
-    char msg[300];
-    DWORD dwWritten;
-    int chars;
-    const char *s;
-
-    /*
-     * 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> ?<mandatory 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], argc-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;
-	    }
-	    s = GetVersionFromFile(argv[2], argv[3], *(argv[1]+2) - '0');
-	    if (s && *s) {
-		printf("%s\n", s);
-		return 0;
-	    } else
-		return 1; /* Version not found. Return non-0 exit code */
-
-	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]);
-
-	case 'L':
-	    if (argc != 3) {
-		chars = snprintf(msg, sizeof(msg) - 1,
-		    "usage: %s -L keypath\n"
-		    "Emit the fully qualified path of directory containing keypath\n"
-		    "exitcodes: 0 == success, 1 == not found, 2 == error\n", argv[0]);
-		WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
-		    &dwWritten, NULL);
-		return 2;
-	    }
-	    return LocateDependency(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, (LPSTR)&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(
-    char **options,
-    int count)
-{
-    STARTUPINFO si;
-    PROCESS_INFORMATION pi;
-    SECURITY_ATTRIBUTES sa;
-    DWORD threadID;
-    char msg[300];
-    BOOL ok;
-    HANDLE hProcess, h, pipeThreads[2];
-    int i;
-    char cmdline[255];
-
-    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.
-     */
-
-    for (i = 0; i < count; i++) {
-	lstrcat(cmdline, " \"");
-	lstrcat(cmdline, options[i]);
-	lstrcat(cmdline, "\"");
-    }
-
-    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, (LPSTR)&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 ||
-	    strstr(Out.buffer, "LNK4224") != NULL ||
-	    strstr(Err.buffer, "LNK4224") != 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,
-    int numdots)
-{
-    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, sizeof(szBuffer), fp) != NULL) {
-	    LPSTR p, q;
-
-	    p = strstr(szBuffer, match);
-	    if (p != NULL) {
-		/*
-		 * Skip to first digit after the match.
-		 */
-
-		p += strlen(match);
-		while (*p && !isdigit((unsigned char)*p)) {
-		    ++p;
-		}
-
-		/*
-		 * Find ending whitespace.
-		 */
-
-		q = p;
-		while (*q && (strchr("0123456789.ab", *q)) && (((!strchr(".ab", *q)
-			    && !strchr("ab", q[-1])) || --numdots))) {
-		    ++q;
-		}
-
-		*q = 0;
-		szResult = p;
-		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 = (list_item_t *)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)
-{
-    static char szBuffer[1024], szCopy[1024];
-    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, sizeof(szBuffer), 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 */
-#ifndef NDEBUG
-	{
-	    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, sizeof(szBuffer), 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("%s", szBuffer);
-	}
-
-	list_free(&substPtr);
-    }
-    fclose(fp);
-    return 0;
-}
-
-BOOL FileExists(LPCTSTR szPath)
-{
-#ifndef INVALID_FILE_ATTRIBUTES
-    #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
-#endif
-    DWORD pathAttr = GetFileAttributes(szPath);
-    return (pathAttr != INVALID_FILE_ATTRIBUTES &&
-	    !(pathAttr & FILE_ATTRIBUTE_DIRECTORY));
-}
-
-
-/*
- * 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];
-
-    GetFullPathName(szPath, sizeof(szCwd)-1, szCwd, NULL);
-    printf("%s\n", szCwd);
-    return 0;
-}
-
-/*
- * Implements LocateDependency for a single directory. See that command
- * for an explanation.
- * Returns 0 if found after printing the directory.
- * Returns 1 if not found but no errors.
- * Returns 2 on any kind of error
- * Basically, these are used as exit codes for the process.
- */
-static int LocateDependencyHelper(const char *dir, const char *keypath)
-{
-    HANDLE hSearch;
-    char path[MAX_PATH+1];
-    size_t dirlen;
-    int keylen, ret;
-    WIN32_FIND_DATA finfo;
-
-    if (dir == NULL || keypath == NULL)
-	return 2; /* Have no real error reporting mechanism into nmake */
-    dirlen = strlen(dir);
-    if ((dirlen + 3) > sizeof(path))
-	return 2;
-    strncpy(path, dir, dirlen);
-    strncpy(path+dirlen, "\\*", 3);	/* Including terminating \0 */
-    keylen = strlen(keypath);
-
-#if 0 /* This function is not available in Visual C++ 6 */
-    /*
-     * Use numerics 0 -> FindExInfoStandard,
-     * 1 -> FindExSearchLimitToDirectories,
-     * as these are not defined in Visual C++ 6
-     */
-    hSearch = FindFirstFileEx(path, 0, &finfo, 1, NULL, 0);
-#else
-    hSearch = FindFirstFile(path, &finfo);
-#endif
-    if (hSearch == INVALID_HANDLE_VALUE)
-	return 1; /* Not found */
-
-    /* Loop through all subdirs checking if the keypath is under there */
-    ret = 1; /* Assume not found */
-    do {
-	int sublen;
-	/*
-	 * We need to check it is a directory despite the
-	 * FindExSearchLimitToDirectories in the above call. See SDK docs
-	 */
-	if ((finfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
-	    continue;
-	sublen = strlen(finfo.cFileName);
-	if ((dirlen+1+sublen+1+keylen+1) > sizeof(path))
-	    continue;		/* Path does not fit, assume not matched */
-	strncpy(path+dirlen+1, finfo.cFileName, sublen);
-	path[dirlen+1+sublen] = '\\';
-	strncpy(path+dirlen+1+sublen+1, keypath, keylen+1);
-	if (FileExists(path)) {
-	    /* Found a match, print to stdout */
-	    path[dirlen+1+sublen] = '\0';
-	    QualifyPath(path);
-	    ret = 0;
-	    break;
-	}
-    } while (FindNextFile(hSearch, &finfo));
-    FindClose(hSearch);
-    return ret;
-}
-
-/*
- * LocateDependency --
- *
- *	Locates a dependency for a package.
- *        keypath - a relative path within the package directory
- *          that is used to confirm it is the correct directory.
- *	The search path for the package directory is currently only
- *      the parent and grandparent of the current working directory.
- *      If found, the command prints
- *         name_DIRPATH=<full path of located directory>
- *      and returns 0. If not found, does not print anything and returns 1.
- */
-static int LocateDependency(const char *keypath)
-{
-    size_t i;
-    int ret;
-    static const char *paths[] = {"..", "..\\..", "..\\..\\.."};
-
-    for (i = 0; i < (sizeof(paths)/sizeof(paths[0])); ++i) {
-	ret = LocateDependencyHelper(paths[i], keypath);
-	if (ret == 0)
-	    return ret;
-    }
-    return ret;
-}
-
-
-/*
- * Local variables:
- *   mode: c
- *   c-basic-offset: 4
- *   fill-column: 78
- *   indent-tabs-mode: t
- *   tab-width: 8
- * End:
- */
@@ -1,123 +0,0 @@
-# This file should only be included in makefiles for Tcl extensions,
-# NOT in the makefile for Tcl itself.
-
-!ifndef _RULES_EXT_VC
-
-# We need to run from the directory the parent makefile is located in.
-# nmake does not tell us what makefile was used to invoke it so parent
-# makefile has to set the MAKEFILEVC macro or we just make a guess and
-# warn if we think that is not the case.
-!if "$(MAKEFILEVC)" == ""
-
-!if exist("$(PROJECT).vc")
-MAKEFILEVC = $(PROJECT).vc
-!elseif exist("makefile.vc")
-MAKEFILEVC = makefile.vc
-!endif
-!endif # "$(MAKEFILEVC)" == ""
-
-!if !exist("$(MAKEFILEVC)")
-MSG = ^
-You must run nmake from the directory containing the project makefile.^
-If you are doing that and getting this message, set the MAKEFILEVC^
-macro to the name of the project makefile.
-!message WARNING: $(MSG)
-!endif
-
-!if "$(PROJECT)" == "tcl"
-!error The rules-ext.vc file is not intended for Tcl itself.
-!endif
-
-# We extract version numbers using the nmakehlp program. For now use
-# the local copy of nmakehlp. Once we locate Tcl, we will use that
-# one if it is newer.
-!if "$(MACHINE)" == "IX86" || "$(MACHINE)" == "$(NATIVE_ARCH)"
-!if [$(CC) -nologo -DNDEBUG "nmakehlp.c" -link -subsystem:console > nul]
-!endif
-!else
-!if [copy x86_64-w64-mingw32-nmakehlp.exe nmakehlp.exe >NUL]
-!endif
-!endif
-
-# First locate the Tcl directory that we are working with.
-!if "$(TCLDIR)" != ""
-
-_RULESDIR = $(TCLDIR:/=\)
-
-!else
-
-# If an installation path is specified, that is also the Tcl directory.
-# Also Tk never builds against an installed Tcl, it needs Tcl sources
-!if defined(INSTALLDIR) && "$(PROJECT)" != "tk"
-_RULESDIR=$(INSTALLDIR:/=\)
-!else
-# Locate Tcl sources
-!if [echo _RULESDIR = \> nmakehlp.out] \
-   || [nmakehlp -L generic\tcl.h >> nmakehlp.out]
-_RULESDIR = ..\..\tcl
-!else
-!include nmakehlp.out
-!endif
-
-!endif # defined(INSTALLDIR)....
-
-!endif # ifndef TCLDIR
-
-# Now look for the targets.vc file under the Tcl root. Note we check this
-# file and not rules.vc because the latter also exists on older systems.
-!if exist("$(_RULESDIR)\lib\nmake\targets.vc") # Building against installed Tcl
-_RULESDIR = $(_RULESDIR)\lib\nmake
-!elseif exist("$(_RULESDIR)\win\targets.vc")   # Building against Tcl sources
-_RULESDIR = $(_RULESDIR)\win
-!else
-# If we have not located Tcl's targets file, most likely we are compiling
-# against an older version of Tcl and so must use our own support files.
-_RULESDIR = .
-!endif
-
-!if "$(_RULESDIR)" != "."
-# Potentially using Tcl's support files. If this extension has its own
-# nmake support files, need to compare the versions and pick newer.
-
-!if exist("rules.vc") # The extension has its own copy
-
-!if [echo TCL_RULES_MAJOR = \> versions.vc] \
-   && [nmakehlp -V "$(_RULESDIR)\rules.vc" RULES_VERSION_MAJOR >> versions.vc]
-!endif
-!if [echo TCL_RULES_MINOR = \>> versions.vc] \
-   && [nmakehlp -V "$(_RULESDIR)\rules.vc" RULES_VERSION_MINOR >> versions.vc]
-!endif
-
-!if [echo OUR_RULES_MAJOR = \>> versions.vc] \
-   && [nmakehlp -V "rules.vc" RULES_VERSION_MAJOR >> versions.vc]
-!endif
-!if [echo OUR_RULES_MINOR = \>> versions.vc] \
-   && [nmakehlp -V "rules.vc" RULES_VERSION_MINOR >> versions.vc]
-!endif
-!include versions.vc
-# We have a newer version of the support files, use them
-!if ($(TCL_RULES_MAJOR) != $(OUR_RULES_MAJOR)) || ($(TCL_RULES_MINOR) < $(OUR_RULES_MINOR))
-_RULESDIR = .
-!endif
-
-!endif # if exist("rules.vc")
-
-!endif # if $(_RULESDIR) != "."
-
-# Let rules.vc know what copy of nmakehlp.c to use.
-NMAKEHLPC = $(_RULESDIR)\nmakehlp.c
-
-# Get rid of our internal defines before calling rules.vc
-!undef TCL_RULES_MAJOR
-!undef TCL_RULES_MINOR
-!undef OUR_RULES_MAJOR
-!undef OUR_RULES_MINOR
-
-!if exist("$(_RULESDIR)\rules.vc")
-!message *** Using $(_RULESDIR)\rules.vc
-!include "$(_RULESDIR)\rules.vc"
-!else
-!error *** Could not locate rules.vc in $(_RULESDIR)
-!endif
-
-!endif # _RULES_EXT_VC
@@ -1,98 +0,0 @@
-#------------------------------------------------------------- -*- makefile -*-
-# targets.vc --
-#
-# Part of the nmake based build system for Tcl and its extensions.
-# This file defines some standard targets for the convenience of extensions
-# and can be optionally included by the extension makefile.
-# See TIP 477 (https://core.tcl-lang.org/tips/doc/main/tip/477.md) for docs.
-
-$(PROJECT): setup pkgindex $(PRJLIB)
-
-!ifdef PRJ_STUBOBJS
-$(PROJECT): $(PRJSTUBLIB)
-$(PRJSTUBLIB): $(PRJ_STUBOBJS)
-	$(LIBCMD) $**
-
-$(PRJ_STUBOBJS):
-	$(CCSTUBSCMD) %s
-!endif # PRJ_STUBOBJS
-
-!ifdef PRJ_MANIFEST
-$(PROJECT): $(PRJLIB).manifest
-$(PRJLIB).manifest: $(PRJ_MANIFEST)
-	@nmakehlp -s << $** >$@
-@MACHINE@	  $(MACHINE:IX86=X86)
-<<
-!endif
-
-!if "$(PROJECT)" != "tcl" && "$(PROJECT)" != "tk"
-$(PRJLIB): $(PRJ_OBJS) $(RESFILE)
-!if $(STATIC_BUILD)
-       $(LIBCMD) $**
-!else
-       $(DLLCMD) $**
-       $(_VC_MANIFEST_EMBED_DLL)
-!endif
-       -@del $*.exp
-!endif
-
-!if "$(PRJ_HEADERS)" != "" && "$(PRJ_OBJS)" != ""
-$(PRJ_OBJS): $(PRJ_HEADERS)
-!endif
-
-# If parent makefile has defined stub objects, add their installation
-# to the default install
-!if "$(PRJ_STUBOBJS)" != ""
-default-install: default-install-stubs
-!endif
-
-# Unlike the other default targets, these cannot be in rules.vc because
-# the executed command depends on existence of macro PRJ_HEADERS_PUBLIC
-# that the parent makefile will not define until after including rules-ext.vc
-!if "$(PRJ_HEADERS_PUBLIC)" != ""
-default-install: default-install-headers
-default-install-headers:
-	@echo Installing headers to '$(INCLUDE_INSTALL_DIR)'
-	@for %f in ($(PRJ_HEADERS_PUBLIC)) do @$(COPY) %f "$(INCLUDE_INSTALL_DIR)"
-!endif
-
-!if "$(DISABLE_STANDARD_TARGETS)" == ""
-DISABLE_STANDARD_TARGETS = 0
-!endif
-
-!if "$(DISABLE_TARGET_setup)" == ""
-DISABLE_TARGET_setup = 0
-!endif
-!if "$(DISABLE_TARGET_install)" == ""
-DISABLE_TARGET_install = 0
-!endif
-!if "$(DISABLE_TARGET_clean)" == ""
-DISABLE_TARGET_clean = 0
-!endif
-!if "$(DISABLE_TARGET_test)" == ""
-DISABLE_TARGET_test = 0
-!endif
-!if "$(DISABLE_TARGET_shell)" == ""
-DISABLE_TARGET_shell = 0
-!endif
-
-!if !$(DISABLE_STANDARD_TARGETS)
-!if !$(DISABLE_TARGET_setup)
-setup: default-setup
-!endif
-!if !$(DISABLE_TARGET_install)
-install: default-install
-!endif
-!if !$(DISABLE_TARGET_clean)
-clean: default-clean
-realclean: hose
-hose: default-hose
-distclean: realclean default-distclean
-!endif
-!if !$(DISABLE_TARGET_test)
-test: default-test
-!endif
-!if !$(DISABLE_TARGET_shell)
-shell: default-shell
-!endif
-!endif # DISABLE_STANDARD_TARGETS
@@ -14,7 +14,9 @@ build infrastructure. It is not an [Autosetup][] reference.
  - Symbolic Names of Feature Flags
  - Do Not Update Global Shared State
 - [Updating Autosetup](#updating)
-  - [Patching Autosetup for Project-local changes](#patching)
+  - ***[Patching Autosetup for Project-local changes](#patching)***
+- [Branch-specific Customization](#branch-customization)
+

 ------------------------------------------------------------------------

@@ -42,12 +44,13 @@ following files:
  (e.g. Fossil), and personal projects of SQLite's developers.  It is
  essentially an amalgamation of a decade's worth of autosetup-related
  utility code.
- [auto.def][]: the primary driver for the `./configure` process.
-  When we talk about "the configure script," we're referring to
-  this file.
 - [sqlite-config.tcl][]: utility code which is too project-specific
  for `proj.tcl`. We split this out of `auto.def` so that it can be
  used by both `auto.def` and...
+- [auto.def][]: the primary driver for the `./configure` process.
+  When we talk about "the configure script," we're technically
+  referring to this file, though it actually contains very little
+  of the TCL code.
 - [autoconf/auto.def][]: the main driver script for the "autoconf"
  bundle's configure script. It is essentially a slightly trimmed-down
  version of the main `auto.def` file. The `autoconf` dir was ported
@@ -61,11 +64,11 @@ Autosetup API Tips

 This section briefly covers only APIs which are frequently useful in
 day-to-day maintenance and might not be immediately recognized as such
-obvious from a casual perusal of the relevant TCL files. The complete
-docs of those with `proj-` prefix can be found in [proj.tcl][] and
-those with an `sqlite-` prefix are in [sqlite-config.tcl][]. The
-others are scattered around [the TCL files in
-./autosetup](/dir/autosetup).
+from a casual perusal of the relevant TCL files. The complete docs of
+those with `proj-` prefix can be found in [proj.tcl][] and those with
+an `sqlite-` prefix are in [sqlite-config.tcl][]. The others are part
+of Autosetup's core packages and are scattered around [the TCL files
+in ./autosetup](/dir/autosetup).

 In (mostly) alphabetical order:

@@ -83,19 +86,14 @@ In (mostly) alphabetical order:
    Works like `get-env` but will, if that function finds no match,
    look for a file named `./.env-$VAR` and, if found, return its
    trimmed contents. This can be used, e.g., to set a developer's
-    local preferences for the default `CFLAGS`.
-
- **`define-for-opt flag defineName ?checkingMsg? ?yesVal=1? ?noVal=0?`**\  
-  `[define $defineName]` to either `$yesVal` or `$noVal`, depending on
-  whether `--$flag` is truthy or not. `$checkingMsg` is a
-  human-readable description of the check being made, e.g. "enable foo?"
-  If no `checkingMsg` is provided, the operation is silent.\  
-  Potential TODO: change the final two args to `-yes` and `-no`
-  flags. They're rarely needed, though: search [auto.def][] for
-  `TSTRNNR_OPTS` for an example of where they are used.
+    local preferences for the default `CFLAGS`.\  
+    Tip: adding `-O0` to `.env-CFLAGS` reduces rebuild times
+    considerably at the cost of performance in `make devtest` and the
+    like.

 - **`proj-fatal msg`**\  
-  Emits `$msg` to stderr and exits with non-zero.
+  Emits `$msg` to stderr and exits with non-zero. Its differences from
+  autosetup's `user-error` are purely cosmetic.

 - **`proj-if-opt-truthy flag thenScript ?elseScript?`**\  
  Evals `thenScript` if the given `--flag` is truthy, else it
@@ -117,7 +115,10 @@ In (mostly) alphabetical order:
  else 0. This distinction can be used to determine, e.g., whether
  `--with-readline` was provided or whether we're searching for
  readline by default. In the former case, failure to find it should
-  be treated as fatal, where in the latter case it's not.
+  be treated as fatal, where in the latter case it's not.\  
+  Unlike most functions which deal with `--flags`, this one does not
+  validate that `$FLAG` is a registered flag so will not fail fatally
+  if `$FLAG` is not registered as an Autosetup option.

 - **`proj-val-truthy value`**\  
  Returns 1 if `$value` is "truthy," See `proj-opt-truthy` for the definition
@@ -139,6 +140,15 @@ In (mostly) alphabetical order:
  The shell-specific counterpart of `sqlite-add-feature-flag` which
  only adds the given flag(s) to the CLI-shell-specific CFLAGS.

+- **`sqlite-configure BUILD-NAME {script}`**\  
+  This is where all configure `--flags` are defined for all known
+  build modes ("canonical" or "autoconf"). After processing all flags,
+  this function runs `$script`, which contains the build-mode-specific
+  configuration bits, and then runs any finalization bits which are
+  common to all build modes. The `auto.def` files are intended to contain
+  exactly two commands:
+  `use sqlite-config; sqlite-configure BUILD-NAME {script}`
+
 - **`user-notice msg`**\  
  Queues `$msg` to be sent to stderr, but does not emit it until
  either `show-notices` is called or the next time autosetup would
@@ -152,13 +162,18 @@ In (mostly) alphabetical order:
 Ensuring TCL Compatibility
 ========================================================================

-It is important that any TCL files used by the configure process
-remain compatible with both [JimTCL][] and the canonical TCL. Though
-JimTCL has outstanding compatibility with canonical TCL, it does have
-a few corners with incompatibilities, e.g. regular expressions. If a
-script runs in JimTCL without using any JimTCL-specific features, then
-it's a certainty that it will run in canonical TCL as well. The
-opposite, however, is not _always_ the case.
+One of the significant benefits of using Autosetup is that (A) this
+project uses many TCL scripts in the build process and (B) Autosetup
+comes with a TCL interpreter named [JimTCL][].
+
+It is important that any TCL files used by the configure process and
+makefiles remain compatible with both [JimTCL][] and the canonical
+TCL. Though JimTCL has outstanding compatibility with canonical TCL,
+it does have a few corners with incompatibilities, e.g. regular
+expressions. If a script runs in JimTCL without using any
+JimTCL-specific features, then it's a certainty that it will run in
+canonical TCL as well. The opposite, however, is not _always_ the
+case.

 When [`./configure`](/file/configure) is run, it goes through a
 bootstrapping process to find a suitable TCL with which to run the
@@ -187,14 +202,17 @@ compatibility across TCL implementations:
   before looking for a system-level `tclsh`. Be aware, though, that
   `make distclean` will remove that file.

-**Note that `jimsh0` is distinctly different from the `jimsh`** which
-gets built for code-generation purposes.  The latter requires
+**Note that `./jimsh0` is distinctly different from the `./jimsh`**
+which gets built for code-generation purposes.  The latter requires
 non-default build flags to enable features which are
 platform-dependent, most notably to make its `[file normalize]` work.
 This means, for example, that the configure script and its utility
 APIs must not use `[file normalize]`, but autosetup provides a
 TCL-only implementation of `[file-normalize]` (note the dash) for
-portable use in the configure script.
+portable use in the configure script. Contrariwise, code-generation
+scripts invoked via `make` may use `[file normalize]`, as they'll use
+`./jimsh` or `tclsh` instead of `./jimsh0`.
+

 Known TCL Incompatibilities
 ------------------------------------------------------------------------
@@ -221,6 +239,7 @@ A summary of known incompatibilities in JimTCL
  - `regsub` does not support the `\y` flag. A workaround is demonstrated
    in [](/info/c2e5dd791cce3ec4).

+
 <a name="conventions"></a>
 Design Conventions
 ========================================================================
@@ -247,8 +266,9 @@ dots are not permitted.
 The `X.y` convention is used in the makefiles primarily because the
 person who did the initial port finds that considerably easier on the
 eyes and fingers. In practice, the `X_Y` form of such exports is used
-exactly once in [Makefile.in][], where it's translated into into `X.y`
-form for consumption by [Makefile.in][] and [main.mk][]. For example:
+exactly once in [Makefile.in][], where it's translated from `@X_Y@`
+into into `X.y` form for consumption by [Makefile.in][] and
+[main.mk][]. For example:

 >
 ```
@@ -265,9 +285,9 @@ of taste, for which there is no accounting.)
 Do Not Update Global Shared State
 ------------------------------------------------------------------------

-In both the legacy Autotools-driven build and in common Autosetup
-usage, feature tests performed by the configure script may amend
-global flags such as `LIBS`, `LDFLAGS`, and `CFLAGS`[^as-cflags].  That's
+In both the legacy Autotools-driven build and common Autosetup usage,
+feature tests performed by the configure script may amend global flags
+such as `LIBS`, `LDFLAGS`, and `CFLAGS`[^as-cflags].  That's
 appropriate for a makefile which builds a single deliverable, but less
 so for makefiles which produce multiple deliverables. Drawbacks of
 that approach include:
@@ -275,8 +295,8 @@ that approach include:
 - It's unlikely that every single deliverable will require the same
  core set of those flags.
 - It can be difficult to determine the origin of any given change to
-  that global state because those changes are hidden behind voodoo performed
-  outside the immediate visibility of the configure script's
+  that global state because those changes are hidden behind voodoo
+  performed outside the immediate visibility of the configure script's
  maintainer.
 - It can force the maintainers of the configure script to place tests
  in a specific order so that the resulting flags get applied at
@@ -357,17 +377,70 @@ Patching Autosetup for Project-local Changes

 Autosetup reserves the flag name **`--debug`** for its own purposes,
 and its own special handling of `--enable-...` flags makes `--debug`
-an alias for `--enable-debug`. As we have a long history of using
-`--enable-debug` for this project's own purposes, we patch autosetup
-to use the name `--autosetup-debug` in place of `--debug`. That
-requires (as of this writing) four small edits in
-[](/file/autosetup/autosetup), as demonstrated in [check-in
-3296c8d3](/info/3296c8d3).
+an alias for `--enable-debug`. As this project has a long history of
+using `--enable-debug`, we patch autosetup to use the name
+`--autosetup-debug` in place of `--debug`. That requires (as of this
+writing) four small edits in [](/file/autosetup/autosetup), as
+demonstrated in [check-in 3296c8d3](/info/3296c8d3).

 If autosetup is upgraded and this patch is _not_ applied the invoking
 `./configure` will fail loudly because of the declaration of the
 `debug` flag in `auto.def` - duplicated flags are not permitted.

+<a name="branch-customization"></a>
+Branch-specific Customization
+========================================================================
+
+Certain vendor-specific branches require slight configure script
+customization. Rather than editing `sqlite-config.tcl` for this,
+which frequently leads to merge conflicts, the following approach
+is recommended:
+
+In the vendor-specific branch, create a file named
+`autosetup/sqlite-custom.tcl`.
+
+That file should contain the following content...
+
+If flag customization is required, add:
+
+>
+```
+proc sqlite-custom-flags {} {
+  # If any existing --flags require different default values
+  # then call:
+  options-defaults {
+    flag-name new-default-value
+    ...
+  }
+  # ^^^ That will replace the default value but will not update
+  # the --help text, which may lead to some confusion:
+  # https://github.com/msteveb/autosetup/issues/77
+
+  return {
+   {*} {
+     new-flag-name => {Help text}
+     ...
+   }
+  }; #see below
+}
+```
+
+That function must return either an empty string or a list in the form
+used internally by `sqlite-config.tcl:sqlite-configure`.
+
+Next, define:
+
+>
+```
+proc sqlite-custom-handle-flags {} {
+  ... do any custom flag handling here ...
+}
+```
+
+That function, if defined, will be called relatively late in the
+configure process, before any filtered files are generated but after
+all other significant processing.
+

 [Autosetup]: https://msteveb.github.io/autosetup/
 [auto.def]: /file/auto.def
@@ -9132,7 +9132,7 @@ int Jim_StringEqObj(Jim_Obj *aObjPtr, Jim_Obj *bObjPtr)
        const char *sA = Jim_GetString(aObjPtr, &Alen);
        const char *sB = Jim_GetString(bObjPtr, &Blen);

-        return Alen == Blen && memcmp(sA, sB, Alen) == 0;
+        return Alen == Blen && *sA == *sB && memcmp(sA, sB, Alen) == 0;
    }
 }

@@ -10242,7 +10242,7 @@ static int JimCommandsHT_KeyCompare(void *privdata, const void *key1, const void
    int len1, len2;
    const char *str1 = Jim_GetStringNoQualifier((Jim_Obj *)key1, &len1);
    const char *str2 = Jim_GetStringNoQualifier((Jim_Obj *)key2, &len2);
-    return len1 == len2 && memcmp(str1, str2, len1) == 0;
+    return len1 == len2 && *str1 == *str2 && memcmp(str1, str2, len1) == 0;
 }

 static void JimCommandsHT_ValDestructor(void *interp, void *val)
@@ -13864,6 +13864,13 @@ static int JimExprOpNumUnary(Jim_Interp *interp, struct JimExprNode *node)
            case JIM_EXPROP_NOT:
                wC = !bA;
                break;
+            case JIM_EXPROP_UNARYPLUS:
+            case JIM_EXPROP_UNARYMINUS:
+                rc = JIM_ERR;
+                Jim_SetResultFormatted(interp,
+                    "can't use non-numeric string as operand of \"%s\"",
+                        node->type == JIM_EXPROP_UNARYPLUS ? "+" : "-");
+                break;
            default:
                abort();
        }
@@ -19868,16 +19875,22 @@ wrongargs:
                    }
                    else if (errorCodeObj) {
                        int len = Jim_ListLength(interp, argv[idx + 1]);
-                        int i;

-                        ret = JIM_OK;
+                        if (len > Jim_ListLength(interp, errorCodeObj)) {

-                        for (i = 0; i < len; i++) {
-                            Jim_Obj *matchObj = Jim_ListGetIndex(interp, argv[idx + 1], i);
-                            Jim_Obj *objPtr = Jim_ListGetIndex(interp, errorCodeObj, i);
-                            if (Jim_StringCompareObj(interp, matchObj, objPtr, 0) != 0) {
-                                ret = -1;
-                                break;
+                            ret = -1;
+                        }
+                        else {
+                            int i;
+                            ret = JIM_OK;
+
+                            for (i = 0; i < len; i++) {
+                                Jim_Obj *matchObj = Jim_ListGetIndex(interp, argv[idx + 1], i);
+                                Jim_Obj *objPtr = Jim_ListGetIndex(interp, errorCodeObj, i);
+                                if (Jim_StringCompareObj(interp, matchObj, objPtr, 0) != 0) {
+                                    ret = -1;
+                                    break;
+                                }
                            }
                        }
                    }
@@ -20253,7 +20266,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
        }

        case OPT_SET:
-            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 4, argv[argc - 1], JIM_ERRMSG);
+            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 4, argv[argc - 1], JIM_ERRMSG | JIM_UNSHARED);

        case OPT_EXISTS:{
                int rc = Jim_DictKeysVector(interp, argv[2], argv + 3, argc - 3, &objPtr, JIM_NONE);
@@ -20265,7 +20278,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
            }

        case OPT_UNSET:
-            if (Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 3, NULL, JIM_NONE) != JIM_OK) {
+            if (Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 3, NULL, JIM_UNSHARED) != JIM_OK) {
                return JIM_ERR;
            }
            return JIM_OK;
@@ -0,0 +1,4 @@
+The *.tcl files in this directory are part of the SQLite's "autoconf"
+bundle which are specific to the TEA(-ish) build. During the tarball
+generation process, they are copied into <TOP>/autoconf/autosetup/teaish
+(which itself is created as part of that process).
@@ -0,0 +1,214 @@
+########################################################################
+# 2025 April 7
+#
+# 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.
+#
+########################################################################
+# ----- @module feature-tests.tcl -----
+# @section TEA-ish collection of feature tests.
+#
+# Functions in this file with a prefix of teaish__ are
+# private/internal APIs. Those with a prefix of teaish- are
+# public APIs.
+
+
+# @teaish-check-libz
+#
+# Checks for zlib.h and the function deflate in libz. If found,
+# prepends -lz to the extension's ldflags and returns 1, else returns
+# 0. It also defines LDFLAGS_LIBZ to the libs flag.
+#
+proc teaish-check-libz {} {
+  teaish-check-cached "Checking for libz" {
+    set rc 0
+    if {[msg-quiet cc-check-includes zlib.h] && [msg-quiet proj-check-function-in-lib deflate z]} {
+      teaish-ldflags-prepend [define LDFLAGS_LIBZ [get-define lib_deflate]]
+      undefine lib_deflate
+      incr rc
+    }
+    expr $rc
+  }
+}
+
+# @teaish-check-librt ?funclist?
+#
+# Checks whether -lrt is needed for any of the given functions.  If
+# so, appends -lrt via [teaish-ldflags-prepend] and returns 1, else
+# returns 0. It also defines LDFLAGS_LIBRT to the libs flag or an
+# empty string.
+#
+# Some systems (ex: SunOS) require -lrt in order to use nanosleep.
+#
+proc teaish-check-librt {{funclist {fdatasync nanosleep}}} {
+  teaish-check-cached -nostatus "Checking whether ($funclist) need librt" {
+    define LDFLAGS_LIBRT ""
+    foreach func $funclist {
+      if {[msg-quiet proj-check-function-in-lib $func rt]} {
+        set ldrt [get-define lib_${func}]
+        undefine lib_${func}
+        if {"" ne $ldrt} {
+          teaish-ldflags-prepend -r [define LDFLAGS_LIBRT $ldrt]
+          msg-result $ldrt
+          return 1
+        } else {
+          msg-result "no lib needed"
+          return 1
+        }
+      }
+    }
+    msg-result "not found"
+    return 0
+  }
+}
+
+# @teaish-check-stdint
+#
+# A thin proxy for [cc-with] which checks for <stdint.h> and the
+# various fixed-size int types it declares. It defines HAVE_STDINT_T
+# to 0 or 1 and (if it's 1) defines HAVE_XYZ_T for each XYZ int type
+# to 0 or 1, depending on whether its available.
+proc teaish-check-stdint {} {
+  teaish-check-cached "Checking for stdint.h" {
+    msg-quiet cc-with {-includes stdint.h} \
+      {cc-check-types int8_t int16_t int32_t int64_t intptr_t \
+         uint8_t uint16_t uint32_t uint64_t uintptr_t}
+  }
+}
+
+# @teaish-is-mingw
+#
+# Returns 1 if building for mingw, else 0.
+proc teaish-is-mingw {} {
+  return [expr {
+    [string match *mingw* [get-define host]] &&
+    ![file exists /dev/null]
+  }]
+}
+
+# @teaish-check-libdl
+#
+# Checks for whether dlopen() can be found and whether it requires
+# -ldl for linking. If found, returns 1, defines LDFLAGS_DLOPEN to the
+# linker flags (if any), and passes those flags to
+# teaish-ldflags-prepend. It unconditionally defines HAVE_DLOPEN to 0
+# or 1 (the its return result value).
+proc teaish-check-dlopen {} {
+  teaish-check-cached -nostatus "Checking for dlopen()" {
+    set rc 0
+    set lfl ""
+    if {[cc-with {-includes dlfcn.h} {
+      cctest -link 1 -declare "extern char* dlerror(void);" -code "dlerror();"}]} {
+      msg-result "-ldl not needed"
+      incr rc
+    } elseif {[cc-check-includes dlfcn.h]} {
+      incr rc
+      if {[cc-check-function-in-lib dlopen dl]} {
+        set lfl [get-define lib_dlopen]
+        undefine lib_dlopen
+        msg-result " dlopen() needs $lfl"
+      } else {
+        msg-result " - dlopen() not found in libdl. Assuming dlopen() is built-in."
+      }
+    } else {
+      msg-result "not found"
+    }
+    teaish-ldflags-prepend [define LDFLAGS_DLOPEN $lfl]
+    define HAVE_DLOPEN $rc
+  }
+}
+
+#
+# @teaish-check-libmath
+#
+# Handles the --enable-math flag. Returns 1 if found, else 0.
+# If found, it prepends -lm (if needed) to the linker flags.
+proc teaish-check-libmath {} {
+  teaish-check-cached "Checking for libc math library" {
+    set lfl ""
+    set rc 0
+    if {[msg-quiet proj-check-function-in-lib ceil m]} {
+      incr rc
+      set lfl [get-define lib_ceil]
+      undefine lib_ceil
+      teaish-ldflags-prepend $lfl
+      msg-checking "$lfl "
+    }
+    define LDFLAGS_LIBMATH $lfl
+    expr $rc
+  }
+}
+
+# @teaish-import-features ?-flags? feature-names...
+#
+# For each $name in feature-names... it invokes:
+#
+#   use teaish/feature/$name
+#
+# to load TEAISH_AUTOSETUP_DIR/feature/$name.tcl
+#
+# By default, if a proc named teaish-check-${name}-options is defined
+# after sourcing a file, it is called and its result is passed to
+# proj-append-options. This can be suppressed with the -no-options
+# flag.
+#
+# Flags:
+#
+#   -no-options: disables the automatic running of
+#    teaish-check-NAME-options,
+#
+#   -run: if the function teaish-check-NAME exists after importing
+#    then it is called. This flag must not be used when calling this
+#    function from teaish-options. This trumps both -pre and -post.
+#
+#   -pre: if the function teaish-check-NAME exists after importing
+#    then it is passed to [teaish-checks-queue -pre].
+#
+#   -post: works like -pre but instead uses[teaish-checks-queue -post].
+proc teaish-import-features {args} {
+  set pk ""
+  set doOpt 1
+  proj-parse-simple-flags args flags {
+    -no-options 0 {set doOpt 0}
+    -run        0 {expr 1}
+    -pre        0 {set pk -pre}
+    -post       0 {set pk -post}
+  }
+  #
+  # TODO: never import the same module more than once. The "use"
+  # command is smart enough to not do that but we would need to
+  # remember whether or not any teaish-check-${arg}* procs have been
+  # called before, and skip them.
+  #
+  if {$flags(-run) && "" ne $pk} {
+    proj-error "Cannot use both -run and $pk" \
+      " (called from [proj-scope 1])"
+  }
+
+  foreach arg $args {
+    uplevel "use teaish/feature/$arg"
+    if {$doOpt} {
+      set n "teaish-check-${arg}-options"
+      if {[llength [info proc $n]] > 0} {
+        if {"" ne [set x [$n]]} {
+          options-add $x
+        }
+      }
+    }
+    if {$flags(-run)} {
+      set n "teaish-check-${arg}"
+      if {[llength [info proc $n]] > 0} {
+        uplevel 1 $n
+      }
+    } elseif {"" ne $pk} {
+      set n "teaish-check-${arg}"
+      if {[llength [info proc $n]] > 0} {
+        teaish-checks-queue {*}$pk $n
+      }
+    }
+  }
+}
@@ -0,0 +1,293 @@
+########################################################################
+# 2025 April 5
+#
+# 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.
+#
+########################################################################
+#
+# Helper routines for running tests on teaish extensions
+#
+########################################################################
+# ----- @module teaish/tester.tcl -----
+#
+# @section TEA-ish Testing APIs.
+#
+# Though these are part of the autosup dir hierarchy, they are not
+# intended to be run from autosetup code. Rather, they're for use
+# with/via teaish.tester.tcl and target canonical Tcl only, not JimTcl
+# (which the autosetup pieces do target).
+
+#
+# @test-current-scope ?lvl?
+#
+# Returns the name of the _calling_ proc from ($lvl + 1) levels up the
+# call stack (where the caller's level will be 1 up from _this_
+# call). If $lvl would resolve to global scope "global scope" is
+# returned and if it would be negative then a string indicating such
+# is returned (as opposed to throwing an error).
+#
+proc test-current-scope {{lvl 0}} {
+  #uplevel [expr {$lvl + 1}] {lindex [info level 0] 0}
+  set ilvl [info level]
+  set offset [expr {$ilvl  - $lvl - 1}]
+  if { $offset < 0} {
+    return "invalid scope ($offset)"
+  } elseif { $offset == 0} {
+    return "global scope"
+  } else {
+    return [lindex [info level $offset] 0]
+  }
+}
+
+# @test-msg
+#
+# Emits all arugments to stdout.
+#
+proc test-msg {args} {
+  puts "$args"
+}
+
+# @test-warn
+#
+# Emits all arugments to stderr.
+#
+proc test-warn {args} {
+  puts stderr "WARNING: $args"
+}
+
+#
+# @test-error msg
+#
+# Triggers a test-failed error with a string describing the calling
+# scope and the provided message.
+#
+proc test-fail {args} {
+  #puts stderr "ERROR: \[[test-current-scope 1]]: $msg"
+  #exit 1
+  error "FAIL: \[[test-current-scope 1]]: $args"
+}
+
+array set ::test__Counters {}
+array set ::test__Config {
+  verbose-assert 0 verbose-affirm 0
+}
+
+# Internal impl for affirm and assert.
+#
+# $args = ?-v? script {msg-on-fail ""}
+proc test__affert {failMode args} {
+  if {$failMode} {
+    set what assert
+  } else {
+    set what affirm
+  }
+  set verbose $::test__Config(verbose-$what)
+  if {"-v" eq [lindex $args 0]} {
+    lassign $args - script msg
+    if {1 == [llength $args]} {
+      # If -v is the only arg, toggle default verbose mode
+      set ::test__Config(verbose-$what) [expr {!$::test__Config(verbose-$what)}]
+      return
+    }
+    incr verbose
+  } else {
+    lassign $args script msg
+  }
+  incr ::test__Counters($what)
+  if {![uplevel 1 expr [list $script]]} {
+    if {"" eq $msg} {
+      set msg $script
+    }
+    set txt [join [list $what # $::test__Counters($what) "failed:" $msg]]
+    if {$failMode} {
+      puts stderr $txt
+      exit 1
+    } else {
+      error $txt
+    }
+  } elseif {$verbose} {
+    puts stderr [join [list $what # $::test__Counters($what) "passed:" $script]]
+  }
+}
+
+#
+# @affirm ?-v? script ?msg?
+#
+# Works like a conventional assert method does, but reports failures
+# using [error] instead of [exit]. If -v is used, it reports passing
+# assertions to stderr. $script is evaluated in the caller's scope as
+# an argument to [expr].
+#
+proc affirm {args} {
+  tailcall test__affert 0 {*}$args
+}
+
+#
+# @assert ?-v? script ?msg?
+#
+# Works like [affirm] but exits on error.
+#
+proc assert {args} {
+  tailcall test__affert 1 {*}$args
+}
+
+#
+# @assert-matches ?-e? pattern ?-e? rhs ?msg?
+#
+# Equivalent to assert {[string match $pattern $rhs]} except that
+# if either of those are prefixed with an -e flag, they are eval'd
+# and their results are used.
+#
+proc assert-matches {args} {
+  set evalLhs 0
+  set evalRhs 0
+  if {"-e" eq [lindex $args 0]} {
+    incr evalLhs
+    set args [lassign $args -]
+  }
+  set args [lassign $args pattern]
+  if {"-e" eq [lindex $args 0]} {
+    incr evalRhs
+    set args [lassign $args -]
+  }
+  set args [lassign $args rhs msg]
+
+  if {$evalLhs} {
+    set pattern [uplevel 1 $pattern]
+  }
+  if {$evalRhs} {
+    set rhs [uplevel 1 $rhs]
+  }
+  #puts "***pattern=$pattern\n***rhs=$rhs"
+  tailcall test__affert 1 \
+    [join [list \[ string match [list $pattern] [list $rhs] \]]] $msg
+  # why does this not work? [list \[ string match [list $pattern] [list $rhs] \]] $msg
+  # "\[string match [list $pattern] [list $rhs]\]"
+}
+
+#
+# @test-assert testId script ?msg?
+#
+# Works like [assert] but emits $testId to stdout first.
+#
+proc test-assert {testId script {msg ""}} {
+  puts "test $testId"
+  tailcall test__affert 1 $script $msg
+}
+
+#
+# @test-expect testId script result
+#
+# Runs $script in the calling scope and compares its result to
+# $result, minus any leading or trailing whitespace.  If they differ,
+# it triggers an [assert].
+#
+proc test-expect {testId script result} {
+  puts "test $testId"
+  set x [string trim [uplevel 1 $script]]
+  set result [string trim $result]
+  tailcall test__affert 0 [list "{$x}" eq "{$result}"] \
+    "\nEXPECTED: <<$result>>\nGOT:      <<$x>>"
+}
+
+#
+# @test-catch cmd ?...args?
+#
+# Runs [cmd ...args], repressing any exception except to possibly log
+# the failure. Returns 1 if it caught anything, 0 if it didn't.
+#
+proc test-catch {cmd args} {
+  if {[catch {
+    uplevel 1 $cmd {*}$args
+  } rc xopts]} {
+    puts "[test-current-scope] ignoring failure of: $cmd [lindex $args 0]: $rc"
+    return 1
+  }
+  return 0
+}
+
+#
+# @test-catch-matching pattern (script|cmd args...)
+#
+# Works like test-catch, but it expects its argument(s) to to throw an
+# error matching the given string (checked with [string match]).  If
+# they do not throw, or the error does not match $pattern, this
+# function throws, else it returns 1.
+#
+# If there is no second argument, the $cmd is assumed to be a script,
+# and will be eval'd in the caller's scope.
+#
+# TODO: add -glob and -regex flags to control matching flavor.
+#
+proc test-catch-matching {pattern cmd args} {
+  if {[catch {
+    #puts "**** catch-matching cmd=$cmd args=$args"
+    if {0 == [llength $args]} {
+      uplevel 1 $cmd {*}$args
+    } else {
+      $cmd {*}$args
+    }
+  } rc xopts]} {
+    if {[string match $pattern $rc]} {
+      return 1
+    } else {
+      error "[test-current-scope] exception does not match {$pattern}: {$rc}"
+    }
+  }
+  error "[test-current-scope] expecting to see an error matching {$pattern}"
+}
+
+if {![array exists ::teaish__BuildFlags]} {
+  array set ::teaish__BuildFlags {}
+}
+
+#
+# @teaish-build-flag3 flag tgtVar ?dflt?
+#
+# If the current build has the configure-time flag named $flag set
+# then tgtVar is assigned its value and 1 is returned, else tgtVal is
+# assigned $dflt and 0 is returned.
+#
+# Caveat #1: only valid when called in the context of teaish's default
+# "make test" recipe, e.g. from teaish.test.tcl. It is not valid from
+# a teaish.tcl configure script because (A) the state it relies on
+# doesn't fully exist at that point and (B) that level of the API has
+# more direct access to the build state. This function requires that
+# an external script have populated its internal state, which is
+# normally handled via teaish.tester.tcl.in.
+#
+# Caveat #2: defines in the style of HAVE_FEATURENAME with a value of
+# 0 are, by long-standing configure script conventions, treated as
+# _undefined_ here.
+#
+proc teaish-build-flag3 {flag tgtVar {dflt ""}} {
+  upvar $tgtVar tgt
+  if {[info exists ::teaish__BuildFlags($flag)]} {
+    set tgt $::teaish__BuildFlags($flag)
+    return 1;
+  } elseif {0==[array size ::teaish__BuildFlags]} {
+    test-warn \
+      "\[[test-current-scope]] was called from " \
+      "[test-current-scope 1] without the build flags imported."
+  }
+  set tgt $dflt
+  return 0
+}
+
+#
+# @teaish-build-flag flag ?dflt?
+#
+# Convenience form of teaish-build-flag3 which returns the
+# configure-time-defined value of $flag or "" if it's not defined (or
+# if it's an empty string).
+#
+proc teaish-build-flag {flag {dflt ""}} {
+  set tgt ""
+  teaish-build-flag3 $flag tgt $dflt
+  return $tgt
+}
@@ -725,10 +725,6 @@ as part of the output file.</p>
 <p>There can be multiple <tt>%code</tt> directives.  The arguments of
 all <tt>%code</tt> directives are concatenated.</p>

-<p>If the argument to <tt>%code</tt> is a filename within <tt>&lt;...&gt;</tt>
-then the content of the named file is inserted instead of the text of the
-argument itself.
-
 <a id='default_destructor'></a>
 <h4>4.4.2 The <tt>%default_destructor</tt> directive</h4>

@@ -850,7 +846,7 @@ or more tokens.  The alternative meaning is tried if the original token
 would have generated a syntax error.</p>

 <p>The <tt>%fallback</tt> directive was added to support robust parsing of SQL
-syntax in <a href='https://www.sqlite.org/'>SQLite</a>.
+syntax in <a href='https://sqlite.org/'>SQLite</a>.
 The SQL language contains a large assortment of keywords, each of which
 appears as a different token to the language parser.  SQL contains so
 many keywords that it can be difficult for programmers to keep up with
@@ -924,11 +920,6 @@ For example:</p>
 <p>This might be needed, for example, if some of the C actions in the
 grammar call functions that are prototyped in unistd.h.</p>

-<p>If the argument to <tt>%include</tt> is a filename within
-<tt>&lt;...&gt;</tt> then the content of that file is inserted instead
-of the text of the argument itself.
-
-
 <p>Use the <tt><a href="#pcode">%code</a></tt> directive to add code to
 the end of the generated parser.</p>

@@ -1,142 +0,0 @@
-
-Shared-Schema Mode Notes
-========================
-
-The [reuse-schema](/timeline?r=reuse-schema) branch contains changes 
-to allow SQLite connections to share schemas
-between database connections within the same process in order to save memory.
-Schemas may be shared between multiple databases attached to the same or
-distinct connection handles.
-
-Compile with -DSQLITE\_ENABLE\_SHARED\_SCHEMA in order to enable the
-shared-schema enhancement.  Enabling the shared-schema enhancement causes
-approximately a 0.1% increase in CPU cycles consumed and about a 3000-byte
-increase in the size of the library, even if shared-schema is never used.
-
-Assuming the compile-time requirements are satisfied, the shared-schema
-feature is engaged by opening the database connection using the
-sqlite3&#95;open&#95;v2() API with the SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA
-flag specified.  The main database and any attached databases will then share
-an in-memory Schema object with any other database opened within the process
-for which: 
-
-  * the contents of the sqlite&#95;master table, including all object names,
-    SQL statements and root pages are identical, and
-  * have the same values for the schema-cookie.
-
-Temp databases (those populated with "CREATE TEMP TABLE" and similar
-statements) never share schemas.
-
-Connections opened with the SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA flag
-specified may not modify any database schema except that belonging to the
-temp database in anyway. This includes creating or dropping database 
-objects, vacuuming the database, or running ANALYZE when the
-sqlite&#95;stat\[14\] tables do not exist.
-
-For SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA connections, the
-SQLITE&#95;DBSTATUS&#95;SCHEMA&#95;USED sqlite3&#95;db&#95;status() verb
-distributes the memory used for a shared schema object evenly between all
-database connections that share it.
-
-## The ".shared-schema" Command
-
-The shell tool on this branch contains a special dot-command to help with
-managing databases. The ".shared-schema" dot-command can be used to test
-whether or not two databases are similar enough to share in-memory schemas,
-and to fix minor problems that prevent them from doing so. To test if
-two or more database are compatible, one database is opened directly using 
-the shell tool and the following command issued:
-
-        .shared-schema check <database-1> [<database-2>]...
-
-where &lt;database-1&gt; etc. are replaced with the names of database files
-on disk. For each database specified on the command line, a single line of
-output is produced. If the database can share an in-memory schema with the
-main database opened by the shell tool, the output is of the form:
-
-        <database> is compatible
-
-Otherwise, if the database cannot share a schema with the main db, the output
-is of the form:
-
-        <database> is NOT compatible (<reason>)
-
-where &lt;reason&gt; indicates the cause of the incompatibility. &lt;reason&gt;
-is always one of the following.
-
-<ul>
-  <li> <b>objects</b> - the databases contain a different set schema objects
-  (tables, indexes, views and triggers).
-
-  <li> <b>SQL</b> - the databases contain the same set of objects, but the SQL
-  statements used to create them were not the same.
-
-  <li> <b>root pages</b> - the databases contain the same set of objects created
-  by the same SQL statements, but the root pages are not the same.
-
-  <li> <b>order of sqlite&#95;master rows</b> - the databases contain the same
-  set of objects created by the same SQL statements with the same root pages,
-  but the order of the rows in the sqlite&#95;master tables are different.
-
-  <li> <b>schema cookie</b> - the database schemas are compatible, but the 
-  schema cookie values ("PRAGMA schema&#95;version") are different.
-</ul>
-
-The final three problems in the list above can be fixed using the
-.shared-schema command. To modify such a database so that it can share a 
-schema with the main database, the following shell command is used:
-
-        .shared-schema fix <database-1> [<database-2>]...
-
-If a database can be modified so that it may share a schema with the main
-database opened by the shell tool, output is as follows:
-
-        Fixing <database>... <database> is compatible
-
-If a database does not require modification, or cannot be modified such that
-it can share a schema with the main database, the output of "fix" is identical
-to that of the "check" command.
-
-## Implementation Notes
-
-A single Schema object is never used by more than one database simultaneously,
-regardless of whether or not those databases are attached to the same or
-different database handles. Instead, a pool of schema objects is maintained 
-for each unique sqlite&#95;master-contents/schema-cookie combination
-opened within the process. Each time database schemas are required by a
-connection, for example as part of an sqlite3&#95;prepare\*(),
-sqlite3&#95;blob&#95;open() or sqlite3&#95;blob&#95;open() call, it obtains
-the minimum number of schemas required from the various schema-pools, returning
-them at the end of the call. This means that a single schema-pool only ever
-contains more than one copy of the schema if:
-
-  * Two threads require schemas from the same pool at the same time, or
-  * A single sqlite3&#95;prepare\*() call requires schemas for two or more
-    attached databases that use the same schema-pool.
-
-The size of a schema-pool never shrinks. Each schema pool always maintains 
-a number of schema objects equal to the highwater mark of schema objects
-simultaneously required by clients.
-
-This approach is preferred to allowing multiple databases to use the same
-Schema object simultaneously for three reasons:
-
-  * The Schema object is not completely read-only. For example, the 
-    Index.zIdxAff string is allocated lazily.
-  * Throughout the statement compiler, SQLite uses variables like 
-    Table.pSchema and Index.pSchema with the sqlite3SchemaToIndex() routine
-    in order to determine which attached database a Table or Index object
-    resides in. This mechanism does not work if the same Schema may be
-    used by two or more attached databases.
-  * It may be easier to modify this approach in order to allow
-    SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA connections to modify database
-    schemas, should that be required.
-
-SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA connections do not store their
-virtual-table handles in the Table.pVTable list of each table. This would not
-work, as (a) there is no guarantee that a connection will be assigned the same
-Schema object each time it requests one from a schema-pool and (b) a single
-Schema (and therefore Table) object may correspond to tables in two or more
-databases attached to a single connection. Instead, all virtual-table handles
-associated with a single database are stored in a linked-list headed at
-Db.pVTable.
@@ -35,84 +35,69 @@ perspective on how to compile SQLite on unix-like systems.
 ###  2.1 Setup

 <ol type="1">
-<li value="1"> 
-    [Fossil](https://fossil-scm.org/) installed.
+<li value="1">
+    [Fossil][] installed.
 <li> Check out source code and set environment variables:
   <ol type="a">
   <li> **TCLSOURCE** &rarr;
-    The top-level directory of a Fossil check-out of the TCL source tree.
+    The top-level directory of a [Fossil][] check-out of the
+    [TCL source tree][tcl-fossil].
   <li> **SQLITESOURCE** &rarr;
    A Fossil check-out of the SQLite source tree.
-   <li> **TCLBUILD** &rarr;
+   <li> **TCLHOME** &rarr;
    A directory that does not exist at the start of the test and which
    will be deleted at the end of the test, and that will contain the
    test builds of the TCL libraries and the SQLite TCL Extensions.
+    It is the top-most installation directory, i.e. the one provided
+    to Tcl's `./configure --prefix=/path/to/tcl`.
+   <li> **TCLVERSION** &rarr;
+    The `X.Y`-form version of Tcl being used: 8.6, 9.0, 9.1...
   </ol>
 </ol>

-### 2.2 Testing TCL 8.6 on unix
+### 2.2 Testing TCL 8.x and 9.x on unix
+
+From a checked-out copy of [the core Tcl tree][tcl-fossil]

 <ol type="1">
-<li value="3">  `mkdir -p $TCLBUILD/tcl86`
-<li>  `cd $TCLSOURCE/unix`
-<li>  `fossil up core-8-6-16` <br>
-      &uarr; Or some other version of Tcl8.6.
+<li value="3">`TCLVERSION=8.6` <br>
+      &uarr; A version of your choice. This process has been tested with
+      values of 8.6, 9.0, and 9.1 (as of 2025-04-16). The out-of-life
+      version 8.5 fails some of `make devtest` for undetermined reasons.
+<li>`TCLHOME=$HOME/tcl/$TCLVERSION`
+<li>`TCLSOURCE=/path/to/tcl/checkout`
+<li>`SQLITESOURCE=/path/to/sqlite/checkout`
+<li>`rm -fr $TCLHOME` <br>
+      &uarr; Ensure that no stale Tcl installation is laying around.
+<li> `cd $TCLSOURCE`
+<li>  `fossil up core-8-6-branch` <br>
+      &uarr; The branch corresponding to `$TCLVERSION`, e.g.
+      `core-9-0-branch` or `trunk`.
 <li>  `fossil clean -x`
-<li>  `./configure --prefix=$TCLBUILD/tcl86 --disable-shared` <br>
-      &uarr; The --disable-shared is to avoid the need to set LD_LIBRARY_PATH
+<li>  `cd unix`
+<li>  `./configure --prefix=$TCLHOME --disable-shared` <br>
+      &uarr; The `--disable-shared` is to avoid the need to set `LD_LIBRARY_PATH`
      when using this Tcl build.
 <li>  `make install`
 <li> `cd $SQLITESOURCE`
 <li> `fossil clean -x`
-<li> `./configure --with-tclsh=$TCLBUILD/tcl86/bin/tclsh8.6 --all`
+<li> `./configure --with-tcl=$TCLHOME --all`
 <li> `make tclextension-install` <br>
-     &uarr; Verify extension installed at $TCLBUILD/tcl86/lib/tcl8.6/sqlite3.*
+     &uarr; Verify extension installed at
+     `$TCLHOME/lib/tcl${TCLVERSION}/sqlite<SQLITE_VERSION>`.
 <li> `make tclextension-list` <br>
     &uarr; Verify TCL extension correctly installed.
 <li> `make tclextension-verify` <br>
     &uarr; Verify that the correct version is installed.
-<li> `$TCLBUILD/tcl86/bin/tclsh8.6 test/testrunner.tcl release --explain` <br>
+<li> `$TCLHOME/bin/tclsh[89].[0-9] test/testrunner.tcl release --explain` <br>
     &uarr; Verify thousands of lines of output with no errors. Or
     consider running "devtest" without --explain instead of "release".
 </ol>

-### 2.3 Testing TCL 9.0 on unix
-
-<ol>
-<li value="16">  `mkdir -p $TCLBUILD/tcl90`
-<li>  `fossil up core-9-0-0` <br>
-      &uarr; Or some other version of Tcl9
-<li>  `fossil clean -x`
-<li>  `./configure --prefix=$TCLBUILD/tcl90 --disable-shared` <br>
-      &uarr; The --disable-shared is to avoid the need to set LD_LIBRARY_PATH
-      when using this Tcl build.
-<li>  `make install`
-<li>  `cp -r ../library $TCLBUILD/tcl90/lib/tcl9.0` <br>
-      &uarr; The Tcl library is not installed by "make install" for Tcl9.0 unless
-      you also include the --disable-zipfs to ./configure.  But if you do that
-      then the generated tclsh9.0 is no longer stand-alone.  On the other hand,
-      if you don't install the Tcl library, other programs like testfixture
-      won't be able to find the Tcl library and hence won't work.  This
-      extra installation step resolves the dilemma.
-      This step is not required when building Tcl8.6, which lacks support for
-      zipfs and hence always installs its Tcl library.
-<li> `cd $SQLITESOURCE`
-<li> `fossil clean -x`
-<li> `./configure --with-tclsh=$TCLBUILD/tcl90/bin/tclsh9.0 --all`
-<li> `make tclextension-install` <br>
-     &uarr; Verify extension installed at $TCLBUILD/tcl90/lib/sqlite3.*
-<li> `make tclextension-list` <br>
-     &uarr; Verify TCL extension correctly installed.
-<li> `make tclextension-verify`
-<li> `$TCLBUILD/tcl90/bin/tclsh9.0 test/testrunner.tcl release --explain` <br>
-     &uarr; Verify thousands of lines of output with no errors.  Or
-     consider running "devtest" without --explain instead of "release".
-</ol>
-
-### 2.4 Cleanup
+### 2.3 Cleanup

 <ol type="1">
-<li value="29"> `rm -rf $TCLBUILD`
+<li value="29"> `rm -rf $TCLHOME`
 </ol>

 <a id="windows"></a>
@@ -123,9 +108,11 @@ perspective on how to compile SQLite on Windows.

 ###  3.1 Setup for Windows

+(These docs are not as up-to-date as the Unix docs, above.)
+
 <ol type="1">
-<li value="1"> 
-    [Fossil](https://fossil-scm.org/) installed.
+<li value="1">
+    [Fossil][] installed.
 <li>
    Unix-like command-line tools installed.  Example:
    [unxutils](https://unxutils.sourceforge.net/)
@@ -206,3 +193,72 @@ perspective on how to compile SQLite on Windows.
 <ol type="1">
 <li value="35"> `rm -rf %TCLBUILD%`
 </ol>
+
+## 4.0 Testing the TEA(ish) Build (unix only)
+
+This part requires following the setup instructions for Unix systems,
+at the top of this document.
+
+The former TEA, now TEA(ish), build of this extension uses the same
+code as the builds described above but is provided in a form more
+convenient for downstream Tcl users.
+
+It lives in `autoconf/tea` and, as part of the `autoconf` bundle,
+_cannot be tested directly from the canonical tree_. Instead it has to
+be packaged.
+
+### 4.1 Teaish Setup
+
+Follow the same Tcl- and environment-related related setup described
+in the first section of this document, up to and including the
+installation of Tcl (unless, of course, it was already installed using
+those same instructions).
+
+### 4.2 Teaish Testing
+
+<ol>
+<li>`cd $SQLITESOURCE`
+<li>Run either `make snapshot-tarball` or `make amalgamation-tarball`
+    &uarr;
+    Those steps will leave behind a temp dir called `mkpkg_tmp_dir`,
+    under which the extension is most readily reached. It can optionally
+    be extracted from the generated tarball, but that tarball was
+    generated from this dir, and reusing this dir is a time saver
+    during development.
+<li> `cd mkpkg_tmp/tea`
+<li> `./configure --with-tcl=$TCLHOME`
+<li> `make test install` <br>
+     &uarr; Should run to completion without any errors.
+<li> `make uninstall` <br>
+     &uarr; Will uninstall the extension. This _can_ be run
+     in the same invocation as the `install` target, but only
+     if the `-j#` make flag is _not_ used. If it is, the
+     install/uninstall steps will race and make a mess of things.
+     Parallel builds do not help in this build, anyway, as there's
+     only a single C file to compile.
+</ol>
+
+When actively developing and testing the teaish build, which requires
+going through the tarball generation, there's a caveat about the
+`mkpkg_tmp_dir` dir: it will be deleted every time a tarball is
+built, the shell console which is parked in that
+directory for testing needs to add `cd $PWD &&` to the start of the
+build commands, like:
+
+>
+```
+[user@host:.../mkpkg_tmp_dir/tea]$ \
+  cd $PWD && ./configure CFLAGS=-O0 --with-tcl=$TCLHOME \
+  && make test install uninstall
+```
+
+### 4.3 Teaish Cleanup
+
+
+<ol type="1">
+<li> `rm -rf $TCLHOME`
+<li> `cd $SQLITESOURCE; rm -fr mkpkg_tmp_dir; fossil clean -x`
+</ol>
+
+[Fossil]: https://fossil-scm.org/home
+[tcl-fossil]: https://core.tcl-lang.org/tcl
@@ -15,6 +15,7 @@
  <li> 3.1. <a href=#commands_to_run_tests>Commands to Run SQLite Tests</a>
  <li> 3.2. <a href=#zipvfs_tests>Running ZipVFS Tests</a>
  <li> 3.3. <a href=#source_code_test_failures>Investigating Source Code Test Failures</a>
+  <li> 3.4. <a href=#fuzzdb>External Fuzzcheck Databases</a>
 </ul>
  <li> 4. <a href=#testrunner_options>Extra testrunner.tcl Options</a>
  <li> 5. <a href=#cpu_cores>Controlling CPU Core Utilization</a>
@@ -23,47 +24,62 @@
 <a name=overview></a>
 # 1. Overview

-testrunner.tcl is a Tcl script used to run multiple SQLite tests using 
-multiple jobs. It supports the following types of tests:
+The testrunner.tcl program is a Tcl script used to run multiple SQLite
+tests in parallel, thus reducing testing time on multi-core machines.
+It supports the following types of tests:

  *  Tcl test scripts.

+  *  Fuzzcheck tests, including using an external fuzzcheck database.
+
  *  Tests run with `make` commands.  Examples:
-      -  `make mdevtest`
+      -  `make devtest`
      -  `make releasetest`
      -  `make sdevtest`
      -  `make testrunner`

-testrunner.tcl pipes the output of all tests and builds run into log file
-**testrunner.log**, created in the current working directory. Search this
-file to find details of errors.  Suggested search commands:
+The testrunner.tcl program stores output of all tests and builds run in
+log file **testrunner.log**, created in the current working directory.
+Search this file to find details of errors.  Suggested search commands:

   *  `grep "^!" testrunner.log`
   *  `grep failed testrunner.log`

-testrunner.tcl also populates SQLite database **testrunner.db**. This database
-contains details of all tests run, running and to be run. A useful query
-might be:
+The testrunner.tcl program also populates SQLite database **testrunner.db**.
+This database contains details of all tests run, running and to be run.
+A useful query might be:

 ```
  SELECT * FROM script WHERE state='failed'
 ```

+You can get a summary of errors in a prior run by invoking commands like
+these:
+
+```
+  tclsh $(TESTDIR)/testrunner.tcl errors
+  tclsh $(TESTDIR)/testrunner.tcl errors -v
+```
+
 Running the command:

 ```
-  ./testfixture $(TESTDIR)/testrunner.tcl status
+  tclsh $(TESTDIR)/testrunner.tcl status
 ```

 in the directory containing the testrunner.db database runs various queries
 to produce a succinct report on the state of a running testrunner.tcl script.
-Running:
+A good way to keep and eye on test progress is to run either of the two
+following commands:

 ```
-  watch ./testfixture $(TESTDIR)/testrunner.tcl status
+  watch tclsh $(TESTDIR)/testrunner.tcl status
+  tclsh $(TESTDIR)/testrunner.tcl status -d 2
 ```

-in another terminal is a good way to keep an eye on a long running test.
+Both of the commands above accomplish about the same thing, but the second
+one has the advantage of not requiring "watch" to be installed on your
+system.

 Sometimes testrunner.tcl uses the `testfixture` binary that it is run with
 to run tests (see "Binary Tests" below). Sometimes it builds testfixture and
@@ -239,9 +255,7 @@ of the specific tests run.

 As with <a href=#source code tests>source code tests</a>, one or more patterns
 may be appended to any of the above commands (mdevtest, sdevtest or release).
-In that case only Tcl tests (no fuzz or other tests) that match the specified
-pattern are run. For example, to run the just the Tcl rtree tests in all 
-builds and configurations supported by "release":
+Pattern matching is used for both Tcl tests and fuzz tests.

 ```
  tclsh $TESTDIR/testrunner.tcl release rtree%
@@ -292,6 +306,34 @@ target to build. This may be used either to run a `make` command test directly,
 or else to build a testfixture (or testfixture.exe) binary with which to
 run a Tcl test script, as <a href=#binary_test_failures>described above</a>.

+<a name=fuzzdb></a>
+## 3.4 External Fuzzcheck Databases
+
+Testrunner.tcl will also run fuzzcheck against an external (out of tree)
+database, for example fuzzcheck databases generated by dbsqlfuzz.  To do
+this, simply add the "`--fuzzdb` *FILENAME*" command-line option or set 
+the FUZZDB environment variable to the name of the external
+database.  For large external databases, testrunner.tcl will automatically use
+the "`--slice`" command-line option of fuzzcheck to divide the work up into
+multiple jobs, to increase parallelism.
+
+Thus, for example, to run a full releasetest including an external
+dbsqlfuzz database, run a command like one of these:
+
+```
+  tclsh test/testrunner.tcl releasetest --fuzzdb ../fuzz/20250415.db
+  FUZZDB=../fuzz/20250415.db make releasetest
+  nmake /f Makefile.msc FUZZDB=../fuzz/20250415.db releasetest
+```
+
+The patternlist option to testrunner.tcl will match against fuzzcheck
+databases.  So if you want to run *only* tests involving the external
+database, you can use a command something like this:
+
+```
+  tclsh test/testrunner.tcl releasetest 20250415 --fuzzdb ../fuzz/20250415.db
+```
+
 <a name=testrunner_options></a>
 # 4. Extra testrunner.tcl Options

@@ -315,16 +357,22 @@ would normally execute into the testrunner.log file. Example:
  tclsh $TESTDIR/testrunner.tcl --dryrun mdevtest"
 ```

-The **--explain** option is similar to --dryrun in that it prevents testrunner.tcl
-from building any binaries or running any tests.  The difference is that --explain
-prints on standard output a human-readable summary of all the builds and tests that
-would have been run.
+The **--explain** option is similar to --dryrun in that it prevents
+testrunner.tcl from building any binaries or running any tests.  The
+difference is that --explain prints on standard output a human-readable
+summary of all the builds and tests that would have been run.

 ```
  # Show what builds and tests would have been run
  tclsh $TESTDIR/testrunner.tcl --explain mdevtest
 ```

+The **--status** option uses VT100 escape sequences to display the test
+status full-screen.  This is similar to running 
+"`watch test/testrunner status`" in a separate window, just more convenient.
+Unfortunately, this option does not work correctly on Windows, due to the
+sketchy implementation of VT100 escapes on the Windows console.
+
 <a name=cpu_cores></a>
 # 5. Controlling CPU Core Utilization

@@ -1,6 +1,6 @@
 ## Loadable Extensions

-Various [loadable extensions](https://www.sqlite.org/loadext.html) for
+Various [loadable extensions](https://sqlite.org/loadext.html) for
 SQLite are found in subfolders.

 Most subfolders are dedicated to a single loadable extension (for
@@ -28,7 +28,7 @@
 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);
+    Tcl_AppendResult(interp, "no such handle: ", Tcl_GetString(pObj), NULL);
    return TCL_ERROR;
  }

@@ -62,20 +62,20 @@
  matches rows that contain both the "engineering" and "consultancy" tokens
  in the same column with not more than 10 other words between them. It does
  not matter which of the two terms occurs first in the document, only that
-  they be seperated by only 10 tokens or less. The user may also specify
+  they be separated by only 10 tokens or less. The user may also specify
  a different required proximity by adding "/N" immediately after the NEAR
  operator, where N is an integer. For example:

    <col> MATCH 'engineering NEAR/5 consultancy'

-  searches for a row containing an instance of each specified token seperated
+  searches for a row containing an instance of each specified token separated
  by not more than 5 other tokens. More than one NEAR operator can be used
  in as sequence. For example this query:

    <col> MATCH 'reliable NEAR/2 engineering NEAR/5 consultancy'

  searches for a row that contains an instance of the token "reliable" 
-  seperated by not more than two tokens from an instance of "engineering",
+  separated by not more than two tokens from an instance of "engineering",
  which is in turn separated by not more than 5 other tokens from an
  instance of the term "consultancy". Phrases enclosed in quotes may
  also be used as arguments to the NEAR operator.
@@ -295,12 +295,6 @@
 # define SQLITE_CORE 1
 #endif

-#include <assert.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>

 #include "fts3.h"
 #ifndef SQLITE_CORE 
@@ -14,6 +14,13 @@
 #ifndef _FTSINT_H
 #define _FTSINT_H

+#include <assert.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 
 # define NDEBUG 1
 #endif
@@ -202,6 +209,19 @@ typedef sqlite3_int64 i64;        /* 8-byte signed integer */

 #define deliberate_fall_through

+/*
+** Macros needed to provide flexible arrays in a portable way
+*/
+#ifndef offsetof
+# define offsetof(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0))
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define FLEXARRAY
+#else
+# define FLEXARRAY 1
+#endif
+
+
 #endif /* SQLITE_AMALGAMATION */

 #ifdef SQLITE_DEBUG
@@ -431,9 +451,13 @@ struct Fts3Phrase {
  */
  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 */
+  Fts3PhraseToken aToken[FLEXARRAY]; /* One for each token in the phrase */
 };

+/* Size (in bytes) of an Fts3Phrase object large enough to hold N tokens */
+#define SZ_FTS3PHRASE(N) \
+  (offsetof(Fts3Phrase,aToken)+(N)*sizeof(Fts3PhraseToken))
+
 /*
 ** A tree of these objects forms the RHS of a MATCH operator.
 **
@@ -161,6 +161,23 @@ int sqlite3Fts3OpenTokenizer(
 */
 static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *);

+/*
+** Search buffer z[], size n, for a '"' character. Or, if enable_parenthesis
+** is defined, search for '(' and ')' as well. Return the index of the first
+** such character in the buffer. If there is no such character, return -1.
+*/
+static int findBarredChar(const char *z, int n){
+  int ii;
+  for(ii=0; ii<n; ii++){
+    if( (z[ii]=='"')
+     || (sqlite3_fts3_enable_parentheses && (z[ii]=='(' || z[ii]==')'))
+    ){
+      return ii;
+    }
+  }
+  return -1;
+}
+
 /*
 ** Extract the next token from buffer z (length n) using the tokenizer
 ** and other information (column names etc.) in pParse. Create an Fts3Expr
@@ -185,16 +202,9 @@ static int getNextToken(
  int rc;
  sqlite3_tokenizer_cursor *pCursor;
  Fts3Expr *pRet = 0;
-  int i = 0;

-  /* Set variable i to the maximum number of bytes of input to tokenize. */
-  for(i=0; i<n; i++){
-    if( sqlite3_fts3_enable_parentheses && (z[i]=='(' || z[i]==')') ) break;
-    if( z[i]=='"' ) break;
-  }
-
-  *pnConsumed = i;
-  rc = sqlite3Fts3OpenTokenizer(pTokenizer, pParse->iLangid, z, i, &pCursor);
+  *pnConsumed = n;
+  rc = sqlite3Fts3OpenTokenizer(pTokenizer, pParse->iLangid, z, n, &pCursor);
  if( rc==SQLITE_OK ){
    const char *zToken;
    int nToken = 0, iStart = 0, iEnd = 0, iPosition = 0;
@@ -202,7 +212,18 @@ static int getNextToken(

    rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition);
    if( rc==SQLITE_OK ){
-      nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
+      /* Check that this tokenization did not gobble up any " characters. Or,
+      ** if enable_parenthesis is true, that it did not gobble up any 
+      ** open or close parenthesis characters either. If it did, call
+      ** getNextToken() again, but pass only that part of the input buffer
+      ** up to the first such character.  */
+      int iBarred = findBarredChar(z, iEnd);
+      if( iBarred>=0 ){
+        pModule->xClose(pCursor);
+        return getNextToken(pParse, iCol, z, iBarred, ppExpr, pnConsumed);
+      }
+
+      nByte = sizeof(Fts3Expr) + SZ_FTS3PHRASE(1) + nToken;
      pRet = (Fts3Expr *)sqlite3Fts3MallocZero(nByte);
      if( !pRet ){
        rc = SQLITE_NOMEM;
@@ -212,7 +233,7 @@ static int getNextToken(
        pRet->pPhrase->nToken = 1;
        pRet->pPhrase->iColumn = iCol;
        pRet->pPhrase->aToken[0].n = nToken;
-        pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1];
+        pRet->pPhrase->aToken[0].z = (char*)&pRet->pPhrase->aToken[1];
        memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken);

        if( iEnd<n && z[iEnd]=='*' ){
@@ -236,7 +257,11 @@ static int getNextToken(

      }
      *pnConsumed = iEnd;
-    }else if( i && rc==SQLITE_DONE ){
+    }else if( n && rc==SQLITE_DONE ){
+      int iBarred = findBarredChar(z, n);
+      if( iBarred>=0 ){
+        *pnConsumed = iBarred;
+      }
      rc = SQLITE_OK;
    }

@@ -285,7 +310,7 @@ static int getNextString(
  char *zTemp = 0;
  i64 nTemp = 0;

-  const int nSpace = sizeof(Fts3Expr) + sizeof(Fts3Phrase);
+  const int nSpace = sizeof(Fts3Expr) + SZ_FTS3PHRASE(1);
  int nToken = 0;

  /* The final Fts3Expr data structure, including the Fts3Phrase,
@@ -1239,7 +1264,6 @@ static void fts3ExprTestCommon(
  }

  if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
-    sqlite3Fts3ExprFree(pExpr);
    sqlite3_result_error(context, "Error parsing expression", -1);
  }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
    sqlite3_result_error_nomem(context);
@@ -108,9 +108,13 @@ struct MatchinfoBuffer {
  int nElem;
  int bGlobal;                    /* Set if global data is loaded */
  char *zMatchinfo;
-  u32 aMatchinfo[1];
+  u32 aMI[FLEXARRAY];
 };

+/* Size (in bytes) of a MatchinfoBuffer sufficient for N elements */
+#define SZ_MATCHINFOBUFFER(N) \
+            (offsetof(MatchinfoBuffer,aMI)+(((N)+1)/2)*sizeof(u64))
+

 /*
 ** The snippet() and offsets() functions both return text values. An instance
@@ -135,13 +139,13 @@ struct StrBuffer {
 static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){
  MatchinfoBuffer *pRet;
  sqlite3_int64 nByte = sizeof(u32) * (2*(sqlite3_int64)nElem + 1)
-                           + sizeof(MatchinfoBuffer);
+                           + SZ_MATCHINFOBUFFER(1);
  sqlite3_int64 nStr = strlen(zMatchinfo);

  pRet = sqlite3Fts3MallocZero(nByte + nStr+1);
  if( pRet ){
-    pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet;
-    pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0]
+    pRet->aMI[0] = (u8*)(&pRet->aMI[1]) - (u8*)pRet;
+    pRet->aMI[1+nElem] = pRet->aMI[0]
                                      + sizeof(u32)*((int)nElem+1);
    pRet->nElem = (int)nElem;
    pRet->zMatchinfo = ((char*)pRet) + nByte;
@@ -155,10 +159,10 @@ static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){
 static void fts3MIBufferFree(void *p){
  MatchinfoBuffer *pBuf = (MatchinfoBuffer*)((u8*)p - ((u32*)p)[-1]);

-  assert( (u32*)p==&pBuf->aMatchinfo[1] 
-       || (u32*)p==&pBuf->aMatchinfo[pBuf->nElem+2] 
+  assert( (u32*)p==&pBuf->aMI[1] 
+       || (u32*)p==&pBuf->aMI[pBuf->nElem+2] 
  );
-  if( (u32*)p==&pBuf->aMatchinfo[1] ){
+  if( (u32*)p==&pBuf->aMI[1] ){
    pBuf->aRef[1] = 0;
  }else{
    pBuf->aRef[2] = 0;
@@ -175,18 +179,18 @@ static void (*fts3MIBufferAlloc(MatchinfoBuffer *p, u32 **paOut))(void*){

  if( p->aRef[1]==0 ){
    p->aRef[1] = 1;
-    aOut = &p->aMatchinfo[1];
+    aOut = &p->aMI[1];
    xRet = fts3MIBufferFree;
  }
  else if( p->aRef[2]==0 ){
    p->aRef[2] = 1;
-    aOut = &p->aMatchinfo[p->nElem+2];
+    aOut = &p->aMI[p->nElem+2];
    xRet = fts3MIBufferFree;
  }else{
    aOut = (u32*)sqlite3_malloc64(p->nElem * sizeof(u32));
    if( aOut ){
      xRet = sqlite3_free;
-      if( p->bGlobal ) memcpy(aOut, &p->aMatchinfo[1], p->nElem*sizeof(u32));
+      if( p->bGlobal ) memcpy(aOut, &p->aMI[1], p->nElem*sizeof(u32));
    }
  }

@@ -196,7 +200,7 @@ static void (*fts3MIBufferAlloc(MatchinfoBuffer *p, u32 **paOut))(void*){

 static void fts3MIBufferSetGlobal(MatchinfoBuffer *p){
  p->bGlobal = 1;
-  memcpy(&p->aMatchinfo[2+p->nElem], &p->aMatchinfo[1], p->nElem*sizeof(u32));
+  memcpy(&p->aMI[2+p->nElem], &p->aMI[1], p->nElem*sizeof(u32));
 }

 /*
@@ -1023,16 +1027,16 @@ static size_t fts3MatchinfoSize(MatchInfo *pInfo, char cArg){
      break;

    case FTS3_MATCHINFO_LHITS:
-      nVal = pInfo->nCol * pInfo->nPhrase;
+      nVal = (size_t)pInfo->nCol * pInfo->nPhrase;
      break;

    case FTS3_MATCHINFO_LHITS_BM:
-      nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
+      nVal = (size_t)pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
      break;

    default:
      assert( cArg==FTS3_MATCHINFO_HITS );
-      nVal = pInfo->nCol * pInfo->nPhrase * 3;
+      nVal = (size_t)pInfo->nCol * pInfo->nPhrase * 3;
      break;
  }

@@ -219,7 +219,7 @@ static int SQLITE_TCLAPI fts3_near_match_cmd(
    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);
+      Tcl_AppendResult(interp, "Too many tokens in phrase", NULL);
      rc = TCL_ERROR;
      goto near_match_out;
    }
@@ -547,7 +547,7 @@ static int SQLITE_TCLAPI fts3_test_varint_cmd(
  if( w!=w2 || nByte!=nByte2 ){
    char *zErr = sqlite3_mprintf("error testing %lld", w);
    Tcl_ResetResult(interp);
-    Tcl_AppendResult(interp, zErr, 0);
+    Tcl_AppendResult(interp, zErr, NULL);
    return TCL_ERROR;
  }

@@ -557,7 +557,7 @@ static int SQLITE_TCLAPI fts3_test_varint_cmd(
    if( (int)w!=i || nByte!=nByte2 ){
      char *zErr = sqlite3_mprintf("error testing %lld (32-bit)", w);
      Tcl_ResetResult(interp);
-      Tcl_AppendResult(interp, zErr, 0);
+      Tcl_AppendResult(interp, zErr, NULL);
      return TCL_ERROR;
    }
  }
@@ -346,7 +346,7 @@ static int fts3tokFilterMethod(
  fts3tokResetCursor(pCsr);
  if( idxNum==1 ){
    const char *zByte = (const char *)sqlite3_value_text(apVal[0]);
-    int nByte = sqlite3_value_bytes(apVal[0]);
+    sqlite3_int64 nByte = sqlite3_value_bytes(apVal[0]);
    pCsr->zInput = sqlite3_malloc64(nByte+1);
    if( pCsr->zInput==0 ){
      rc = SQLITE_NOMEM;
@@ -20,6 +20,7 @@ SQLITE_EXTENSION_INIT1

 #include <string.h>
 #include <assert.h>
+#include <stddef.h>

 #ifndef SQLITE_AMALGAMATION

@@ -75,6 +76,18 @@ typedef sqlite3_uint64 u64;
 # define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&7)==0)
 #endif

+/*
+** Macros needed to provide flexible arrays in a portable way
+*/
+#ifndef offsetof
+# define offsetof(ST,M) ((size_t)((char*)&((ST*)0)->M - (char*)0))
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define FLEXARRAY
+#else
+# define FLEXARRAY 1
+#endif
+
 #endif

 /* Truncate very long tokens to this many bytes. Hard limit is 
@@ -147,10 +160,11 @@ typedef struct Fts5Colset Fts5Colset;
 */
 struct Fts5Colset {
  int nCol;
-  int aiCol[1];
+  int aiCol[FLEXARRAY];
 };

-
+/* Size (int bytes) of a complete Fts5Colset object with N columns. */
+#define SZ_FTS5COLSET(N) (sizeof(i64)*((N+2)/2))

 /**************************************************************************
 ** Interface to code in fts5_config.c. fts5_config.c contains contains code
@@ -86,9 +86,13 @@ struct Fts5ExprNode {
  /* Child nodes. For a NOT node, this array always contains 2 entries. For 
  ** AND or OR nodes, it contains 2 or more entries.  */
  int nChild;                     /* Number of child nodes */
-  Fts5ExprNode *apChild[1];       /* Array of child nodes */
+  Fts5ExprNode *apChild[FLEXARRAY]; /* Array of child nodes */
 };

+/* Size (in bytes) of an Fts5ExprNode object that holds up to N children */
+#define SZ_FTS5EXPRNODE(N) \
+  (offsetof(Fts5ExprNode,apChild) + (N)*sizeof(Fts5ExprNode*))
+
 #define Fts5NodeIsString(p) ((p)->eType==FTS5_TERM || (p)->eType==FTS5_STRING)

 /*
@@ -119,9 +123,13 @@ struct Fts5ExprPhrase {
  Fts5ExprNode *pNode;            /* FTS5_STRING node this phrase is part of */
  Fts5Buffer poslist;             /* Current position list */
  int nTerm;                      /* Number of entries in aTerm[] */
-  Fts5ExprTerm aTerm[1];          /* Terms that make up this phrase */
+  Fts5ExprTerm aTerm[FLEXARRAY];  /* Terms that make up this phrase */
 };

+/* Size (in bytes) of an Fts5ExprPhrase object that holds up to N terms */
+#define SZ_FTS5EXPRPHRASE(N) \
+    (offsetof(Fts5ExprPhrase,aTerm) + (N)*sizeof(Fts5ExprTerm))
+
 /*
 ** One or more phrases that must appear within a certain token distance of
 ** each other within each matching document.
@@ -130,9 +138,12 @@ struct Fts5ExprNearset {
  int nNear;                      /* NEAR parameter */
  Fts5Colset *pColset;            /* Columns to search (NULL -> all columns) */
  int nPhrase;                    /* Number of entries in aPhrase[] array */
-  Fts5ExprPhrase *apPhrase[1];    /* Array of phrase pointers */
+  Fts5ExprPhrase *apPhrase[FLEXARRAY]; /* Array of phrase pointers */
 };

+/* Size (in bytes) of an Fts5ExprNearset object covering up to N phrases */
+#define SZ_FTS5EXPRNEARSET(N) \
+  (offsetof(Fts5ExprNearset,apPhrase)+(N)*sizeof(Fts5ExprPhrase*))

 /*
 ** Parse context.
@@ -292,7 +303,7 @@ int sqlite3Fts5ExprNew(
  /* If the LHS of the MATCH expression was a user column, apply the
  ** implicit column-filter.  */
  if( sParse.rc==SQLITE_OK && iCol<pConfig->nCol ){
-    int n = sizeof(Fts5Colset);
+    int n = SZ_FTS5COLSET(1);
    Fts5Colset *pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&sParse.rc, n);
    if( pColset ){
      pColset->nCol = 1;
@@ -1650,7 +1661,7 @@ Fts5ExprNearset *sqlite3Fts5ParseNearset(
  if( pParse->rc==SQLITE_OK ){
    if( pNear==0 ){
      sqlite3_int64 nByte;
-      nByte = sizeof(Fts5ExprNearset) + SZALLOC * sizeof(Fts5ExprPhrase*);
+      nByte = SZ_FTS5EXPRNEARSET(SZALLOC+1);
      pRet = sqlite3_malloc64(nByte);
      if( pRet==0 ){
        pParse->rc = SQLITE_NOMEM;
@@ -1661,7 +1672,7 @@ Fts5ExprNearset *sqlite3Fts5ParseNearset(
      int nNew = pNear->nPhrase + SZALLOC;
      sqlite3_int64 nByte;

-      nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*);
+      nByte = SZ_FTS5EXPRNEARSET(nNew+1);
      pRet = (Fts5ExprNearset*)sqlite3_realloc64(pNear, nByte);
      if( pRet==0 ){
        pParse->rc = SQLITE_NOMEM;
@@ -1752,12 +1763,12 @@ static int fts5ParseTokenize(
      int nNew = SZALLOC + (pPhrase ? pPhrase->nTerm : 0);

      pNew = (Fts5ExprPhrase*)sqlite3_realloc64(pPhrase, 
-          sizeof(Fts5ExprPhrase) + sizeof(Fts5ExprTerm) * nNew
+          SZ_FTS5EXPRPHRASE(nNew+1)
      );
      if( pNew==0 ){
        rc = SQLITE_NOMEM;
      }else{
-        if( pPhrase==0 ) memset(pNew, 0, sizeof(Fts5ExprPhrase));
+        if( pPhrase==0 ) memset(pNew, 0, SZ_FTS5EXPRPHRASE(1));
        pCtx->pPhrase = pPhrase = pNew;
        pNew->nTerm = nNew - SZALLOC;
      }
@@ -1865,7 +1876,7 @@ Fts5ExprPhrase *sqlite3Fts5ParseTerm(
    if( sCtx.pPhrase==0 ){
      /* This happens when parsing a token or quoted phrase that contains
      ** no token characters at all. (e.g ... MATCH '""'). */
-      sCtx.pPhrase = sqlite3Fts5MallocZero(&pParse->rc, sizeof(Fts5ExprPhrase));
+      sCtx.pPhrase = sqlite3Fts5MallocZero(&pParse->rc, SZ_FTS5EXPRPHRASE(1));
    }else if( sCtx.pPhrase->nTerm ){
      sCtx.pPhrase->aTerm[sCtx.pPhrase->nTerm-1].bPrefix = (u8)bPrefix;
    }
@@ -1900,19 +1911,18 @@ int sqlite3Fts5ExprClonePhrase(
        sizeof(Fts5ExprPhrase*));
  }
  if( rc==SQLITE_OK ){
-    pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&rc, 
-        sizeof(Fts5ExprNode));
+    pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&rc, SZ_FTS5EXPRNODE(1));
  }
  if( rc==SQLITE_OK ){
-    pNew->pRoot->pNear = (Fts5ExprNearset*)sqlite3Fts5MallocZero(&rc, 
-        sizeof(Fts5ExprNearset) + sizeof(Fts5ExprPhrase*));
+    pNew->pRoot->pNear = (Fts5ExprNearset*)sqlite3Fts5MallocZero(&rc,
+                                                    SZ_FTS5EXPRNEARSET(2));
  }
  if( rc==SQLITE_OK && ALWAYS(pOrig!=0) ){
    Fts5Colset *pColsetOrig = pOrig->pNode->pNear->pColset;
    if( pColsetOrig ){
      sqlite3_int64 nByte;
      Fts5Colset *pColset;
-      nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
+      nByte = SZ_FTS5COLSET(pColsetOrig->nCol);
      pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&rc, nByte);
      if( pColset ){ 
        memcpy(pColset, pColsetOrig, (size_t)nByte);
@@ -1940,7 +1950,7 @@ int sqlite3Fts5ExprClonePhrase(
    }else{
      /* This happens when parsing a token or quoted phrase that contains
      ** no token characters at all. (e.g ... MATCH '""'). */
-      sCtx.pPhrase = sqlite3Fts5MallocZero(&rc, sizeof(Fts5ExprPhrase));
+      sCtx.pPhrase = sqlite3Fts5MallocZero(&rc, SZ_FTS5EXPRPHRASE(1));
    }
  }

@@ -2005,7 +2015,8 @@ void sqlite3Fts5ParseSetDistance(
              );
          return;
        }
-        nNear = nNear * 10 + (p->p[i] - '0');
+        if( nNear<214748363 ) nNear = nNear * 10 + (p->p[i] - '0');
+        /*  ^^^^^^^^^^^^^^^---  Prevent integer overflow */
      }
    }else{
      nNear = FTS5_DEFAULT_NEARDIST;
@@ -2034,7 +2045,7 @@ static Fts5Colset *fts5ParseColset(
  assert( pParse->rc==SQLITE_OK );
  assert( iCol>=0 && iCol<pParse->pConfig->nCol );

-  pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
+  pNew = sqlite3_realloc64(p, SZ_FTS5COLSET(nCol+1));
  if( pNew==0 ){
    pParse->rc = SQLITE_NOMEM;
  }else{
@@ -2069,7 +2080,7 @@ Fts5Colset *sqlite3Fts5ParseColsetInvert(Fts5Parse *pParse, Fts5Colset *p){
  int nCol = pParse->pConfig->nCol;

  pRet = (Fts5Colset*)sqlite3Fts5MallocZero(&pParse->rc, 
-      sizeof(Fts5Colset) + sizeof(int)*nCol
+      SZ_FTS5COLSET(nCol+1)
  );
  if( pRet ){
    int i;
@@ -2130,7 +2141,7 @@ Fts5Colset *sqlite3Fts5ParseColset(
 static Fts5Colset *fts5CloneColset(int *pRc, Fts5Colset *pOrig){
  Fts5Colset *pRet;
  if( pOrig ){
-    sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
+    sqlite3_int64 nByte = SZ_FTS5COLSET(pOrig->nCol);
    pRet = (Fts5Colset*)sqlite3Fts5MallocZero(pRc, nByte);
    if( pRet ){ 
      memcpy(pRet, pOrig, (size_t)nByte);
@@ -2298,7 +2309,7 @@ static Fts5ExprNode *fts5ParsePhraseToAnd(
  assert( pNear->nPhrase==1 );
  assert( pParse->bPhraseToAnd );

-  nByte = sizeof(Fts5ExprNode) + nTerm*sizeof(Fts5ExprNode*);
+  nByte = SZ_FTS5EXPRNODE(nTerm+1);
  pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
  if( pRet ){
    pRet->eType = FTS5_AND;
@@ -2308,7 +2319,7 @@ static Fts5ExprNode *fts5ParsePhraseToAnd(
    pParse->nPhrase--;
    for(ii=0; ii<nTerm; ii++){
      Fts5ExprPhrase *pPhrase = (Fts5ExprPhrase*)sqlite3Fts5MallocZero(
-          &pParse->rc, sizeof(Fts5ExprPhrase)
+          &pParse->rc, SZ_FTS5EXPRPHRASE(1)
      );
      if( pPhrase ){
        if( parseGrowPhraseArray(pParse) ){
@@ -2377,7 +2388,7 @@ Fts5ExprNode *sqlite3Fts5ParseNode(
        if( pRight->eType==eType ) nChild += pRight->nChild-1;
      }

-      nByte = sizeof(Fts5ExprNode) + sizeof(Fts5ExprNode*)*(nChild-1);
+      nByte = SZ_FTS5EXPRNODE(nChild);
      pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);

      if( pRet ){
@@ -422,9 +422,13 @@ struct Fts5Structure {
  u64 nOriginCntr;                /* Origin value for next top-level segment */
  int nSegment;                   /* Total segments in this structure */
  int nLevel;                     /* Number of levels in this index */
-  Fts5StructureLevel aLevel[1];   /* Array of nLevel level objects */
+  Fts5StructureLevel aLevel[FLEXARRAY]; /* Array of nLevel level objects */
 };

+/* Size (in bytes) of an Fts5Structure object holding up to N levels */
+#define SZ_FTS5STRUCTURE(N) \
+         (offsetof(Fts5Structure,aLevel) + (N)*sizeof(Fts5StructureLevel))
+
 /*
 ** An object of type Fts5SegWriter is used to write to segments.
 */
@@ -550,15 +554,49 @@ struct Fts5SegIter {
  u8 bDel;                        /* True if the delete flag is set */
 };

+static int fts5IndexCorruptRowid(Fts5Index *pIdx, i64 iRowid){
+  pIdx->rc = FTS5_CORRUPT;
+  sqlite3Fts5ConfigErrmsg(pIdx->pConfig, 
+      "fts5: corruption found reading blob %lld from table \"%s\"", 
+      iRowid, pIdx->pConfig->zName
+  );
+  return SQLITE_CORRUPT_VTAB;
+}
+#define FTS5_CORRUPT_ROWID(pIdx, iRowid) fts5IndexCorruptRowid(pIdx, iRowid)
+
+static int fts5IndexCorruptIter(Fts5Index *pIdx, Fts5SegIter *pIter){
+  pIdx->rc = FTS5_CORRUPT;
+  sqlite3Fts5ConfigErrmsg(pIdx->pConfig, 
+      "fts5: corruption on page %d, segment %d, table \"%s\"", 
+      pIter->iLeafPgno, pIter->pSeg->iSegid, pIdx->pConfig->zName
+  );
+  return SQLITE_CORRUPT_VTAB;
+}
+#define FTS5_CORRUPT_ITER(pIdx, pIter) fts5IndexCorruptIter(pIdx, pIter)
+
+static int fts5IndexCorruptIdx(Fts5Index *pIdx){
+  pIdx->rc = FTS5_CORRUPT;
+  sqlite3Fts5ConfigErrmsg(pIdx->pConfig, 
+      "fts5: corruption in table \"%s\"", pIdx->pConfig->zName
+  );
+  return SQLITE_CORRUPT_VTAB;
+}
+#define FTS5_CORRUPT_IDX(pIdx) fts5IndexCorruptIdx(pIdx)
+
+
 /*
 ** Array of tombstone pages. Reference counted.
 */
 struct Fts5TombstoneArray {
-  int nRef;                       /* Number of pointers to this object */
+  int nRef;                         /* Number of pointers to this object */
  int nTombstone;
-  Fts5Data *apTombstone[1];       /* Array of tombstone pages */
+  Fts5Data *apTombstone[FLEXARRAY]; /* Array of tombstone pages */
 };

+/* Size (in bytes) of an Fts5TombstoneArray holding up to N tombstones */
+#define SZ_FTS5TOMBSTONEARRAY(N) \
+  (offsetof(Fts5TombstoneArray,apTombstone)+(N)*sizeof(Fts5Data*))
+
 /*
 ** Argument is a pointer to an Fts5Data structure that contains a 
 ** leaf page.
@@ -627,9 +665,12 @@ struct Fts5Iter {

  i64 iSwitchRowid;               /* Firstest rowid of other than aFirst[1] */
  Fts5CResult *aFirst;            /* Current merge state (see above) */
-  Fts5SegIter aSeg[1];            /* Array of segment iterators */
+  Fts5SegIter aSeg[FLEXARRAY];    /* Array of segment iterators */
 };

+/* Size (in bytes) of an Fts5Iter object holding up to N segment iterators */
+#define SZ_FTS5ITER(N)  (offsetof(Fts5Iter,aSeg)+(N)*sizeof(Fts5SegIter))
+
 /*
 ** An instance of the following type is used to iterate through the contents
 ** of a doclist-index record.
@@ -656,9 +697,13 @@ struct Fts5DlidxLvl {
 struct Fts5DlidxIter {
  int nLvl;
  int iSegid;
-  Fts5DlidxLvl aLvl[1];
+  Fts5DlidxLvl aLvl[FLEXARRAY];
 };

+/* Size (in bytes) of an Fts5DlidxIter object with up to N levels */
+#define SZ_FTS5DLIDXITER(N) \
+          (offsetof(Fts5DlidxIter,aLvl)+(N)*sizeof(Fts5DlidxLvl))
+
 static void fts5PutU16(u8 *aOut, u16 iVal){
  aOut[0] = (iVal>>8);
  aOut[1] = (iVal&0xFF);
@@ -828,7 +873,7 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
    ** All the reasons those functions might return SQLITE_ERROR - missing
    ** table, missing row, non-blob/text in block column - indicate 
    ** backing store corruption.  */
-    if( rc==SQLITE_ERROR ) rc = FTS5_CORRUPT;
+    if( rc==SQLITE_ERROR ) rc = FTS5_CORRUPT_ROWID(p, iRowid);

    if( rc==SQLITE_OK ){
      u8 *aOut = 0;               /* Read blob data into this buffer */
@@ -878,7 +923,7 @@ static Fts5Data *fts5LeafRead(Fts5Index *p, i64 iRowid){
  Fts5Data *pRet = fts5DataRead(p, iRowid);
  if( pRet ){
    if( pRet->nn<4 || pRet->szLeaf>pRet->nn ){
-      p->rc = FTS5_CORRUPT;
+      FTS5_CORRUPT_ROWID(p, iRowid);
      fts5DataRelease(pRet);
      pRet = 0;
    }
@@ -1026,7 +1071,7 @@ int sqlite3Fts5StructureTest(Fts5Index *p, void *pStruct){
 static void fts5StructureMakeWritable(int *pRc, Fts5Structure **pp){
  Fts5Structure *p = *pp;
  if( *pRc==SQLITE_OK && p->nRef>1 ){
-    i64 nByte = sizeof(Fts5Structure)+(p->nLevel-1)*sizeof(Fts5StructureLevel);
+    i64 nByte = SZ_FTS5STRUCTURE(p->nLevel);
    Fts5Structure *pNew;
    pNew = (Fts5Structure*)sqlite3Fts5MallocZero(pRc, nByte);
    if( pNew ){
@@ -1100,10 +1145,7 @@ static int fts5StructureDecode(
  ){
    return FTS5_CORRUPT;
  }
-  nByte = (
-      sizeof(Fts5Structure) +                    /* Main structure */
-      sizeof(Fts5StructureLevel) * (nLevel-1)    /* aLevel[] array */
-  );
+  nByte = SZ_FTS5STRUCTURE(nLevel);
  pRet = (Fts5Structure*)sqlite3Fts5MallocZero(&rc, nByte);

  if( pRet ){
@@ -1183,10 +1225,7 @@ static void fts5StructureAddLevel(int *pRc, Fts5Structure **ppStruct){
  if( *pRc==SQLITE_OK ){
    Fts5Structure *pStruct = *ppStruct;
    int nLevel = pStruct->nLevel;
-    sqlite3_int64 nByte = (
-        sizeof(Fts5Structure) +                  /* Main structure */
-        sizeof(Fts5StructureLevel) * (nLevel+1)  /* aLevel[] array */
-    );
+    sqlite3_int64 nByte = SZ_FTS5STRUCTURE(nLevel+2);

    pStruct = sqlite3_realloc64(pStruct, nByte);
    if( pStruct ){
@@ -1243,8 +1282,14 @@ static Fts5Structure *fts5StructureReadUncached(Fts5Index *p){
    /* TODO: Do we need this if the leaf-index is appended? Probably... */
    memset(&pData->p[pData->nn], 0, FTS5_DATA_PADDING);
    p->rc = fts5StructureDecode(pData->p, pData->nn, &iCookie, &pRet);
-    if( p->rc==SQLITE_OK && (pConfig->pgsz==0 || pConfig->iCookie!=iCookie) ){
-      p->rc = sqlite3Fts5ConfigLoad(pConfig, iCookie);
+    if( p->rc==SQLITE_OK ){
+      if( (pConfig->pgsz==0 || pConfig->iCookie!=iCookie) ){
+        p->rc = sqlite3Fts5ConfigLoad(pConfig, iCookie);
+      }
+    }else if( p->rc==SQLITE_CORRUPT_VTAB ){
+      sqlite3Fts5ConfigErrmsg(p->pConfig, 
+          "fts5: corrupt structure record for table \"%s\"", p->pConfig->zName
+      );
    }
    fts5DataRelease(pData);
    if( p->rc!=SQLITE_OK ){
@@ -1725,7 +1770,7 @@ static Fts5DlidxIter *fts5DlidxIterInit(
  int bDone = 0;

  for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
-    sqlite3_int64 nByte = sizeof(Fts5DlidxIter) + i * sizeof(Fts5DlidxLvl);
+    sqlite3_int64 nByte = SZ_FTS5DLIDXITER(i+1);
    Fts5DlidxIter *pNew;

    pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
@@ -1867,7 +1912,7 @@ static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
  while( iOff>=pIter->pLeaf->szLeaf ){
    fts5SegIterNextPage(p, pIter);
    if( pIter->pLeaf==0 ){
-      if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT;
+      if( p->rc==SQLITE_OK ) FTS5_CORRUPT_ITER(p, pIter);
      return;
    }
    iOff = 4;
@@ -1899,7 +1944,7 @@ static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){

  iOff += fts5GetVarint32(&a[iOff], nNew);
  if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
-    p->rc = FTS5_CORRUPT;
+    FTS5_CORRUPT_ITER(p, pIter);
    return;
  }
  pIter->term.n = nKeep;
@@ -1943,7 +1988,7 @@ static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
 static void fts5SegIterAllocTombstone(Fts5Index *p, Fts5SegIter *pIter){
  const int nTomb = pIter->pSeg->nPgTombstone;
  if( nTomb>0 ){
-    int nByte = nTomb * sizeof(Fts5Data*) + sizeof(Fts5TombstoneArray);
+    int nByte = SZ_FTS5TOMBSTONEARRAY(nTomb+1);
    Fts5TombstoneArray *pNew;
    pNew = (Fts5TombstoneArray*)sqlite3Fts5MallocZero(&p->rc, nByte);
    if( pNew ){
@@ -2094,7 +2139,7 @@ static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
        iRowidOff = fts5LeafFirstRowidOff(pNew);
        if( iRowidOff ){
          if( iRowidOff>=pNew->szLeaf ){
-            p->rc = FTS5_CORRUPT;
+            FTS5_CORRUPT_ITER(p, pIter);
          }else{
            pIter->pLeaf = pNew;
            pIter->iLeafOffset = iRowidOff;
@@ -2328,7 +2373,7 @@ static void fts5SegIterNext(
      }
      assert_nc( iOff<pLeaf->szLeaf );
      if( iOff>pLeaf->szLeaf ){
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_ITER(p, pIter);
        return;
      }
    }
@@ -2436,18 +2481,20 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
    fts5DataRelease(pIter->pLeaf);
    pIter->pLeaf = pLast;
    pIter->iLeafPgno = pgnoLast;
-    iOff = fts5LeafFirstRowidOff(pLast);
-    if( iOff>pLast->szLeaf ){
-      p->rc = FTS5_CORRUPT;
-      return;
-    }
-    iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
-    pIter->iLeafOffset = iOff;
+    if( p->rc==SQLITE_OK ){
+      iOff = fts5LeafFirstRowidOff(pLast);
+      if( iOff>pLast->szLeaf ){
+        FTS5_CORRUPT_ITER(p, pIter);
+        return;
+      }
+      iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
+      pIter->iLeafOffset = iOff;

-    if( fts5LeafIsTermless(pLast) ){
-      pIter->iEndofDoclist = pLast->nn+1;
-    }else{
-      pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
+      if( fts5LeafIsTermless(pLast) ){
+        pIter->iEndofDoclist = pLast->nn+1;
+      }else{
+        pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
+      }
    }
  }

@@ -2517,7 +2564,7 @@ static void fts5LeafSeek(
  iPgidx += fts5GetVarint32(&a[iPgidx], iTermOff);
  iOff = iTermOff;
  if( iOff>n ){
-    p->rc = FTS5_CORRUPT;
+    FTS5_CORRUPT_ITER(p, pIter);
    return;
  }

@@ -2560,7 +2607,7 @@ static void fts5LeafSeek(
    iOff = iTermOff;

    if( iOff>=n ){
-      p->rc = FTS5_CORRUPT;
+      FTS5_CORRUPT_ITER(p, pIter);
      return;
    }

@@ -2582,7 +2629,7 @@ static void fts5LeafSeek(
        iPgidx = (u32)pIter->pLeaf->szLeaf;
        iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
        if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
-          p->rc = FTS5_CORRUPT;
+          FTS5_CORRUPT_ITER(p, pIter);
          return;
        }else{
          nKeep = 0;
@@ -2597,7 +2644,7 @@ static void fts5LeafSeek(

 search_success:
  if( (i64)iOff+nNew>n || nNew<1 ){
-    p->rc = FTS5_CORRUPT;
+    FTS5_CORRUPT_ITER(p, pIter);
    return;
  }
  pIter->iLeafOffset = iOff + nNew;
@@ -3062,7 +3109,7 @@ static void fts5SegIterGotoPage(
  assert( iLeafPgno>pIter->iLeafPgno );

  if( iLeafPgno>pIter->pSeg->pgnoLast ){
-    p->rc = FTS5_CORRUPT;
+    FTS5_CORRUPT_IDX(p);
  }else{
    fts5DataRelease(pIter->pNextLeaf);
    pIter->pNextLeaf = 0;
@@ -3077,7 +3124,7 @@ static void fts5SegIterGotoPage(
        u8 *a = pIter->pLeaf->p;
        int n = pIter->pLeaf->szLeaf;
        if( iOff<4 || iOff>=n ){
-          p->rc = FTS5_CORRUPT;
+          FTS5_CORRUPT_IDX(p);
        }else{
          iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
          pIter->iLeafOffset = iOff;
@@ -3404,8 +3451,7 @@ static Fts5Iter *fts5MultiIterAlloc(

  for(nSlot=2; nSlot<nSeg; nSlot=nSlot*2);
  pNew = fts5IdxMalloc(p, 
-      sizeof(Fts5Iter) +                  /* pNew */
-      sizeof(Fts5SegIter) * (nSlot-1) +   /* pNew->aSeg[] */
+      SZ_FTS5ITER(nSlot) +                /* pNew + pNew->aSeg[] */
      sizeof(Fts5CResult) * nSlot         /* pNew->aFirst[] */
  );
  if( pNew ){
@@ -3557,7 +3603,7 @@ static void fts5ChunkIterate(
    if( nRem<=0 ){
      break;
    }else if( pSeg->pSeg==0 ){
-      p->rc = FTS5_CORRUPT;
+      FTS5_CORRUPT_IDX(p);
      return;
    }else{
      pgno++;
@@ -4660,7 +4706,7 @@ static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
          ** a single page has been assigned to more than one segment. In
          ** this case a prior iteration of this loop may have corrupted the
          ** segment currently being trimmed.  */
-          p->rc = FTS5_CORRUPT;
+          FTS5_CORRUPT_ROWID(p, iLeafRowid);
        }else{
          fts5BufferZero(&buf);
          fts5BufferGrow(&p->rc, &buf, pData->nn);
@@ -5127,7 +5173,7 @@ static void fts5SecureDeleteOverflow(
    }else if( bDetailNone ){
      break;
    }else if( iNext>=pLeaf->szLeaf || pLeaf->nn<pLeaf->szLeaf || iNext<4 ){
-      p->rc = FTS5_CORRUPT;
+      FTS5_CORRUPT_ROWID(p, iRowid);
      break;
    }else{
      int nShift = iNext - 4;
@@ -5147,7 +5193,7 @@ static void fts5SecureDeleteOverflow(

        i1 += fts5GetVarint32(&aPg[i1], iFirst);
        if( iFirst<iNext ){
-          p->rc = FTS5_CORRUPT;
+          FTS5_CORRUPT_ROWID(p, iRowid);
          break;
        }
        aIdx = sqlite3Fts5MallocZero(&p->rc, (pLeaf->nn-pLeaf->szLeaf)+2);
@@ -5370,14 +5416,14 @@ static void fts5DoSecureDelete(
      nSuffix = (nPrefix2 + nSuffix2) - nPrefix;

      if( (iKeyOff+nSuffix)>iPgIdx || (iNextOff+nSuffix2)>iPgIdx ){
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_IDX(p);
      }else{
        if( iKey!=1 ){
          iOff += sqlite3Fts5PutVarint(&aPg[iOff], nPrefix);
        }
        iOff += sqlite3Fts5PutVarint(&aPg[iOff], nSuffix);
        if( nPrefix2>pSeg->term.n ){
-          p->rc = FTS5_CORRUPT;
+          FTS5_CORRUPT_IDX(p);
        }else if( nPrefix2>nPrefix ){
          memcpy(&aPg[iOff], &pSeg->term.p[nPrefix], nPrefix2-nPrefix);
          iOff += (nPrefix2-nPrefix);
@@ -5771,7 +5817,7 @@ static Fts5Structure *fts5IndexOptimizeStruct(
  Fts5Structure *pStruct
 ){
  Fts5Structure *pNew = 0;
-  sqlite3_int64 nByte = sizeof(Fts5Structure);
+  sqlite3_int64 nByte = SZ_FTS5STRUCTURE(1);
  int nSeg = pStruct->nSegment;
  int i;

@@ -5801,6 +5847,7 @@ static Fts5Structure *fts5IndexOptimizeStruct(
  }

  nByte += (((i64)pStruct->nLevel)+1) * sizeof(Fts5StructureLevel);
+  assert( nByte==(i64)SZ_FTS5STRUCTURE(pStruct->nLevel+2) );
  pNew = (Fts5Structure*)sqlite3Fts5MallocZero(&p->rc, nByte);

  if( pNew ){
@@ -6169,7 +6216,7 @@ static void fts5MergePrefixLists(
      }

      if( pHead==0 || pHead->pNext==0 ){
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_IDX(p);
        break;
      }

@@ -6206,7 +6253,7 @@ static void fts5MergePrefixLists(
      assert_nc( tmp.n+nTail<=nTmp );
      assert( tmp.n+nTail<=nTmp+nMerge*10 );
      if( tmp.n+nTail>nTmp-FTS5_DATA_ZERO_PADDING ){
-        if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT;
+        if( p->rc==SQLITE_OK ) FTS5_CORRUPT_IDX(p);
        break;
      }
      fts5BufferSafeAppendVarint(&out, (tmp.n+nTail) * 2);
@@ -6377,9 +6424,13 @@ struct Fts5TokenDataIter {
  int nIterAlloc;
  Fts5PoslistReader *aPoslistReader;
  int *aPoslistToIter;
-  Fts5Iter *apIter[1];
+  Fts5Iter *apIter[FLEXARRAY];
 };

+/* Size in bytes of an Fts5TokenDataIter object holding up to N iterators */
+#define SZ_FTS5TOKENDATAITER(N) \
+    (offsetof(Fts5TokenDataIter,apIter) + (N)*sizeof(Fts5Iter))
+
 /*
 ** The two input arrays - a1[] and a2[] - are in sorted order. This function
 ** merges the two arrays together and writes the result to output array 
@@ -6642,7 +6693,7 @@ static void fts5SetupPrefixIter(
   && p->pConfig->bPrefixInsttoken 
  ){
    s.pTokendata = &s2;
-    s2.pT = (Fts5TokenDataIter*)fts5IdxMalloc(p, sizeof(*s2.pT));
+    s2.pT = (Fts5TokenDataIter*)fts5IdxMalloc(p, SZ_FTS5TOKENDATAITER(1));
  }

  if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
@@ -6770,15 +6821,17 @@ int sqlite3Fts5IndexRollback(Fts5Index *p){
 ** and the initial version of the "averages" record (a zero-byte blob).
 */
 int sqlite3Fts5IndexReinit(Fts5Index *p){
-  Fts5Structure s;
+  Fts5Structure *pTmp;
+  u8 tmpSpace[SZ_FTS5STRUCTURE(1)];
  fts5StructureInvalidate(p);
  fts5IndexDiscardData(p);
-  memset(&s, 0, sizeof(Fts5Structure));
+  pTmp = (Fts5Structure*)tmpSpace;
+  memset(pTmp, 0, SZ_FTS5STRUCTURE(1));
  if( p->pConfig->bContentlessDelete ){
-    s.nOriginCntr = 1;
+    pTmp->nOriginCntr = 1;
  }
  fts5DataWrite(p, FTS5_AVERAGES_ROWID, (const u8*)"", 0);
-  fts5StructureWrite(p, &s);
+  fts5StructureWrite(p, pTmp);
  return fts5IndexReturn(p);
 }

@@ -6986,7 +7039,7 @@ static Fts5TokenDataIter *fts5AppendTokendataIter(
  if( p->rc==SQLITE_OK ){
    if( pIn==0 || pIn->nIter==pIn->nIterAlloc ){
      int nAlloc = pIn ? pIn->nIterAlloc*2 : 16;
-      int nByte = nAlloc * sizeof(Fts5Iter*) + sizeof(Fts5TokenDataIter);
+      int nByte = SZ_FTS5TOKENDATAITER(nAlloc+1);
      Fts5TokenDataIter *pNew = (Fts5TokenDataIter*)sqlite3_realloc(pIn, nByte);

      if( pNew==0 ){
@@ -7502,7 +7555,8 @@ static int fts5SetupPrefixIterTokendata(

  fts5BufferGrow(&p->rc, &token, nToken+1);
  assert( token.p!=0 || p->rc!=SQLITE_OK );
-  ctx.pT = (Fts5TokenDataIter*)sqlite3Fts5MallocZero(&p->rc, sizeof(*ctx.pT));
+  ctx.pT = (Fts5TokenDataIter*)sqlite3Fts5MallocZero(&p->rc,
+                                                   SZ_FTS5TOKENDATAITER(1));

  if( p->rc==SQLITE_OK ){

@@ -7633,7 +7687,8 @@ int sqlite3Fts5IndexIterWriteTokendata(
  if( pIter->nSeg>0 ){
    /* This is a prefix term iterator. */
    if( pT==0 ){
-      pT = (Fts5TokenDataIter*)sqlite3Fts5MallocZero(&p->rc, sizeof(*pT));
+      pT = (Fts5TokenDataIter*)sqlite3Fts5MallocZero(&p->rc,
+                                           SZ_FTS5TOKENDATAITER(1));
      pIter->pTokenDataIter = pT;
    }
    if( pT ){
@@ -8327,14 +8382,17 @@ static void fts5IndexIntegrityCheckEmpty(
  for(i=iFirst; p->rc==SQLITE_OK && i<=iLast; i++){
    Fts5Data *pLeaf = fts5DataRead(p, FTS5_SEGMENT_ROWID(pSeg->iSegid, i));
    if( pLeaf ){
-      if( !fts5LeafIsTermless(pLeaf) ) p->rc = FTS5_CORRUPT;
-      if( i>=iNoRowid && 0!=fts5LeafFirstRowidOff(pLeaf) ) p->rc = FTS5_CORRUPT;
+      if( !fts5LeafIsTermless(pLeaf)
+       || (i>=iNoRowid && 0!=fts5LeafFirstRowidOff(pLeaf))
+      ){
+        FTS5_CORRUPT_ROWID(p, FTS5_SEGMENT_ROWID(pSeg->iSegid, i));
+      }
    }
    fts5DataRelease(pLeaf);
  }
 }

-static void fts5IntegrityCheckPgidx(Fts5Index *p, Fts5Data *pLeaf){
+static void fts5IntegrityCheckPgidx(Fts5Index *p, i64 iRowid, Fts5Data *pLeaf){
  i64 iTermOff = 0;
  int ii;

@@ -8352,12 +8410,12 @@ static void fts5IntegrityCheckPgidx(Fts5Index *p, Fts5Data *pLeaf){
    iOff = iTermOff;

    if( iOff>=pLeaf->szLeaf ){
-      p->rc = FTS5_CORRUPT;
+      FTS5_CORRUPT_ROWID(p, iRowid);
    }else if( iTermOff==nIncr ){
      int nByte;
      iOff += fts5GetVarint32(&pLeaf->p[iOff], nByte);
      if( (iOff+nByte)>pLeaf->szLeaf ){
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_ROWID(p, iRowid);
      }else{
        fts5BufferSet(&p->rc, &buf1, nByte, &pLeaf->p[iOff]);
      }
@@ -8366,7 +8424,7 @@ static void fts5IntegrityCheckPgidx(Fts5Index *p, Fts5Data *pLeaf){
      iOff += fts5GetVarint32(&pLeaf->p[iOff], nKeep);
      iOff += fts5GetVarint32(&pLeaf->p[iOff], nByte);
      if( nKeep>buf1.n || (iOff+nByte)>pLeaf->szLeaf ){
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_ROWID(p, iRowid);
      }else{
        buf1.n = nKeep;
        fts5BufferAppendBlob(&p->rc, &buf1, nByte, &pLeaf->p[iOff]);
@@ -8374,7 +8432,7 @@ static void fts5IntegrityCheckPgidx(Fts5Index *p, Fts5Data *pLeaf){

      if( p->rc==SQLITE_OK ){
        res = fts5BufferCompare(&buf1, &buf2);
-        if( res<=0 ) p->rc = FTS5_CORRUPT;
+        if( res<=0 ) FTS5_CORRUPT_ROWID(p, iRowid);
      }
    }
    fts5BufferSet(&p->rc, &buf2, buf1.n, buf1.p);
@@ -8435,7 +8493,7 @@ static void fts5IndexIntegrityCheckSegment(
        ** entry even if all the terms are removed from it by secure-delete 
        ** operations. */
      }else{
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_ROWID(p, iRow);
      }

    }else{
@@ -8447,15 +8505,15 @@ static void fts5IndexIntegrityCheckSegment(
      iOff = fts5LeafFirstTermOff(pLeaf);
      iRowidOff = fts5LeafFirstRowidOff(pLeaf);
      if( iRowidOff>=iOff || iOff>=pLeaf->szLeaf ){
-        p->rc = FTS5_CORRUPT;
+        FTS5_CORRUPT_ROWID(p, iRow);
      }else{
        iOff += fts5GetVarint32(&pLeaf->p[iOff], nTerm);
        res = fts5Memcmp(&pLeaf->p[iOff], zIdxTerm, MIN(nTerm, nIdxTerm));
        if( res==0 ) res = nTerm - nIdxTerm;
-        if( res<0 ) p->rc = FTS5_CORRUPT;
+        if( res<0 ) FTS5_CORRUPT_ROWID(p, iRow);
      }

-      fts5IntegrityCheckPgidx(p, pLeaf);
+      fts5IntegrityCheckPgidx(p, iRow, pLeaf);
    }
    fts5DataRelease(pLeaf);
    if( p->rc ) break;
@@ -8485,7 +8543,7 @@ static void fts5IndexIntegrityCheckSegment(
          iKey = FTS5_SEGMENT_ROWID(iSegid, iPg);
          pLeaf = fts5DataRead(p, iKey);
          if( pLeaf ){
-            if( fts5LeafFirstRowidOff(pLeaf)!=0 ) p->rc = FTS5_CORRUPT;
+            if( fts5LeafFirstRowidOff(pLeaf)!=0 ) FTS5_CORRUPT_ROWID(p, iKey);
            fts5DataRelease(pLeaf);
          }
        }
@@ -8500,12 +8558,12 @@ static void fts5IndexIntegrityCheckSegment(
          int iRowidOff = fts5LeafFirstRowidOff(pLeaf);
          ASSERT_SZLEAF_OK(pLeaf);
          if( iRowidOff>=pLeaf->szLeaf ){
-            p->rc = FTS5_CORRUPT;
+            FTS5_CORRUPT_ROWID(p, iKey);
          }else if( bSecureDelete==0 || iRowidOff>0 ){
            i64 iDlRowid = fts5DlidxIterRowid(pDlidx);
            fts5GetVarint(&pLeaf->p[iRowidOff], (u64*)&iRowid);
            if( iRowid<iDlRowid || (bSecureDelete==0 && iRowid!=iDlRowid) ){
-              p->rc = FTS5_CORRUPT;
+              FTS5_CORRUPT_ROWID(p, iKey);
            }
          }
          fts5DataRelease(pLeaf);
@@ -8620,7 +8678,12 @@ int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum){
  fts5TestTerm(p, &term, 0, 0, cksum2, &cksum3);

  fts5MultiIterFree(pIter);
-  if( p->rc==SQLITE_OK && bUseCksum && cksum!=cksum2 ) p->rc = FTS5_CORRUPT;
+  if( p->rc==SQLITE_OK && bUseCksum && cksum!=cksum2 ){
+    p->rc = FTS5_CORRUPT;
+    sqlite3Fts5ConfigErrmsg(p->pConfig, 
+        "fts5: checksum mismatch for table \"%s\"", p->pConfig->zName
+    );
+  }

  fts5StructureRelease(pStruct);
 #ifdef SQLITE_DEBUG
@@ -170,9 +170,11 @@ struct Fts5Sorter {
  i64 iRowid;                     /* Current rowid */
  const u8 *aPoslist;             /* Position lists for current row */
  int nIdx;                       /* Number of entries in aIdx[] */
-  int aIdx[1];                    /* Offsets into aPoslist for current row */
+  int aIdx[FLEXARRAY];            /* Offsets into aPoslist for current row */
 };

+/* Size (int bytes) of an Fts5Sorter object with N indexes */
+#define SZ_FTS5SORTER(N) (offsetof(Fts5Sorter,nIdx)+((N+2)/2)*sizeof(i64))

 /*
 ** Virtual-table cursor object.
@@ -1050,7 +1052,7 @@ static int fts5CursorFirstSorted(
  const char *zRankArgs = pCsr->zRankArgs;
  
  nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
-  nByte = sizeof(Fts5Sorter) + sizeof(int) * (nPhrase-1);
+  nByte = SZ_FTS5SORTER(nPhrase);
  pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte);
  if( pSorter==0 ) return SQLITE_NOMEM;
  memset(pSorter, 0, (size_t)nByte);
@@ -3699,8 +3701,9 @@ static int fts5IntegrityMethod(
          " FTS5 table %s.%s: %s",
          zSchema, zTabname, sqlite3_errstr(rc));
    }
+  }else if( (rc&0xff)==SQLITE_CORRUPT ){
+    rc = SQLITE_OK;
  }
-
  sqlite3Fts5IndexCloseReader(pTab->p.pIndex);
  pTab->p.pConfig->pzErrmsg = 0;

@@ -539,6 +539,7 @@ static int fts5StorageDeleteFromIndex(
  for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
    if( pConfig->abUnindexed[iCol-1]==0 ){
      sqlite3_value *pVal = 0;
+      sqlite3_value *pFree = 0;
      const char *pText = 0;
      int nText = 0;
      const char *pLoc = 0;
@@ -555,11 +556,22 @@ static int fts5StorageDeleteFromIndex(
      if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
        rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
      }else{
-        pText = (const char*)sqlite3_value_text(pVal);
-        nText = sqlite3_value_bytes(pVal);
-        if( pConfig->bLocale && pSeek ){
-          pLoc = (const char*)sqlite3_column_text(pSeek, iCol + pConfig->nCol);
-          nLoc = sqlite3_column_bytes(pSeek, iCol + pConfig->nCol);
+        if( sqlite3_value_type(pVal)!=SQLITE_TEXT ){
+          /* Make a copy of the value to work with. This is because the call
+          ** to sqlite3_value_text() below forces the type of the value to
+          ** SQLITE_TEXT, and we may need to use it again later. */
+          pFree = pVal = sqlite3_value_dup(pVal);
+          if( pVal==0 ){
+            rc = SQLITE_NOMEM;
+          }
+        }
+        if( rc==SQLITE_OK ){
+          pText = (const char*)sqlite3_value_text(pVal);
+          nText = sqlite3_value_bytes(pVal);
+          if( pConfig->bLocale && pSeek ){
+            pLoc = (const char*)sqlite3_column_text(pSeek, iCol+pConfig->nCol);
+            nLoc = sqlite3_column_bytes(pSeek, iCol + pConfig->nCol);
+          }
        }
      }

@@ -575,6 +587,7 @@ static int fts5StorageDeleteFromIndex(
        }
        sqlite3Fts5ClearLocale(pConfig);
      }
+      sqlite3_value_free(pFree);
    }
  }
  if( rc==SQLITE_OK && p->nTotalRow<1 ){
@@ -14,7 +14,7 @@
 ** versions of FTS5. It contains the implementation of an FTS5 auxiliary
 ** function very similar to the FTS4 function matchinfo():
 **
-**     https://www.sqlite.org/fts3.html#matchinfo
+**     https://sqlite.org/fts3.html#matchinfo
 **
 ** Known differences are that:
 **
@@ -778,4 +778,3 @@ void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){
  }
  aAscii[0] = 0;                  /* 0x00 is never a token character */
 }
-
@@ -428,7 +428,7 @@ do_execsql_test 15.1 {
 }
 do_catchsql_test 15.2 {
  INSERT INTO t1(t1) VALUES('integrity-check');
-} {1 {database disk image is malformed}}
+} {1 {fts5: checksum mismatch for table "t1"}}

 #-------------------------------------------------------------------------
 #
@@ -47,11 +47,10 @@ do_test 1.3 {
    DELETE FROM t1_data WHERE rowid = fts5_rowid('segment', $segid, 4);
  }
  catchsql { INSERT INTO t1(t1) VALUES('integrity-check') }
-} {1 {database disk image is malformed}}
+} {1 {fts5: corruption found reading blob 137438953476 from table "t1"}}
 do_execsql_test 1.3b {
  PRAGMA integrity_check(t1);
-} {{malformed inverted index for FTS5 table main.t1}}
-
+} {{fts5: corruption found reading blob 137438953476 from table "t1"}}

 do_test 1.4 {
  db_restore_and_reopen
@@ -61,7 +60,7 @@ do_test 1.4 {
    rowid = fts5_rowid('segment', $segid, 4);
  }
  catchsql { INSERT INTO t1(t1) VALUES('integrity-check') }
-} {1 {database disk image is malformed}}
+} {1 {fts5: corruption found reading blob 137438953476 from table "t1"}}

 db_restore_and_reopen
 #db eval {SELECT rowid, fts5_decode(rowid, block) aS r FROM t1_data} {puts $r}
@@ -109,12 +109,12 @@ for {set i [expr $nbyte-2]} {$i>=0} {incr i -1} {

  do_catchsql_test 2.$i.2 {
    INSERT INTO t1(t1) VALUES('integrity-check');
-  } {1 {database disk image is malformed}}
+  } {/1.*fts5: corruption.*/}

  do_test 2.$i.3 {
    set res [catchsql {SELECT rowid FROM t1 WHERE t1 MATCH 'x*'}]
    expr {
-        $res=="1 {database disk image is malformed}" 
+        [string match {*fts5: corruption*} $res]
     || $res=="0 {$all}" 
    }
  } 1
@@ -160,17 +160,17 @@ foreach {tn hdr} {
      close $fd

      set res [catchsql {SELECT rowid FROM x3 WHERE x3 MATCH 'x AND a'}]
-      if {$res == "1 {database disk image is malformed}"} {incr nCorrupt}
+      if {[string match {*fts5: corruption*} $res]} {incr nCorrupt}
      set {} 1
    } {1}

    if {($tn2 % 10)==0 && $existing != $hdr} {
      do_test 3.$tn.$tn2.2 {
        catchsql { INSERT INTO x3(x3) VALUES('integrity-check') }
-      } {1 {database disk image is malformed}}
+      } {/.*fts5: corruption.*/}
      do_execsql_test 3.$tn.$tn2.3 {
        PRAGMA integrity_check(x3);
-      } {{malformed inverted index for FTS5 table main.x3}}
+      } {/.*fts5: corruption.*/}
    }

    execsql ROLLBACK
@@ -209,7 +209,7 @@ foreach {tn nCut} {
      set res [catchsql {
        SELECT rowid FROM x4 WHERE x4 MATCH 'a' ORDER BY 1 DESC
      }]
-      if {$res == "1 {database disk image is malformed}"} {incr nCorrupt}
+      if {[string match {*fts5: corruption*} $res]} {incr nCorrupt}
      set {} 1
    } {1}

@@ -237,7 +237,7 @@ do_test 1.0 {

 do_catchsql_test 1.1 {
  SELECT * FROM t1('R*') WHERE (a,b)<=(current_date,0) ORDER BY rowid DESC;
-} {1 {database disk image is malformed}}
+} {/.*fts5: corrupt.*/}

 #-------------------------------------------------------------------------
 #
@@ -450,7 +450,7 @@ do_test 2.0 {

 do_catchsql_test 2.1 {
 SELECT * FROM t1('R*R*R*R*') WHERE (a,b)<=(current_date,0) ORDER BY rowid DESC;
-} {1 {database disk image is malformed}}
+} {/.*fts5: corrupt.*/}

 #-------------------------------------------------------------------------
 reset_db
@@ -569,7 +569,7 @@ do_test 3.0 {

 do_catchsql_test 3.1 {
  UPDATE t1 SET b=quote(zeroblob(200)) WHERE a MATCH 'thra*T';
-} {1 {database disk image is malformed}}
+} {/.*fts5: corrupt.*/}

 #-------------------------------------------------------------------------
 reset_db
@@ -878,7 +878,7 @@ do_execsql_test 5.1 {
 }
 do_catchsql_test 5.4 {
  UPDATE t1 SET content=randomblob(500);
-} {1 {database disk image is malformed}}
+} {/.*fts5: corrupt.*/}

 #-------------------------------------------------------------------------
 reset_db
@@ -123,6 +123,6 @@ do_execsql_test 2.2 {

 do_catchsql_test 2.3 {
  DELETE FROM t1 WHERE rowid = 1
-} {1 {database disk image is malformed}}
+} {/.*fts5: corrupt.*/}

 finish_test
@@ -32,7 +32,7 @@ sqlite3 db test.db

 do_catchsql_test 1.2 {
  SELECT * FROM t1
-} {1 {database disk image is malformed}}
+} {1 {fts5: corrupt structure record for table "t1"}}
 do_catchsql_test 1.3 {
  DROP TABLE t1
 } {0 {}}
@@ -325,5 +325,25 @@ ifcapable foreignkey {
  }
 }

+#-------------------------------------------------------------------------
+reset_db
+
+do_execsql_test 13.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(a, b);
+  INSERT INTO t1 VALUES('abc def', X'123456');
+}
+faultsim_save_and_close
+
+
+do_faultsim_test 13 -faults oom* -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql {
+    UPDATE t1 SET a='def abc'
+  }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
 finish_test

@@ -528,9 +528,12 @@ do_execsql_test 16.0 {
  BEGIN EXCLUSIVE;
 }

-sqlite3 db2 test.db
 do_test 16.1 { 
-  catchsql { SELECT * FROM t1 } db2
+  set rc [catch {
+    sqlite3 db2 test.db
+    db2 eval {SELECT * FROM t1}
+  } errmsg]
+  lappend rc $errmsg
 } {1 {database is locked}}

 do_execsql_test 16.2 {
@@ -542,4 +545,3 @@ do_test 16.3 {
 } {0 {}}

 finish_test
-
@@ -46,7 +46,7 @@ do_execsql_test 1.5 {

 do_catchsql_test 1.6 {
  INSERT INTO f1(f1) VALUES('integrity-check');
-} {1 {database disk image is malformed}}
+} {/.*fts5: corrupt.*/}

 do_execsql_test 1.7 {
  INSERT INTO f1(f1) VALUES('rebuild');
@@ -28,4 +28,34 @@ do_execsql_test 1.1 {
  INSERT INTO sss VALUES('まりや');
 }

+foreach {tn enc tok} {
+  1   utf-8    ascii
+  2   utf-16   ascii
+  3   utf-8    unicode61
+  4   utf-16   unicode61
+} {
+  reset_db
+
+  do_execsql_test 1.$tn.0 " 
+    PRAGMA encoding = '$enc'; 
+    CREATE VIRTUAL TABLE vt2 USING fts5(c0, c1, tokenize=$tok);
+  "
+
+  do_execsql_test 1.$tn.1 {
+    INSERT INTO vt2(c0, c1) VALUES ('bhal', x'17db');
+  }
+
+  do_execsql_test 1.$tn.2 {
+    UPDATE vt2 SET c0='bhal';
+  }
+
+  do_execsql_test 1.$tn.3 {
+    INSERT INTO vt2(vt2) VALUES('integrity-check')
+  }
+
+  do_execsql_test 1.$tn.4 {
+    SELECT quote(c1) FROM vt2
+  } {X'17DB'}
+}
+
 finish_test
@@ -429,7 +429,7 @@ $(doc.index): $(JAVA_FILES.main) $(MAKEFILE)
 .FORCE: doc
 doc: $(doc.index)
 javadoc: $(doc.index)
-# Force rebild of docs
+# Force rebuild of docs
 redoc:
 	@rm -f $(doc.index)
 	@$(MAKE) doc
@@ -133,7 +133,7 @@
 ** Which sqlite3.c we're using needs to be configurable to enable
 ** building against a custom copy, e.g. the SEE variant. We have to
 ** include sqlite3.c, as opposed to sqlite3.h, in order to get access
-** to some interal details like SQLITE_MAX_... and friends. This
+** to some internal details like SQLITE_MAX_... and friends. This
 ** increases the rebuild time considerably but we need this in order
 ** to access some internal functionality and keep the to-Java-exported
 ** values of SQLITE_MAX_... and SQLITE_LIMIT_... in sync with the C
@@ -5512,7 +5512,7 @@ static inline jobject new_java_fts5_api(JNIEnv * const env, fts5_api *sv){
 ** Returns a per-JNIEnv global ref to the Fts5ExtensionApi singleton
 ** instance, or NULL on OOM.
 */
-static jobject s3jni_getFts5ExensionApi(JNIEnv * const env){
+static jobject s3jni_getFts5ExtensionApi(JNIEnv * const env){
  if( !SJG.fts5.jExt ){
    S3JniGlobal_mutex_enter;
    if( !SJG.fts5.jExt ){
@@ -5578,7 +5578,7 @@ JniDeclFtsApi(jobject,getInstanceForDb)(JniArgsEnvClass,jobject jDb){


 JniDeclFtsXA(jobject,getInstance)(JniArgsEnvClass){
-  return s3jni_getFts5ExensionApi(env);
+  return s3jni_getFts5ExtensionApi(env);
 }

 JniDeclFtsXA(jint,xColumnCount)(JniArgsEnvObj,jobject jCtx){
@@ -5641,7 +5641,7 @@ static void s3jni_fts5_extension_function(Fts5ExtensionApi const *pApi,
  S3JniDeclLocal_env;

  assert(pAux);
-  jFXA = s3jni_getFts5ExensionApi(env);
+  jFXA = s3jni_getFts5ExtensionApi(env);
  if( !jFXA ) goto error_oom;
  jpFts = new_java_Fts5Context(env, pFts);
  if( !jpFts ) goto error_oom;
@@ -1342,7 +1342,7 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1data_1count
 * Method:    sqlite3_db_config
 * Signature: (Lorg/sqlite/jni/capi/sqlite3;IILorg/sqlite/jni/capi/OutputPointer/Int32;)I
 */
-JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1config__Lorg_sqlite_jni_capi_sqlite3_2IILorg_sqlite_jni_capi_OutputPointer_Int32_2
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1db_1config__Lorg_sqlite_jni_capi_sqlite3_2IILorg_sqlite_jni_capi_OutputPointer_00024Int32_2
  (JNIEnv *, jclass, jobject, jint, jint, jobject);

 /*
@@ -31,11 +31,11 @@ import java.lang.annotation.*;
   never pass a null value to the callback for that parameter.</p>

   <p>Passing a null, for this annotation's definition of null, for
-   any parameter marked with this annoation specifically invokes
+   any parameter marked with this annotation specifically invokes
   undefined behavior (see below).</p>

   <p>Passing 0 (i.e. C NULL) or a negative value for any long-type
-   parameter marked with this annoation specifically invokes undefined
+   parameter marked with this annotation specifically invokes undefined
   behavior (see below). Such values are treated as C pointers in the
   JNI layer.</p>

@@ -120,7 +120,7 @@ public abstract class AggregateFunction<T> implements SQLFunction {
     argument, the context is set to the given initial value. On all other
     calls, the 2nd argument is ignored.

-     @see SQLFunction.PerContextState#getAggregateState
+     @see AggregateFunction.PerContextState#getAggregateState
  */
  protected final ValueHolder<T> getAggregateState(sqlite3_context cx, T initialValue){
    return map.getAggregateState(cx, initialValue);
@@ -130,7 +130,7 @@ public abstract class AggregateFunction<T> implements SQLFunction {
     To be called from the implementation's xFinal() method to fetch
     the final state of the UDF and remove its mapping.

-     see SQLFunction.PerContextState#takeAggregateState
+     see AggregateFunction.PerContextState#takeAggregateState
  */
  protected final T takeAggregateState(sqlite3_context cx){
    return map.takeAggregateState(cx);
@@ -12,14 +12,9 @@
 ** This file declares the main JNI bindings for the sqlite3 C API.
 */
 package org.sqlite.jni.capi;
-import java.nio.charset.StandardCharsets;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import org.sqlite.jni.annotation.*;
 import java.util.Arrays;
+import java.nio.charset.StandardCharsets;
+import org.sqlite.jni.annotation.*;

 /**
  This class contains the entire C-style sqlite3 JNI API binding,
@@ -169,7 +164,7 @@ public final class CApi {
     <p>Like the C API, it returns 0 if allocation fails or if
     initialize is false and no prior aggregate context was allocated
     for cx.  If initialize is true then it returns 0 only on
-     allocation error. In all casses, 0 is considered the sentinel
+     allocation error. In all cases, 0 is considered the sentinel
     "not a key" value.
  */
  public static native long sqlite3_aggregate_context(sqlite3_context cx, boolean initialize);
@@ -563,7 +558,7 @@ public final class CApi {
    sqlite3_blob_open(db.getNativePointer(), dbName, tableName, columnName,
                      iRow, flags, out);
    return out.take();
-  };
+  }

  private static native int sqlite3_blob_read(
    @NotNull long ptrToBlob, @NotNull byte[] target, int srcOffset
@@ -1298,7 +1293,7 @@ public final class CApi {
    final OutputPointer.sqlite3 out = new OutputPointer.sqlite3();
    sqlite3_open(filename, out);
    return out.take();
-  };
+  }

  public static native int sqlite3_open_v2(
    @Nullable String filename, @NotNull OutputPointer.sqlite3 ppDb,
@@ -1314,7 +1309,7 @@ public final class CApi {
    final OutputPointer.sqlite3 out = new OutputPointer.sqlite3();
    sqlite3_open_v2(filename, out, flags, zVfs);
    return out.take();
-  };
+  }

  /**
     The sqlite3_prepare() family of functions require slightly
@@ -1410,7 +1405,7 @@ public final class CApi {

  /**
     Works like the canonical sqlite3_prepare_v2() but its "tail"
-     output paramter is returned as the index offset into the given
+     output parameter is returned as the index offset into the given
     byte array at which SQL parsing stopped.
  */
  public static int sqlite3_prepare_v2(
@@ -1462,7 +1457,7 @@ public final class CApi {

  /**
     Works like the canonical sqlite3_prepare_v2() but its "tail"
-     output paramter is returned as the index offset into the given
+     output parameter is returned as the index offset into the given
     byte array at which SQL parsing stopped.
  */
  public static int sqlite3_prepare_v3(
@@ -1542,7 +1537,7 @@ public final class CApi {
    int rc = 0;
    final OutputPointer.sqlite3_stmt outStmt = new OutputPointer.sqlite3_stmt();
    while( 0==rc && pos<sqlChunk.length ){
-      sqlite3_stmt stmt = null;
+      sqlite3_stmt stmt;
      if( pos>0 ){
        sqlChunk = Arrays.copyOfRange(sqlChunk, pos,
                                      sqlChunk.length);
@@ -13,7 +13,7 @@
 */
 package org.sqlite.jni.capi;
 /**
-   This marker interface exists soley for use as a documentation and
+   This marker interface exists solely for use as a documentation and
   class-grouping tool. It should be applied to interfaces or
   classes which have a call() method implementing some specific
   callback interface on behalf of the C library.
@@ -34,7 +34,7 @@ package org.sqlite.jni.capi;
   proxying for, minus the {@code sqlite3_} prefix, plus a {@code
   Callback} suffix. e.g. {@code sqlite3_busy_handler()}'s callback is
   named {@code BusyHandlerCallback}. Exceptions are made where that
-   would potentially be ambiguous, e.g. {@link ConfigSqllogCallback}
+   would potentially be ambiguous, e.g. {@link ConfigSqlLogCallback}
   instead of {@code ConfigCallback} because the {@code
   sqlite3_config()} interface may need to support more callback types
   in the future.
@@ -20,7 +20,7 @@ package org.sqlite.jni.capi;
   from the native JNI code is unduly quirky due to a lack of
   autoboxing at that level.

-   <p>The usage is similar for all of thes types:
+   <p>The usage is similar for all of these types:

   <pre>{@code
   OutputPointer.sqlite3 out = new OutputPointer.sqlite3();
@@ -55,9 +55,9 @@ public final class OutputPointer {
    /** Sets the current value to null. */
    public void clear(){value = null;}
    /** Returns the current value. */
-    public final org.sqlite.jni.capi.sqlite3 get(){return value;}
+    public org.sqlite.jni.capi.sqlite3 get(){return value;}
    /** Equivalent to calling get() then clear(). */
-    public final org.sqlite.jni.capi.sqlite3 take(){
+    public org.sqlite.jni.capi.sqlite3 take(){
      final org.sqlite.jni.capi.sqlite3 v = value;
      value = null;
      return v;
@@ -76,9 +76,9 @@ public final class OutputPointer {
    /** Sets the current value to null. */
    public void clear(){value = null;}
    /** Returns the current value. */
-    public final org.sqlite.jni.capi.sqlite3_blob get(){return value;}
+    public org.sqlite.jni.capi.sqlite3_blob get(){return value;}
    /** Equivalent to calling get() then clear(). */
-    public final org.sqlite.jni.capi.sqlite3_blob take(){
+    public org.sqlite.jni.capi.sqlite3_blob take(){
      final org.sqlite.jni.capi.sqlite3_blob v = value;
      value = null;
      return v;
@@ -98,9 +98,9 @@ public final class OutputPointer {
    /** Sets the current value to null. */
    public void clear(){value = null;}
    /** Returns the current value. */
-    public final org.sqlite.jni.capi.sqlite3_stmt get(){return value;}
+    public org.sqlite.jni.capi.sqlite3_stmt get(){return value;}
    /** Equivalent to calling get() then clear(). */
-    public final org.sqlite.jni.capi.sqlite3_stmt take(){
+    public org.sqlite.jni.capi.sqlite3_stmt take(){
      final org.sqlite.jni.capi.sqlite3_stmt v = value;
      value = null;
      return v;
@@ -120,9 +120,9 @@ public final class OutputPointer {
    /** Sets the current value to null. */
    public void clear(){value = null;}
    /** Returns the current value. */
-    public final org.sqlite.jni.capi.sqlite3_value get(){return value;}
+    public org.sqlite.jni.capi.sqlite3_value get(){return value;}
    /** Equivalent to calling get() then clear(). */
-    public final org.sqlite.jni.capi.sqlite3_value take(){
+    public org.sqlite.jni.capi.sqlite3_value take(){
      final org.sqlite.jni.capi.sqlite3_value v = value;
      value = null;
      return v;
@@ -144,9 +144,9 @@ public final class OutputPointer {
    /** Initializes with the value v. */
    public Bool(boolean v){value = v;}
    /** Returns the current value. */
-    public final boolean get(){return value;}
+    public boolean get(){return value;}
    /** Sets the current value to v. */
-    public final void set(boolean v){value = v;}
+    public void set(boolean v){value = v;}
  }

  /**
@@ -164,9 +164,9 @@ public final class OutputPointer {
    /** Initializes with the value v. */
    public Int32(int v){value = v;}
    /** Returns the current value. */
-    public final int get(){return value;}
+    public int get(){return value;}
    /** Sets the current value to v. */
-    public final void set(int v){value = v;}
+    public void set(int v){value = v;}
  }

  /**
@@ -184,9 +184,9 @@ public final class OutputPointer {
    /** Initializes with the value v. */
    public Int64(long v){value = v;}
    /** Returns the current value. */
-    public final long get(){return value;}
+    public long get(){return value;}
    /** Sets the current value. */
-    public final void set(long v){value = v;}
+    public void set(long v){value = v;}
  }

  /**
@@ -204,9 +204,9 @@ public final class OutputPointer {
    /** Initializes with the value v. */
    public String(java.lang.String v){value = v;}
    /** Returns the current value. */
-    public final java.lang.String get(){return value;}
+    public java.lang.String get(){return value;}
    /** Sets the current value. */
-    public final void set(java.lang.String v){value = v;}
+    public void set(java.lang.String v){value = v;}
  }

  /**
@@ -224,9 +224,9 @@ public final class OutputPointer {
    /** Initializes with the value v. */
    public ByteArray(byte[] v){value = v;}
    /** Returns the current value. */
-    public final byte[] get(){return value;}
+    public byte[] get(){return value;}
    /** Sets the current value. */
-    public final void set(byte[] v){value = v;}
+    public void set(byte[] v){value = v;}
  }

  /**
@@ -246,8 +246,8 @@ public final class OutputPointer {
    /** Initializes with the value v. */
    public ByteBuffer(java.nio.ByteBuffer v){value = v;}
    /** Returns the current value. */
-    public final java.nio.ByteBuffer get(){return value;}
+    public java.nio.ByteBuffer get(){return value;}
    /** Sets the current value. */
-    public final void set(java.nio.ByteBuffer v){value = v;}
+    public void set(java.nio.ByteBuffer v){value = v;}
  }
 }
@@ -65,7 +65,7 @@ public interface PrepareMultiCallback extends CallbackProxy {
     A PrepareMultiCallback impl which steps entirely through a result set,
     ignoring all non-error results.
  */
-  public static final class StepAll implements PrepareMultiCallback {
+  final class StepAll implements PrepareMultiCallback {
    public StepAll(){}
    /**
       Calls sqlite3_step() on st until it returns something other than
@@ -13,7 +13,6 @@
 ** SQLTester framework.
 */
 package org.sqlite.jni.capi;
-import java.util.List;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.nio.charset.StandardCharsets;
@@ -31,7 +30,7 @@ enum ResultBufferMode {
  ESCAPED,
  //! Append output as-is
  ASIS
-};
+}

 /**
   Modes to specify how to emit multi-row output from
@@ -42,7 +41,7 @@ enum ResultRowMode {
  ONELINE,
  //! Add a newline between each result row.
  NEWLINE
-};
+}

 /**
   Base exception type for test-related failures.
@@ -278,7 +277,7 @@ public class SQLTester {
  }

  private StringBuilder clearBuffer(StringBuilder b){
-    b.setLength(0);;
+    b.setLength(0);
    return b;
  }

@@ -334,7 +333,7 @@ public class SQLTester {
    return this;
  }

-  sqlite3 setCurrentDb(int n) throws Exception{
+  sqlite3 setCurrentDb(int n){
    affirmDbId(n);
    iCurrentDb = n;
    return this.aDb[n];
@@ -342,7 +341,7 @@ public class SQLTester {

  sqlite3 getCurrentDb(){ return aDb[iCurrentDb]; }

-  sqlite3 getDbById(int id) throws Exception{
+  sqlite3 getDbById(int id){
    return affirmDbId(id).aDb[id];
  }

@@ -363,7 +362,7 @@ public class SQLTester {
    }
  }

-  sqlite3 openDb(String name, boolean createIfNeeded) throws DbException {
+  sqlite3 openDb(String name, boolean createIfNeeded) {
    closeDb();
    int flags = SQLITE_OPEN_READWRITE;
    if( createIfNeeded ) flags |= SQLITE_OPEN_CREATE;
@@ -755,7 +754,7 @@ abstract class Command {
     fall in the inclusive range (min,max) then this function throws. Use
     a max value of -1 to mean unlimited.
  */
-  protected final void argcCheck(TestScript ts, String[] argv, int min, int max) throws Exception{
+  protected final void argcCheck(TestScript ts, String[] argv, int min, int max){
    int argc = argv.length-1;
    if(argc<min || (max>=0 && argc>max)){
      if( min==max ){
@@ -771,16 +770,16 @@ abstract class Command {
  /**
     Equivalent to argcCheck(argv,argc,argc).
  */
-  protected final void argcCheck(TestScript ts, String[] argv, int argc) throws Exception{
+  protected final void argcCheck(TestScript ts, String[] argv, int argc){
    argcCheck(ts, argv, argc, argc);
  }
 }

 //! --close command
 class CloseDbCommand extends Command {
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,0,1);
-    Integer id;
+    int id;
    if(argv.length>1){
      String arg = argv[1];
      if("all".equals(arg)){
@@ -801,7 +800,7 @@ class CloseDbCommand extends Command {
 class ColumnNamesCommand extends Command {
  public void process(
    SQLTester st, TestScript ts, String[] argv
-  ) throws Exception{
+  ){
    argcCheck(ts,argv,1);
    st.outputColumnNames( Integer.parseInt(argv[1])!=0 );
  }
@@ -809,7 +808,7 @@ class ColumnNamesCommand extends Command {

 //! --db command
 class DbCommand extends Command {
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,1);
    t.setCurrentDb( Integer.parseInt(argv[1]) );
  }
@@ -821,7 +820,7 @@ class GlobCommand extends Command {
  public GlobCommand(){}
  protected GlobCommand(boolean negate){ this.negate = negate; }

-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,1,-1);
    t.incrementTestCounter();
    final String sql = t.takeInputBuffer();
@@ -851,7 +850,7 @@ class JsonBlockCommand extends TableResultCommand {
 //! --new command
 class NewDbCommand extends OpenDbCommand {
  public NewDbCommand(){ super(true); }
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    if(argv.length>1){
      Util.unlink(argv[1]);
    }
@@ -867,7 +866,7 @@ class NoopCommand extends Command {
    this.verbose = verbose;
  }
  public NoopCommand(){}
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    if( this.verbose ){
      t.outln("Skipping unhandled command: "+argv[0]);
    }
@@ -885,7 +884,7 @@ class NotGlobCommand extends GlobCommand {
 class NullCommand extends Command {
  public void process(
    SQLTester st, TestScript ts, String[] argv
-  ) throws Exception{
+  ){
    argcCheck(ts,argv,1);
    st.setNullValue( argv[1] );
  }
@@ -896,7 +895,7 @@ class OpenDbCommand extends Command {
  private boolean createIfNeeded = false;
  public OpenDbCommand(){}
  protected OpenDbCommand(boolean c){createIfNeeded = c;}
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,1);
    t.openDb(argv[1], createIfNeeded);
  }
@@ -906,7 +905,7 @@ class OpenDbCommand extends Command {
 class PrintCommand extends Command {
  public void process(
    SQLTester st, TestScript ts, String[] argv
-  ) throws Exception{
+  ){
    st.out(ts.getOutputPrefix(),": ");
    if( 1==argv.length ){
      st.out( st.getInputText() );
@@ -921,7 +920,7 @@ class ResultCommand extends Command {
  private final ResultBufferMode bufferMode;
  protected ResultCommand(ResultBufferMode bm){ bufferMode = bm; }
  public ResultCommand(){ this(ResultBufferMode.ESCAPED); }
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,0,-1);
    t.incrementTestCounter();
    final String sql = t.takeInputBuffer();
@@ -939,7 +938,7 @@ class ResultCommand extends Command {

 //! --run command
 class RunCommand extends Command {
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,0,1);
    final sqlite3 db = (1==argv.length)
      ? t.getCurrentDb() : t.getDbById( Integer.parseInt(argv[1]) );
@@ -959,7 +958,7 @@ class TableResultCommand extends Command {
  private final boolean jsonMode;
  protected TableResultCommand(boolean jsonMode){ this.jsonMode = jsonMode; }
  public TableResultCommand(){ this(false); }
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,0);
    t.incrementTestCounter();
    String body = ts.fetchCommandBody(t);
@@ -1002,7 +1001,7 @@ class TableResultCommand extends Command {

 //! --testcase command
 class TestCaseCommand extends Command {
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,1);
    ts.setTestCaseName(argv[1]);
    t.clearResultBuffer();
@@ -1012,7 +1011,7 @@ class TestCaseCommand extends Command {

 //! --verbosity command
 class VerbosityCommand extends Command {
-  public void process(SQLTester t, TestScript ts, String[] argv) throws Exception{
+  public void process(SQLTester t, TestScript ts, String[] argv){
    argcCheck(ts,argv,1);
    ts.setVerbosity( Integer.parseInt(argv[1]) );
  }
@@ -1020,7 +1019,7 @@ class VerbosityCommand extends Command {

 class CommandDispatcher {

-  private static java.util.Map<String,Command> commandMap =
+  private static final java.util.Map<String,Command> commandMap =
    new java.util.HashMap<>();

  /**
@@ -1244,7 +1243,7 @@ class TestScript {
    }
    cur.pos = i;
    final String rv = cur.sb.toString();
-    if( i==cur.src.length && 0==rv.length() ){
+    if( i==cur.src.length && rv.isEmpty() ){
      return null /* EOF */;
    }
    return rv;
@@ -1364,7 +1363,7 @@ class TestScript {
    if( m.find() ){
      throw new IncompatibleDirective(this, m.group(1)+": "+m.group(3));
    }
-    if( line.indexOf("\n|")>=0 ){
+    if( line.contains("\n|") ){
      throw new IncompatibleDirective(this, "newline-pipe combination.");
    }
    return;
@@ -18,11 +18,11 @@ package org.sqlite.jni.capi;
   They are populated only via that interface.
 */
 public final class TableColumnMetadata {
-  OutputPointer.Bool pNotNull = new OutputPointer.Bool();
-  OutputPointer.Bool pPrimaryKey = new OutputPointer.Bool();
-  OutputPointer.Bool pAutoinc = new OutputPointer.Bool();
-  OutputPointer.String pzCollSeq = new OutputPointer.String();
-  OutputPointer.String pzDataType = new OutputPointer.String();
+  final OutputPointer.Bool pNotNull = new OutputPointer.Bool();
+  final OutputPointer.Bool pPrimaryKey = new OutputPointer.Bool();
+  final OutputPointer.Bool pAutoinc = new OutputPointer.Bool();
+  final OutputPointer.String pzCollSeq = new OutputPointer.String();
+  final OutputPointer.String pzDataType = new OutputPointer.String();

  public TableColumnMetadata(){
  }
@@ -19,7 +19,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.Future;

 /**
   An annotation for Tester1 tests which we do not want to run in
@@ -62,13 +61,13 @@ public class Tester1 implements Runnable {
  //! List of test*() methods to run.
  private static List<java.lang.reflect.Method> testMethods = null;
  //! List of exceptions collected by run()
-  private static List<Exception> listErrors = new ArrayList<>();
+  private static final List<Exception> listErrors = new ArrayList<>();
  private static final class Metrics {
    //! Number of times createNewDb() (or equivalent) is invoked.
    volatile int dbOpen = 0;
  }

-  private Integer tId;
+  private final Integer tId;

  Tester1(Integer id){
    tId = id;
@@ -78,7 +77,7 @@ public class Tester1 implements Runnable {

  public static synchronized void outln(){
    if( !quietMode ){
-      System.out.println("");
+      System.out.println();
    }
  }

@@ -523,7 +522,7 @@ public class Tester1 implements Runnable {
    }
    sqlite3_finalize(stmt);
    affirm(3 == n);
-    affirm("w😃rldhell🤩!🤩".equals(sbuf.toString()));
+    affirm("w😃rldhell🤩!🤩".contentEquals(sbuf));

    try( sqlite3_stmt stmt2 = prepare(db, "SELECT ?, ?") ){
      rc = sqlite3_bind_text(stmt2, 1, "");
@@ -668,7 +667,7 @@ public class Tester1 implements Runnable {
    execSql(db, "CREATE TABLE t(a); INSERT INTO t(a) VALUES('a'),('b'),('c')");
    final ValueHolder<Integer> xDestroyCalled = new ValueHolder<>(0);
    final CollationCallback myCollation = new CollationCallback() {
-        private String myState =
+        private final String myState =
          "this is local state. There is much like it, but this is mine.";
        @Override
        // Reverse-sorts its inputs...
@@ -847,7 +846,7 @@ public class Tester1 implements Runnable {
    SQLFunction funcAgg = new AggregateFunction<Integer>(){
        @Override public void xStep(sqlite3_context cx, sqlite3_value[] args){
          /** Throwing from here should emit loud noise on stdout or stderr
-              but the exception is supressed because we have no way to inform
+              but the exception is suppressed because we have no way to inform
              sqlite about it from these callbacks. */
          //throw new RuntimeException("Throwing from an xStep");
        }
@@ -1850,7 +1849,7 @@ public class Tester1 implements Runnable {
      "; insert into t(a) values(1),(2),(3);",
      "select a from t;"
    };
-    final List<sqlite3_stmt> liStmt = new ArrayList<sqlite3_stmt>();
+    final List<sqlite3_stmt> liStmt = new ArrayList<>();
    final PrepareMultiCallback proxy = new PrepareMultiCallback.StepAll();
    final ValueHolder<String> toss = new ValueHolder<>(null);
    PrepareMultiCallback m = new PrepareMultiCallback() {
@@ -1984,9 +1983,9 @@ public class Tester1 implements Runnable {
     -v: emit some developer-mode info at the end.
  */
  public static void main(String[] args) throws Exception {
-    Integer nThread = 1;
+    int nThread = 1;
    boolean doSomethingForDev = false;
-    Integer nRepeat = 1;
+    int nRepeat = 1;
    boolean forceFail = false;
    boolean sqlLog = false;
    boolean configLog = false;
@@ -2048,7 +2047,7 @@ public class Tester1 implements Runnable {
      final ConfigLogCallback log = new ConfigLogCallback() {
          @Override public void call(int code, String msg){
            outln("ConfigLogCallback: ",ResultCode.getEntryForInt(code),": ", msg);
-          };
+          }
        };
      int rc = sqlite3_config( log );
      affirm( 0==rc );
@@ -33,5 +33,5 @@ public interface XDestroyCallback {
     each individual reference, leading to memory corruption or a
     crash via duplicate free().
  */
-  public void xDestroy();
+  void xDestroy();
 }
@@ -12,7 +12,6 @@
 ** This file is part of the JNI bindings for the sqlite3 C API.
 */
 package org.sqlite.jni.fts5;
-import java.nio.charset.StandardCharsets;
 import org.sqlite.jni.capi.*;
 import org.sqlite.jni.annotation.*;

@@ -24,7 +23,7 @@ public final class Fts5ExtensionApi extends NativePointerHolder<Fts5ExtensionApi
  private final int iVersion = 2;

  /* Callback type for used by xQueryPhrase(). */
-  public static interface XQueryPhraseCallback {
+  public interface XQueryPhraseCallback {
    int call(Fts5ExtensionApi fapi, Fts5Context cx);
  }

@@ -12,12 +12,11 @@
 ** This file contains a set of tests for the sqlite3 JNI bindings.
 */
 package org.sqlite.jni.fts5;
+import java.util.*;
 import static org.sqlite.jni.capi.CApi.*;
 import static org.sqlite.jni.capi.Tester1.*;
 import org.sqlite.jni.capi.*;
-import org.sqlite.jni.fts5.*;
-
-import java.util.*;
+import java.nio.charset.StandardCharsets;

 public class TesterFts5 {

@@ -88,7 +87,7 @@ public class TesterFts5 {
  ** thrown.
  */
  private static String[] sqlite3_exec(sqlite3 db, String sql) {
-    List<String> aOut = new ArrayList<String>();
+    List<String> aOut = new ArrayList<>();

    /* Iterate through the list of SQL statements. For each, step through
    ** it and add any results to the aOut[] array.  */
@@ -137,14 +136,14 @@ public class TesterFts5 {
  **     fts5_columncount()
  */
  private static void create_test_functions(sqlite3 db){
-    /* 
+    /*
    ** A user-defined-function fts5_rowid() that uses xRowid()
    */
    fts5_extension_function fts5_rowid = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        long rowid = ext.xRowid(fCx);
@@ -153,14 +152,14 @@ public class TesterFts5 {
      public void xDestroy(){ }
    };

-    /* 
-    ** fts5_columncount() - xColumnCount() 
+    /*
+    ** fts5_columncount() - xColumnCount()
    */
    fts5_extension_function fts5_columncount = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        int nCol = ext.xColumnCount(fCx);
@@ -169,14 +168,14 @@ public class TesterFts5 {
      public void xDestroy(){ }
    };

-    /* 
-    ** fts5_columnsize() - xColumnSize() 
+    /*
+    ** fts5_columnsize() - xColumnSize()
    */
    fts5_extension_function fts5_columnsize = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=1 ){
@@ -194,14 +193,14 @@ public class TesterFts5 {
      public void xDestroy(){ }
    };

-    /* 
-    ** fts5_columntext() - xColumnText() 
+    /*
+    ** fts5_columntext() - xColumnText()
    */
    fts5_extension_function fts5_columntext = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=1 ){
@@ -219,14 +218,14 @@ public class TesterFts5 {
      public void xDestroy(){ }
    };

-    /* 
-    ** fts5_columntotalsize() - xColumnTotalSize() 
+    /*
+    ** fts5_columntotalsize() - xColumnTotalSize()
    */
    fts5_extension_function fts5_columntsize = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=1 ){
@@ -251,9 +250,9 @@ public class TesterFts5 {
    */
    class fts5_aux implements fts5_extension_function {
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length>1 ){
@@ -268,13 +267,13 @@ public class TesterFts5 {

        if( argv.length==1 ){
          String val = sqlite3_value_text16(argv[0]);
-          if( !val.equals("") ){
+          if( !val.isEmpty() ){
            ext.xSetAuxdata(fCx, val);
          }
        }
      }
      public void xDestroy(){ }
-    };
+    }

    /*
    ** fts5_inst(<fts>);
@@ -286,9 +285,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_inst = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=0 ){
@@ -299,7 +298,7 @@ public class TesterFts5 {
        OutputPointer.Int32 piPhrase = new OutputPointer.Int32();
        OutputPointer.Int32 piCol = new OutputPointer.Int32();
        OutputPointer.Int32 piOff = new OutputPointer.Int32();
-        String ret = new String();
+        String ret = "";

        int rc = ext.xInstCount(fCx, pnInst);
        int nInst = pnInst.get();
@@ -327,9 +326,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_pinst = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=0 ){
@@ -338,7 +337,7 @@ public class TesterFts5 {

        OutputPointer.Int32 piCol = new OutputPointer.Int32();
        OutputPointer.Int32 piOff = new OutputPointer.Int32();
-        String ret = new String();
+        String ret = "";
        int rc = SQLITE_OK;

        int nPhrase = ext.xPhraseCount(fCx);
@@ -350,7 +349,7 @@ public class TesterFts5 {
              rc==SQLITE_OK && piCol.get()>=0;
              ext.xPhraseNext(fCx, pIter, piCol, piOff)
          ){
-            if( !ret.equals("") ) ret += " ";
+            if( !ret.isEmpty() ) ret += " ";
            ret += "{"+ii+" "+piCol.get()+" "+piOff.get()+"}";
          }
        }
@@ -374,9 +373,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_pcolinst = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=0 ){
@@ -384,7 +383,7 @@ public class TesterFts5 {
        }

        OutputPointer.Int32 piCol = new OutputPointer.Int32();
-        String ret = new String();
+        String ret = "";
        int rc = SQLITE_OK;

        int nPhrase = ext.xPhraseCount(fCx);
@@ -396,7 +395,7 @@ public class TesterFts5 {
              rc==SQLITE_OK && piCol.get()>=0;
              ext.xPhraseNextColumn(fCx, pIter, piCol)
          ){
-            if( !ret.equals("") ) ret += " ";
+            if( !ret.isEmpty() ) ret += " ";
            ret += "{"+ii+" "+piCol.get()+"}";
          }
        }
@@ -415,9 +414,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_rowcount = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=0 ){
@@ -440,9 +439,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_phrasesize = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=1 ){
@@ -464,9 +463,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_phrasehits = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=1 ){
@@ -503,9 +502,9 @@ public class TesterFts5 {
    */
    fts5_extension_function fts5_tokenize = new fts5_extension_function(){
      @Override public void call(
-          Fts5ExtensionApi ext, 
+          Fts5ExtensionApi ext,
          Fts5Context fCx,
-          sqlite3_context pCx, 
+          sqlite3_context pCx,
          sqlite3_value argv[]
      ){
        if( argv.length!=1 ){
@@ -515,7 +514,7 @@ public class TesterFts5 {
        int rc = SQLITE_OK;

        class MyCallback implements XTokenizeCallback {
-          private List<String> myList = new ArrayList<String>();
+          private List<String> myList = new ArrayList<>();

          public String getval() {
            return String.join("+", myList);
@@ -524,7 +523,7 @@ public class TesterFts5 {
          @Override
          public int call(int tFlags, byte[] txt, int iStart, int iEnd){
            try {
-              String str = new String(txt, "UTF-8");
+              String str = new String(txt, StandardCharsets.UTF_8);
              myList.add(str);
            } catch (Exception e) {
            }
@@ -39,7 +39,11 @@ public interface fts5_extension_function {
  */
  void xDestroy();

-  public static abstract class Abstract implements fts5_extension_function {
+  /**
+     A base implementation of fts5_extension_function() which has a
+     no-op xDestroy() method.
+  */
+  abstract class Abstract implements fts5_extension_function {
    @Override public abstract void call(Fts5ExtensionApi ext, Fts5Context fCx,
                                        sqlite3_context pCx, sqlite3_value argv[]);
    @Override public void xDestroy(){}
@@ -4,7 +4,7 @@

 The purpose of the Test Script Interpreter is to read and interpret
 script files that contain SQL commands and desired results.  The
-interpreter will check results and report any discrepencies found.
+interpreter will check results and report any discrepancies found.

 The test script files are ASCII text files.  The filename always ends with
 ".test".  Each script is evaluated independently; context does not carry
@@ -160,7 +160,7 @@ the result buffer.  This distinction does not matter for the --result
 command itself, but it is important for related commands like --glob
 and --notglob.  Sometimes test cases will contains a bunch of SQL
 followed by multiple --glob and/or --notglob statements.  All of the
-globs should be evaluated agains the result buffer, but the SQL should
+globs should be evaluated against the result buffer, but the SQL should
 only be run once.  This is accomplished by resetting the input buffer
 but not the result buffer.

@@ -12,10 +12,6 @@
 ** This file is part of the wrapper1 interface for sqlite3.
 */
 package org.sqlite.jni.wrapper1;
-import org.sqlite.jni.capi.CApi;
-import org.sqlite.jni.annotation.*;
-import org.sqlite.jni.capi.sqlite3_context;
-import org.sqlite.jni.capi.sqlite3_value;

 /**
   The SqlFunction type for scalar SQL functions.
@@ -22,13 +22,13 @@ import org.sqlite.jni.capi.sqlite3_value;
 */
 public interface SqlFunction  {

-  public static final int DETERMINISTIC = CApi.SQLITE_DETERMINISTIC;
-  public static final int INNOCUOUS = CApi.SQLITE_INNOCUOUS;
-  public static final int DIRECTONLY = CApi.SQLITE_DIRECTONLY;
-  public static final int SUBTYPE = CApi.SQLITE_SUBTYPE;
-  public static final int RESULT_SUBTYPE = CApi.SQLITE_RESULT_SUBTYPE;
-  public static final int UTF8 = CApi.SQLITE_UTF8;
-  public static final int UTF16 = CApi.SQLITE_UTF16;
+  int DETERMINISTIC = CApi.SQLITE_DETERMINISTIC;
+  int INNOCUOUS = CApi.SQLITE_INNOCUOUS;
+  int DIRECTONLY = CApi.SQLITE_DIRECTONLY;
+  int SUBTYPE = CApi.SQLITE_SUBTYPE;
+  int RESULT_SUBTYPE = CApi.SQLITE_RESULT_SUBTYPE;
+  int UTF8 = CApi.SQLITE_UTF8;
+  int UTF16 = CApi.SQLITE_UTF16;

  /**
     The Arguments type is an abstraction on top of the lower-level
@@ -36,7 +36,7 @@ public interface SqlFunction  {
     of the lower-level interface, insofar as possible without "leaking"
     those types into this API.
  */
-  public final static class Arguments implements Iterable<SqlFunction.Arguments.Arg>{
+  final class Arguments implements Iterable<SqlFunction.Arguments.Arg>{
    private final sqlite3_context cx;
    private final sqlite3_value args[];
    public final int length;
@@ -144,7 +144,7 @@ public interface SqlFunction  {
       range.
    */
    public void setAuxData(int argNdx, Object o){
-      /* From the API docs: https://www.sqlite.org/c3ref/get_auxdata.html
+      /* From the API docs: https://sqlite.org/c3ref/get_auxdata.html

         The value of the N parameter to these interfaces should be
         non-negative. Future enhancements may make use of negative N
@@ -207,7 +207,7 @@ public interface SqlFunction  {
     Internal-use adapter for wrapping this package's ScalarFunction
     for use with the org.sqlite.jni.capi.ScalarFunction interface.
  */
-  static final class ScalarAdapter extends org.sqlite.jni.capi.ScalarFunction {
+  final class ScalarAdapter extends org.sqlite.jni.capi.ScalarFunction {
    private final ScalarFunction impl;
    ScalarAdapter(ScalarFunction impl){
      this.impl = impl;
@@ -234,8 +234,8 @@ public interface SqlFunction  {
     Internal-use adapter for wrapping this package's AggregateFunction
     for use with the org.sqlite.jni.capi.AggregateFunction interface.
  */
-  static /*cannot be final without duplicating the whole body in WindowAdapter*/
  class AggregateAdapter extends org.sqlite.jni.capi.AggregateFunction {
+  /*cannot be final without duplicating the whole body in WindowAdapter*/
    private final AggregateFunction impl;
    AggregateAdapter(AggregateFunction impl){
      this.impl = impl;
@@ -277,7 +277,7 @@ public interface SqlFunction  {
     Internal-use adapter for wrapping this package's WindowFunction
     for use with the org.sqlite.jni.capi.WindowFunction interface.
  */
-  static final class WindowAdapter extends AggregateAdapter {
+  final class WindowAdapter extends AggregateAdapter {
    private final WindowFunction impl;
    WindowAdapter(WindowFunction impl){
      super(impl);
@@ -19,7 +19,6 @@ import org.sqlite.jni.capi.sqlite3_stmt;
 import org.sqlite.jni.capi.sqlite3_backup;
 import org.sqlite.jni.capi.sqlite3_blob;
 import org.sqlite.jni.capi.OutputPointer;
-import java.nio.ByteBuffer;

 /**
   This class represents a database connection, analog to the C-side
@@ -388,10 +387,10 @@ public final class Sqlite implements AutoCloseable  {
    return CApi.sqlite3_compileoption_used(optName);
  }

-  private static boolean hasNormalizeSql =
+  private static final boolean hasNormalizeSql =
    compileOptionUsed("ENABLE_NORMALIZE");

-  private static boolean hasSqlLog =
+  private static final boolean hasSqlLog =
    compileOptionUsed("ENABLE_SQLLOG");

  /**
@@ -450,7 +449,7 @@ public final class Sqlite implements AutoCloseable  {
    long current;
    /** The peak value for the requested status() or libStatus() metric. */
    long peak;
-  };
+  }

  /**
     As per sqlite3_status64(), but returns its current and high-water
@@ -696,7 +695,7 @@ public final class Sqlite implements AutoCloseable  {
    final org.sqlite.jni.capi.OutputPointer.Int32 oTail =
      new org.sqlite.jni.capi.OutputPointer.Int32();
    while( pos < sqlChunk.length ){
-      sqlite3_stmt stmt = null;
+      sqlite3_stmt stmt;
      if( pos>0 ){
        sqlChunk = java.util.Arrays.copyOfRange(sqlChunk, pos, sqlChunk.length);
      }
@@ -988,15 +987,15 @@ public final class Sqlite implements AutoCloseable  {
          }
        };
    checkRc( CApi.sqlite3_trace_v2(thisDb(), traceMask, tc) );
-  };
+  }

  /**
     Corresponds to the sqlite3_stmt class. Use Sqlite.prepare() to
     create new instances.
  */
  public static final class Stmt implements AutoCloseable {
-    private Sqlite _db = null;
-    private sqlite3_stmt stmt = null;
+    private Sqlite _db;
+    private sqlite3_stmt stmt;

    /** Only called by the prepare() factory functions. */
    Stmt(Sqlite db, sqlite3_stmt stmt){
@@ -1379,9 +1378,9 @@ public final class Sqlite implements AutoCloseable  {
     Sqlite.initBackup() to create new instances.
  */
  public static final class Backup implements AutoCloseable {
-    private sqlite3_backup b = null;
-    private Sqlite dbTo = null;
-    private Sqlite dbFrom = null;
+    private sqlite3_backup b;
+    private Sqlite dbTo;
+    private Sqlite dbFrom;

    Backup(Sqlite dbDest, String schemaDest,Sqlite dbSrc, String schemaSrc){
      this.dbTo = dbDest;
@@ -1491,7 +1490,7 @@ public final class Sqlite implements AutoCloseable  {
       Warning: the SQLite core has no mechanism for reporting errors
       from custom collations and its workflow does not accommodate
       propagation of exceptions from callbacks. Any exceptions thrown
-       from collations will be silently supressed and sorting results
+       from collations will be silently suppressed and sorting results
       will be unpredictable.
    */
    int call(byte[] lhs, byte[] rhs);
@@ -1506,7 +1505,7 @@ public final class Sqlite implements AutoCloseable  {
  */
  public void createCollation(String name, int encoding, Collation c){
    thisDb();
-    if( null==name || 0==name.length()){
+    if( null==name || name.isEmpty()){
      throw new IllegalArgumentException("Collation name may not be null or empty.");
    }
    if( null==c ){
@@ -1599,11 +1598,12 @@ public final class Sqlite implements AutoCloseable  {
  public void setBusyHandler( BusyHandler b ){
    org.sqlite.jni.capi.BusyHandlerCallback bhc = null;
    if( null!=b ){
-      bhc = new org.sqlite.jni.capi.BusyHandlerCallback(){
+      /*bhc = new org.sqlite.jni.capi.BusyHandlerCallback(){
          @Override public int call(int n){
            return b.call(n);
          }
-        };
+        };*/
+      bhc = b::call;
    }
    checkRc( CApi.sqlite3_busy_handler(thisDb(), bhc) );
  }
@@ -1781,9 +1781,10 @@ public final class Sqlite implements AutoCloseable  {
  public void setProgressHandler( int n, ProgressHandler p ){
    org.sqlite.jni.capi.ProgressHandlerCallback phc = null;
    if( null!=p ){
-      phc = new org.sqlite.jni.capi.ProgressHandlerCallback(){
+      /*phc = new org.sqlite.jni.capi.ProgressHandlerCallback(){
          @Override public int call(){ return p.call(); }
-        };
+          };*/
+      phc = p::call;
    }
    CApi.sqlite3_progress_handler( thisDb(), n, phc );
  }
@@ -1808,11 +1809,12 @@ public final class Sqlite implements AutoCloseable  {
  public void setAuthorizer( Authorizer a ) {
    org.sqlite.jni.capi.AuthorizerCallback ac = null;
    if( null!=a ){
-      ac = new org.sqlite.jni.capi.AuthorizerCallback(){
+      /*ac = new org.sqlite.jni.capi.AuthorizerCallback(){
          @Override public int call(int opId, String s1, String s2, String s3, String s4){
            return a.call(opId, s1, s2, s3, s4);
          }
-        };
+          };*/
+      ac = a::call;
    }
    checkRc( CApi.sqlite3_set_authorizer( thisDb(), ac ) );
  }
@@ -1932,11 +1934,12 @@ public final class Sqlite implements AutoCloseable  {
    final org.sqlite.jni.capi.ConfigLogCallback l =
      null==log
      ? null
-      : new org.sqlite.jni.capi.ConfigLogCallback() {
+      /*: new org.sqlite.jni.capi.ConfigLogCallback() {
          @Override public void call(int errCode, String msg){
            log.call(errCode, msg);
          }
-        };
+          };*/
+      : log::call;
      checkRcStatic(CApi.sqlite3_config(l));
  }

@@ -13,7 +13,6 @@
 */
 package org.sqlite.jni.wrapper1;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
@@ -53,14 +52,14 @@ public class Tester2 implements Runnable {
  //! List of test*() methods to run.
  private static List<java.lang.reflect.Method> testMethods = null;
  //! List of exceptions collected by run()
-  private static List<Exception> listErrors = new ArrayList<>();
+  private static final List<Exception> listErrors = new ArrayList<>();
  private static final class Metrics {
    //! Number of times createNewDb() (or equivalent) is invoked.
    volatile int dbOpen = 0;
  }

  //! Instance ID.
-  private Integer tId;
+  private final Integer tId;

  Tester2(Integer id){
    tId = id;
@@ -70,7 +69,7 @@ public class Tester2 implements Runnable {

  public static synchronized void outln(){
    if( !quietMode ){
-      System.out.println("");
+      System.out.println();
    }
  }

@@ -547,7 +546,7 @@ public class Tester2 implements Runnable {
      err = e;
    }
    affirm( err!=null );
-    affirm( err.getMessage().indexOf(toss.value)>=0 );
+    affirm( err.getMessage().contains(toss.value) );
    toss.value = null;

    val.value = 0;
@@ -616,7 +615,7 @@ public class Tester2 implements Runnable {
    final Sqlite db = openDb();
    execSql(db, "CREATE TABLE t(a); INSERT INTO t(a) VALUES('a'),('b'),('c')");
    final Sqlite.Collation myCollation = new Sqlite.Collation() {
-        private String myState =
+        private final String myState =
          "this is local state. There is much like it, but this is mine.";
        @Override
        // Reverse-sorts its inputs...
@@ -1038,9 +1037,9 @@ public class Tester2 implements Runnable {
     -v: emit some developer-mode info at the end.
  */
  public static void main(String[] args) throws Exception {
-    Integer nThread = 1;
+    int nThread = 1;
+    int nRepeat = 1;
    boolean doSomethingForDev = false;
-    Integer nRepeat = 1;
    boolean forceFail = false;
    boolean sqlLog = false;
    boolean configLog = false;
@@ -1097,7 +1096,7 @@ public class Tester2 implements Runnable {
      Sqlite.libConfigLog( new Sqlite.ConfigLog() {
          @Override public void call(int code, String msg){
            outln("ConfigLog: ",Sqlite.errstr(code),": ", msg);
-          };
+          }
        }
      );
    }
@@ -1,7 +1,7 @@
 ## Miscellaneous Extensions

 This folder contains a collection of smaller loadable extensions.
-See <https://www.sqlite.org/loadext.html> for instructions on how
+See <https://sqlite.org/loadext.html> for instructions on how
 to compile and use loadable extensions.
 Each extension in this folder is implemented in a single file of C code.

@@ -10,9 +10,9 @@ header comments for details about each extension.  Additional notes are
 as follows:

  *  **carray.c** &mdash;  This module implements the
-     [carray](https://www.sqlite.org/carray.html) table-valued function.
+     [carray](https://sqlite.org/carray.html) table-valued function.
     It is a good example of how to go about implementing a custom
-     [table-valued function](https://www.sqlite.org/vtab.html#tabfunc2).
+     [table-valued function](https://sqlite.org/vtab.html#tabfunc2).

  *  **csv.c** &mdash;  A [virtual table](https://sqlite.org/vtab.html)
     for reading 
@@ -21,7 +21,7 @@ as follows:
  *  **dbdump.c** &mdash;  This is not actually a loadable extension, but
     rather a library that implements an approximate equivalent to the
     ".dump" command of the
-     [command-line shell](https://www.sqlite.org/cli.html).
+     [command-line shell](https://sqlite.org/cli.html).

  *  **json1.c** &mdash;  Various SQL functions and table-valued functions
     for processing JSON.  This extension is already built into the
@@ -29,7 +29,7 @@ as follows:
     <https://sqlite.org/json1.html> for additional information.

  *  **memvfs.c** &mdash;  This file implements a custom
-     [VFS](https://www.sqlite.org/vfs.html) that stores an entire database
+     [VFS](https://sqlite.org/vfs.html) that stores an entire database
     file in a single block of RAM.  It serves as a good example of how
     to implement a simple custom VFS.

@@ -38,7 +38,7 @@ as follows:
     new custom SQL functions for SQLite.

  *  **series.c** &mdash;  This is an implementation of the
-     "generate_series" [virtual table](https://www.sqlite.org/vtab.html).
+     "generate_series" [virtual table](https://sqlite.org/vtab.html).
     It can make a good template for new custom virtual table implementations.

  *  **shathree.c** &mdash;  An implementation of the sha3() and
@@ -137,7 +137,7 @@
 **       AND closure.idname='groupId'
 **       AND closure.parentname='parentId';
 **
-** See the documentation at http://www.sqlite.org/loadext.html for information
+** See the documentation at http://sqlite.org/loadext.html for information
 ** on how to compile and use loadable extensions such as this one.
 */
 #include "sqlite3ext.h"
@@ -41,6 +41,11 @@ SQLITE_EXTENSION_INIT1

 #ifndef SQLITE_OMIT_VIRTUALTABLE

+#ifndef IsAlnum
+#define IsAlnum(X)  isalnum((unsigned char)X)
+#endif
+
+
 /* completion_vtab is a subclass of sqlite3_vtab which will
 ** serve as the underlying representation of a completion virtual table
 */
@@ -377,7 +382,7 @@ static int completionFilter(
  }
  if( pCur->zLine!=0 && pCur->zPrefix==0 ){
    int i = pCur->nLine;
-    while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){
+    while( i>0 && (IsAlnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){
      i--;
    }
    pCur->nPrefix = pCur->nLine - i;
@@ -27,6 +27,9 @@ SQLITE_EXTENSION_INIT1
 # define UNUSED_PARAMETER(X)  (void)(X)
 #endif

+#ifndef IsSpace
+#define IsSpace(X)  isspace((unsigned char)X)
+#endif

 /* A decimal object */
 typedef struct Decimal Decimal;
@@ -76,7 +79,7 @@ static Decimal *decimalNewFromText(const char *zIn, int n){
  p->nFrac = 0;
  p->a = sqlite3_malloc64( n+1 );
  if( p->a==0 ) goto new_from_text_failed;
-  for(i=0; isspace(zIn[i]); i++){}
+  for(i=0; IsSpace(zIn[i]); i++){}
  if( zIn[i]=='-' ){
    p->sign = 1;
    i++;
@@ -67,6 +67,7 @@
 **     data:  For a regular file, a blob containing the file data. For a
 **            symlink, a text value containing the text of the link. For a
 **            directory, NULL.
+**     level: Directory hierarchy level.  Topmost is 1.
 **
 **   If a non-NULL value is specified for the optional $dir parameter and
 **   $path is a relative path, then $path is interpreted relative to $dir. 
@@ -92,20 +93,13 @@ SQLITE_EXTENSION_INIT1
 #  include <dirent.h>
 #  include <utime.h>
 #  include <sys/time.h>
+#  define STRUCT_STAT struct stat
 #else
-#  include "windows.h"
-#  include <io.h>
+#  include "windirent.h"
 #  include <direct.h>
-#  include "test_windirent.h"
-#  define dirent DIRENT
-#  ifndef chmod
-#    define chmod _chmod
-#  endif
-#  ifndef stat
-#    define stat _stat
-#  endif
-#  define mkdir(path,mode) _mkdir(path)
-#  define lstat(path,buf) stat(path,buf)
+#  define STRUCT_STAT struct _stat
+#  define chmod(path,mode) fileio_chmod(path,mode)
+#  define mkdir(path,mode) fileio_mkdir(path)
 #endif
 #include <time.h>
 #include <errno.h>
@@ -121,14 +115,50 @@ SQLITE_EXTENSION_INIT1
 /*
 ** Structure of the fsdir() table-valued function
 */
-                 /*    0    1    2     3    4           5             */
-#define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"
+                 /*    0    1    2     3    4     5           6          */
+#define FSDIR_SCHEMA "(name,mode,mtime,data,level,path HIDDEN,dir HIDDEN)"
+
 #define FSDIR_COLUMN_NAME     0     /* Name of the file */
 #define FSDIR_COLUMN_MODE     1     /* Access mode */
 #define FSDIR_COLUMN_MTIME    2     /* Last modification time */
 #define FSDIR_COLUMN_DATA     3     /* File content */
-#define FSDIR_COLUMN_PATH     4     /* Path to top of search */
-#define FSDIR_COLUMN_DIR      5     /* Path is relative to this directory */
+#define FSDIR_COLUMN_LEVEL    4     /* Level.  Topmost is 1 */
+#define FSDIR_COLUMN_PATH     5     /* Path to top of search */
+#define FSDIR_COLUMN_DIR      6     /* Path is relative to this directory */
+
+/*
+** UTF8 chmod() function for Windows
+*/
+#if defined(_WIN32) || defined(WIN32)
+static int fileio_chmod(const char *zPath, int pmode){
+  sqlite3_int64 sz = strlen(zPath);
+  wchar_t *b1 = sqlite3_malloc64( (sz+1)*sizeof(b1[0]) );
+  int rc;
+  if( b1==0 ) return -1;
+  sz = MultiByteToWideChar(CP_UTF8, 0, zPath, sz, b1, sz);
+  b1[sz] = 0;
+  rc = _wchmod(b1, pmode);
+  sqlite3_free(b1);
+  return rc;
+}
+#endif
+
+/*
+** UTF8 mkdir() function for Windows
+*/
+#if defined(_WIN32) || defined(WIN32)
+static int fileio_mkdir(const char *zPath){
+  sqlite3_int64 sz = strlen(zPath);
+  wchar_t *b1 = sqlite3_malloc64( (sz+1)*sizeof(b1[0]) );
+  int rc;
+  if( b1==0 ) return -1;
+  sz = MultiByteToWideChar(CP_UTF8, 0, zPath, sz, b1, sz);
+  b1[sz] = 0;
+  rc = _wmkdir(b1);
+  sqlite3_free(b1);
+  return rc;
+}
+#endif


 /*
@@ -260,7 +290,7 @@ LPWSTR utf8_to_utf16(const char *z){
 */
 static void statTimesToUtc(
  const char *zPath,
-  struct stat *pStatBuf
+  STRUCT_STAT *pStatBuf
 ){
  HANDLE hFindFile;
  WIN32_FIND_DATAW fd;
@@ -288,10 +318,16 @@ static void statTimesToUtc(
 */
 static int fileStat(
  const char *zPath,
-  struct stat *pStatBuf
+  STRUCT_STAT *pStatBuf
 ){
 #if defined(_WIN32)
-  int rc = stat(zPath, pStatBuf);
+  sqlite3_int64 sz = strlen(zPath);
+  wchar_t *b1 = sqlite3_malloc64( (sz+1)*sizeof(b1[0]) );
+  int rc;
+  if( b1==0 ) return 1;
+  sz = MultiByteToWideChar(CP_UTF8, 0, zPath, sz, b1, sz);
+  b1[sz] = 0;
+  rc = _wstat(b1, pStatBuf);
  if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
  return rc;
 #else
@@ -306,12 +342,10 @@ static int fileStat(
 */
 static int fileLinkStat(
  const char *zPath,
-  struct stat *pStatBuf
+  STRUCT_STAT *pStatBuf
 ){
 #if defined(_WIN32)
-  int rc = lstat(zPath, pStatBuf);
-  if( rc==0 ) statTimesToUtc(zPath, pStatBuf);
-  return rc;
+  return fileStat(zPath, pStatBuf);
 #else
  return lstat(zPath, pStatBuf);
 #endif
@@ -341,7 +375,7 @@ static int makeDirectory(
    int i = 1;

    while( rc==SQLITE_OK ){
-      struct stat sStat;
+      STRUCT_STAT sStat;
      int rc2;

      for(; zCopy[i]!='/' && i<nCopy; i++);
@@ -391,7 +425,7 @@ static int writeFile(
        ** be an error though - if there is already a directory at the same
        ** path and either the permissions already match or can be changed
        ** to do so using chmod(), it is not an error.  */
-        struct stat sStat;
+        STRUCT_STAT sStat;
        if( errno!=EEXIST
         || 0!=fileStat(zFile, &sStat)
         || !S_ISDIR(sStat.st_mode)
@@ -587,13 +621,14 @@ struct fsdir_cursor {
  sqlite3_vtab_cursor base;  /* Base class - must be first */

  int nLvl;                  /* Number of entries in aLvl[] array */
+  int mxLvl;                 /* Maximum level */
  int iLvl;                  /* Index of current entry */
  FsdirLevel *aLvl;          /* Hierarchy of directories being traversed */

  const char *zBase;
  int nBase;

-  struct stat sStat;         /* Current lstat() results */
+  STRUCT_STAT sStat;         /* Current lstat() results */
  char *zPath;               /* Path to current entry */
  sqlite3_int64 iRowid;      /* Current rowid */
 };
@@ -705,7 +740,7 @@ static int fsdirNext(sqlite3_vtab_cursor *cur){
  mode_t m = pCur->sStat.st_mode;

  pCur->iRowid++;
-  if( S_ISDIR(m) ){
+  if( S_ISDIR(m) && pCur->iLvl+3<pCur->mxLvl ){
    /* Descend into this directory */
    int iNew = pCur->iLvl + 1;
    FsdirLevel *pLvl;
@@ -813,7 +848,11 @@ static int fsdirColumn(
      }else{
        readFileContents(ctx, pCur->zPath);
      }
+      break;
    }
+    case FSDIR_COLUMN_LEVEL:
+      sqlite3_result_int(ctx, pCur->iLvl+2);
+      break;
    case FSDIR_COLUMN_PATH:
    default: {
      /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters.
@@ -847,8 +886,11 @@ static int fsdirEof(sqlite3_vtab_cursor *cur){
 /*
 ** xFilter callback.
 **
-** idxNum==1   PATH parameter only
-** idxNum==2   Both PATH and DIR supplied
+** idxNum bit      Meaning
+**     0x01         PATH=N
+**     0x02         DIR=N
+**     0x04         LEVEL<N
+**     0x08         LEVEL<=N  
 */
 static int fsdirFilter(
  sqlite3_vtab_cursor *cur, 
@@ -857,6 +899,7 @@ static int fsdirFilter(
 ){
  const char *zDir = 0;
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
+  int i;
  (void)idxStr;
  fsdirResetCursor(pCur);

@@ -865,14 +908,24 @@ static int fsdirFilter(
    return SQLITE_ERROR;
  }

-  assert( argc==idxNum && (argc==1 || argc==2) );
+  assert( (idxNum & 0x01)!=0 && argc>0 );
  zDir = (const char*)sqlite3_value_text(argv[0]);
  if( zDir==0 ){
    fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument");
    return SQLITE_ERROR;
  }
-  if( argc==2 ){
-    pCur->zBase = (const char*)sqlite3_value_text(argv[1]);
+  i = 1;
+  if( (idxNum & 0x02)!=0 ){
+    assert( argc>i );
+    pCur->zBase = (const char*)sqlite3_value_text(argv[i++]);
+  }
+  if( (idxNum & 0x0c)!=0 ){
+    assert( argc>i );
+    pCur->mxLvl = sqlite3_value_int(argv[i++]);
+    if( idxNum & 0x08 ) pCur->mxLvl++;
+    if( pCur->mxLvl<=0 ) pCur->mxLvl = 1000000000;
+  }else{
+    pCur->mxLvl = 1000000000;
  }
  if( pCur->zBase ){
    pCur->nBase = (int)strlen(pCur->zBase)+1;
@@ -901,10 +954,11 @@ static int fsdirFilter(
 ** In this implementation idxNum is used to represent the
 ** query plan.  idxStr is unused.
 **
-** The query plan is represented by values of idxNum:
+** The query plan is represented by bits in idxNum:
 **
-**  (1)  The path value is supplied by argv[0]
-**  (2)  Path is in argv[0] and dir is in argv[1]
+**  0x01  The path value is supplied by argv[0]
+**  0x02  dir is in argv[1]
+**  0x04  maxdepth is in argv[1] or [2]
 */
 static int fsdirBestIndex(
  sqlite3_vtab *tab,
@@ -913,6 +967,9 @@ static int fsdirBestIndex(
  int i;                 /* Loop over constraints */
  int idxPath = -1;      /* Index in pIdxInfo->aConstraint of PATH= */
  int idxDir = -1;       /* Index in pIdxInfo->aConstraint of DIR= */
+  int idxLevel = -1;     /* Index in pIdxInfo->aConstraint of LEVEL< or <= */
+  int idxLevelEQ = 0;    /* 0x08 for LEVEL<= or LEVEL=.  0x04 for LEVEL< */
+  int omitLevel = 0;     /* omit the LEVEL constraint */
  int seenPath = 0;      /* True if an unusable PATH= constraint is seen */
  int seenDir = 0;       /* True if an unusable DIR= constraint is seen */
  const struct sqlite3_index_constraint *pConstraint;
@@ -920,25 +977,48 @@ static int fsdirBestIndex(
  (void)tab;
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
-    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
-    switch( pConstraint->iColumn ){
-      case FSDIR_COLUMN_PATH: {
-        if( pConstraint->usable ){
-          idxPath = i;
-          seenPath = 0;
-        }else if( idxPath<0 ){
-          seenPath = 1;
+    if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){
+      switch( pConstraint->iColumn ){
+        case FSDIR_COLUMN_PATH: {
+          if( pConstraint->usable ){
+            idxPath = i;
+            seenPath = 0;
+          }else if( idxPath<0 ){
+            seenPath = 1;
+          }
+          break;
+        }
+        case FSDIR_COLUMN_DIR: {
+          if( pConstraint->usable ){
+            idxDir = i;
+            seenDir = 0;
+          }else if( idxDir<0 ){
+            seenDir = 1;
+          }
+          break;
+        }
+        case FSDIR_COLUMN_LEVEL: {
+          if( pConstraint->usable && idxLevel<0 ){
+            idxLevel = i;
+            idxLevelEQ = 0x08;
+            omitLevel = 0;
+          }
+          break;
        }
-        break;
      }
-      case FSDIR_COLUMN_DIR: {
-        if( pConstraint->usable ){
-          idxDir = i;
-          seenDir = 0;
-        }else if( idxDir<0 ){
-          seenDir = 1;
-        }
-        break;
+    }else
+    if( pConstraint->iColumn==FSDIR_COLUMN_LEVEL
+     && pConstraint->usable
+     && idxLevel<0
+    ){
+      if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_LE ){
+        idxLevel = i;
+        idxLevelEQ = 0x08;
+        omitLevel = 1;
+      }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_LT ){
+        idxLevel = i;
+        idxLevelEQ = 0x04;
+        omitLevel = 1;
      }
    } 
  }
@@ -955,14 +1035,20 @@ static int fsdirBestIndex(
  }else{
    pIdxInfo->aConstraintUsage[idxPath].omit = 1;
    pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1;
+    pIdxInfo->idxNum = 0x01;
+    pIdxInfo->estimatedCost = 1.0e9;
+    i = 2;
    if( idxDir>=0 ){
      pIdxInfo->aConstraintUsage[idxDir].omit = 1;
-      pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2;
-      pIdxInfo->idxNum = 2;
-      pIdxInfo->estimatedCost = 10.0;
-    }else{
-      pIdxInfo->idxNum = 1;
-      pIdxInfo->estimatedCost = 100.0;
+      pIdxInfo->aConstraintUsage[idxDir].argvIndex = i++;
+      pIdxInfo->idxNum |= 0x02;
+      pIdxInfo->estimatedCost /= 1.0e4;
+    }
+    if( idxLevel>=0 ){
+      pIdxInfo->aConstraintUsage[idxLevel].omit = omitLevel;
+      pIdxInfo->aConstraintUsage[idxLevel].argvIndex = i++;
+      pIdxInfo->idxNum |= idxLevelEQ;
+      pIdxInfo->estimatedCost /= 1.0e4;
    }
  }

@@ -22,7 +22,7 @@
 ** The delta format is the Fossil delta format, described in a comment
 ** on the delete_create() function implementation below, and also at
 **
-**    https://www.fossil-scm.org/fossil/doc/trunk/www/delta_format.wiki
+**    https://fossil-scm.org/fossil/doc/trunk/www/delta_format.wiki
 **
 ** This delta format is used by the RBU extension, which is the main
 ** reason that these routines are included in the extension library.
@@ -401,8 +401,14 @@ static sqlite3_module memstatModule = {

 #endif /* SQLITE_OMIT_VIRTUALTABLE */

-int sqlite3MemstatVtabInit(sqlite3 *db){
+int sqlite3MemstatVtabInit(
+  sqlite3 *db,
+  char **NotUsed1,
+  const sqlite3_api_routines *NotUsed2
+){
  int rc = SQLITE_OK;
+  (void)NotUsed1;
+  (void)NotUsed2;
 #ifndef SQLITE_OMIT_VIRTUALTABLE
  rc = sqlite3_create_module(db, "sqlite_memstat", &memstatModule, 0);
 #endif
@@ -421,7 +427,7 @@ int sqlite3_memstat_init(
  int rc = SQLITE_OK;
  SQLITE_EXTENSION_INIT2(pApi);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-  rc = sqlite3MemstatVtabInit(db);
+  rc = sqlite3MemstatVtabInit(db, 0, 0);
 #endif
  return rc;
 }
@@ -60,8 +60,7 @@
 **       step HIDDEN
 **     );
 **
-** The virtual table also has a rowid, logically equivalent to n+1 where
-** "n" is the ascending integer in the aforesaid production definition.
+** The virtual table also has a rowid which is an alias for the value.
 **
 ** Function arguments in queries against this virtual table are translated
 ** into equality constraints against successive hidden columns.  In other
@@ -116,6 +115,7 @@ SQLITE_EXTENSION_INIT1
 #include <assert.h>
 #include <string.h>
 #include <limits.h>
+#include <math.h>

 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /*
@@ -276,6 +276,7 @@ static int seriesConnect(
  int rc;

 /* Column numbers */
+#define SERIES_COLUMN_ROWID (-1)
 #define SERIES_COLUMN_VALUE 0
 #define SERIES_COLUMN_START 1
 #define SERIES_COLUMN_STOP  2
@@ -363,13 +364,11 @@ static int seriesColumn(
 #endif

 /*
-** Return the rowid for the current row, logically equivalent to n+1 where
-** "n" is the ascending integer in the aforesaid production definition.
+** The rowid is the same as the value.
 */
 static int seriesRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
  series_cursor *pCur = (series_cursor*)cur;
-  sqlite3_uint64 n = pCur->ss.uSeqIndexNow;
-  *pRowid = (sqlite3_int64)((n<LARGEST_UINT64)? n+1 : 0);
+  *pRowid = pCur->ss.iValueNow;
  return SQLITE_OK;
 }

@@ -482,25 +481,52 @@ static int seriesFilter(
    ** constraints on the "value" column.
    */
    if( idxNum & 0x0080 ){
-      iMin = iMax = sqlite3_value_int64(argv[i++]);
+      if( sqlite3_value_numeric_type(argv[i])==SQLITE_FLOAT ){
+        double r = sqlite3_value_double(argv[i++]);
+        if( r==ceil(r) ){
+          iMin = iMax = (sqlite3_int64)r;
+        }else{
+          returnNoRows = 1;
+        }
+      }else{
+        iMin = iMax = sqlite3_value_int64(argv[i++]);
+      }
    }else{
      if( idxNum & 0x0300 ){
-        iMin = sqlite3_value_int64(argv[i++]);
-        if( idxNum & 0x0200 ){
-          if( iMin==LARGEST_INT64 ){
-            returnNoRows = 1;
+        if( sqlite3_value_numeric_type(argv[i])==SQLITE_FLOAT ){
+          double r = sqlite3_value_double(argv[i++]);
+          if( idxNum & 0x0200 && r==ceil(r) ){
+            iMin = (sqlite3_int64)ceil(r+1.0);
          }else{
-            iMin++;
+            iMin = (sqlite3_int64)ceil(r);
+          }
+        }else{
+          iMin = sqlite3_value_int64(argv[i++]);
+          if( idxNum & 0x0200 ){
+            if( iMin==LARGEST_INT64 ){
+              returnNoRows = 1;
+            }else{
+              iMin++;
+            }
          }
        }
      }
      if( idxNum & 0x3000 ){
-        iMax = sqlite3_value_int64(argv[i++]);
-        if( idxNum & 0x2000 ){
-          if( iMax==SMALLEST_INT64 ){
-            returnNoRows = 1;
+        if( sqlite3_value_numeric_type(argv[i])==SQLITE_FLOAT ){
+          double r = sqlite3_value_double(argv[i++]);
+          if( (idxNum & 0x2000)!=0 && r==floor(r) ){
+            iMax = (sqlite3_int64)(r-1.0);
          }else{
-            iMax--;
+            iMax = (sqlite3_int64)floor(r);
+          }
+        }else{
+          iMax = sqlite3_value_int64(argv[i++]);
+          if( idxNum & 0x2000 ){
+            if( iMax==SMALLEST_INT64 ){
+              returnNoRows = 1;
+            }else{
+              iMax--;
+            }
          }
        }
      }
@@ -519,8 +545,7 @@ static int seriesFilter(
        pCur->ss.iBase += ((d+szStep-1)/szStep)*szStep;
      }
      if( pCur->ss.iTerm>iMax ){
-        sqlite3_uint64 d = pCur->ss.iTerm - iMax;
-        pCur->ss.iTerm -= ((d+szStep-1)/szStep)*szStep;
+        pCur->ss.iTerm = iMax;
      }
    }else{
      sqlite3_int64 szStep = -pCur->ss.iStep;
@@ -530,8 +555,7 @@ static int seriesFilter(
        pCur->ss.iBase -= ((d+szStep-1)/szStep)*szStep;
      }
      if( pCur->ss.iTerm<iMin ){
-        sqlite3_uint64 d = iMin - pCur->ss.iTerm;
-        pCur->ss.iTerm += ((d+szStep-1)/szStep)*szStep;
+        pCur->ss.iTerm = iMin;
      }
    }
  }
@@ -556,7 +580,7 @@ static int seriesFilter(
  for(i=0; i<argc; i++){
    if( sqlite3_value_type(argv[i])==SQLITE_NULL ){
      /* If any of the constraints have a NULL value, then return no rows.
-      ** See ticket https://www.sqlite.org/src/info/fac496b61722daf2 */
+      ** See ticket https://sqlite.org/src/info/fac496b61722daf2 */
      returnNoRows = 1;
      break;
    }
@@ -659,7 +683,10 @@ static int seriesBestIndex(
      continue;
    }
    if( pConstraint->iColumn<SERIES_COLUMN_START ){
-      if( pConstraint->iColumn==SERIES_COLUMN_VALUE && pConstraint->usable ){
+      if( (pConstraint->iColumn==SERIES_COLUMN_VALUE ||
+           pConstraint->iColumn==SERIES_COLUMN_ROWID)
+       && pConstraint->usable
+      ){
        switch( op ){
          case SQLITE_INDEX_CONSTRAINT_EQ:
          case SQLITE_INDEX_CONSTRAINT_IS: {
@@ -12,7 +12,7 @@
 **
 ** This module implements the spellfix1 VIRTUAL TABLE that can be used
 ** to search a large vocabulary for close matches.  See separate
-** documentation (http://www.sqlite.org/spellfix1.html) for details.
+** documentation (http://sqlite.org/spellfix1.html) for details.
 */
 #include "sqlite3ext.h"
 SQLITE_EXTENSION_INIT1
@@ -22,7 +22,7 @@ SQLITE_EXTENSION_INIT1
 ** most VFS calls to be recorded.
 **
 ** To use this module, first compile it as a loadable extension.  See
-** https://www.sqlite.org/loadext.html#build for compilations instructions.
+** https://sqlite.org/loadext.html#build for compilations instructions.
 **
 ** After compiling, load this extension, then open database connections to be
 ** measured.  Query usages status using the vfsstat virtual table:
@@ -581,7 +581,7 @@ static int vfstraceFileControl(sqlite3_file *pFile, int op, void *pArg){
      const char *const* a = (const char*const*)pArg;
      if( a[1] && strcmp(a[1],"vfstrace")==0 && a[2] ){
        const u8 *zArg = (const u8*)a[2];
-        if( zArg[0]>='0' && zArg[0]<=9 ){
+        if( zArg[0]>='0' && zArg[0]<='9' ){
          pInfo->mTrace = (sqlite3_uint64)strtoll(a[2], 0, 0);
        }else{
          static const struct {
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .50.0
 .51.0