[nongnu] elpa/sqlite3 0bae137c63 26/62: LIB and INC added to Makefile

[ELPA Syncer]

branch: elpa/sqlite3
commit 0bae137c639d453d152956f19dbce0164ab663e9
Author: Y. N. Lo <gordonynlo@yahoo.com>
Commit: Y. N. Lo <gordonynlo@yahoo.com>

    LIB and INC added to Makefile
---
 .gitignore              |   1 -
 Makefile                |  23 ++--
 README-in.md            |  13 +-
 README.md               |  13 +-
 consts.c                | 358 ++++++++++++++++++++++++++++++++++++++++++++++++
 tests/regression.el     |   2 -
 tools/find-sqlite3-h.sh |   3 +-
 7 files changed, 393 insertions(+), 20 deletions(-)

diff --git a/.gitignore b/.gitignore
index 239bfd03e3..b770ade4ff 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,5 @@
 *.so
 **/.DS_Store
 sqlite3-napi-module-with-create-function.c
-consts.c
 xxx.el
 **/sqlite3-api-*
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 5882d6bafe..ac979abd22 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,11 @@
 CC = gcc
-CFLAGS = -g3 -Wall -std=c99
+INC=-I.
+LIB=-lsqlite3
+CFLAGS=-g3 -Wall -std=c99 $(INC)
+
 EMACS252=$(HOME)/test-emacs/bin/emacs
 EMACS251=$(HOME)/test-emacs-251/bin/emacs
-SQLITE3_H=$(shell tools/find-sqlite3-h.sh)
+SQLITE3_H=$(shell tools/find-sqlite3-h.sh $(INC))
 
 # Melpa package
 PKG=sqlite3-api
@@ -14,14 +17,14 @@ MODULE_BASENAME=$(MODULE)-$(MODULE_VERSION)
 MODULE_PKG_EL=$(MODULE_BASENAME)/$(MODULE)-pkg.el
 MODULE_TAR=$(MODULE_BASENAME).tar
 
-all: consts.c $(MODULE).so 
+all: $(MODULE).so 
 
 clean:
-       rm -rf *.so *.o *.tar consts.c $(MODULE_BASENAME)
+       rm -rf *.so *.o *.tar $(MODULE_BASENAME)
 
 # File "MODULE" is read by (sqlite3-api-install-dynamic-module)
 # during installation
-module: consts.c $(MODULE).so 
+module: $(MODULE).so 
        mkdir -p $(MODULE_BASENAME)
        cp $(MODULE).so $(MODULE_BASENAME)
        echo "(define-package \"$(MODULE)\" \"$(MODULE_VERSION)\" \"SQLite3 API 
dynamic module\")" > $(MODULE_PKG_EL)
@@ -30,19 +33,19 @@ module: consts.c $(MODULE).so
 install: module
        emacsclient -e '(package-install-file "$(MODULE_TAR)")'
 
-consts.c: $(SQLITE_H)
-       grep "^#define SQLITE" $(SQLITE3_H) | tools/gen-consts.py > $@
+#consts.c: $(SQLITE_H)
+#      grep "^#define SQLITE" $(SQLITE3_H) | tools/gen-consts.py > $@
 
 %.so: %.o
-       $(CC) -shared -o $@ $< -lsqlite3
+       $(CC) -shared -o $@ $< $(LIB)
 
 %.o: %.c
        $(CC) $(CFLAGS) -fPIC -c $<
 
 # Emacs 25.2
 test:
-       $(EMACS252) -batch -Q -l tests/regression.el
+       $(EMACS252) -batch -Q -L . -l tests/regression.el
 
 # Emacs 25.1
 t251:
-       $(EMACS251) -batch -Q -l tests/regression.el
+       $(EMACS251) -batch -Q -L . -l tests/regression.el
diff --git a/README-in.md b/README-in.md
index ffbf18cd9d..6ebdc8f24d 100644
--- a/README-in.md
+++ b/README-in.md
@@ -1,4 +1,4 @@
-# SQLite3 API for Emacs 25+
+# SQLite3 API v0.1 for Emacs 25+
 `sqlite3-api` is a dynamic module for GNU Emacs 25+ that provides 
 direct access to the core SQLite3 C API from Emacs Lisp.
 ~~~el
@@ -25,6 +25,8 @@ direct access to the core SQLite3 C API from Emacs Lisp.
 While this module provides only 14 functions (vs [200+ in the C 
API](https://sqlite.org/c3ref/funclist.html)), it should satisfy most
 users' needs.
 
+The current version is 0.1.
+
 This is an alpha release so it might crash your Emacs. Save your work before 
you try it out!
 
 <<TOC>>
@@ -50,6 +52,10 @@ $ make module
 A tar archive called `sqlite3-api-X.Y.tar` will be created. Do a `M-x 
package-install-file` in Emacs to install that tar archive and 
 you'll all set.
 -->
+If you have sqlite3 installed in a nonstandard location, you can do
+~~~sh
+$ make INC=/path/to/sqlite3/include LIB="-L/path/to/sqlite3/lib -lsqlite3"
+~~~
 Currently there's no way to reload a dynamic module in Emacs
 (`unload-feature` doesn't seem to work for dynamic modules.)
 If you are updating from an older version, you'll need to restart Emacs
@@ -287,9 +293,10 @@ For integers > 61 bits you can retrieve them as text as a 
workaround.
 The code is licensed under the [GNU GPL 
v3](https://www.gnu.org/licenses/gpl-3.0.html).
 
 ## Changelog
-*2017-09-04*
+*v0.1 - 2017-09-04*
 - Emacs Lisp code removed. The package is now pure C.
-*2017-08-29*
+
+*v0.0 - 2017-08-29*
 - Fixed a memory leak in `sql_api_exec()`
 - Changed `sqlite3_close()` to `sqlite3_close_v2()` in `sqlite_api_close()`
 - Better error handling: Error code is returned along with error message
diff --git a/README.md b/README.md
index a05aab8f75..eb0a4befb1 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# SQLite3 API for Emacs 25+
+# SQLite3 API v0.1 for Emacs 25+
 `sqlite3-api` is a dynamic module for GNU Emacs 25+ that provides 
 direct access to the core SQLite3 C API from Emacs Lisp.
 ~~~el
@@ -25,6 +25,8 @@ direct access to the core SQLite3 C API from Emacs Lisp.
 While this module provides only 14 functions (vs [200+ in the C 
API](https://sqlite.org/c3ref/funclist.html)), it should satisfy most
 users' needs.
 
+The current version is 0.1.
+
 This is an alpha release so it might crash your Emacs. Save your work before 
you try it out!
 
 ## Table of Contents
@@ -75,6 +77,10 @@ $ make module
 A tar archive called `sqlite3-api-X.Y.tar` will be created. Do a `M-x 
package-install-file` in Emacs to install that tar archive and 
 you'll all set.
 -->
+If you have sqlite3 installed in a nonstandard location, you can do
+~~~sh
+$ make INC=/path/to/sqlite3/include LIB="-L/path/to/sqlite3/lib -lsqlite3"
+~~~
 Currently there's no way to reload a dynamic module in Emacs
 (`unload-feature` doesn't seem to work for dynamic modules.)
 If you are updating from an older version, you'll need to restart Emacs
@@ -312,9 +318,10 @@ For integers > 61 bits you can retrieve them as text as a 
workaround.
 The code is licensed under the [GNU GPL 
v3](https://www.gnu.org/licenses/gpl-3.0.html).
 
 ## <a name="9"/> Changelog
-*2017-09-04*
+*v0.1 - 2017-09-04*
 - Emacs Lisp code removed. The package is now pure C.
-*2017-08-29*
+
+*v0.0 - 2017-08-29*
 - Fixed a memory leak in `sql_api_exec()`
 - Changed `sqlite3_close()` to `sqlite3_close_v2()` in `sqlite_api_close()`
 - Better error handling: Error code is returned along with error message
diff --git a/consts.c b/consts.c
new file mode 100644
index 0000000000..271f50424e
--- /dev/null
+++ b/consts.c
@@ -0,0 +1,358 @@
+defconst(env, "sqlite-ok", env->make_integer(env, SQLITE_OK));
+defconst(env, "sqlite-error", env->make_integer(env, SQLITE_ERROR));
+defconst(env, "sqlite-internal", env->make_integer(env, SQLITE_INTERNAL));
+defconst(env, "sqlite-perm", env->make_integer(env, SQLITE_PERM));
+defconst(env, "sqlite-abort", env->make_integer(env, SQLITE_ABORT));
+defconst(env, "sqlite-busy", env->make_integer(env, SQLITE_BUSY));
+defconst(env, "sqlite-locked", env->make_integer(env, SQLITE_LOCKED));
+defconst(env, "sqlite-nomem", env->make_integer(env, SQLITE_NOMEM));
+defconst(env, "sqlite-readonly", env->make_integer(env, SQLITE_READONLY));
+defconst(env, "sqlite-interrupt", env->make_integer(env, SQLITE_INTERRUPT));
+defconst(env, "sqlite-ioerr", env->make_integer(env, SQLITE_IOERR));
+defconst(env, "sqlite-corrupt", env->make_integer(env, SQLITE_CORRUPT));
+defconst(env, "sqlite-notfound", env->make_integer(env, SQLITE_NOTFOUND));
+defconst(env, "sqlite-full", env->make_integer(env, SQLITE_FULL));
+defconst(env, "sqlite-cantopen", env->make_integer(env, SQLITE_CANTOPEN));
+defconst(env, "sqlite-protocol", env->make_integer(env, SQLITE_PROTOCOL));
+defconst(env, "sqlite-empty", env->make_integer(env, SQLITE_EMPTY));
+defconst(env, "sqlite-schema", env->make_integer(env, SQLITE_SCHEMA));
+defconst(env, "sqlite-toobig", env->make_integer(env, SQLITE_TOOBIG));
+defconst(env, "sqlite-constraint", env->make_integer(env, SQLITE_CONSTRAINT));
+defconst(env, "sqlite-mismatch", env->make_integer(env, SQLITE_MISMATCH));
+defconst(env, "sqlite-misuse", env->make_integer(env, SQLITE_MISUSE));
+defconst(env, "sqlite-nolfs", env->make_integer(env, SQLITE_NOLFS));
+defconst(env, "sqlite-auth", env->make_integer(env, SQLITE_AUTH));
+defconst(env, "sqlite-format", env->make_integer(env, SQLITE_FORMAT));
+defconst(env, "sqlite-range", env->make_integer(env, SQLITE_RANGE));
+defconst(env, "sqlite-notadb", env->make_integer(env, SQLITE_NOTADB));
+defconst(env, "sqlite-notice", env->make_integer(env, SQLITE_NOTICE));
+defconst(env, "sqlite-warning", env->make_integer(env, SQLITE_WARNING));
+defconst(env, "sqlite-row", env->make_integer(env, SQLITE_ROW));
+defconst(env, "sqlite-done", env->make_integer(env, SQLITE_DONE));
+defconst(env, "sqlite-ioerr-read", env->make_integer(env, SQLITE_IOERR_READ));
+defconst(env, "sqlite-ioerr-short-read", env->make_integer(env, 
SQLITE_IOERR_SHORT_READ));
+defconst(env, "sqlite-ioerr-write", env->make_integer(env, 
SQLITE_IOERR_WRITE));
+defconst(env, "sqlite-ioerr-fsync", env->make_integer(env, 
SQLITE_IOERR_FSYNC));
+defconst(env, "sqlite-ioerr-dir-fsync", env->make_integer(env, 
SQLITE_IOERR_DIR_FSYNC));
+defconst(env, "sqlite-ioerr-truncate", env->make_integer(env, 
SQLITE_IOERR_TRUNCATE));
+defconst(env, "sqlite-ioerr-fstat", env->make_integer(env, 
SQLITE_IOERR_FSTAT));
+defconst(env, "sqlite-ioerr-unlock", env->make_integer(env, 
SQLITE_IOERR_UNLOCK));
+defconst(env, "sqlite-ioerr-rdlock", env->make_integer(env, 
SQLITE_IOERR_RDLOCK));
+defconst(env, "sqlite-ioerr-delete", env->make_integer(env, 
SQLITE_IOERR_DELETE));
+defconst(env, "sqlite-ioerr-blocked", env->make_integer(env, 
SQLITE_IOERR_BLOCKED));
+defconst(env, "sqlite-ioerr-nomem", env->make_integer(env, 
SQLITE_IOERR_NOMEM));
+defconst(env, "sqlite-ioerr-access", env->make_integer(env, 
SQLITE_IOERR_ACCESS));
+defconst(env, "sqlite-ioerr-checkreservedlock", env->make_integer(env, 
SQLITE_IOERR_CHECKRESERVEDLOCK));
+defconst(env, "sqlite-ioerr-lock", env->make_integer(env, SQLITE_IOERR_LOCK));
+defconst(env, "sqlite-ioerr-close", env->make_integer(env, 
SQLITE_IOERR_CLOSE));
+defconst(env, "sqlite-ioerr-dir-close", env->make_integer(env, 
SQLITE_IOERR_DIR_CLOSE));
+defconst(env, "sqlite-ioerr-shmopen", env->make_integer(env, 
SQLITE_IOERR_SHMOPEN));
+defconst(env, "sqlite-ioerr-shmsize", env->make_integer(env, 
SQLITE_IOERR_SHMSIZE));
+defconst(env, "sqlite-ioerr-shmlock", env->make_integer(env, 
SQLITE_IOERR_SHMLOCK));
+defconst(env, "sqlite-ioerr-shmmap", env->make_integer(env, 
SQLITE_IOERR_SHMMAP));
+defconst(env, "sqlite-ioerr-seek", env->make_integer(env, SQLITE_IOERR_SEEK));
+defconst(env, "sqlite-ioerr-delete-noent", env->make_integer(env, 
SQLITE_IOERR_DELETE_NOENT));
+defconst(env, "sqlite-ioerr-mmap", env->make_integer(env, SQLITE_IOERR_MMAP));
+defconst(env, "sqlite-ioerr-gettemppath", env->make_integer(env, 
SQLITE_IOERR_GETTEMPPATH));
+defconst(env, "sqlite-ioerr-convpath", env->make_integer(env, 
SQLITE_IOERR_CONVPATH));
+defconst(env, "sqlite-ioerr-vnode", env->make_integer(env, 
SQLITE_IOERR_VNODE));
+defconst(env, "sqlite-ioerr-auth", env->make_integer(env, SQLITE_IOERR_AUTH));
+defconst(env, "sqlite-locked-sharedcache", env->make_integer(env, 
SQLITE_LOCKED_SHAREDCACHE));
+defconst(env, "sqlite-busy-recovery", env->make_integer(env, 
SQLITE_BUSY_RECOVERY));
+defconst(env, "sqlite-busy-snapshot", env->make_integer(env, 
SQLITE_BUSY_SNAPSHOT));
+defconst(env, "sqlite-cantopen-notempdir", env->make_integer(env, 
SQLITE_CANTOPEN_NOTEMPDIR));
+defconst(env, "sqlite-cantopen-isdir", env->make_integer(env, 
SQLITE_CANTOPEN_ISDIR));
+defconst(env, "sqlite-cantopen-fullpath", env->make_integer(env, 
SQLITE_CANTOPEN_FULLPATH));
+defconst(env, "sqlite-cantopen-convpath", env->make_integer(env, 
SQLITE_CANTOPEN_CONVPATH));
+defconst(env, "sqlite-corrupt-vtab", env->make_integer(env, 
SQLITE_CORRUPT_VTAB));
+defconst(env, "sqlite-readonly-recovery", env->make_integer(env, 
SQLITE_READONLY_RECOVERY));
+defconst(env, "sqlite-readonly-cantlock", env->make_integer(env, 
SQLITE_READONLY_CANTLOCK));
+defconst(env, "sqlite-readonly-rollback", env->make_integer(env, 
SQLITE_READONLY_ROLLBACK));
+defconst(env, "sqlite-readonly-dbmoved", env->make_integer(env, 
SQLITE_READONLY_DBMOVED));
+defconst(env, "sqlite-abort-rollback", env->make_integer(env, 
SQLITE_ABORT_ROLLBACK));
+defconst(env, "sqlite-constraint-check", env->make_integer(env, 
SQLITE_CONSTRAINT_CHECK));
+defconst(env, "sqlite-constraint-commithook", env->make_integer(env, 
SQLITE_CONSTRAINT_COMMITHOOK));
+defconst(env, "sqlite-constraint-foreignkey", env->make_integer(env, 
SQLITE_CONSTRAINT_FOREIGNKEY));
+defconst(env, "sqlite-constraint-function", env->make_integer(env, 
SQLITE_CONSTRAINT_FUNCTION));
+defconst(env, "sqlite-constraint-notnull", env->make_integer(env, 
SQLITE_CONSTRAINT_NOTNULL));
+defconst(env, "sqlite-constraint-primarykey", env->make_integer(env, 
SQLITE_CONSTRAINT_PRIMARYKEY));
+defconst(env, "sqlite-constraint-trigger", env->make_integer(env, 
SQLITE_CONSTRAINT_TRIGGER));
+defconst(env, "sqlite-constraint-unique", env->make_integer(env, 
SQLITE_CONSTRAINT_UNIQUE));
+defconst(env, "sqlite-constraint-vtab", env->make_integer(env, 
SQLITE_CONSTRAINT_VTAB));
+defconst(env, "sqlite-constraint-rowid", env->make_integer(env, 
SQLITE_CONSTRAINT_ROWID));
+defconst(env, "sqlite-notice-recover-wal", env->make_integer(env, 
SQLITE_NOTICE_RECOVER_WAL));
+defconst(env, "sqlite-notice-recover-rollback", env->make_integer(env, 
SQLITE_NOTICE_RECOVER_ROLLBACK));
+defconst(env, "sqlite-warning-autoindex", env->make_integer(env, 
SQLITE_WARNING_AUTOINDEX));
+defconst(env, "sqlite-auth-user", env->make_integer(env, SQLITE_AUTH_USER));
+defconst(env, "sqlite-ok-load-permanently", env->make_integer(env, 
SQLITE_OK_LOAD_PERMANENTLY));
+defconst(env, "sqlite-open-readonly", env->make_integer(env, 
SQLITE_OPEN_READONLY));
+defconst(env, "sqlite-open-readwrite", env->make_integer(env, 
SQLITE_OPEN_READWRITE));
+defconst(env, "sqlite-open-create", env->make_integer(env, 
SQLITE_OPEN_CREATE));
+defconst(env, "sqlite-open-deleteonclose", env->make_integer(env, 
SQLITE_OPEN_DELETEONCLOSE));
+defconst(env, "sqlite-open-exclusive", env->make_integer(env, 
SQLITE_OPEN_EXCLUSIVE));
+defconst(env, "sqlite-open-autoproxy", env->make_integer(env, 
SQLITE_OPEN_AUTOPROXY));
+defconst(env, "sqlite-open-uri", env->make_integer(env, SQLITE_OPEN_URI));
+defconst(env, "sqlite-open-memory", env->make_integer(env, 
SQLITE_OPEN_MEMORY));
+defconst(env, "sqlite-open-main-db", env->make_integer(env, 
SQLITE_OPEN_MAIN_DB));
+defconst(env, "sqlite-open-temp-db", env->make_integer(env, 
SQLITE_OPEN_TEMP_DB));
+defconst(env, "sqlite-open-transient-db", env->make_integer(env, 
SQLITE_OPEN_TRANSIENT_DB));
+defconst(env, "sqlite-open-main-journal", env->make_integer(env, 
SQLITE_OPEN_MAIN_JOURNAL));
+defconst(env, "sqlite-open-temp-journal", env->make_integer(env, 
SQLITE_OPEN_TEMP_JOURNAL));
+defconst(env, "sqlite-open-subjournal", env->make_integer(env, 
SQLITE_OPEN_SUBJOURNAL));
+defconst(env, "sqlite-open-master-journal", env->make_integer(env, 
SQLITE_OPEN_MASTER_JOURNAL));
+defconst(env, "sqlite-open-nomutex", env->make_integer(env, 
SQLITE_OPEN_NOMUTEX));
+defconst(env, "sqlite-open-fullmutex", env->make_integer(env, 
SQLITE_OPEN_FULLMUTEX));
+defconst(env, "sqlite-open-sharedcache", env->make_integer(env, 
SQLITE_OPEN_SHAREDCACHE));
+defconst(env, "sqlite-open-privatecache", env->make_integer(env, 
SQLITE_OPEN_PRIVATECACHE));
+defconst(env, "sqlite-open-wal", env->make_integer(env, SQLITE_OPEN_WAL));
+defconst(env, "sqlite-iocap-atomic", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC));
+defconst(env, "sqlite-iocap-atomic512", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC512));
+defconst(env, "sqlite-iocap-atomic1k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC1K));
+defconst(env, "sqlite-iocap-atomic2k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC2K));
+defconst(env, "sqlite-iocap-atomic4k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC4K));
+defconst(env, "sqlite-iocap-atomic8k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC8K));
+defconst(env, "sqlite-iocap-atomic16k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC16K));
+defconst(env, "sqlite-iocap-atomic32k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC32K));
+defconst(env, "sqlite-iocap-atomic64k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC64K));
+defconst(env, "sqlite-iocap-safe-append", env->make_integer(env, 
SQLITE_IOCAP_SAFE_APPEND));
+defconst(env, "sqlite-iocap-sequential", env->make_integer(env, 
SQLITE_IOCAP_SEQUENTIAL));
+defconst(env, "sqlite-iocap-undeletable-when-open", env->make_integer(env, 
SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN));
+defconst(env, "sqlite-iocap-powersafe-overwrite", env->make_integer(env, 
SQLITE_IOCAP_POWERSAFE_OVERWRITE));
+defconst(env, "sqlite-iocap-immutable", env->make_integer(env, 
SQLITE_IOCAP_IMMUTABLE));
+defconst(env, "sqlite-lock-none", env->make_integer(env, SQLITE_LOCK_NONE));
+defconst(env, "sqlite-lock-shared", env->make_integer(env, 
SQLITE_LOCK_SHARED));
+defconst(env, "sqlite-lock-reserved", env->make_integer(env, 
SQLITE_LOCK_RESERVED));
+defconst(env, "sqlite-lock-pending", env->make_integer(env, 
SQLITE_LOCK_PENDING));
+defconst(env, "sqlite-lock-exclusive", env->make_integer(env, 
SQLITE_LOCK_EXCLUSIVE));
+defconst(env, "sqlite-sync-normal", env->make_integer(env, 
SQLITE_SYNC_NORMAL));
+defconst(env, "sqlite-sync-full", env->make_integer(env, SQLITE_SYNC_FULL));
+defconst(env, "sqlite-sync-dataonly", env->make_integer(env, 
SQLITE_SYNC_DATAONLY));
+defconst(env, "sqlite-fcntl-lockstate", env->make_integer(env, 
SQLITE_FCNTL_LOCKSTATE));
+defconst(env, "sqlite-fcntl-get-lockproxyfile", env->make_integer(env, 
SQLITE_FCNTL_GET_LOCKPROXYFILE));
+defconst(env, "sqlite-fcntl-set-lockproxyfile", env->make_integer(env, 
SQLITE_FCNTL_SET_LOCKPROXYFILE));
+defconst(env, "sqlite-fcntl-last-errno", env->make_integer(env, 
SQLITE_FCNTL_LAST_ERRNO));
+defconst(env, "sqlite-fcntl-size-hint", env->make_integer(env, 
SQLITE_FCNTL_SIZE_HINT));
+defconst(env, "sqlite-fcntl-chunk-size", env->make_integer(env, 
SQLITE_FCNTL_CHUNK_SIZE));
+defconst(env, "sqlite-fcntl-file-pointer", env->make_integer(env, 
SQLITE_FCNTL_FILE_POINTER));
+defconst(env, "sqlite-fcntl-sync-omitted", env->make_integer(env, 
SQLITE_FCNTL_SYNC_OMITTED));
+defconst(env, "sqlite-fcntl-win32-av-retry", env->make_integer(env, 
SQLITE_FCNTL_WIN32_AV_RETRY));
+defconst(env, "sqlite-fcntl-persist-wal", env->make_integer(env, 
SQLITE_FCNTL_PERSIST_WAL));
+defconst(env, "sqlite-fcntl-overwrite", env->make_integer(env, 
SQLITE_FCNTL_OVERWRITE));
+defconst(env, "sqlite-fcntl-vfsname", env->make_integer(env, 
SQLITE_FCNTL_VFSNAME));
+defconst(env, "sqlite-fcntl-powersafe-overwrite", env->make_integer(env, 
SQLITE_FCNTL_POWERSAFE_OVERWRITE));
+defconst(env, "sqlite-fcntl-pragma", env->make_integer(env, 
SQLITE_FCNTL_PRAGMA));
+defconst(env, "sqlite-fcntl-busyhandler", env->make_integer(env, 
SQLITE_FCNTL_BUSYHANDLER));
+defconst(env, "sqlite-fcntl-tempfilename", env->make_integer(env, 
SQLITE_FCNTL_TEMPFILENAME));
+defconst(env, "sqlite-fcntl-mmap-size", env->make_integer(env, 
SQLITE_FCNTL_MMAP_SIZE));
+defconst(env, "sqlite-fcntl-trace", env->make_integer(env, 
SQLITE_FCNTL_TRACE));
+defconst(env, "sqlite-fcntl-has-moved", env->make_integer(env, 
SQLITE_FCNTL_HAS_MOVED));
+defconst(env, "sqlite-fcntl-sync", env->make_integer(env, SQLITE_FCNTL_SYNC));
+defconst(env, "sqlite-fcntl-commit-phasetwo", env->make_integer(env, 
SQLITE_FCNTL_COMMIT_PHASETWO));
+defconst(env, "sqlite-fcntl-win32-set-handle", env->make_integer(env, 
SQLITE_FCNTL_WIN32_SET_HANDLE));
+defconst(env, "sqlite-fcntl-wal-block", env->make_integer(env, 
SQLITE_FCNTL_WAL_BLOCK));
+defconst(env, "sqlite-fcntl-zipvfs", env->make_integer(env, 
SQLITE_FCNTL_ZIPVFS));
+defconst(env, "sqlite-fcntl-rbu", env->make_integer(env, SQLITE_FCNTL_RBU));
+defconst(env, "sqlite-fcntl-vfs-pointer", env->make_integer(env, 
SQLITE_FCNTL_VFS_POINTER));
+defconst(env, "sqlite-fcntl-journal-pointer", env->make_integer(env, 
SQLITE_FCNTL_JOURNAL_POINTER));
+defconst(env, "sqlite-fcntl-win32-get-handle", env->make_integer(env, 
SQLITE_FCNTL_WIN32_GET_HANDLE));
+defconst(env, "sqlite-fcntl-pdb", env->make_integer(env, SQLITE_FCNTL_PDB));
+defconst(env, "sqlite-get-lockproxyfile", env->make_integer(env, 
SQLITE_GET_LOCKPROXYFILE));
+defconst(env, "sqlite-set-lockproxyfile", env->make_integer(env, 
SQLITE_SET_LOCKPROXYFILE));
+defconst(env, "sqlite-last-errno", env->make_integer(env, SQLITE_LAST_ERRNO));
+defconst(env, "sqlite-access-exists", env->make_integer(env, 
SQLITE_ACCESS_EXISTS));
+defconst(env, "sqlite-access-readwrite", env->make_integer(env, 
SQLITE_ACCESS_READWRITE));
+defconst(env, "sqlite-access-read", env->make_integer(env, 
SQLITE_ACCESS_READ));
+defconst(env, "sqlite-shm-unlock", env->make_integer(env, SQLITE_SHM_UNLOCK));
+defconst(env, "sqlite-shm-lock", env->make_integer(env, SQLITE_SHM_LOCK));
+defconst(env, "sqlite-shm-shared", env->make_integer(env, SQLITE_SHM_SHARED));
+defconst(env, "sqlite-shm-exclusive", env->make_integer(env, 
SQLITE_SHM_EXCLUSIVE));
+defconst(env, "sqlite-shm-nlock", env->make_integer(env, SQLITE_SHM_NLOCK));
+defconst(env, "sqlite-config-singlethread", env->make_integer(env, 
SQLITE_CONFIG_SINGLETHREAD));
+defconst(env, "sqlite-config-multithread", env->make_integer(env, 
SQLITE_CONFIG_MULTITHREAD));
+defconst(env, "sqlite-config-serialized", env->make_integer(env, 
SQLITE_CONFIG_SERIALIZED));
+defconst(env, "sqlite-config-malloc", env->make_integer(env, 
SQLITE_CONFIG_MALLOC));
+defconst(env, "sqlite-config-getmalloc", env->make_integer(env, 
SQLITE_CONFIG_GETMALLOC));
+defconst(env, "sqlite-config-scratch", env->make_integer(env, 
SQLITE_CONFIG_SCRATCH));
+defconst(env, "sqlite-config-pagecache", env->make_integer(env, 
SQLITE_CONFIG_PAGECACHE));
+defconst(env, "sqlite-config-heap", env->make_integer(env, 
SQLITE_CONFIG_HEAP));
+defconst(env, "sqlite-config-memstatus", env->make_integer(env, 
SQLITE_CONFIG_MEMSTATUS));
+defconst(env, "sqlite-config-mutex", env->make_integer(env, 
SQLITE_CONFIG_MUTEX));
+defconst(env, "sqlite-config-getmutex", env->make_integer(env, 
SQLITE_CONFIG_GETMUTEX));
+defconst(env, "sqlite-config-lookaside", env->make_integer(env, 
SQLITE_CONFIG_LOOKASIDE));
+defconst(env, "sqlite-config-pcache", env->make_integer(env, 
SQLITE_CONFIG_PCACHE));
+defconst(env, "sqlite-config-getpcache", env->make_integer(env, 
SQLITE_CONFIG_GETPCACHE));
+defconst(env, "sqlite-config-log", env->make_integer(env, SQLITE_CONFIG_LOG));
+defconst(env, "sqlite-config-uri", env->make_integer(env, SQLITE_CONFIG_URI));
+defconst(env, "sqlite-config-pcache2", env->make_integer(env, 
SQLITE_CONFIG_PCACHE2));
+defconst(env, "sqlite-config-getpcache2", env->make_integer(env, 
SQLITE_CONFIG_GETPCACHE2));
+defconst(env, "sqlite-config-covering-index-scan", env->make_integer(env, 
SQLITE_CONFIG_COVERING_INDEX_SCAN));
+defconst(env, "sqlite-config-sqllog", env->make_integer(env, 
SQLITE_CONFIG_SQLLOG));
+defconst(env, "sqlite-config-mmap-size", env->make_integer(env, 
SQLITE_CONFIG_MMAP_SIZE));
+defconst(env, "sqlite-config-win32-heapsize", env->make_integer(env, 
SQLITE_CONFIG_WIN32_HEAPSIZE));
+defconst(env, "sqlite-config-pcache-hdrsz", env->make_integer(env, 
SQLITE_CONFIG_PCACHE_HDRSZ));
+defconst(env, "sqlite-config-pmasz", env->make_integer(env, 
SQLITE_CONFIG_PMASZ));
+defconst(env, "sqlite-config-stmtjrnl-spill", env->make_integer(env, 
SQLITE_CONFIG_STMTJRNL_SPILL));
+defconst(env, "sqlite-dbconfig-maindbname", env->make_integer(env, 
SQLITE_DBCONFIG_MAINDBNAME));
+defconst(env, "sqlite-dbconfig-lookaside", env->make_integer(env, 
SQLITE_DBCONFIG_LOOKASIDE));
+defconst(env, "sqlite-dbconfig-enable-fkey", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_FKEY));
+defconst(env, "sqlite-dbconfig-enable-trigger", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_TRIGGER));
+defconst(env, "sqlite-dbconfig-enable-fts3-tokenizer", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER));
+defconst(env, "sqlite-dbconfig-enable-load-extension", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION));
+defconst(env, "sqlite-dbconfig-no-ckpt-on-close", env->make_integer(env, 
SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE));
+defconst(env, "sqlite-deny", env->make_integer(env, SQLITE_DENY));
+defconst(env, "sqlite-ignore", env->make_integer(env, SQLITE_IGNORE));
+defconst(env, "sqlite-create-index", env->make_integer(env, 
SQLITE_CREATE_INDEX));
+defconst(env, "sqlite-create-table", env->make_integer(env, 
SQLITE_CREATE_TABLE));
+defconst(env, "sqlite-create-temp-index", env->make_integer(env, 
SQLITE_CREATE_TEMP_INDEX));
+defconst(env, "sqlite-create-temp-table", env->make_integer(env, 
SQLITE_CREATE_TEMP_TABLE));
+defconst(env, "sqlite-create-temp-trigger", env->make_integer(env, 
SQLITE_CREATE_TEMP_TRIGGER));
+defconst(env, "sqlite-create-temp-view", env->make_integer(env, 
SQLITE_CREATE_TEMP_VIEW));
+defconst(env, "sqlite-create-trigger", env->make_integer(env, 
SQLITE_CREATE_TRIGGER));
+defconst(env, "sqlite-create-view", env->make_integer(env, 
SQLITE_CREATE_VIEW));
+defconst(env, "sqlite-delete", env->make_integer(env, SQLITE_DELETE));
+defconst(env, "sqlite-drop-index", env->make_integer(env, SQLITE_DROP_INDEX));
+defconst(env, "sqlite-drop-table", env->make_integer(env, SQLITE_DROP_TABLE));
+defconst(env, "sqlite-drop-temp-index", env->make_integer(env, 
SQLITE_DROP_TEMP_INDEX));
+defconst(env, "sqlite-drop-temp-table", env->make_integer(env, 
SQLITE_DROP_TEMP_TABLE));
+defconst(env, "sqlite-drop-temp-trigger", env->make_integer(env, 
SQLITE_DROP_TEMP_TRIGGER));
+defconst(env, "sqlite-drop-temp-view", env->make_integer(env, 
SQLITE_DROP_TEMP_VIEW));
+defconst(env, "sqlite-drop-trigger", env->make_integer(env, 
SQLITE_DROP_TRIGGER));
+defconst(env, "sqlite-drop-view", env->make_integer(env, SQLITE_DROP_VIEW));
+defconst(env, "sqlite-insert", env->make_integer(env, SQLITE_INSERT));
+defconst(env, "sqlite-pragma", env->make_integer(env, SQLITE_PRAGMA));
+defconst(env, "sqlite-read", env->make_integer(env, SQLITE_READ));
+defconst(env, "sqlite-select", env->make_integer(env, SQLITE_SELECT));
+defconst(env, "sqlite-transaction", env->make_integer(env, 
SQLITE_TRANSACTION));
+defconst(env, "sqlite-update", env->make_integer(env, SQLITE_UPDATE));
+defconst(env, "sqlite-attach", env->make_integer(env, SQLITE_ATTACH));
+defconst(env, "sqlite-detach", env->make_integer(env, SQLITE_DETACH));
+defconst(env, "sqlite-alter-table", env->make_integer(env, 
SQLITE_ALTER_TABLE));
+defconst(env, "sqlite-reindex", env->make_integer(env, SQLITE_REINDEX));
+defconst(env, "sqlite-analyze", env->make_integer(env, SQLITE_ANALYZE));
+defconst(env, "sqlite-create-vtable", env->make_integer(env, 
SQLITE_CREATE_VTABLE));
+defconst(env, "sqlite-drop-vtable", env->make_integer(env, 
SQLITE_DROP_VTABLE));
+defconst(env, "sqlite-function", env->make_integer(env, SQLITE_FUNCTION));
+defconst(env, "sqlite-savepoint", env->make_integer(env, SQLITE_SAVEPOINT));
+defconst(env, "sqlite-copy", env->make_integer(env, SQLITE_COPY));
+defconst(env, "sqlite-recursive", env->make_integer(env, SQLITE_RECURSIVE));
+defconst(env, "sqlite-trace-stmt", env->make_integer(env, SQLITE_TRACE_STMT));
+defconst(env, "sqlite-trace-profile", env->make_integer(env, 
SQLITE_TRACE_PROFILE));
+defconst(env, "sqlite-trace-row", env->make_integer(env, SQLITE_TRACE_ROW));
+defconst(env, "sqlite-trace-close", env->make_integer(env, 
SQLITE_TRACE_CLOSE));
+defconst(env, "sqlite-limit-length", env->make_integer(env, 
SQLITE_LIMIT_LENGTH));
+defconst(env, "sqlite-limit-sql-length", env->make_integer(env, 
SQLITE_LIMIT_SQL_LENGTH));
+defconst(env, "sqlite-limit-column", env->make_integer(env, 
SQLITE_LIMIT_COLUMN));
+defconst(env, "sqlite-limit-expr-depth", env->make_integer(env, 
SQLITE_LIMIT_EXPR_DEPTH));
+defconst(env, "sqlite-limit-compound-select", env->make_integer(env, 
SQLITE_LIMIT_COMPOUND_SELECT));
+defconst(env, "sqlite-limit-vdbe-op", env->make_integer(env, 
SQLITE_LIMIT_VDBE_OP));
+defconst(env, "sqlite-limit-function-arg", env->make_integer(env, 
SQLITE_LIMIT_FUNCTION_ARG));
+defconst(env, "sqlite-limit-attached", env->make_integer(env, 
SQLITE_LIMIT_ATTACHED));
+defconst(env, "sqlite-limit-like-pattern-length", env->make_integer(env, 
SQLITE_LIMIT_LIKE_PATTERN_LENGTH));
+defconst(env, "sqlite-limit-variable-number", env->make_integer(env, 
SQLITE_LIMIT_VARIABLE_NUMBER));
+defconst(env, "sqlite-limit-trigger-depth", env->make_integer(env, 
SQLITE_LIMIT_TRIGGER_DEPTH));
+defconst(env, "sqlite-limit-worker-threads", env->make_integer(env, 
SQLITE_LIMIT_WORKER_THREADS));
+defconst(env, "sqlite-integer", env->make_integer(env, SQLITE_INTEGER));
+defconst(env, "sqlite-float", env->make_integer(env, SQLITE_FLOAT));
+defconst(env, "sqlite-blob", env->make_integer(env, SQLITE_BLOB));
+defconst(env, "sqlite-null", env->make_integer(env, SQLITE_NULL));
+defconst(env, "sqlite3-text", env->make_integer(env, SQLITE3_TEXT));
+defconst(env, "sqlite-utf8", env->make_integer(env, SQLITE_UTF8));
+defconst(env, "sqlite-utf16le", env->make_integer(env, SQLITE_UTF16LE));
+defconst(env, "sqlite-utf16be", env->make_integer(env, SQLITE_UTF16BE));
+defconst(env, "sqlite-utf16", env->make_integer(env, SQLITE_UTF16));
+defconst(env, "sqlite-any", env->make_integer(env, SQLITE_ANY));
+defconst(env, "sqlite-utf16-aligned", env->make_integer(env, 
SQLITE_UTF16_ALIGNED));
+defconst(env, "sqlite-deterministic", env->make_integer(env, 
SQLITE_DETERMINISTIC));
+defconst(env, "sqlite-static", env->make_integer(env, SQLITE_STATIC));
+defconst(env, "sqlite-transient", env->make_integer(env, SQLITE_TRANSIENT));
+defconst(env, "sqlite-index-scan-unique", env->make_integer(env, 
SQLITE_INDEX_SCAN_UNIQUE));
+defconst(env, "sqlite-index-constraint-eq", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_EQ));
+defconst(env, "sqlite-index-constraint-gt", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_GT));
+defconst(env, "sqlite-index-constraint-le", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_LE));
+defconst(env, "sqlite-index-constraint-lt", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_LT));
+defconst(env, "sqlite-index-constraint-ge", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_GE));
+defconst(env, "sqlite-index-constraint-match", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_MATCH));
+defconst(env, "sqlite-index-constraint-like", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_LIKE));
+defconst(env, "sqlite-index-constraint-glob", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_GLOB));
+defconst(env, "sqlite-index-constraint-regexp", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_REGEXP));
+defconst(env, "sqlite-mutex-fast", env->make_integer(env, SQLITE_MUTEX_FAST));
+defconst(env, "sqlite-mutex-recursive", env->make_integer(env, 
SQLITE_MUTEX_RECURSIVE));
+defconst(env, "sqlite-mutex-static-master", env->make_integer(env, 
SQLITE_MUTEX_STATIC_MASTER));
+defconst(env, "sqlite-mutex-static-mem", env->make_integer(env, 
SQLITE_MUTEX_STATIC_MEM));
+defconst(env, "sqlite-mutex-static-mem2", env->make_integer(env, 
SQLITE_MUTEX_STATIC_MEM2));
+defconst(env, "sqlite-mutex-static-open", env->make_integer(env, 
SQLITE_MUTEX_STATIC_OPEN));
+defconst(env, "sqlite-mutex-static-prng", env->make_integer(env, 
SQLITE_MUTEX_STATIC_PRNG));
+defconst(env, "sqlite-mutex-static-lru", env->make_integer(env, 
SQLITE_MUTEX_STATIC_LRU));
+defconst(env, "sqlite-mutex-static-lru2", env->make_integer(env, 
SQLITE_MUTEX_STATIC_LRU2));
+defconst(env, "sqlite-mutex-static-pmem", env->make_integer(env, 
SQLITE_MUTEX_STATIC_PMEM));
+defconst(env, "sqlite-mutex-static-app1", env->make_integer(env, 
SQLITE_MUTEX_STATIC_APP1));
+defconst(env, "sqlite-mutex-static-app2", env->make_integer(env, 
SQLITE_MUTEX_STATIC_APP2));
+defconst(env, "sqlite-mutex-static-app3", env->make_integer(env, 
SQLITE_MUTEX_STATIC_APP3));
+defconst(env, "sqlite-mutex-static-vfs1", env->make_integer(env, 
SQLITE_MUTEX_STATIC_VFS1));
+defconst(env, "sqlite-mutex-static-vfs2", env->make_integer(env, 
SQLITE_MUTEX_STATIC_VFS2));
+defconst(env, "sqlite-mutex-static-vfs3", env->make_integer(env, 
SQLITE_MUTEX_STATIC_VFS3));
+defconst(env, "sqlite-testctrl-first", env->make_integer(env, 
SQLITE_TESTCTRL_FIRST));
+defconst(env, "sqlite-testctrl-prng-save", env->make_integer(env, 
SQLITE_TESTCTRL_PRNG_SAVE));
+defconst(env, "sqlite-testctrl-prng-restore", env->make_integer(env, 
SQLITE_TESTCTRL_PRNG_RESTORE));
+defconst(env, "sqlite-testctrl-prng-reset", env->make_integer(env, 
SQLITE_TESTCTRL_PRNG_RESET));
+defconst(env, "sqlite-testctrl-bitvec-test", env->make_integer(env, 
SQLITE_TESTCTRL_BITVEC_TEST));
+defconst(env, "sqlite-testctrl-fault-install", env->make_integer(env, 
SQLITE_TESTCTRL_FAULT_INSTALL));
+defconst(env, "sqlite-testctrl-benign-malloc-hooks", env->make_integer(env, 
SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS));
+defconst(env, "sqlite-testctrl-pending-byte", env->make_integer(env, 
SQLITE_TESTCTRL_PENDING_BYTE));
+defconst(env, "sqlite-testctrl-assert", env->make_integer(env, 
SQLITE_TESTCTRL_ASSERT));
+defconst(env, "sqlite-testctrl-always", env->make_integer(env, 
SQLITE_TESTCTRL_ALWAYS));
+defconst(env, "sqlite-testctrl-reserve", env->make_integer(env, 
SQLITE_TESTCTRL_RESERVE));
+defconst(env, "sqlite-testctrl-optimizations", env->make_integer(env, 
SQLITE_TESTCTRL_OPTIMIZATIONS));
+defconst(env, "sqlite-testctrl-iskeyword", env->make_integer(env, 
SQLITE_TESTCTRL_ISKEYWORD));
+defconst(env, "sqlite-testctrl-scratchmalloc", env->make_integer(env, 
SQLITE_TESTCTRL_SCRATCHMALLOC));
+defconst(env, "sqlite-testctrl-localtime-fault", env->make_integer(env, 
SQLITE_TESTCTRL_LOCALTIME_FAULT));
+defconst(env, "sqlite-testctrl-explain-stmt", env->make_integer(env, 
SQLITE_TESTCTRL_EXPLAIN_STMT));
+defconst(env, "sqlite-testctrl-once-reset-threshold", env->make_integer(env, 
SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD));
+defconst(env, "sqlite-testctrl-never-corrupt", env->make_integer(env, 
SQLITE_TESTCTRL_NEVER_CORRUPT));
+defconst(env, "sqlite-testctrl-vdbe-coverage", env->make_integer(env, 
SQLITE_TESTCTRL_VDBE_COVERAGE));
+defconst(env, "sqlite-testctrl-byteorder", env->make_integer(env, 
SQLITE_TESTCTRL_BYTEORDER));
+defconst(env, "sqlite-testctrl-isinit", env->make_integer(env, 
SQLITE_TESTCTRL_ISINIT));
+defconst(env, "sqlite-testctrl-sorter-mmap", env->make_integer(env, 
SQLITE_TESTCTRL_SORTER_MMAP));
+defconst(env, "sqlite-testctrl-imposter", env->make_integer(env, 
SQLITE_TESTCTRL_IMPOSTER));
+defconst(env, "sqlite-testctrl-last", env->make_integer(env, 
SQLITE_TESTCTRL_LAST));
+defconst(env, "sqlite-status-memory-used", env->make_integer(env, 
SQLITE_STATUS_MEMORY_USED));
+defconst(env, "sqlite-status-pagecache-used", env->make_integer(env, 
SQLITE_STATUS_PAGECACHE_USED));
+defconst(env, "sqlite-status-pagecache-overflow", env->make_integer(env, 
SQLITE_STATUS_PAGECACHE_OVERFLOW));
+defconst(env, "sqlite-status-scratch-used", env->make_integer(env, 
SQLITE_STATUS_SCRATCH_USED));
+defconst(env, "sqlite-status-scratch-overflow", env->make_integer(env, 
SQLITE_STATUS_SCRATCH_OVERFLOW));
+defconst(env, "sqlite-status-malloc-size", env->make_integer(env, 
SQLITE_STATUS_MALLOC_SIZE));
+defconst(env, "sqlite-status-parser-stack", env->make_integer(env, 
SQLITE_STATUS_PARSER_STACK));
+defconst(env, "sqlite-status-pagecache-size", env->make_integer(env, 
SQLITE_STATUS_PAGECACHE_SIZE));
+defconst(env, "sqlite-status-scratch-size", env->make_integer(env, 
SQLITE_STATUS_SCRATCH_SIZE));
+defconst(env, "sqlite-status-malloc-count", env->make_integer(env, 
SQLITE_STATUS_MALLOC_COUNT));
+defconst(env, "sqlite-dbstatus-lookaside-used", env->make_integer(env, 
SQLITE_DBSTATUS_LOOKASIDE_USED));
+defconst(env, "sqlite-dbstatus-cache-used", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_USED));
+defconst(env, "sqlite-dbstatus-schema-used", env->make_integer(env, 
SQLITE_DBSTATUS_SCHEMA_USED));
+defconst(env, "sqlite-dbstatus-stmt-used", env->make_integer(env, 
SQLITE_DBSTATUS_STMT_USED));
+defconst(env, "sqlite-dbstatus-lookaside-hit", env->make_integer(env, 
SQLITE_DBSTATUS_LOOKASIDE_HIT));
+defconst(env, "sqlite-dbstatus-lookaside-miss-size", env->make_integer(env, 
SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE));
+defconst(env, "sqlite-dbstatus-lookaside-miss-full", env->make_integer(env, 
SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL));
+defconst(env, "sqlite-dbstatus-cache-hit", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_HIT));
+defconst(env, "sqlite-dbstatus-cache-miss", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_MISS));
+defconst(env, "sqlite-dbstatus-cache-write", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_WRITE));
+defconst(env, "sqlite-dbstatus-deferred-fks", env->make_integer(env, 
SQLITE_DBSTATUS_DEFERRED_FKS));
+defconst(env, "sqlite-dbstatus-cache-used-shared", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_USED_SHARED));
+defconst(env, "sqlite-dbstatus-max", env->make_integer(env, 
SQLITE_DBSTATUS_MAX));
+defconst(env, "sqlite-stmtstatus-fullscan-step", env->make_integer(env, 
SQLITE_STMTSTATUS_FULLSCAN_STEP));
+defconst(env, "sqlite-stmtstatus-sort", env->make_integer(env, 
SQLITE_STMTSTATUS_SORT));
+defconst(env, "sqlite-stmtstatus-autoindex", env->make_integer(env, 
SQLITE_STMTSTATUS_AUTOINDEX));
+defconst(env, "sqlite-stmtstatus-vm-step", env->make_integer(env, 
SQLITE_STMTSTATUS_VM_STEP));
+defconst(env, "sqlite-checkpoint-passive", env->make_integer(env, 
SQLITE_CHECKPOINT_PASSIVE));
+defconst(env, "sqlite-checkpoint-full", env->make_integer(env, 
SQLITE_CHECKPOINT_FULL));
+defconst(env, "sqlite-checkpoint-restart", env->make_integer(env, 
SQLITE_CHECKPOINT_RESTART));
+defconst(env, "sqlite-checkpoint-truncate", env->make_integer(env, 
SQLITE_CHECKPOINT_TRUNCATE));
+defconst(env, "sqlite-vtab-constraint-support", env->make_integer(env, 
SQLITE_VTAB_CONSTRAINT_SUPPORT));
+defconst(env, "sqlite-rollback", env->make_integer(env, SQLITE_ROLLBACK));
+defconst(env, "sqlite-fail", env->make_integer(env, SQLITE_FAIL));
+defconst(env, "sqlite-replace", env->make_integer(env, SQLITE_REPLACE));
+defconst(env, "sqlite-scanstat-nloop", env->make_integer(env, 
SQLITE_SCANSTAT_NLOOP));
+defconst(env, "sqlite-scanstat-nvisit", env->make_integer(env, 
SQLITE_SCANSTAT_NVISIT));
+defconst(env, "sqlite-scanstat-est", env->make_integer(env, 
SQLITE_SCANSTAT_EST));
+defconst(env, "sqlite-scanstat-name", env->make_integer(env, 
SQLITE_SCANSTAT_NAME));
+defconst(env, "sqlite-scanstat-explain", env->make_integer(env, 
SQLITE_SCANSTAT_EXPLAIN));
+defconst(env, "sqlite-scanstat-selectid", env->make_integer(env, 
SQLITE_SCANSTAT_SELECTID));
diff --git a/tests/regression.el b/tests/regression.el
index 2721ceea9d..ce85a20b0b 100644
--- a/tests/regression.el
+++ b/tests/regression.el
@@ -14,8 +14,6 @@
 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ;;
 
-(setq lexical-binding t)
-(add-to-list 'load-path ".")
 (require 'sqlite3-api)
 (require 'cl)
 
diff --git a/tools/find-sqlite3-h.sh b/tools/find-sqlite3-h.sh
index ff13bbc6ff..ebda553bb9 100755
--- a/tools/find-sqlite3-h.sh
+++ b/tools/find-sqlite3-h.sh
@@ -1,3 +1,4 @@
 #!/bin/bash
 # locate the path of sqlite3.h
-echo '#include <sqlite3.h>' | gcc -x c -H -fsyntax-only - 2>&1 | grep '^\. ' | 
cut -f2 -d' '
+# Take -I... as the only argument
+echo '#include <sqlite3.h>' | gcc $* -x c -H -fsyntax-only - 2>&1 | grep '^\. 
' | cut -f2 -d' '