# Created by migrate-autoconf - fix items marked XXX global autosetup use cc cc-db cc-shared cc-lib hwaci-common set DUMP_DEFINES_FILE defines.list define ENABLE_SHARED 1 # Are we cross compiling? set cross_compiling 0 if {[get-define host] ne [get-define build]} { set cross_compiling 1 } ######################################################################## # A very long story made short, autosetup's --flag handling has # some behaviors which make it impossible to implement 100% identical # flags, compared to the historical autotools build. The differences # are documented here: # # # 1) --debug is used by autosetup itself, so we have to rename it to # --with-debug. We cannot use --enable-debug because that is, for # autosetup, and alias for --debug=1. # # 2) In autosetup, all flags starting with (--enable, --disable) are # forced to be booleans and received special handling in how they're # resolved. Because of that we have to rename: # # 2.1) --enable-tempstore[=no] to --with-tempstore[=no]. # options { with-debug:=1 => {Enable debug build flags} with-tclsh:PATH => {Full pathname of tclsh to use} with-tcl:DIR => {Directory containing tclConfig.sh} tcl=1 => {Disable building accessory programs that require TCL-dev} test-status => {Enable status of tests} threadsafe=1 => {Disable mutexing} with-tempstore:=no => {Use an in-ram database for temporary tables: never,no,yes,always.} editline=0 => {BSD editline support} readline=1 => {Disable readline support} largefile=1 => {Disable large file support} with-readline-lib => {readline library} with-readline-inc => {readline include paths} with-linenoise:DIR => {} amalgamation=1 => {Disable the amalgamation and instead build all files separately} load-extension=1 => {Disable loading of external extensions} math=1 => {Disable math functions} json=1 => {Disable JSON functions} all => {Enable FTS4, FTS5, Geopoly, RTree, Sessions} 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} gcov=0 => {Enable coverage testing using gcov} linemacros => {Enable #line macros in the amalgamation.} with-wasi-sdk:=/opt/wasi-sdk => {Top-most dir of the wasi-sdk for a WASI build.} with-emsdk:DIR => {Top-most dir of the Emscripten SDK installation} dump-defines=1 => {Disable dump of autosetup defines to $DUMP_DEFINES_FILE} } ######################################################################## # Notes about certain historical flags: # # --releasemode: libtool-specific (which we don't have now) # # set srcdir $autosetup(srcdir) set top_srcdir [get-define abs_top_srcdir] puts "srcdir = $srcdir" puts "top_srcdir = $top_srcdir" set RELEASE [readfile $autosetup(srcdir)/VERSION] regsub {([0-9]*\.*[0-9]*).*} $RELEASE {\1} VERSION define VERSION $VERSION define RELEASE $RELEASE puts "RELEASE = $RELEASE" puts "VERSION = $VERSION" define SQLITE_AUTOREMAKE cd define-append SQLITE_AUTOREMAKE $autosetup(srcdir) && $top_srcdir/configure {*}$autosetup(argv) set outOfTreeBuild 0 if {![file exists sqlite3.pc.in]} { puts "This appears to be an out-of-tree build." set outOfTreeBuild 1 } cc-check-tools ld ar ######################################################################## # The build process allows for using a cross-compiler. But the default # action is to target the same platform that we are running on. The # configure script needs to discover the following properties of the # build and target systems: # # srcdir # # The is the name of the directory that contains the # "configure" shell script. All source files are # located relative to this directory. # # bindir # # The name of the directory where executables should be # written by the "install" target of the makefile. # # program_prefix # # Add this prefix to the names of all executables that run # on the target machine. Default: "" # # ENABLE_SHARED # # True if shared libraries should be generated. # # BUILD_CC # # The name of a command that is used to convert C # source files into executables that run on the build # platform. # # BUILD_CFLAGS # # Switches that the build compiler needs in order to construct # command-line programs. # # BUILD_LIBS # # Libraries that the build compiler needs in order to construct # command-line programs. # # TCL_* # # Lots of values are read in from the tclConfig.sh script, # if that script is available. This values are used for # constructing and installing the TCL extension. # # TARGET_READLINE_LIBS # # This is the library directives passed to the target linker # that cause the executable to link against the readline library. # This might be a switch like "-lreadline" or pathnames of library # file like "../../src/libreadline.a". # # TARGET_READLINE_INC # # This variables define the directory that contain header # files for the readline library. If the compiler is able # to find on its own, then this can be blank. # # OPT_FEATURE_FLAGS = -DSQLITE_OMIT/ENABLE flags. define OPT_FEATURE_FLAGS {} define OPT_SHELL {}; # CFLAGS for the sqlite3 CLI app # Adds $flag, if not empty, to OPT_FEATURE_FLAGS. proc add-feature-flag {args} { if {"" ne $args} { define-append OPT_FEATURE_FLAGS {*}$args } } # add-feature-flag -DSQLITE_JUST_TESTING=3 proc add-shell-opt {args} { if {"" ne $args} { define-append OPT_SHELL {*}$args } } hwaci-file-extensions if {".exe" eq [get-define TARGET_EXEEXT]} { define SQLITE_OS_UNIX 0 define SQLITE_OS_WIN 1 # todo? add -DSQLITE_OS_WIN=1 to CFLAGS? } else { define SQLITE_OS_UNIX 1 define SQLITE_OS_WIN 0 # todo? add -DSQLITE_OS_UNIX=1 to CFLAGS? } ######### # Programs needed if {"" eq [hwaci-bin-define install]} { msg-result "Cannot find install binary, so 'make install' will not work." } ######################################################################## # Locate a compiler for the build machine. This compiler should # generate command-line programs that run on the build machine. # # XXX if test x"$cross_compiling" = xno; then # XXX BUILD_CC=$CC # XXX BUILD_CFLAGS=$CFLAGS # XXX else # XXX if test "${BUILD_CC+set}" != set; then # XXX AC_CHECK_PROGS BUILD_CC gcc cc cl # XXX fi # XXX if test "${BUILD_CFLAGS+set}" != set; then # XXX BUILD_CFLAGS="-g" # XXX fi # XXX fi # XXX AC_SUBST BUILD_CC define BUILD_CC [get-define CC_FOR_BUILD] define BUILD_CFLAGS [get-env CFLAGS {-g}] ######################################################################## # Handle --with-wasi-sdk=DIR # # This must be early because it may change the toolchain and several # config options. # # It's unclear whether we can actually get away with making these # changes to the autosetup environment. if {1} { set wasiSdkDir [opt-val with-wasi-sdk] ; # ??? [lindex [opt-val with-wasi-sdk] end] #puts "x wasiSdkDir=$wasiSdkDir foo=[lindex [opt-val with-wasi-sdk] end]" if {$wasiSdkDir ne ""} { msg-checking "Checking WASI SDK directory \[$wasiSdkDir]... " puts "prefix = [prefix $wasiSdkDir/bin {clang ld}]" hwaci-affirm-files-exist -v {*}[prefix "$wasiSdkDir/bin/" {clang wasm-ld}] msg-result "Using wasi-sdk clang, disabling: tcl, CLI shell, DLL, loadable extensions, threading" define HAVE_WASI_SDK 1 define WASI_SDK_DIR $wasiSdkDir hwaci-opt-set load-extension 0; # ==> --disable-load-extension hwaci-opt-set threadsafe 0; # ==> --threadsafe=0 hwaci-opt-set tcl 0; # ==> --disable-tcl define HAVE_TCL 0 set cross_compiling 1 # libtool is apparently hard-coded to use gcc for linking DLLs, so # we disable the DLL build. define ENABLE_SHARED 0 # Changing --host and --target have no effect here except to possibly # cause confusion. autoconf has finished processing them by this # point. # # host_alias=wasm32-wasi # target=wasm32-wasi # # Merely changing CC and LD to the wasi-sdk's is enough to get # sqlite3.o building in WASM format. # XXX CC="${wasiSdkDir}/bin/clang" # XXX LD="${wasiSdkDir}/bin/wasm-ld" # XXX RANLIB="${wasiSdkDir}/bin/llvm-ranlib" define CC "${wasiSdkDir}/bin/clang" define LD "${wasiSdkDir}/bin/wasm-ld" #define STRIP "${wasiSdkDir}/bin/strip" } unset wasiSdkDir }; # --wasi-sdk-dir # # Enable large file support (if special flags are necessary) cc-check-lfs # # Check for needed/wanted data types 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 \ malloc_usable_size strchrnul usleep utime pread pread64 pwrite pwrite64 hwaci-check-function-in-lib fdatasync rt define LDFLAGS_FDATASYNC [get-define lib_fdatasync] undefine lib_fdatasync # # 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 \ stdint.h inttypes.h # These are optional for JimTCL but necessary if we want to use it for # code generation: cc-check-includes dirent.h sys/time.h if {[cc-check-includes zlib.h] && [hwaci-check-function-in-lib deflate z]} { # TODO: port over the more sophisticated zlib search from the fossil auto.def define HAVE_ZLIB 1; # "-DSQLITE_HAVE_ZLIB=1" define LDFLAGS_ZLIB -lz # -DSQLITE_HAVE_ZLIB=1 is handled separately from the other feature # flags in the autotools build # add-feature-flag -DSQLITE_HAVE_ZLIB=1 define CFLAGS_ZLIB -DSQLITE_HAVE_ZLIB=1 } else { define HAVE_ZLIB 0 define LDFLAGS_ZLIB "" define CFLAGS_ZLIB "" } hwaci-define-if-opt-truthy amalgamation USE_AMALGAMATION \ "Use amalgamation for builds?" hwaci-define-if-opt-truthy gcov USE_GCOV "Use gcov?" hwaci-define-if-opt-truthy test-status TSTRNNR_OPTS \ "test-runner flags:" {--status} {} hwaci-define-if-opt-truthy linemacros AMALGAMATION_LINE_MACROS \ "Use #line macros in the amalgamation:" {--linemacros=1} {--linemacros=0} msg-checking "Debug build? " hwaci-if-opt-truthy with-debug { define SQLITE_DEBUG 1 define TARGET_DEBUG {-DSQLITE_DEBUG=1 -DSQLITE_ENABLE_SELECTTRACE -DSQLITE_ENABLE_WHERETRACE -O0 -Wall} msg-result yes } { define TARGET_DEBUG {-DNDEBUG} msg-result no } ######################################################################## # TCL... # # Under construction. An attempt to port most of the # --with-tcl/--with-tclsh logic from configure.ac to autosetup. This # part would actually be easier in the shell, and some of it will # seemingly be impossible without shell code. define HAVE_TCL 0 define TCLSH_CMD {exit 1} proc hwaci-check-tcl {} { global top_srcdir puts "Checking for a suitable tcl... " set optTcl [hwaci-opt-truthy tcl] set use_tcl $optTcl set tclsh "" set with_tclsh [opt-val with-tclsh] set with_tcl [opt-val with-tcl] # puts "hwaci-check-tcl: use_tcl ${use_tcl}" # puts "hwaci-check-tcl: with_tclsh=${with_tclsh}" # puts "hwaci-check-tcl: with_tcl=$with_tcl" if {"" eq $with_tclsh && "" eq $with_tcl} { set with_tclsh [hwaci-first-bin-of tclsh8.6 tclsh tclsh9.0] } if {"" ne $with_tclsh} { if {![file isfile $with_tclsh]} { hwaci-error "TCL shell $with_tclsh is not a file" } elseif {![file executable $with_tclsh]} { hwaci-error "TCL shell $with_tclsh is not executable" } else { define TCLSH_CMD $with_tclsh puts "Using tclsh at \"$with_tclsh\"" } if {$use_tcl} { #set with_tcl [exec $with_tclsh $top_srcdir/tool/find_tclconfig.tcl] if {[catch {exec $with_tclsh $top_srcdir/tool/find_tclconfig.tcl} result] == 0} { set with_tcl $result } if {"" ne $with_tcl && [file isdir $with_tcl]} { puts "$with_tclsh recommends the tclConfig.sh from $with_tcl" } else { puts "$with_tclsh is unable to recommand a tclConfig.sh" set use_tcl 0 } } } set cfg "" set tclSubdirs {tcl8.6 tcl9.0 lib} if {$use_tcl} { if {"" ne $with_tcl} { 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} { hwaci-error "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 by 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]} { hwaci-error { 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 TCL is required to build SQLite from canonical sources and TCL is required for testing. } } } } elseif {!$optTcl} { puts "Unable to run tests because of --disable-tcl" } else { puts "Unable to run tests because no tclConfig.sh file could be located" } define HAVE_TCL $use_tcl define TCL_CONFIG_SH $cfg # The historical configure.ac sources tclConfig.sh so that it can # use the several TCL_... env vars. We obviously cannot do that from # TCL, so we apply a level of indirection. If the config is not # available, this generates empty-string entries for the various # options we're interested in. eval [exec "${top_srcdir}/tool/tclConfigShToTcl.sh" "[get-define TCL_CONFIG_SH]"] # puts "hwaci-check-tcl: with_tclsh=$with_tclsh" # puts "hwaci-check-tcl: with_tcl=$with_tcl" # puts "hwaci-check-tcl: cfg=$cfg" # puts "hwaci-check-tcl: use_tcl ${use_tcl}" } hwaci-check-tcl ######################################################################## # Check which TCL to use as a code generator. Prefer jimsh simply # because we have it in-tree (it's part of autosetup). define CFLAGS_JIMSH {} puts "Which TCL to use for code generation... " set cgtcl jimtcl if {[cc-check-functions realpath]} { define-append CFLAGS_JIMSH -DHAVE_REALPATH define BTCL "\$(JIMSH)" } elseif {[cc-check-functions _fullpath]} { # _fullpath() is a Windows API define-append CFLAGS_JIMSH -DHAVE__FULLPATH define BTCL "\$(JIMSH)" } elseif {"" ne [get-define TCLSH_CMD]} { set cgtcl [get-define TCLSH_CMD] define BTCL "\$(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 executable "${tpre}/bin/tclsh${tv}"]} { define TCLSH_CMD "${tpre}/bin/tclsh${tv}" } elseif {[file executable "${tpre}/bin/tclsh"]} { define TCLSH_CMD "${tpre}/bin/tclsh" } unset tv } unset tpre if {"" eq [get-define TCLSH_CMD]} { hwaci-error "Cannot find a tclsh to use for code generation." } } set cgtcl [get-define TCLSH_CMD] define BTCL "\$(TCLSH_CMD)" } puts "TCL for code generation: $cgtcl" unset cgtcl # /TCL ######################################################################## ######################################################################## # Thread safety? msg-checking "Support threadsafe operation? " hwaci-if-opt-truthy threadsafe { msg-result yes add-feature-flag -DSQLITE_THREADSAFE=1 if {![hwaci-check-function-in-lib pthread_create pthread] || ![hwaci-check-function-in-lib pthread_mutexattr_init pthread]} { user-error "Missing required pthread bits" } define LDFLAGS_PTHREAD [get-define lib_pthread_create] undefine lib_pthread_create } { msg-result no add-feature-flag -DSQLITE_THREADSAFE=0 define LDFLAGS_PTHREAD "" } ######################################################################## # Do we want temporary databases in memory? # if {1} { set ts [opt-val with-tempstore no] set tsn 1 msg-checking "Use an in-ram database for temporary tables? " switch -- $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 define TEMP_STORE $tsn unset ts tsn } if {1} { ########## # Figure out what C libraries are required to compile programs # that use "readline()" library. hwaci-check-readline } else { # Older impl solely for reference while porting... # # XXX TARGET_READLINE_LIBS="" # XXX TARGET_READLINE_INC="" # XXX TARGET_HAVE_READLINE=0 # XXX TARGET_HAVE_EDITLINE=0 if {[opt-bool editline]} { set with_editline $enableval } else { set with_editline auto } if {![opt-bool readline]} { set with_readline $enableval } else { set with_readline auto } # XXX if test x"$with_editline" != xno; then # XXX sLIBS=$LIBS # XXX LIBS="" # XXX TARGET_HAVE_EDITLINE=1 if {[hwaci-check-function-in-lib readline edit]} { set with_readline no } else { # XXX TARGET_HAVE_EDITLINE=0 } # XXX TARGET_READLINE_LIBS=$LIBS # XXX LIBS=$sLIBS # XXX fi # XXX if test x"$with_readline" != xno; then set found "yes" if {[opt-val with-readline-lib] ne {}} { set withval [lindex [opt-val with-readline-lib] end] set with_readline_lib $withval } else { set with_readline_lib "auto" } # XXX if test "x$with_readline_lib" = xauto; then # XXX save_LIBS="$LIBS" # XXX LIBS="" if {[hwaci-check-function-in-lib tgetent readline ncurses curses termcap]} { # XXX term_LIBS="$LIBS" } else { # XXX term_LIBS="" } if {[hwaci-check-function-in-lib readline readline]} { # XXX TARGET_READLINE_LIBS="-lreadline" } else { set found "no" } # XXX TARGET_READLINE_LIBS="$TARGET_READLINE_LIBS $term_LIBS" # XXX LIBS="$save_LIBS" # XXX else # XXX TARGET_READLINE_LIBS="$with_readline_lib" # XXX fi if {[opt-val with-readline-inc] ne {}} { set withval [lindex [opt-val with-readline-inc] end] set with_readline_inc $withval } else { set with_readline_inc "auto" } # XXX if test "x$with_readline_inc" = xauto; then if {[cc-check-includes readline.h]} { set found "yes" } else { set found "no" # XXX if test "$cross_compiling" != yes; then # XXX for dir in /usr /usr/local /usr/local/readline /usr/contrib /mingw; do # XXX for subdir in include include/readline; do # XXX AC_CHECK_FILE $dir/$subdir/readline.h found=yes # XXX if test "$found" = "yes"; then # XXX TARGET_READLINE_INC="-I$dir/$subdir" # XXX break # XXX fi # XXX done # XXX test "$found" = "yes" && break # XXX done # XXX fi } # XXX else # XXX TARGET_READLINE_INC="$with_readline_inc" # XXX fi # XXX if test x"$found" = xno; then # XXX TARGET_READLINE_LIBS="" # XXX TARGET_READLINE_INC="" # XXX TARGET_HAVE_READLINE=0 # XXX else # XXX TARGET_HAVE_READLINE=1 # XXX fi # XXX fi if {[opt-val with-linenoise] ne {}} { set withval [lindex [opt-val with-linenoise] end] set with_linenoise $withval } else { set with_linenoise "no" } # XXX if test "x$with_linenoise" != "xno"; then # XXX TARGET_HAVE_READLINE=0 # XXX TARGET_HAVE_EDITLINE=0 # XXX TARGET_HAVE_LINENOISE=1 # XXX TARGET_READLINE_INC="-I${with_linenoise}" # XXX TARGET_READLINE_LIBS="${with_linenoise}/linenoise.c" # XXX echo "using linenoise source code at ${with_linenoise}" # XXX else # XXX TARGET_HAVE_LINENOISE=0 # XXX echo "not using linenoise" # XXX fi # XXX AC_SUBST TARGET_READLINE_LIBS # XXX AC_SUBST TARGET_READLINE_INC # XXX AC_SUBST TARGET_HAVE_READLINE # XXX AC_SUBST TARGET_HAVE_EDITLINE # XXX AC_SUBST TARGET_HAVE_LINENOISE } hwaci-if-opt-truthy load-extension { if {[hwaci-check-function-in-lib dlopen dl]} { define LDFLAGS_DLOPEN [get-define lib_dlopen] undefine lib_dlopen } else { user-error "dlopen() not found. Use --disable-load-extension to bypass this check." } } { define LDFLAGS_DLOPEN "" add-feature-flag {-DSQLITE_OMIT_LOAD_EXTENSION=1} msg-result "Disabling loadable extensions." } hwaci-if-opt-truthy math { if {![hwaci-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 add-feature-flag {-DSQLITE_ENABLE_MATH_FUNCTIONS} msg-result "Enabling math SQL functions [get-define LDFLAGS_MATH]" } { define LDFLAGS_MATH "" msg-result "Disabling math SQL functions" } define cross_compiling ${cross_compiling} ######################################################################## # Emscripten SDK for building the web-based wasm components. # if {[hwaci-check-emsdk]} { set wrapper $srcdir/tool/emcc.sh define EMCC_WRAPPER $wrapper hwaci-make-from-dot-in $wrapper catch {exec chmod u+x $wrapper} unset wrapper } else { define EMCC_WRAPPER "" catch {exec rm -f $srcdir/tool/emcc.sh} } ######################################################################## # Check for log(3) in libm and die with an error if it is not # found. $why 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 affirm-have-math {why} { if {![hwaci-check-function-in-lib log m]} { user-error "Missing math APIs for $why" } define LDFLAGS_MATH [get-define lib_log ""] undefine lib_log } ######################################################################## # Handle various SQLITE_ENABLE_... feature flags. foreach {boolFlag featureFlag ifSetEvalThis} { all {} { hwaci-opt-set fts4 hwaci-opt-set fts5 hwaci-opt-set geopoly hwaci-opt-set rtree hwaci-opt-set session } fts4 -DSQLITE_ENABLE_FTS4 {affirm-have-math fts4} fts5 -DSQLITE_ENABLE_FTS5 {affirm-have-math fts5} geopoly -DSQLITE_ENABLE_GEOPOLY {hwaci-opt-set rtree} rtree -DSQLITE_ENABLE_RTREE {} session {-DSQLITE_ENABLE_SESSION -DSQLITE_ENABLE_PREUPDATE_HOOK} {} update-limit -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT {} memsys3 {} { if {[opt-bool memsys5]} { msg-result "NOT enabling memsys3 because memsys5 is enabled." } else { add-feature-flag -DSQLITE_ENABLE_MEMSYS3 } } memsys5 -DSQLITE_ENABLE_MEMSYS5 {} } { hwaci-if-opt-truthy $boolFlag { add-feature-flag $featureFlag eval $ifSetEvalThis if {"all" ne $boolFlag} { msg-result "Enabling $boolFlag" } } { msg-result "Not enabling $boolFlag" } } ######################################################################## # Invert the above loop's logic for some explicit SQLITE_OMIT_... # cases. If config option $boolFlag is set, [add-feature-flag # $featureFlag], where $featureFlag is intended to be # -DSQLITE_OMIT_... foreach {boolFlag featureFlag} { json -DSQLITE_OMIT_JSON } { if {[hwaci-opt-truthy $boolFlag]} { msg-result "Enabling $boolFlag" } else { add-feature-flag $featureFlag msg-result "Disabling $boolFlag" } } ######################################################################## # Maybe extend JimTCL a bit. As of this writing (2024-09-27) it only # needs (-DHAVE_REALPATH or -DHAVE__FULLPATH) and -DHAVE_DIRENT_H to # be compatible with our code generators. It can, however, be slightly # extended via easy-to-detect features, should we need them. if {0 && "" ne [get-define CFLAGS_JIMSH]} { foreach jimFunc {opendir fsync isascii} { if {[cc-check-functions $jimFunc]} { define-append CFLAGS_JIMSH -DHAVE_[string toupper $jimFunc] } } #These are hard-coded into jimsh0.c, so we must not -D them: #foreach jimDef {HAVE_UNISTD_H HAVE_DIRENT_H} { # if {[is-defined $jimDef]} { # define-append CFLAGS_JIMSH -D$jimDef # } #} define-append CFLAGS_JIMSH -DHAVE_LONG_LONG; # SQLite relies on long long, so we know it's available }; # JimTCL ######################################################################## # Determine proper rpath-handling flags hwaci-check-rpath ######################################################################## # Generate the output files. # if {1} { hwaci-make-from-dot-in Makefile hwaci-make-from-dot-in sqlite3.pc if {1} { # for sqlite_cfg.h define PACKAGE_URL {https://sqlite.org} define PACKAGE_VERSION [get-define VERSION] } if {0} { # Requires a hand-written sqlite_cfg.h.in... hwaci-make-from-dot-in sqlite_cfg.h # vs... } else { # Requires no input template... make-config-header sqlite_cfg.h \ -bare {SIZEOF_* HAVE_DECL_*} \ -auto {HAVE_* PACKAGE_*} -none * } #hwaci-make-from-dot-in ext/wasm/GNUmakefile } set oFF [get-define OPT_FEATURE_FLAGS] if {"" ne $oFF} { define OPT_FEATURE_FLAGS [lsort -unique $oFF] msg-result "Final feature flags: [get-define OPT_FEATURE_FLAGS]" } set oFF [get-define OPT_SHELL] if {"" ne $oFF} { msg-result "Final shell opts: [get-define OPT_SHELL]" } unset oFF ######################################################################## # Some build-dev/debug-only output hwaci-if-opt-truthy dump-defines { global DUMP_DEFINES_FILE msg-result "--dump-defines is creating file: $DUMP_DEFINES_FILE" make-config-header $DUMP_DEFINES_FILE \ -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 {0} { foreach x [all-defines] { puts "\t$x" } } } puts { Done! Now run "make". }