diff options
| author | Marcos Magueta <maguetamarcos@gmail.com> | 2026-05-10 23:17:06 -0300 |
|---|---|---|
| committer | Marcos Magueta <maguetamarcos@gmail.com> | 2026-05-10 23:17:06 -0300 |
| commit | c1b70cfe745d935bded3053fba8c1f9573aa07aa (patch) | |
| tree | 22aa61c5e23dbff22663673de89728bfb77af17f /vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl | |
| parent | 7d0fdcf2048bc736c82f84e92dcfc68b3d6ac45c (diff) | |
| download | RNT-c1b70cfe745d935bded3053fba8c1f9573aa07aa.tar.gz RNT-c1b70cfe745d935bded3053fba8c1f9573aa07aa.zip | |
remove vcpkg installation added by mistake
Diffstat (limited to 'vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl')
| -rw-r--r-- | vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl | 2279 |
1 files changed, 0 insertions, 2279 deletions
diff --git a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl b/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl deleted file mode 100644 index 59ecb71..0000000 --- a/vcpkg_installed/vcpkg/blds/sqlite3/src/nf-3530100-fcf7ac0798.clean/autosetup/sqlite-config.tcl +++ /dev/null @@ -1,2279 +0,0 @@ -# This file holds functions for autosetup which are specific to the -# sqlite build tree. They are in this file, instead of auto.def, so -# that they can be reused in the autoconf sub-tree. This file requires -# functions from the project-agnostic proj.tcl. - -if {[string first " " $autosetup(srcdir)] != -1} { - user-error "The pathname of the source tree\ - may not contain space characters" -} -if {[string first " " $autosetup(builddir)] != -1} { - user-error "The pathname of the build directory\ - may not contain space characters" -} - -use proj -# -# We want the package version info to be emitted early on, but doing -# so requires a bit of juggling. We have to [use system] for -# --prefix=... to work and to emit the Host/Build system info, but we -# don't want those to interfere with --help output. -define PACKAGE_VERSION [proj-file-content -trim $::autosetup(srcdir)/VERSION] -if {"--help" ni $::argv} { - msg-result "Configuring SQLite version [get-define PACKAGE_VERSION]" -} -use system ; # Will output "Host System" and "Build System" lines -if {"--help" ni $::argv} { - proj-tweak-default-env-dirs - msg-result "Source dir = $::autosetup(srcdir)" - msg-result "Build dir = $::autosetup(builddir)" - use cc cc-db cc-shared cc-lib pkg-config -} - -# -# Object for communicating certain config-time state across various -# auto.def-related pieces. -array set sqliteConfig [subst [proj-strip-hash-comments { - # - # Gets set by [sqlite-configure] (the main configure script driver). - build-mode unknown - # - # Gets set to 1 when using jimsh for code generation. May affect - # later decisions. - use-jim-for-codegen 0 - # - # Set to 1 when cross-compiling This value may be changed by certain - # build options, so it's important that config code which checks for - # cross-compilation uses this var instead of - # [proj-is-cross-compiling]. - is-cross-compiling [proj-is-cross-compiling] - # - # Pass msg-debug=1 to configure to enable obnoxiously loud output - # from [msg-debug]. - msg-debug-enabled 0 - # - # Output file for --dump-defines. Intended only for build debugging - # and not part of the public build interface. - dump-defines-txt ./config.defines.txt - # - # If not empty then --dump-defines will dump not only - # (dump-defines-txt) but also a JSON file named after this option's - # value. - dump-defines-json "" - - # - # The list of feature --flags which the --all flag implies. This - # requires special handling in a few places. - # - all-flag-enables {fts4 fts5 rtree geopoly session dbpage dbstat carray} - - # - # Default value for the --all flag. Can hypothetically be modified - # by non-canonical builds (it was added for a Tcl extension build - # mode which was eventually removed). - # - all-flag-default 0 -}]] - -######################################################################## -# Processes all configure --flags for this build, run build-specific -# config checks, then finalize the configure process. $buildMode must -# be one of (canonical, autoconf), and others may be added in the -# future. After bootstrapping, $configScript is eval'd in the caller's -# scope, then post-configuration finalization is run. $configScript is -# intended to hold configure code which is specific to the given -# $buildMode, with the caveat that _some_ build-specific code is -# encapsulated in the configuration finalization step. -# -# The intent is that all (or almost all) build-mode-specific -# configuration goes inside the $configScript argument to this -# function, and that an auto.def file contains only two commands: -# -# use sqlite-config -# sqlite-configure BUILD_NAME { build-specific configure script } -# -# There are snippets of build-mode-specific decision-making in -# [sqlite-configure-finalize], which gets run after $configScript. -proc sqlite-configure {buildMode configScript} { - proj-assert {$::sqliteConfig(build-mode) eq "unknown"} \ - "sqlite-configure must not be called more than once" - set allBuildModes {canonical autoconf} - if {$buildMode ni $allBuildModes} { - user-error "Invalid build mode: $buildMode. Expecting one of: $allBuildModes" - } - if {$::sqliteConfig(all-flag-default)} { - set allFlagHelp "Disable these extensions: $::sqliteConfig(all-flag-enables)" - } else { - set allFlagHelp "Enable these extensions: $::sqliteConfig(all-flag-enables)" - } - - set ::sqliteConfig(build-mode) $buildMode - ######################################################################## - # A gentle introduction to flags handling in autosetup - # - # Reference: https://msteveb.github.io/autosetup/developer/ - # - # All configure flags must be described in one or more calls to - # autosetup's [options] and [options-add] functions. The general - # syntax of the single argument to those functions is a list contain - # a mapping of flags to help text: - # - # FLAG => {Help text} - # - # Where FLAG can have any of the following formats: - # - # boolopt => "a boolean option which defaults to disabled" - # boolopt2=1 => "a boolean option which defaults to enabled" - # stringopt: => "an option which takes an argument, e.g. --stringopt=value" - # stringopt:DESCR => As for stringopt: with a description for the value - # stringopt2:=value => "an option where the argument is optional and defaults to 'value'" - # optalias booltopt3 => "a boolean with a hidden alias. --optalias is not shown in --help" - # - # Autosetup does no small amount of specialized handling for flags, - # especially booleans. Each bool-type --FLAG implicitly gets - # --enable-FLAG and --disable-FLAG forms. That can lead lead to some - # confusion when writing help text. For example: - # - # options { json=1 {Disable JSON functions} } - # - # The reason the help text says "disable" is because a boolean option - # which defaults to true is, in the --help text, rendered as: - # - # --disable-json Disable JSON functions - # - # Whereas a bool flag which defaults to false will instead render as: - # - # --enable-FLAG - # - # Non-boolean flags, in contrast, use the names specifically given to - # them in the [options] invocation. e.g. "with-tcl" is the --with-tcl - # flag. - # - # Fetching values for flags: - # - # booleans: use one of: - # - [opt-bool FLAG] is autosetup's built-in command for this, but we - # have some convenience variants: - # - [proj-opt-truthy FLAG] - # - [proj-opt-if-truthy FLAG {THEN} {ELSE}] - # - # Non-boolean (i.e. string) flags: - # - [opt-val FLAG ?default?] - # - [opt-str ...] - see the docs in ./autosetup/autosetup - # - # [proj-opt-was-provided] can be used to determine whether a flag was - # explicitly provided, which is often useful for distinguishing from - # the case of a default value. - ######################################################################## - set allFlags { - # Structure: a list of M {Z} pairs, where M is a descriptive - # option group name and Z is a list of X Y pairs. X is a list of - # $buildMode name(s) to which the Y flags apply, or {*} to apply - # to all builds. Y is a {block} in the form expected by - # autosetup's [options] and [options-add] command. Each block - # which is applicable to $buildMode is passed on to - # [options-add]. The order of each Y and sub-Y is retained, which - # is significant for rendering of --help. - # - # Maintenance note: [options] does not support comments in - # options, but we filter this object through - # [proj-strip-hash-comments] to remove them before passing them on - # to [options]. - - # When writing {help text blocks}, be aware that: - # - # A) autosetup formats them differently if the {block} starts with - # a newline: it starts left-aligned, directly under the --flag, and - # the rest of the block is pasted verbatim rather than - # pretty-printed. - # - # B) Vars and commands are NOT expanded, but we use a [subst] call - # below which will replace (only) $var refs. - - # Options for how to build the library - build-modes { - {canonical autoconf} { - shared=1 => {Disable build of shared library} - static=1 => {Disable build of static library} - } - {canonical} { - amalgamation=1 => {Disable the amalgamation and instead build all files separately} - } - } - - # Library-level features and defaults - lib-features { - {*} { - threadsafe=1 => {Disable mutexing} - with-tempstore:=no => {Use an in-RAM database for temporary tables: never,no,yes,always} - load-extension=1 => {Disable loading of external extensions} - # ^^^ one of the downstream custom builds overrides the load-extension default to 0, which - # confuses the --help text generator. https://github.com/msteveb/autosetup/issues/77 - math=1 => {Disable math functions} - json=1 => {Disable JSON functions} - memsys5 => {Enable MEMSYS5} - memsys3 => {Enable MEMSYS3} - 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} - dbpage => {Enable the sqlite3_dbpage extension} - dbstat => {Enable the sqlite3_dbstat extension} - carray=1 => {Disable the CARRAY extension} - all=$::sqliteConfig(all-flag-default) => {$allFlagHelp} - largefile=1 - => {This legacy flag has no effect on the library but may influence - the generated sqlite_cfg.h by adding #define HAVE_LFS} - } - {canonical} { - column-metadata => {Enable the column metadata APIs} - # ^^^ Affects how sqlite3.c is generated, so is not available in - # the autoconf build. - } - } - - # Options for TCL support - tcl { - {canonical} { - tcl=1 - => {Disable components which require TCL, including all tests. - This tree requires TCL for code generation but can use the in-tree - copy of autosetup/jimsh0.c for that. The SQLite TCL extension and the - test code require a canonical tclsh.} - with-tcl:DIR - => {Directory containing tclConfig.sh or a directory one level up from - that, from which we can derive a directory containing tclConfig.sh. - A dir name of "prefix" is equivalent to the directory specified by - the --prefix flag.} - with-tclsh:PATH - => {Full pathname of tclsh to use. It is used for (A) trying to find - tclConfig.sh and (B) all TCL-based code generation. Use --with-tcl - unless you have a specific need for this flag. Warning: if its - containing dir has multiple tclsh versions, it may select the - wrong tclConfig.sh!} - static-tclsqlite3=0 - => {Statically-link tclsqlite3. This only works if TCL support is - enabled and all requisite libraries are available in - static form. Note that glibc is unable to fully statically - link certain libraries required by tclsqlite3, so this won't - work on most Linux environments.} - } - } - - # Options for line-editing modes for the CLI shell - line-editing { - {canonical autoconf} { - readline=1 - => {Disable readline support} - # --with-readline-lib is a backwards-compatible alias for - # --with-readline-ldflags - with-readline-lib: - with-readline-ldflags:=auto - => {Readline LDFLAGS, e.g. -lreadline -lncurses} - # --with-readline-inc is a backwards-compatible alias for - # --with-readline-cflags. - with-readline-inc: - with-readline-cflags:=auto - => {Readline CFLAGS, e.g. -I/path/to/includes} - with-readline-header:PATH - => {Full path to readline.h, from which --with-readline-cflags will be derived} - with-linenoise:DIR - => {Source directory for linenoise.c and linenoise.h} - editline=0 - => {Enable BSD editline support} - } - } - - # Options for ICU: International Components for Unicode - icu { - {*} { - 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} - } - } - - # Options for exotic/alternative build modes - alternative-builds { - {canonical autoconf} { - with-wasi-sdk:=/opt/wasi-sdk - => {Top-most dir of the wasi-sdk for a WASI build} - } - - {*} { - # Note that --static-cli-shell has a completely different - # meaning from --static-shell in the autoconf build! - # --[disable-]static-shell is a legacy flag which we can't - # remove without breaking downstream builds. - static-cli-shell=0 - => {Statically-link the sqlite3 CLI shell. - This only works if the requisite libraries are all available in - static form.} - } - - {canonical} { - static-shells=0 - => {Shorthand for --static-cli-shell --static-tclsqlite3} - - with-emsdk:=auto - => {Top-most dir of the Emscripten SDK installation. - Needed only by ext/wasm. Default=EMSDK env var.} - - amalgamation-extra-src:FILES - => {Space-separated list of source files to append as-is to the resulting - sqlite3.c amalgamation file. May be provided multiple times.} - } - } - - # Options primarily for downstream packagers/package maintainers - packaging { - {autoconf} { - # --disable-static-shell: https://sqlite.org/forum/forumpost/cc219ee704 - # Note that this has a different meaning from --static-cli-shell in the - # canonical build! - static-shell=1 - => {Link the sqlite3 shell app against the DLL instead of embedding sqlite3.c} - } - {canonical autoconf} { - rpath=1 => {Disable use of the rpath linker flag} - # soname: https://sqlite.org/src/forumpost/5a3b44f510df8ded - soname:=legacy - => {SONAME for libsqlite3.so. "none", or not using this flag, sets no - soname. "legacy" sets it to its historical value of - libsqlite3.so.0. A value matching the glob "libsqlite3.*" sets - it to that literal value. Any other value is assumed to be a - suffix which gets applied to "libsqlite3.so.", - e.g. --soname=9.10 equates to "libsqlite3.so.9.10".} - # dll-basename: https://sqlite.org/forum/forumpost/828fdfe904 - dll-basename:=auto - => {Specifies the base name of the resulting DLL file. - If not provided, "libsqlite3" is usually assumed but on some platforms - a platform-dependent default is used. On some platforms this flag - gets automatically enabled if it is not provided. Use "default" to - explicitly disable platform-dependent activation on such systems.} - # out-implib: https://sqlite.org/forum/forumpost/0c7fc097b2 - out-implib:=auto - => {Enable use of --out-implib linker flag to generate an - "import library" for the DLL. The output's base name is - specified by this flag's value, with "auto" meaning to figure - out a name automatically. On some platforms this flag gets - automatically enabled if it is not provided. Use "none" to - explicitly disable this feature on such platforms.} - } - } - - # Options mostly for sqlite's own development - developer { - {*} { - # Note that using the --debug/--enable-debug flag here - # requires patching autosetup/autosetup to rename its builtin - # --debug to --autosetup-debug. See details in - # autosetup/README.md#patching. - with-debug=0 - debug=0 - => {Enable debug build flags. This option will impact performance by - as much as 4x, as it includes large numbers of assert()s in - performance-critical loops. Never use --debug for production - builds.} - scanstatus - => {Enable the SQLITE_ENABLE_STMT_SCANSTATUS feature flag} - } - {canonical} { - dev - => {Enable dev-mode build: automatically enables certain other flags} - test-status - => {Enable status of tests} - gcov=0 - => {Enable coverage testing using gcov} - linemacros - => {Enable #line macros in the amalgamation} - dynlink-tools - => {Dynamically link libsqlite3 to certain tools which normally statically embed it} - asan-fsanitize:=auto - => {Comma- or space-separated list of -fsanitize flags for use with the - fuzzcheck-asan tool. Only those which the compiler claims to support - will actually be used. May be provided multiple times.} - } - {*} { - dump-defines=0 - => {Dump autosetup defines to $::sqliteConfig(dump-defines-txt) - (for build debugging)} - } - } - }; # $allFlags - - set allFlags [proj-strip-hash-comments $allFlags] - # ^^^ lappend of [sqlite-custom-flags] introduces weirdness if - # we delay [proj-strip-hash-comments] until after that. - - ######################################################################## - # sqlite-custom.tcl is intended only for vendor-branch-specific - # customization. See autosetup/README.md#branch-customization for - # details. - if {[file exists $::autosetup(libdir)/sqlite-custom.tcl]} { - uplevel 1 {source $::autosetup(libdir)/sqlite-custom.tcl} - } - - if {[llength [info proc sqlite-custom-flags]] > 0} { - # sqlite-custom-flags is assumed to be imported via - # autosetup/sqlite-custom.tcl. - set scf [sqlite-custom-flags] - if {"" ne $scf} { - lappend allFlags sqlite-custom-flags $scf - } - } - - #lappend allFlags just-testing {{*} {soname:=duplicateEntry => {x}}} - - # Filter allFlags to create the set of [options] legal for this build - foreach {group XY} [subst -nobackslashes -nocommands $allFlags] { - foreach {X Y} $XY { - if { $buildMode in $X || "*" in $X } { - options-add $Y - } - } - } - - if {[catch {options {}} msg xopts]} { - # Workaround for <https://github.com/msteveb/autosetup/issues/73> - # where [options] behaves oddly on _some_ TCL builds when it's - # called from deeper than the global scope. - dict incr xopts -level - return {*}$xopts $msg - } - sqlite-configure-phase1 $buildMode - uplevel 1 $configScript - sqlite-configure-finalize -}; # sqlite-configure - -######################################################################## -# Runs "phase 1" of the configure process: after initial --flags -# handling but before sqlite-configure's $configScript argument is -# run. $buildMode must be the mode which was passed to -# [sqlite-configure]. -proc sqlite-configure-phase1 {buildMode} { - define PACKAGE_NAME sqlite - define PACKAGE_URL {https://sqlite.org} - define PACKAGE_BUGREPORT [get-define PACKAGE_URL]/forum - define PACKAGE_STRING "[get-define PACKAGE_NAME] [get-define PACKAGE_VERSION]" - proj-xfer-options-aliases { - # Carry values from hidden --flag aliases over to their canonical - # flag forms. This list must include only options which are common - # to all build modes supported by [sqlite-configure]. - with-readline-inc => with-readline-cflags - with-readline-lib => with-readline-ldflags - with-debug => debug - } - set ::sqliteConfig(msg-debug-enabled) [proj-val-truthy [get-env msg-debug 0]] - proc-debug "msg-debug is enabled" - proj-setup-autoreconfig SQLITE_AUTORECONFIG - proj-file-extensions - if {".exe" eq [get-define TARGET_EXEEXT]} { - define SQLITE_OS_UNIX 0 - define SQLITE_OS_WIN 1 - } else { - define SQLITE_OS_UNIX 1 - define SQLITE_OS_WIN 0 - } - sqlite-setup-default-cflags - define HAVE_LFS 0 - if {[opt-bool largefile]} { - # - # Insofar as we can determine HAVE_LFS has no effect on the - # library. Perhaps it did back in the early 2000's. The - # --enable/disable-largefile flag is retained because it's - # harmless, but it doesn't do anything useful. It does have - # visible side-effects, though: the generated sqlite_cfg.h may (or - # may not) define HAVE_LFS. - cc-check-lfs - } - set srcdir $::autosetup(srcdir) - proj-dot-ins-append $srcdir/Makefile.in - if {[file exists $srcdir/sqlite3.pc.in]} { - proj-dot-ins-append $srcdir/sqlite3.pc.in - } - sqlite-handle-hpux; # must be relatively early so that other config tests can work -}; # sqlite-configure-phase1 - -######################################################################## -# Performs late-stage config steps common to all supported -# $::sqliteConfig(build-mode) values. -proc sqlite-configure-finalize {} { - sqlite-handle-rpath - sqlite-handle-soname - sqlite-handle-threadsafe - sqlite-handle-tempstore - sqlite-handle-load-extension - sqlite-handle-math - sqlite-handle-icu - if {[proj-opt-exists readline]} { - sqlite-handle-line-editing - } - if {[proj-opt-exists shared]} { - proj-define-for-opt shared ENABLE_LIB_SHARED "Build shared library?" - } - if {[proj-opt-exists static]} { - if {![proj-define-for-opt static ENABLE_LIB_STATIC "Build static library?"]} { - # This notice really only applies to the canonical build... - proj-indented-notice { - NOTICE: static lib build may be implicitly re-activated by - other components, e.g. some test apps. - } - } - } - sqlite-handle-env-quirks - sqlite-handle-common-feature-flags - sqlite-finalize-feature-flags - sqlite-process-dot-in-files; # do not [define] anything after this - sqlite-dump-defines -} - -######################################################################## -# Internal config-time debugging output routine. It generates no -# output unless msg-debug=1 is passed to the configure script. -proc msg-debug {msg} { - if {$::sqliteConfig(msg-debug-enabled)} { - puts stderr [proj-bold "** DEBUG: $msg"] - } -} -######################################################################## -# A [msg-debug] proxy which prepends the name of the current proc to -# the debug message. It is not legal to call this from the global -# scope. -proc proc-debug {msg} { - msg-debug "\[[proj-scope 1]\]: $msg" -} - -define OPT_FEATURE_FLAGS {} ; # -DSQLITE_OMIT/ENABLE flags. -# -# OPT_SHELL = feature-related CFLAGS for the sqlite3 CLI app. The -# list's initial values are defaults which are always applied and not -# affected by --feature-flags. The list is appended to by various -# --feature-flags. -define OPT_SHELL { - -DSQLITE_DQS=0 - -DSQLITE_ENABLE_FTS4 - -DSQLITE_ENABLE_RTREE - -DSQLITE_ENABLE_EXPLAIN_COMMENTS - -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION - -DSQLITE_ENABLE_STMTVTAB - -DSQLITE_ENABLE_DBPAGE_VTAB - -DSQLITE_ENABLE_DBSTAT_VTAB - -DSQLITE_ENABLE_BYTECODE_VTAB - -DSQLITE_ENABLE_OFFSET_SQL_FUNC - -DSQLITE_ENABLE_PERCENTILE - -DSQLITE_STRICT_SUBTYPE=1 -} -######################################################################## -# Adds $args, if not empty, to OPT_FEATURE_FLAGS. If the first arg is -# -shell then it strips that arg and passes the remaining args the -# sqlite-add-shell-opt in addition to adding them 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} { - set shell "" - if {"-shell" eq [lindex $args 0]} { - set args [lassign $args shell] - } - if {"" ne $args} { - if {"" ne $shell} { - sqlite-add-shell-opt {*}$args - } - define-append OPT_FEATURE_FLAGS {*}$args - } -} - -######################################################################## -# Appends $args, if not empty, to OPT_SHELL. -proc sqlite-add-shell-opt {args} { - if {"" ne $args} { - define-append OPT_SHELL {*}$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 - } -} - -######################################################################## -# Run checks for required binaries, like ld and ar. In the canonical -# build this must come before [sqlite-handle-wasi-sdk]. -proc sqlite-check-common-bins {} { - cc-check-tools ld ar ; # must come before [sqlite-handle-wasi-sdk] - if {"" eq [proj-bin-define install]} { - proj-warn "Cannot find install binary, so 'make install' will not work." - define BIN_INSTALL false - } -} - -######################################################################## -# Run checks for system-level includes and libs which are common to -# both the canonical build and the "autoconf" bundle. -# -# For the canonical build this must come after -# [sqlite-handle-wasi-sdk], as that function may change the -# environment in ways which affect this. -proc sqlite-check-common-system-deps {} { - # Check for needed/wanted data types - 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} - - # Check for needed/wanted functions - cc-check-functions gmtime_r isnan localtime_r localtime_s \ - usleep utime pread pread64 pwrite pwrite64 - - apply {{} { - set ldrt "" - # Collapse funcs from librt into LDFLAGS_RT. - # Some systems (ex: SunOS) require -lrt in order to use nanosleep - foreach func {fdatasync nanosleep} { - if {[proj-check-function-in-lib $func rt]} { - set ldrt [get-define lib_${func} ""] - undefine lib_${func} - if {"" ne $ldrt} { - break - } - } - } - define LDFLAGS_RT $ldrt - }} - - # Check for needed/wanted headers - cc-check-includes \ - sys/types.h sys/stat.h dlfcn.h unistd.h \ - stdlib.h malloc.h memory.h \ - string.h strings.h \ - inttypes.h - - if {[cc-check-includes zlib.h] && [proj-check-function-in-lib deflate z]} { - # TODO? port over the more sophisticated zlib search from the fossil auto.def - define HAVE_ZLIB 1 - define LDFLAGS_ZLIB -lz - sqlite-add-shell-opt -DSQLITE_HAVE_ZLIB=1 - sqlite-add-feature-flag -DSQLITE_HAVE_ZLIB=1 - } else { - define HAVE_ZLIB 0 - define LDFLAGS_ZLIB "" - } -} - -######################################################################## -# 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 legacy build and was missing the 3.48.0 release (the - # initial Autosetup port). - # https://sqlite.org/forum/forumpost/9801e54665afd728 - # - # Handling of CPPFLAGS, as well as removing ENABLE/OMIT from - # CFLAGS/CPPFLAGS, was missing in the 3.49.0 release as well. - # - # 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 - } - - # Strip all SQLITE_ENABLE/OMIT flags from BUILD_CFLAGS, - # for compatibility with the legacy build. - set tmp "" - foreach cf [get-define BUILD_CFLAGS ""] { - switch -glob -- $cf { - -DSQLITE_OMIT* - - -DSQLITE_ENABLE* {} - default { - lappend tmp $cf - } - } - } - define BUILD_CFLAGS $tmp -} - -######################################################################### -# Set up the default CFLAGS and BUILD_CFLAGS values. -proc sqlite-setup-default-cflags {} { - ######################################################################## - # We differentiate between two C compilers: the one used for binaries - # which are to run on the build system (in autosetup it's called - # CC_FOR_BUILD and in Makefile.in it's $(B.cc)) and the one used for - # compiling binaries for the target system (CC a.k.a. $(T.cc)). - # Normally they're the same, but they will differ when - # cross-compiling. - set defaultCFlags {-O2} - if {!$::sqliteConfig(is-cross-compiling)} { - # When cross-compiling we default to not using the -g flag, based - # on a /chat discussion prompted by - # https://sqlite.org/forum/forumpost/9a67df63eda9925c - lappend defaultCFlags -g - } - define CFLAGS [proj-get-env CFLAGS $defaultCFlags] - # BUILD_CFLAGS is the CFLAGS for CC_FOR_BUILD. - define BUILD_CFLAGS [proj-get-env BUILD_CFLAGS {-g}] - sqlite-munge-cflags -} - -######################################################################## -# 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 $::sqliteConfig(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 $::sqliteConfig(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 {} - memsys5 -DSQLITE_ENABLE_MEMSYS5 {} - memsys3 {} { - if {[opt-bool memsys5]} { - proj-warn "not enabling memsys3 because memsys5 is enabled." - expr 0 - } else { - sqlite-add-feature-flag -DSQLITE_ENABLE_MEMSYS3 - } - } - bytecode-vtab -DSQLITE_ENABLE_BYTECODE_VTAB {} - scanstatus {-DSQLITE_ENABLE_STMT_SCANSTATUS -DSQLITE_ENABLE_BYTECODE_VTAB} {} - column-metadata -DSQLITE_ENABLE_COLUMN_METADATA {} - dbpage -DSQLITE_ENABLE_DBPAGE_VTAB {} - dbstat -DSQLITE_ENABLE_DBSTAT_VTAB {} - carray -DSQLITE_ENABLE_CARRAY {} - }] { - 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. -proc sqlite-finalize-feature-flags {} { - 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]" - } - set oFF [get-define OPT_SHELL] - if {"" ne $oFF} { - define OPT_SHELL [lsort -unique $oFF] - msg-result "Shell options: [get-define OPT_SHELL]" - } - if {"" ne [set extraSrc [get-define AMALGAMATION_EXTRA_SRC ""]]} { - proj-assert {"canonical" eq $::sqliteConfig(build-mode)} - msg-result "Appending source files to amalgamation: $extraSrc" - } - if {[lsearch [get-define TARGET_DEBUG ""] -DSQLITE_DEBUG=1] > -1} { - msg-result "Note: this is a debug build, so performance will suffer." - } -} - -######################################################################## -# Checks for the --debug flag and [define]s TARGET_DEBUG based on -# that. TARGET_DEBUG is unused in the autoconf build but that is -# arguably a bug. -proc sqlite-handle-debug {} { - msg-checking "SQLITE_DEBUG build? " - proj-if-opt-truthy debug { - define TARGET_DEBUG {-g -DSQLITE_DEBUG=1 -O0 -Wall} - sqlite-add-feature-flag -DSQLITE_ENABLE_SELECTTRACE -DSQLITE_ENABLE_WHERETRACE - proj-opt-set memsys5 - msg-result yes - } { - define TARGET_DEBUG {-DNDEBUG} - msg-result no - } -} - -######################################################################## -# "soname" for libsqlite3.so. See discussion at: -# https://sqlite.org/src/forumpost/5a3b44f510df8ded -proc sqlite-handle-soname {} { - define LDFLAGS_LIBSQLITE3_SONAME "" - if {[proj-opt-was-provided soname]} { - set soname [join [opt-val soname] ""] - } else { - # Enabling soname breaks linking for the --dynlink-tools feature, - # and this project has no direct use for soname, so default to - # none. Package maintainers, on the other hand, like to have an - # soname. - set soname none - } - switch -exact -- $soname { - none - "" { return 0 } - legacy { set soname libsqlite3.so.0 } - default { - if {[string match libsqlite3.* $soname]} { - # use it as-is - } else { - # Assume it's a suffix - set soname "libsqlite3.so.${soname}" - } - } - } - proc-debug "soname=$soname" - if {[proj-check-soname $soname]} { - define LDFLAGS_LIBSQLITE3_SONAME [get-define LDFLAGS_SONAME_PREFIX]$soname - msg-result "Setting SONAME using: [get-define LDFLAGS_LIBSQLITE3_SONAME]" - } elseif {[proj-opt-was-provided soname]} { - # --soname was explicitly requested but not available, so fail fatally - proj-fatal "This environment does not support SONAME." - } else { - # --soname was not explicitly requested but not available, so just warn - msg-result "This environment does not support SONAME." - } -} - -######################################################################## -# 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. -proc sqlite-handle-threadsafe {} { - msg-checking "Support threadsafe operation? " - define LDFLAGS_PTHREAD "" - set enable 0 - proj-if-opt-truthy threadsafe { - msg-result "Checking for libs..." - if {[proj-check-function-in-lib pthread_create pthread] - && [proj-check-function-in-lib pthread_mutexattr_init pthread]} { - set enable 1 - define LDFLAGS_PTHREAD [get-define lib_pthread_create] - undefine lib_pthread_create - undefine lib_pthread_mutexattr_init - } elseif {[proj-opt-was-provided threadsafe]} { - user-error "Missing required pthread libraries. Use --disable-threadsafe to disable this check." - } else { - msg-result "pthread support not detected" - } - # 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" - } - sqlite-add-feature-flag -DSQLITE_THREADSAFE=${enable} - return $enable -} - -######################################################################## -# 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 - } -} - -######################################################################## -# Check for the Emscripten SDK for building the web-based wasm -# components. The core lib and tools do not require this but ext/wasm -# does. Most of the work is done via [proj-check-emsdk], then this -# function adds the following defines: -# -# - EMCC_WRAPPER = "" or top-srcdir/tool/emcc.sh -# - BIN_WASM_OPT = "" or path to wasm-opt -# - BIN_WASM_STRIP = "" or path to wasm-strip -# -# Noting that: -# -# 1) Not finding the SDK is not fatal at this level, nor is failure to -# find one of the related binaries. -# -# 2) wasm-strip is part of the wabt package: -# -# https://github.com/WebAssembly/wabt -# -# and this project requires it for production-mode builds but not dev -# builds. -# -proc sqlite-handle-emsdk {} { - define EMCC_WRAPPER "" - define BIN_WASM_STRIP "" - define BIN_WASM_OPT "" - set srcdir $::autosetup(srcdir) - if {$srcdir ne $::autosetup(builddir)} { - # The EMSDK pieces require writing to the original source tree - # even when doing an out-of-tree build. The ext/wasm pieces do not - # support an out-of-tree build so we treat that case as if EMSDK - # were not found. - msg-result "Out-of tree build: not checking for EMSDK." - return - } - set emccSh $srcdir/tool/emcc.sh - set extWasmConfig $srcdir/ext/wasm/config.make - if {![get-define HAVE_WASI_SDK] && [proj-check-emsdk]} { - define EMCC_WRAPPER $emccSh - set emsdkHome [get-define EMSDK_HOME ""] - proj-assert {"" ne $emsdkHome} - #define EMCC_WRAPPER ""; # just for testing - proj-bin-define wasm-strip - proj-bin-define bash; # ext/wasm/GNUmakefile requires bash - if {[file-isexec $emsdkHome/upstream/bin/wasm-opt]} { - define BIN_WASM_OPT $emsdkHome/upstream/bin/wasm-opt - } else { - # Maybe there's a copy in the path? - proj-bin-define wasm-opt BIN_WASM_OPT - } - proj-dot-ins-append $emccSh.in $emccSh { - catch {exec chmod u+x $dotInsOut} - } - proj-dot-ins-append $extWasmConfig.in $extWasmConfig - } else { - define EMCC_WRAPPER "" - file delete -force -- $emccSh $extWasmConfig - } -} - -######################################################################## -# Internal helper for [sqlite-check-line-editing]. Returns a list of -# potential locations under which readline.h might be found. -# -# On some environments this function may perform extra work to help -# sqlite-check-line-editing figure out how to find libreadline and -# friends. It will communicate those results via means other than the -# result value, e.g. by modifying configure --flags. -proc sqlite-get-readline-dir-list {} { - # Historical note: the dirs list, except for the inclusion of - # $prefix and some platform-specific dirs, originates from the - # legacy configure script. - set dirs [list [get-define prefix]] - switch -glob -- [get-define host] { - *-linux-android { - # Possibly termux - lappend dirs /data/data/com.termux/files/usr - } - *-mingw32 { - lappend dirs /mingw32 /mingw - } - *-mingw64 { - lappend dirs /mingw64 /mingw - } - *-haiku { - lappend dirs /boot/system/develop/headers - if {[opt-val with-readline-ldflags] in {auto ""}} { - # If the user did not supply their own --with-readline-ldflags - # value, hijack that flag to inject options which are known to - # work on Haiku OS installations. - if {"" ne [glob -nocomplain /boot/system/lib/libreadline*]} { - proj-opt-set with-readline-ldflags {-L/boot/system/lib -lreadline} - } - } - } - } - lappend dirs /usr /usr/local /usr/local/readline /usr/contrib - set rv {} - foreach d $dirs { - if {[file isdir $d]} {lappend rv $d} - } - #proc-debug "dirs=$rv" - return $rv -} - -######################################################################## -# sqlite-check-line-editing jumps through proverbial hoops to try to -# find a working line-editing library, setting: -# -# - HAVE_READLINE to 0 or 1 -# - HAVE_LINENOISE to 0, 1, or 2 -# - HAVE_EDITLINE to 0 or 1 -# -# Only one of ^^^ those will be set to non-0. -# -# - LDFLAGS_READLINE = linker flags or empty string -# -# - CFLAGS_READLINE = compilation flags for clients or empty string. -# -# Note that LDFLAGS_READLINE and CFLAGS_READLINE may refer to -# linenoise or editline, not necessarily libreadline. In some cases -# it will set HAVE_READLINE=1 when it's really using editline, for -# reasons described in this function's comments. -# -# Returns a string describing which line-editing approach to use, or -# "none" if no option is available. -# -# Order of checks: -# -# 1) --with-linenoise trumps all others and skips all of the -# complexities involved with the remaining options. -# -# 2) --editline trumps --readline -# -# 3) --disable-readline trumps --readline -# -# 4) Default to automatic search for optional readline -# -# 5) Try to find readline or editline. If it's not found AND the -# corresponding --FEATURE flag was explicitly given then fail -# fatally, else fail non-fatally. -proc sqlite-check-line-editing {} { - msg-result "Checking for line-editing capability..." - define HAVE_READLINE 0 - define HAVE_LINENOISE 0 - define HAVE_EDITLINE 0 - define LDFLAGS_READLINE "" - define CFLAGS_READLINE "" - set failIfNotFound 0 ; # Gets set to 1 for explicit --FEATURE requests - # so that we know whether to fail fatally or not - # if the library is not found. - set libsForReadline {readline edit} ; # -l<LIB> names to check for readline(). - # The libedit check changes this. - set editLibName "readline" ; # "readline" or "editline" - set editLibDef "HAVE_READLINE" ; # "HAVE_READLINE" or "HAVE_EDITLINE" - set dirLn [opt-val with-linenoise] - - # If none of --with-linenoise, --enable-readline, or --enable-editline - # are provided, but there exists a directory "linenoise" at $HOME or - # a sibling of the build or source directory, then try to use that linenoise - # direcctory. - # - if {"" eq $dirLn - && ![proj-opt-was-provided readline] - && ![proj-opt-was-provided editline] - } { - set dirlist ../linenoise - catch {lappend dirlist [file-normalize $::autosetup(srcdir)/../linenoise]} - catch {lappend dirlist $::env(HOME)/linenoise} - foreach d $dirlist { - if {[file exists $d/linenoise.c] && [file exists $d/linenoise.h]} { - set dirLn $d - break - } - } - } - - if {"" ne $dirLn} { - # Use linenoise from a copy of its sources (not a library)... - if {![file isdir $dirLn]} { - proj-fatal "--with-linenoise value is not a directory" - } - set lnH $dirLn/linenoise.h - if {![file exists $lnH] } { - proj-fatal "Cannot find linenoise.h in $dirLn" - } - set lnC "" - set lnCOpts {linenoise-ship.c linenoise.c} - foreach f $lnCOpts { - if {[file exists $dirLn/$f]} { - set lnC $dirLn/$f - break - } - } - if {"" eq $lnC} { - proj-fatal "Cannot find any of $lnCOpts in $dirLn" - } - set flavor "" - set lnVal [proj-which-linenoise $lnH] - switch -- $lnVal { - 1 { set flavor "antirez" } - 2 { set flavor "msteveb" } - default { - proj-fatal "Cannot determine the flavor of linenoise from $lnH" - } - } - define CFLAGS_READLINE "-I$dirLn $lnC" - define HAVE_LINENOISE $lnVal - sqlite-add-shell-opt -DHAVE_LINENOISE=$lnVal - if {$::sqliteConfig(use-jim-for-codegen) && 2 == $lnVal} { - define-append CFLAGS_JIMSH -DUSE_LINENOISE [get-define CFLAGS_READLINE] - user-notice "Adding linenoise support to jimsh." - } else { - msg-result "Using linenoise at [file-normalize $dirLn]" - } - return "linenoise ($flavor)" - } elseif {[opt-bool editline]} { - # libedit mimics libreadline and on some systems does not have its - # own header installed (instead, that of libreadline is used). - # - # shell.c historically expects HAVE_EDITLINE to be set for - # libedit, but it then expects to see <editline/readline.h>, which - # some system's don't actually have despite having libedit. If we - # end up finding <editline/readline.h> below, we will use - # -DHAVE_EDITLINE=1, else we will use -DHAVE_READLINE=1. In either - # case, we will link against libedit. - set failIfNotFound 1 - set libsForReadline {edit} - set editLibName editline - } elseif {![opt-bool readline]} { - msg-result "Readline support explicitly disabled with --disable-readline" - return "none" - } elseif {[proj-opt-was-provided readline]} { - # If an explicit --[enable-]readline was used, fail if it's not - # found, else treat the feature as optional. - set failIfNotFound 1 - } - - # Transform with-readline-header=X to with-readline-cflags=-I... - set v [opt-val with-readline-header] - proj-opt-set with-readline-header "" - if {"" ne $v} { - if {"auto" eq $v} { - proj-opt-set with-readline-cflags auto - } else { - set v [file dirname $v] - if {[string match */readline $v]} { - # Special case: if the path includes .../readline/readline.h, - # set the -I to one dir up from that because our sources - # #include <readline/readline.h> or <editline/readline.h>. - set v [file dirname $v] - } - proj-opt-set with-readline-cflags "-I$v" - } - } - - # Look for readline.h - set rlInc [opt-val with-readline-cflags auto] - if {"auto" eq $rlInc} { - set rlInc "" - if {$::sqliteConfig(is-cross-compiling)} { - # ^^^ this check is derived from the legacy configure script. - proj-warn "Skipping check for readline.h because we're cross-compiling." - } else { - set dirs [sqlite-get-readline-dir-list] - set subdirs [list \ - include/$editLibName \ - readline] - if {"editline" eq $editLibName} { - lappend subdirs include/readline - # ^^^ editline, on some systems, does not have its own header, - # and uses libreadline's header. - } - lappend subdirs include - set rlInc [proj-search-for-header-dir readline.h \ - -dirs $dirs -subdirs $subdirs] - #proc-debug "rlInc=$rlInc" - if {"" ne $rlInc} { - if {[string match */readline $rlInc]} { - set rlInc [file dirname $rlInc]; # CLI shell: #include <readline/readline.h> - } elseif {[string match */editline $rlInc]} { - set editLibDef HAVE_EDITLINE - set rlInc [file dirname $rlInc]; # CLI shell: #include <editline/readline.h> - } - set rlInc "-I${rlInc}" - } - } - } elseif {"" ne $rlInc && ![string match *-I* $rlInc]} { - proj-fatal "Argument to --with-readline-cflags is intended to be CFLAGS and contain -I..." - } - - # If readline.h was found/specified, look for lib(readline|edit)... - # - # This is not quite straightforward because both libreadline and - # libedit typically require some other library which (according to - # legacy autotools-generated tests) provides tgetent(3). On some - # systems that's built into libreadline/edit, on some (most?) its in - # lib[n]curses, and on some it's in libtermcap. - set rlLib "" - if {"" ne $rlInc} { - set rlLib [opt-val with-readline-ldflags] - #proc-debug "rlLib=$rlLib" - if {$rlLib in {auto ""}} { - set rlLib "" ; # make sure it's not "auto", as we may append to it below - set libTerm ""; # lib with tgetent(3) - if {[proj-check-function-in-lib tgetent [list $editLibName ncurses curses termcap]]} { - # ^^^ that libs list comes from the legacy configure script ^^^ - set libTerm [get-define lib_tgetent] - undefine lib_tgetent - } - if {$editLibName eq $libTerm} { - # tgetent(3) was found in the editing library - set rlLib $libTerm - } elseif {[proj-check-function-in-lib readline $libsForReadline $libTerm]} { - # tgetent(3) was found in an external lib - set rlLib [get-define lib_readline] - lappend rlLib $libTerm - undefine lib_readline - } - } - } - - # If we found a library, configure the build to use it... - if {"" ne $rlLib} { - if {"editline" eq $editLibName && "HAVE_READLINE" eq $editLibDef} { - # Alert the user that, despite outward appearances, we won't be - # linking to the GPL'd libreadline. Presumably that distinction is - # significant for those using --editline. - proj-indented-notice { - NOTE: the local libedit uses <readline/readline.h> so we - will compile with -DHAVE_READLINE=1 but will link with - libedit. - } - } - set rlLib [join $rlLib] - set rlInc [join $rlInc] - define LDFLAGS_READLINE $rlLib - define CFLAGS_READLINE $rlInc - proj-assert {$editLibDef in {HAVE_READLINE HAVE_EDITLINE}} - proj-assert {$editLibName in {readline editline}} - sqlite-add-shell-opt -D${editLibDef}=1 - msg-result "Using $editLibName flags: $rlInc $rlLib" - # Check whether rl_completion_matches() has a signature we can use - # and disable that sub-feature if it doesn't. - if {![cctest -cflags "$rlInc -D${editLibDef}" -libs $rlLib -nooutput 1 \ - -source { - #include <stdio.h> - #ifdef HAVE_EDITLINE - #include <editline/readline.h> - #else - #include <readline/readline.h> - #endif - static char * rcg(const char *z, int i){(void)z; (void)i; return 0;} - int main(void) { - char ** x = rl_completion_matches("one", rcg); - (void)x; - return 0; - } - }]} { - proj-warn "readline-style completion disabled due to rl_completion_matches() signature mismatch" - sqlite-add-shell-opt -DSQLITE_OMIT_READLINE_COMPLETION - } - return $editLibName - } - - if {$failIfNotFound} { - proj-fatal "Explicit --$editLibName failed to find a matching library." - } - return "none" -}; # sqlite-check-line-editing - -######################################################################## -# Runs sqlite-check-line-editing and adds a message around it. In the -# canonical build this must not be called before -# sqlite-determine-codegen-tcl for reasons now lost to history (and -# might not still be applicable). -proc sqlite-handle-line-editing {} { - msg-result "Line-editing support for the sqlite3 shell: [sqlite-check-line-editing]" -} - - -######################################################################## -# 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 and 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_ICU [join [opt-val with-icu-ldflags ""]] - define CFLAGS_ICU [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}} { - 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_ICU [get-define PKG_ICU_IO_LDFLAGS] - define-append LDFLAGS_ICU [get-define PKG_ICU_IO_LIBS] - define CFLAGS_ICU [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_ICU $x - set x [exec $icuConfigBin --cppflags] - define-append CFLAGS_ICU $x - } else { - proj-fatal "--with-icu-config=$icuConfigBin does not refer to an executable" - } - } - } - set ldflags [define LDFLAGS_ICU [string trim [get-define LDFLAGS_ICU]]] - set cflags [define CFLAGS_ICU [string trim [get-define CFLAGS_ICU]]] - if {"" ne $ldflags} { - sqlite-add-feature-flag -shell -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 -shell -DSQLITE_ENABLE_ICU_COLLATIONS - # Recall that shell.c builds with sqlite3.c except in the case - # of --disable-static-shell, a combination we do not - # specifically attempt to account for. - } - } 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 --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 (A) some systems where -# dlopen() is in libc and (B) certain Unix-esque Windows -# environments which identify as Windows for SQLite's purposes so -# use LoadLibrary(). -# -# - 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 - set suffix "" - proj-if-opt-truthy load-extension { - switch -glob -- [get-define host] { - *-*-mingw* - *windows* { - incr found - set suffix "Using LoadLibrary()" - } - default { - set found [proj-check-function-in-lib dlopen dl] - if {$found} { - set suffix [define LDFLAGS_DLOPEN [get-define lib_dlopen]] - 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. $suffix" - } 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 -} - -######################################################################## -# 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." - } - define LDFLAGS_MATH [get-define lib_ceil] - undefine lib_ceil - sqlite-add-feature-flag -DSQLITE_ENABLE_MATH_FUNCTIONS -DSQLITE_ENABLE_PERCENTILE - msg-result "Enabling math SQL functions" - } { - define LDFLAGS_MATH "" - msg-result "Disabling math SQL functions" - } -} - -######################################################################## -# If this OS looks like a Mac, checks for the Mac-specific -# -current_version and -compatibility_version linker flags. Defines -# LDFLAGS_MAC_CVERSION to an empty string and returns 0 if they're not -# supported, else defines that to the linker flags and returns 1. -# -# We don't check this on non-Macs because this whole thing is a -# libtool compatibility kludge to account for a version stamp which -# libtool applied only on Mac platforms. -# -# Based on https://sqlite.org/forum/forumpost/9dfd5b8fd525a5d7. -proc sqlite-handle-mac-cversion {} { - define LDFLAGS_MAC_CVERSION "" - set rc 0 - if {[proj-looks-like-mac]} { - cc-with {-link 1} { - # These version numbers are historical libtool-defined values, not - # library-defined ones - if {[cc-check-flags "-Wl,-current_version,9.6.0"] - && [cc-check-flags "-Wl,-compatibility_version,9.0.0"]} { - define LDFLAGS_MAC_CVERSION "-Wl,-compatibility_version,9.0.0 -Wl,-current_version,9.6.0" - set rc 1 - } elseif {[cc-check-flags "-compatibility_version 9.0.0"] - && [cc-check-flags "-current_version 9.6.0"]} { - define LDFLAGS_MAC_CVERSION "-compatibility_version 9.0.0 -current_version 9.6.0" - set rc 1 - } - } - } - return $rc -} - -######################################################################## -# If this is a Mac platform, check for support for -# -Wl,-install_name,... and, if it's available, define -# LDFLAGS_MAC_INSTALL_NAME to a variant of that string which is -# intended to expand at make-time, else set LDFLAGS_MAC_INSTALL_NAME -# to an empty string. -# -# https://sqlite.org/forum/forumpost/5651662b8875ec0a -proc sqlite-handle-mac-install-name {} { - define LDFLAGS_MAC_INSTALL_NAME ""; # {-Wl,-install_name,"$(install-dir.lib)/$(libsqlite3.DLL)"} - set rc 0 - if {[proj-looks-like-mac]} { - cc-with {-link 1} { - if {[cc-check-flags "-Wl,-install_name,/usr/local/lib/libsqlite3.dylib"]} { - define LDFLAGS_MAC_INSTALL_NAME {-Wl,-install_name,"$(install-dir.lib)/$(libsqlite3.DLL)"} - set rc 1 - } - } - } - return $rc -} - -# -# Checks specific to HP-UX. -# -proc sqlite-handle-hpux {} { - switch -glob -- [get-define host] { - *hpux* { - if {[cc-check-flags "-Ae"]} { - define-append CFLAGS -Ae - } - } - } -} - -######################################################################## -# Handles the --dll-basename configure flag. [define]'s -# SQLITE_DLL_BASENAME to the DLL's preferred base name (minus -# extension). If --dll-basename is not provided (or programmatically -# set - see [sqlite-handle-env-quirks]) then this is always -# "libsqlite3", otherwise it may use a different value based on the -# value of [get-define host]. -proc sqlite-handle-dll-basename {} { - if {[proj-opt-was-provided dll-basename]} { - set dn [join [opt-val dll-basename] ""] - if {$dn in {none default}} { set dn libsqlite3 } - } else { - set dn libsqlite3 - } - if {$dn in {auto ""}} { - switch -glob -- [get-define host] { - *-*-cygwin { set dn cygsqlite3-0 } - *-*-ming* { set dn libsqlite3-0 } - *-*-msys { set dn msys-sqlite3-0 } - default { set dn libsqlite3 } - } - } - define SQLITE_DLL_BASENAME $dn -} - -######################################################################## -# [define]s LDFLAGS_OUT_IMPLIB to either an empty string or to a -# -Wl,... flag for the platform-specific --out-implib flag, which is -# used for building an "import library .dll.a" file on some platforms -# (e.g. msys2, mingw). SQLITE_OUT_IMPLIB is defined to the name of the -# import lib or an empty string. Returns 1 if supported, else 0. -# -# The name of the import library is [define]d in SQLITE_OUT_IMPLIB. -# -# If the configure flag --out-implib is not used (or programmatically -# set) then this simply sets the above-listed defines to empty strings -# (but see [sqlite-handle-env-quirks]). If that flag is used but the -# capability is not available, a fatal error is triggered. -# -# This feature is specifically opt-in because it's supported on far -# more platforms than actually need it and enabling it causes creation -# of libsqlite3.so.a files which are unnecessary in most environments. -# -# Added in response to: https://sqlite.org/forum/forumpost/0c7fc097b2 -# -# Platform notes: -# -# - cygwin sqlite packages historically install no .dll.a file. -# -# - msys2 and mingw sqlite packages historically install -# /usr/lib/libsqlite3.dll.a despite the DLL being in -# /usr/bin. -proc sqlite-handle-out-implib {} { - define LDFLAGS_OUT_IMPLIB "" - define SQLITE_OUT_IMPLIB "" - set rc 0 - if {[proj-opt-was-provided out-implib]} { - set olBaseName [join [opt-val out-implib] ""] - if {$olBaseName in {auto ""}} { - set olBaseName "libsqlite3" ;# [get-define SQLITE_DLL_BASENAME] - # Based on discussions with mingw/msys users, the import lib - # should always be called libsqlite3.dll.a even on platforms - # which rename libsqlite3.dll to something else. - } - if {$olBaseName ne "none"} { - cc-with {-link 1} { - set dll "${olBaseName}[get-define TARGET_DLLEXT]" - set flags [proj-cc-check-Wl-flag --out-implib ${dll}.a] - if {"" ne $flags} { - define LDFLAGS_OUT_IMPLIB $flags - define SQLITE_OUT_IMPLIB ${dll}.a - set rc 1 - } - } - if {!$rc} { - user-error "--out-implib is not supported on this platform" - } - } - } - return $rc -} - -######################################################################## -# If the given platform identifier (defaulting to [get-define host]) -# appears to be one of the Unix-on-Windows environments, returns a -# brief symbolic name for that environment, else returns an empty -# string. -# -# It does not distinguish between msys and msys2, returning msys for -# both. The build does not, as of this writing, specifically support -# msys v1. Similarly, this function returns "mingw" for both "mingw32" -# and "mingw64". -proc sqlite-env-is-unix-on-windows {{envTuple ""}} { - if {"" eq $envTuple} { - set envTuple [get-define host] - } - set name "" - switch -glob -- $envTuple { - *-*-cygwin { set name cygwin } - *-*-ming* { set name mingw } - *-*-msys { set name msys } - } - return $name -} - -######################################################################## -# Performs various tweaks to the build which are only relevant on -# certain platforms, e.g. Mac and "Unix on Windows" platforms (msys2, -# cygwin, ...). -# -# 1) DLL installation: -# -# [define]s SQLITE_DLL_INSTALL_RULES to a symbolic name suffix for a -# set of "make install" rules to use for installation of the DLL -# deliverable. The makefile is tasked with providing rules named -# install-dll-NAME which runs the installation for that set, as well -# as providing a rule named install-dll which resolves to -# install-dll-NAME (perhaps indirectly, depending on whether the DLL -# is (de)activated). -# -# The default value is "unix-generic". -# -# 2) --out-implib: -# -# On platforms where an "import library" is conventionally used but -# --out-implib was not explicitly used, automatically add that flag. -# This conventionally applies only to the "Unix on Windows" -# environments like msys and cygwin. -# -# 3) --dll-basename: -# -# On the same platforms addressed by --out-implib, if --dll-basename -# is not explicitly specified, --dll-basename=auto is implied. -proc sqlite-handle-env-quirks {} { - set instName unix-generic; # name of installation rules set - set autoDll 0; # true if --out-implib/--dll-basename should be implied - set host [get-define host] - switch -glob -- $host { - *apple* - - *darwin* { set instName darwin } - default { - set x [sqlite-env-is-unix-on-windows $host] - if {"" ne $x} { - set instName $x - set autoDll 1 - } - } - } - define SQLITE_DLL_INSTALL_RULES $instName - if {$autoDll} { - if {![proj-opt-was-provided out-implib]} { - # Imply --out-implib=auto - proj-indented-notice [subst -nocommands -nobackslashes { - NOTICE: auto-enabling --out-implib for environment [$host]. - Use --out-implib=none to disable this special case - or --out-implib=auto to squelch this notice. - }] - proj-opt-set out-implib auto - } - if {![proj-opt-was-provided dll-basename]} { - # Imply --dll-basename=auto - proj-indented-notice [subst -nocommands -nobackslashes { - NOTICE: auto-enabling --dll-basename for environment [$host]. - Use --dll-basename=default to disable this special case - or --dll-basename=auto to squelch this notice. - }] - proj-opt-set dll-basename auto - } - } - sqlite-handle-dll-basename - sqlite-handle-out-implib - sqlite-handle-mac-cversion - sqlite-handle-mac-install-name - if {[llength [info proc sqlite-custom-handle-flags]] > 0} { - # sqlite-custom-handle-flags is assumed to be imported via a - # client-specific import: autosetup/sqlite-custom.tcl. - sqlite-custom-handle-flags - } -} - -######################################################################## -# Perform some late-stage work and generate the configure-process -# output file(s). -proc sqlite-process-dot-in-files {} { - ######################################################################## - # "Re-export" the autoconf-conventional --XYZdir flags into something - # which is more easily overridable from a make invocation. See the docs - # for [proj-remap-autoconf-dir-vars] for the explanation of why. - # - # We do this late in the config process, immediately before we export - # the Makefile and other generated files, so that configure tests - # which make make use of the autotools-conventional flags - # (e.g. [proj-check-rpath]) may do so before we "mangle" them here. - proj-remap-autoconf-dir-vars - - proj-dot-ins-process -validate - make-config-header sqlite_cfg.h \ - -bare {SIZEOF_* HAVE_DECL_*} \ - -none {HAVE_CFLAG_* LDFLAGS_* SH_* SQLITE_AUTORECONFIG - TARGET_* USE_GCOV TCL_*} \ - -auto {HAVE_* PACKAGE_*} \ - -none * - proj-touch sqlite_cfg.h ; # help avoid frequent unnecessary @SQLITE_AUTORECONFIG@ -} - -######################################################################## -# Handle --with-wasi-sdk[=DIR] -# -# This must be run relatively early on because it may change the -# toolchain and disable a number of config options. However, in the -# canonical build this must come after [sqlite-check-common-bins]. -proc sqlite-handle-wasi-sdk {} { - set wasiSdkDir [opt-val with-wasi-sdk] ; # ??? [lindex [opt-val with-wasi-sdk] end] - define HAVE_WASI_SDK 0 - if {$wasiSdkDir eq ""} { - return 0 - } elseif {$::sqliteConfig(is-cross-compiling)} { - proj-fatal "Cannot combine --with-wasi-sdk with cross-compilation" - } - msg-result "Checking WASI SDK directory \[$wasiSdkDir]... " - proj-affirm-files-exist -v {*}[prefix "$wasiSdkDir/bin/" {clang wasm-ld ar}] - define HAVE_WASI_SDK 1 - define WASI_SDK_DIR $wasiSdkDir - # Disable numerous options which we know either can't work or are - # not useful in this build... - msg-result "Using wasi-sdk clang. Disabling CLI shell and modifying config flags:" - # Boolean (--enable-/--disable-) flags which must be switched off: - foreach opt { - dynlink-tools - editline - gcov - icu-collations - load-extension - readline - shared - tcl - threadsafe - } { - if {[proj-opt-exists $opt] && [opt-bool $opt]} { - # -^^^^ not all builds define all of these flags - msg-result " --disable-$opt" - proj-opt-set $opt 0 - } - } - # Non-boolean flags which need to be cleared: - foreach opt { - with-emsdk - with-icu-config - with-icu-ldflags - with-icu-cflags - with-linenoise - with-tcl - } { - if {[proj-opt-was-provided $opt]} { - msg-result " removing --$opt" - proj-opt-set $opt "" - } - } - # Remember that we now have a discrepancy between - # $::sqliteConfig(is-cross-compiling) and [proj-is-cross-compiling]. - set ::sqliteConfig(is-cross-compiling) 1 - - # - # Changing --host and --target have no effect here except to - # possibly cause confusion. Autosetup has finished processing them - # by this point. - # - # host_alias=wasm32-wasi - # target=wasm32-wasi - # - # Merely changing CC, LD, and AR to the wasi-sdk's is enough to get - # sqlite3.o building in WASM format. - # - define CC "${wasiSdkDir}/bin/clang" - define LD "${wasiSdkDir}/bin/wasm-ld" - define AR "${wasiSdkDir}/bin/ar" - #define STRIP "${wasiSdkDir}/bin/strip" - return 1 -}; # sqlite-handle-wasi-sdk - -######################################################################## -# TCL... -# -# sqlite-check-tcl performs most of the --with-tcl and --with-tclsh -# handling. Some related bits and pieces are performed before and -# after that function is called. -# -# Important [define]'d vars: -# -# - HAVE_TCL indicates whether we have a tclsh suitable for building -# the TCL SQLite extension and, by extension, the testing -# infrastructure. This must only be 1 for environments where -# tclConfig.sh can be found. -# -# - TCLSH_CMD is the path to the canonical tclsh or "". It never -# refers to jimtcl. -# -# - TCL_CONFIG_SH is the path to tclConfig.sh or "". -# -# - TCLLIBDIR is the dir to which libtclsqlite3 gets installed. -# -# - BTCLSH = the path to the tcl interpreter used for in-tree code -# generation. It may be jimtcl or the canonical tclsh but may not -# be empty - this tree requires TCL to generated numerous -# components. -# -# If --tcl or --with-tcl are provided but no TCL is found, this -# function fails fatally. If they are not explicitly provided then -# failure to find TCL is not fatal but a loud warning will be emitted. -# -proc sqlite-check-tcl {} { - define TCLSH_CMD false ; # Significant is that it exits with non-0 - define HAVE_TCL 0 ; # Will be enabled via --tcl or a successful search - define TCLLIBDIR "" ; # Installation dir for TCL extension lib - define TCL_CONFIG_SH ""; # full path to tclConfig.sh - - # Clear out all vars which would harvest from tclConfig.sh so that - # the late-config validation of @VARS@ works even if --disable-tcl - # is used. - proj-tclConfig-sh-to-autosetup "" - - file delete -force ".tclenv.sh"; # ensure no stale state from previous configures. - if {![opt-bool tcl]} { - proj-indented-notice { - NOTE: TCL is disabled via --disable-tcl. This means that none - of the TCL-based components will be built, including tests - and sqlite3_analyzer. - } - return - } - # TODO: document the steps this is taking. - set srcdir $::autosetup(srcdir) - msg-result "Checking for a suitable tcl... " - proj-assert [proj-opt-truthy tcl] - set use_tcl 1 - set with_tclsh [opt-val with-tclsh] - set with_tcl [opt-val with-tcl] - if {"prefix" eq $with_tcl} { - set with_tcl [get-define prefix] - } - proc-debug "use_tcl ${use_tcl}" - proc-debug "with_tclsh=${with_tclsh}" - proc-debug "with_tcl=$with_tcl" - if {"" eq $with_tclsh && "" eq $with_tcl} { - # If neither --with-tclsh nor --with-tcl are provided, try to find - # a workable tclsh. - set with_tclsh [proj-first-bin-of tclsh9.1 tclsh9.0 tclsh8.6 tclsh] - proc-debug "with_tclsh=${with_tclsh}" - } - - set doConfigLookup 1 ; # set to 0 to test the tclConfig.sh-not-found cases - if {"" ne $with_tclsh} { - # --with-tclsh was provided or found above. Validate it and use it - # to trump any value passed via --with-tcl=DIR. - if {![file-isexec $with_tclsh]} { - proj-fatal "TCL shell $with_tclsh is not executable" - } else { - define TCLSH_CMD $with_tclsh - #msg-result "Using tclsh: $with_tclsh" - } - if {$doConfigLookup && - [catch {exec $with_tclsh $::autosetup(libdir)/find_tclconfig.tcl} result] == 0} { - set with_tcl $result - } - if {"" ne $with_tcl && [file isdir $with_tcl]} { - msg-result "$with_tclsh recommends the tclConfig.sh from $with_tcl" - } else { - proj-warn "$with_tclsh is unable to recommend a tclConfig.sh" - set use_tcl 0 - } - } - set cfg "" - set tclSubdirs {tcl9.1 tcl9.0 tcl8.6 lib} - while {$use_tcl} { - if {"" ne $with_tcl} { - # Ensure that we can find tclConfig.sh under ${with_tcl}/... - if {$doConfigLookup} { - if {[file readable "${with_tcl}/tclConfig.sh"]} { - set cfg "${with_tcl}/tclConfig.sh" - } else { - foreach i $tclSubdirs { - if {[file readable "${with_tcl}/$i/tclConfig.sh"]} { - set cfg "${with_tcl}/$i/tclConfig.sh" - break - } - } - } - } - if {"" eq $cfg} { - proj-fatal "No tclConfig.sh found under ${with_tcl}" - } - } else { - # If we have not yet found a tclConfig.sh file, look in $libdir - # which is set automatically by autosetup or via the --prefix - # command-line option. See - # https://sqlite.org/forum/forumpost/e04e693439a22457 - set libdir [get-define libdir] - if {[file readable "${libdir}/tclConfig.sh"]} { - set cfg "${libdir}/tclConfig.sh" - } else { - foreach i $tclSubdirs { - if {[file readable "${libdir}/$i/tclConfig.sh"]} { - set cfg "${libdir}/$i/tclConfig.sh" - break - } - } - } - if {![file readable $cfg]} { - break - } - } - msg-result "Using tclConfig.sh: $cfg" - break - } - define TCL_CONFIG_SH $cfg - # Export a subset of tclConfig.sh to the current TCL-space. If $cfg - # is an empty string, this emits empty-string entries for the - # various options we're interested in. - proj-tclConfig-sh-to-autosetup $cfg - - if {"" eq $with_tclsh && $cfg ne ""} { - # We have tclConfig.sh but no tclsh. Attempt to locate a tclsh - # based on info from tclConfig.sh. - set tclExecPrefix [get-define TCL_EXEC_PREFIX] - proj-assert {"" ne $tclExecPrefix} - set tryThese [list \ - $tclExecPrefix/bin/tclsh[get-define TCL_VERSION] \ - $tclExecPrefix/bin/tclsh ] - foreach trySh $tryThese { - if {[file-isexec $trySh]} { - set with_tclsh $trySh - break - } - } - if {![file-isexec $with_tclsh]} { - proj-warn "Cannot find a usable tclsh (tried: $tryThese) - } - } - define TCLSH_CMD $with_tclsh - if {$use_tcl} { - # Set up the TCLLIBDIR - # - # 2024-10-28: calculation of TCLLIBDIR is now done via the shell - # in main.mk (search it for T.tcl.env.sh) so that - # static/hand-written makefiles which import main.mk do not have - # to define that before importing main.mk. Even so, we export - # TCLLIBDIR from here, which will cause the canonical makefile to - # use this one rather than to re-calculate it at make-time. - set tcllibdir [get-env TCLLIBDIR ""] - set sq3Ver [get-define PACKAGE_VERSION] - if {"" eq $tcllibdir} { - # Attempt to extract TCLLIBDIR from TCL's $auto_path - if {"" ne $with_tclsh && - [catch {exec echo "puts stdout \$auto_path" | "$with_tclsh"} result] == 0} { - foreach i $result { - if {[file isdir $i]} { - set tcllibdir $i/sqlite${sq3Ver} - break - } - } - } else { - proj-warn "Cannot determine TCLLIBDIR." - # The makefile will fail fatally in this case if a target is - # invoked which requires TCLLIBDIR. - } - } - #if {"" ne $tcllibdir} { msg-result "TCLLIBDIR = ${tcllibdir}"; } - define TCLLIBDIR $tcllibdir - }; # find TCLLIBDIR - - if {[file-isexec $with_tclsh]} { - msg-result "Using tclsh: $with_tclsh" - if {$cfg ne ""} { - define HAVE_TCL 1 - } else { - proj-warn "Found tclsh but no tclConfig.sh." - } - } - show-notices - # If TCL is not found: if it was explicitly requested then fail - # fatally, else just emit a warning. If we can find the APIs needed - # to generate a working JimTCL then that will suffice for build-time - # TCL purposes (see: proc sqlite-determine-codegen-tcl). - if {![get-define HAVE_TCL] && - ([proj-opt-was-provided tcl] || [proj-opt-was-provided with-tcl])} { - proj-fatal "TCL support was requested but no tclConfig.sh could be found." - } - if {"" eq $cfg} { - proj-assert {0 == [get-define HAVE_TCL]} - proj-indented-notice { - WARNING: Cannot find a usable tclConfig.sh file. Use - --with-tcl=DIR to specify a directory where tclConfig.sh can be - found. SQLite does not use TCL internally, but some optional - components require TCL, including tests and sqlite3_analyzer. - } - } -}; # sqlite-check-tcl - -######################################################################## -# sqlite-determine-codegen-tcl checks which TCL to use as a code -# generator. By default, prefer jimsh simply because we have it -# in-tree (it's part of autosetup) unless --with-tclsh=X is used, in -# which case prefer X. -# -# Returns the human-readable name of the TCL it selects. Fails fatally -# if it cannot detect a TCL appropriate for code generation. -# -# Defines: -# -# - BTCLSH = the TCL shell used for code generation. It may set this -# to an unexpanded makefile var name. -# -# - CFLAGS_JIMSH = any flags needed for buildng a BTCLSH-compatible -# jimsh. The defaults may be passed on to configure as -# CFLAGS_JIMSH=... -proc sqlite-determine-codegen-tcl {} { - msg-result "Checking for TCL to use for code generation... " - define CFLAGS_JIMSH [proj-get-env CFLAGS_JIMSH {-O1}] - set cgtcl [opt-val with-tclsh jimsh] - if {"jimsh" ne $cgtcl} { - # When --with-tclsh=X is used, use that for all TCL purposes, - # including in-tree code generation, per developer request. - define BTCLSH "\$(TCLSH_CMD)" - return $cgtcl - } - set flagsToRestore {CC CFLAGS AS_CFLAGS CPPFLAGS AS_CPPFLAGS LDFLAGS LINKFLAGS LIBS CROSS} - define-push $flagsToRestore { - # We have to swap CC to CC_FOR_BUILD for purposes of the various - # [cc-...] tests below. Recall that --with-wasi-sdk may have - # swapped out CC with one which is not appropriate for this block. - # Per consulation with autosetup's creator, doing this properly - # requires us to [define-push] the whole $flagsToRestore list - # (plus a few others which are not relevant in this tree). - # - # These will get set to their previous values at the end of this - # block. - foreach flag $flagsToRestore {define $flag ""} - define CC [get-define CC_FOR_BUILD] - # These headers are technically optional for JimTCL but necessary if - # we want to use it for code generation: - set sysh [cc-check-includes dirent.h sys/time.h] - # jimsh0.c hard-codes #define's for HAVE_DIRENT_H and - # HAVE_SYS_TIME_H on the platforms it supports, so we do not - # need to add -D... flags for those. We check for them here only - # so that we can avoid the situation that we later, at - # make-time, try to compile jimsh but it then fails due to - # missing headers (i.e. fail earlier rather than later). - if {$sysh && [cc-check-functions realpath]} { - define-append CFLAGS_JIMSH -DHAVE_REALPATH - define BTCLSH "\$(JIMSH)" - set ::sqliteConfig(use-jim-for-codegen) 1 - } elseif {$sysh && [cc-check-functions _fullpath]} { - # _fullpath() is a Windows API. It's not entirely clear - # whether we need to add {-DHAVE_SYS_TIME_H -DHAVE_DIRENT_H} - # to CFLAGS_JIMSH in this case. On MinGW32 we definitely do - # not want to because it already hard-codes them. On _MSC_VER - # builds it does not. - define-append CFLAGS_JIMSH -DHAVE__FULLPATH - define BTCLSH "\$(JIMSH)" - set ::sqliteConfig(use-jim-for-codegen) 1 - } elseif {[file-isexec [get-define TCLSH_CMD]]} { - set cgtcl [get-define TCLSH_CMD] - define BTCLSH "\$(TCLSH_CMD)" - } else { - # One last-ditch effort to find TCLSH_CMD: use info from - # tclConfig.sh to try to find a tclsh - if {"" eq [get-define TCLSH_CMD]} { - set tpre [get-define TCL_EXEC_PREFIX] - if {"" ne $tpre} { - set tv [get-define TCL_VERSION] - if {[file-isexec "${tpre}/bin/tclsh${tv}"]} { - define TCLSH_CMD "${tpre}/bin/tclsh${tv}" - } elseif {[file-isexec "${tpre}/bin/tclsh"]} { - define TCLSH_CMD "${tpre}/bin/tclsh" - } - } - } - set cgtcl [get-define TCLSH_CMD] - if {![file-isexec $cgtcl]} { - proj-fatal "Cannot find a tclsh to use for code generation." - } - define BTCLSH "\$(TCLSH_CMD)" - } - }; # /define-push $flagsToRestore - return $cgtcl -}; # sqlite-determine-codegen-tcl - -######################################################################## -# Runs sqlite-check-tcl and, if this is the canonical build, -# sqlite-determine-codegen-tcl. -proc sqlite-handle-tcl {} { - sqlite-check-tcl - if {"canonical" ne $::sqliteConfig(build-mode)} return - msg-result "TCL for code generation: [sqlite-determine-codegen-tcl]" - - # Determine the base name of the Tcl extension's DLL - # - if {[get-define HAVE_TCL]} { - if {[string match *-cygwin [get-define host]]} { - set libname cyg - } else { - set libname lib - } - if {[get-define TCL_MAJOR_VERSION] > 8} { - append libname tcl9 - } - append libname sqlite - } else { - set libname "" - } - define TCL_EXT_DLL_BASENAME $libname - # The extension is added in the makefile -} - -######################################################################## -# Handle the --enable/disable-rpath flag. -proc sqlite-handle-rpath {} { - # autosetup/cc-shared.tcl sets the rpath flag definition in - # [get-define SH_LINKRPATH], but it does so on a per-platform basis - # rather than as a compiler check. Though we should do a proper - # compiler check (as proj-check-rpath does), we may want to consider - # adopting its approach of clearing the rpath flags for environments - # for which sqlite-env-is-unix-on-windows returns a non-empty - # string. - - # https://sqlite.org/forum/forumpost/13cac3b56516f849 - if {[proj-opt-truthy rpath]} { - proj-check-rpath - } else { - msg-result "Disabling use of rpath." - define LDFLAGS_RPATH "" - } -} - -######################################################################## -# If the --dump-defines configure flag is provided then emit a list of -# all [define] values to config.defines.txt, else do nothing. -proc sqlite-dump-defines {} { - proj-if-opt-truthy dump-defines { - make-config-header $::sqliteConfig(dump-defines-txt) \ - -bare {SQLITE_OS* SQLITE_DEBUG USE_*} \ - -str {BIN_* CC LD AR LDFLAG* OPT_*} \ - -auto {*} - # achtung: ^^^^ whichever SQLITE_OS_foo flag which is set to 0 will - # get _undefined_ here unless it's part of the -bare set. - if {"" ne $::sqliteConfig(dump-defines-json)} { - msg-result "--dump-defines is creating $::sqliteConfig(dump-defines-json)" - ######################################################################## - # Dump config-defines.json... - # Demonstrate (mis?)handling of spaces in JSON-export array values: - # define-append OPT_FOO.list {"-DFOO=bar baz" -DBAR="baz barre"} - define OPT_FEATURE_FLAGS.list [get-define OPT_FEATURE_FLAGS] - define OPT_SHELL.list [get-define OPT_SHELL] - set dumpDefsOpt { - -bare {SIZEOF_* HAVE_DECL_*} - -none {HAVE_CFLAG_* LDFLAGS_* SH_* SQLITE_AUTORECONFIG TARGET_* USE_GCOV TCL_*} - -array {*.list} - -auto {OPT_* PACKAGE_* HAVE_*} - } -# if {$::sqliteConfig(dump-defines-json-include-lowercase)} { -# lappend dumpDefsOpt -none {lib_*} ; # remnants from proj-check-function-in-lib and friends -# lappend dumpDefsOpt -auto {[a-z]*} -# } - lappend dumpDefsOpt -none * - proj-dump-defs-json $::sqliteConfig(dump-defines-json) {*}$dumpDefsOpt - undefine OPT_FEATURE_FLAGS.list - undefine OPT_SHELL.list - } - } -} |