Index: Makefile.msc ================================================================== --- Makefile.msc +++ Makefile.msc @@ -12,16 +12,30 @@ USE_AMALGAMATION = 1 # Set this non-0 to use the International Components for Unicode (ICU). # USE_ICU = 0 + +# Set this non-0 to dynamically link to the MSVC runtime library. +# +USE_CRT_DLL = 0 + +# Set this non-0 to use the native libraries paths for cross-compiling +# the command line tools needed during the compilation process. +# +USE_NATIVE_LIBPATHS = 0 # Set this non-0 to compile binaries suitable for the WinRT environment. # This setting does not apply to any binaries that require Tcl to operate # properly (i.e. the text fixture, etc). # FOR_WINRT = 0 + +# Set this non-0 to skip attempting to look for and/or link with the Tcl +# runtime library. +# +NO_TCL = 0 # Set this to non-0 to create and use PDBs. # SYMBOLS = 1 @@ -36,30 +50,112 @@ # 4 == SQLITE_DEBUG_OS_TRACE: Enables output from the OSTRACE() macros. # 5 == SQLITE_ENABLE_IOTRACE: Enables output from the IOTRACE() macros. # DEBUG = 0 -# C Compiler and options for use in building executables that +# Check for the predefined command macro CC. This should point to the compiler +# binary for the target platform. If it is not defined, simply define it to +# the legacy default value 'cl.exe'. +# +!IFNDEF CC +CC = cl.exe +!ENDIF + +# Check for the command macro LD. This should point to the linker binary for +# the target platform. If it is not defined, simply define it to the legacy +# default value 'link.exe'. +# +!IFNDEF LD +LD = link.exe +!ENDIF + +# Check for the command macro NCC. This should point to the compiler binary +# for the platform the compilation process is taking place on. If it is not +# defined, simply define it to have the same value as the CC macro. When +# cross-compiling, it is suggested that this macro be modified via the command +# line (since nmake itself does not provide a built-in method to guess it). +# For example, to use the x86 compiler when cross-compiling for x64, a command +# line similar to the following could be used (all on one line): +# +# nmake /f Makefile.msc +# "NCC=""%VCINSTALLDIR%\bin\cl.exe""" +# USE_NATIVE_LIBPATHS=1 +# +!IFDEF NCC +NCC = $(NCC:\\=\) +!ELSE +NCC = $(CC) +!ENDIF + +# Check for the MSVC runtime library path macro. Othertise, this +# value will default to the 'lib' directory underneath the MSVC +# installation directory. +# +!IFNDEF NCRTLIBPATH +NCRTLIBPATH = $(VCINSTALLDIR)\lib +!ENDIF + +NCRTLIBPATH = $(NCRTLIBPATH:\\=\) + +# Check for the Platform SDK library path macro. Othertise, this +# value will default to the 'lib' directory underneath the Windows +# SDK installation directory (the environment variable used appears +# to be available when using Visual C++ 2008 or later via the +# command line). +# +!IFNDEF NSDKLIBPATH +NSDKLIBPATH = $(WINDOWSSDKDIR)\lib +!ENDIF + +NSDKLIBPATH = $(NSDKLIBPATH:\\=\) + +# C compiler and options for use in building executables that # will run on the platform that is doing the build. # -BCC = cl.exe -W3 +BCC = $(NCC) -W3 -# C Compile and options for use in building executables that +# Check if the native library paths should be used when compiling +# the command line tools used during the compilation process. If +# so, set the necessary macro now. +# +!IF $(USE_NATIVE_LIBPATHS)!=0 +NLTLIBPATHS = "/LIBPATH:$(NCRTLIBPATH)" "/LIBPATH:$(NSDKLIBPATH)" +!ENDIF + +# C compiler and options for use in building executables that # will run on the target platform. (BCC and TCC are usually the # same unless your are cross-compiling.) # -TCC = cl.exe -W3 -DSQLITE_OS_WIN=1 -I. -I$(TOP)\src -fp:precise +TCC = $(CC) -W3 -DSQLITE_OS_WIN=1 -I. -I$(TOP)\src -fp:precise # When compiling the library for use in the WinRT environment, # the following compile-time options must be used as well to # disable use of Win32 APIs that are not available and to enable # use of Win32 APIs that are specific to Windows 8 and/or WinRT. -# Also, we need to dynamically link to the MSVC runtime when -# compiling for WinRT. # !IF $(FOR_WINRT)!=0 -TCC = $(TCC) -DSQLITE_OS_WINRT=1 -MD +TCC = $(TCC) -DSQLITE_OS_WINRT=1 +TCC = $(TCC) -DWINAPI_FAMILY=WINAPI_PARTITION_APP +!ENDIF + +# Also, we need to dynamically link to the correct MSVC runtime +# when compiling for WinRT (e.g. debug or release) OR if the +# USE_CRT_DLL option is set to force dynamically linking to the +# MSVC runtime library. +# +!IF $(FOR_WINRT)!=0 || $(USE_CRT_DLL)!=0 +!IF $(DEBUG)>0 +TCC = $(TCC) -MDd +!ELSE +TCC = $(TCC) -MD +!ENDIF +!ELSE +!IF $(DEBUG)>0 +TCC = $(TCC) -MTd +!ELSE +TCC = $(TCC) -MT +!ENDIF !ENDIF # The mksqlite3c.tcl and mksqlite3h.tcl scripts will pull in # any extension header files by default. For non-amalgamation # builds, we need to make sure the compiler can find these. @@ -89,15 +185,22 @@ !IF $(DEBUG)>4 TCC = $(TCC) -DSQLITE_ENABLE_IOTRACE !ENDIF # -# Prevent warnings about "insecure" runtime library functions being used. +# Prevent warnings about "insecure" MSVC runtime library functions +# being used. # TCC = $(TCC) -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS BCC = $(BCC) -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS +# +# Prevent warnings about "deprecated" POSIX functions being used. +# +TCC = $(TCC) -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS +BCC = $(BCC) -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS + # # Use native Win32 heap instead of malloc/free? # # TCC = $(TCC) -DSQLITE_WIN32_MALLOC=1 @@ -112,47 +215,47 @@ # non-stubs enabled programs using Tcl must link against. These variables # (TCLINCDIR, TCLLIBDIR, and LIBTCL) may be overridden via the environment # prior to running nmake in order to match the actual installed location and # version on this machine. # -!if "$(TCLINCDIR)" == "" +!IFNDEF TCLINCDIR TCLINCDIR = c:\tcl\include -!endif +!ENDIF -!if "$(TCLLIBDIR)" == "" +!IFNDEF TCLLIBDIR TCLLIBDIR = c:\tcl\lib -!endif +!ENDIF -!if "$(LIBTCL)" == "" +!IFNDEF LIBTCL LIBTCL = tcl85.lib -!endif +!ENDIF # The locations of the ICU header and library files. These variables # (ICUINCDIR, ICULIBDIR, and LIBICU) may be overridden via the environment # prior to running nmake in order to match the actual installed location on # this machine. # -!if "$(ICUINCDIR)" == "" +!IFNDEF ICUINCDIR ICUINCDIR = c:\icu\include -!endif +!ENDIF -!if "$(ICULIBDIR)" == "" +!IFNDEF ICULIBDIR ICULIBDIR = c:\icu\lib -!endif +!ENDIF -!if "$(LIBICU)" == "" +!IFNDEF LIBICU LIBICU = icuuc.lib icuin.lib -!endif +!ENDIF # This is the command to use for tclsh - normally just "tclsh", but we may # know the specific version we want to use. This variable (TCLSH_CMD) may be # overridden via the environment prior to running nmake in order to select a # specific Tcl shell to use. # -!if "$(TCLSH_CMD)" == "" +!IFNDEF TCLSH_CMD TCLSH_CMD = tclsh85 -!endif +!ENDIF # Compiler options needed for programs that use the readline() library. # READLINE_FLAGS = -DHAVE_READLINE=0 @@ -168,13 +271,13 @@ # TCC = $(TCC) -DSQLITE_THREAD_OVERRIDE_LOCK=-1 # Any target libraries which libsqlite must be linked against # -!if "$(TLIBS)" == "" +!IFNDEF TLIBS TLIBS = -!endif +!ENDIF # Flags controlling use of the in memory btree implementation # # SQLITE_TEMP_STORE is 0 to force temporary tables to be in a file, 1 to # default to file, 2 to default to memory, and 3 to force temporary @@ -232,11 +335,11 @@ # If a platform was set, force the linker to target that. # Note that the vcvars*.bat family of batch files typically # set this for you. Otherwise, the linker will attempt # to deduce the binary type based on the object files. -!IF "$(PLATFORM)"!="" +!IFDEF PLATFORM LTLINKOPTS = /MACHINE:$(PLATFORM) LTLIBOPTS = /MACHINE:$(PLATFORM) !ENDIF # When compiling for use in the WinRT environment, the following @@ -247,17 +350,18 @@ LTLINKOPTS = $(LTLINKOPTS) /APPCONTAINER !ENDIF # If either debugging or symbols are enabled, enable PDBs. !IF $(DEBUG)>0 || $(SYMBOLS)!=0 -LTLINKOPTS = $(LTLINKOPTS) /DEBUG -BCC = $(BCC) /DEBUG +LDFLAGS = /DEBUG !ENDIF # Start with the Tcl related linker options. +!IF $(NO_TCL)==0 LTLIBPATHS = /LIBPATH:$(TCLLIBDIR) LTLIBS = $(LIBTCL) +!ENDIF # If ICU support is enabled, add the linker options for it. !IF $(USE_ICU)!=0 LTLIBPATHS = $(LTLIBPATHS) /LIBPATH:$(ICULIBDIR) LTLIBS = $(LTLIBS) $(LIBICU) @@ -635,11 +739,11 @@ # lempar.c: $(TOP)\src\lempar.c copy $(TOP)\src\lempar.c . lemon.exe: $(TOP)\tool\lemon.c lempar.c - $(BCC) -Fe$@ $(TOP)\tool\lemon.c + $(BCC) -Daccess=_access -Fe$@ $(TOP)\tool\lemon.c /link $(NLTLIBPATHS) # Rules to build individual *.lo files from generated *.c files. This # applies to: # # parse.lo @@ -897,11 +1001,11 @@ sqlite3.h: $(TOP)\src\sqlite.h.in $(TOP)\manifest.uuid $(TOP)\VERSION $(TCLSH_CMD) $(TOP)\tool\mksqlite3h.tcl $(TOP) > sqlite3.h mkkeywordhash.exe: $(TOP)\tool\mkkeywordhash.c - $(BCC) -Femkkeywordhash.exe $(OPT_FEATURE_FLAGS) $(OPTS) $(TOP)\tool\mkkeywordhash.c + $(BCC) -Fe$@ $(OPT_FEATURE_FLAGS) $(OPTS) $(TOP)\tool\mkkeywordhash.c /link $(NLTLIBPATHS) keywordhash.h: $(TOP)\tool\mkkeywordhash.c mkkeywordhash.exe .\mkkeywordhash.exe > keywordhash.h @@ -1029,10 +1133,11 @@ del /Q tclsqlite3.exe del /Q testfixture.exe testfixture.exp test.db del /Q sqlite3.dll sqlite3.lib sqlite3.exp sqlite3.def del /Q sqlite3.c del /Q sqlite3_analyzer.exe sqlite3_analyzer.exp sqlite3_analyzer.c + del /Q sqlite-output.vsix # # Windows section # dll: sqlite3.dll @@ -1042,6 +1147,6 @@ dumpbin /all libsqlite3.lib \ | $(NAWK) "/ 1 _?sqlite3_/ { sub(/^.* _?/,\"\");print }" \ | sort >> sqlite3.def sqlite3.dll: $(LIBOBJ) sqlite3.def - link $(LTLINKOPTS) $(LTLIBPATHS) /DLL /DEF:sqlite3.def /OUT:$@ $(LIBOBJ) $(LTLIBS) $(TLIBS) + $(LD) $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) /DLL /DEF:sqlite3.def /OUT:$@ $(LIBOBJ) $(LTLIBS) $(TLIBS) ADDED tool/build-all-msvc.bat Index: tool/build-all-msvc.bat ================================================================== --- /dev/null +++ tool/build-all-msvc.bat @@ -0,0 +1,394 @@ +@ECHO OFF + +:: +:: build-all-msvc.bat -- +:: +:: Multi-Platform Build Tool for MSVC +:: + +SETLOCAL + +REM SET __ECHO=ECHO +REM SET __ECHO2=ECHO +IF NOT DEFINED _AECHO (SET _AECHO=REM) +IF NOT DEFINED _CECHO (SET _CECHO=REM) +IF NOT DEFINED _VECHO (SET _VECHO=REM) + +%_AECHO% Running %0 %* + +REM SET DFLAGS=/L + +%_VECHO% DFlags = '%DFLAGS%' + +SET FFLAGS=/V /F /G /H /I /R /Y /Z + +%_VECHO% FFlags = '%FFLAGS%' + +SET ROOT=%~dp0\.. +SET ROOT=%ROOT:\\=\% + +%_VECHO% Root = '%ROOT%' + +REM +REM NOTE: The first and only argument to this batch file should be the output +REM directory where the platform-specific binary directories should be +REM created. +REM +SET BINARYDIRECTORY=%1 + +IF NOT DEFINED BINARYDIRECTORY ( + GOTO usage +) + +%_VECHO% BinaryDirectory = '%BINARYDIRECTORY%' + +SET DUMMY=%2 + +IF DEFINED DUMMY ( + GOTO usage +) + +REM +REM NOTE: From this point, we need a clean error level. Reset it now. +REM +CALL :fn_ResetErrorLevel + +REM +REM NOTE: Change the current directory to the root of the source tree, saving +REM the current directory on the directory stack. +REM +%__ECHO2% PUSHD "%ROOT%" + +IF ERRORLEVEL 1 ( + ECHO Could not change directory to "%ROOT%". + GOTO errors +) + +REM +REM NOTE: This batch file requires the ComSpec environment variable to be set, +REM typically to something like "C:\Windows\System32\cmd.exe". +REM +IF NOT DEFINED ComSpec ( + ECHO The ComSpec environment variable must be defined. + GOTO errors +) + +REM +REM NOTE: This batch file requires the VcInstallDir environment variable to be +REM set. Tyipcally, this means this batch file needs to be run from an +REM MSVC command prompt. +REM +IF NOT DEFINED VCINSTALLDIR ( + ECHO The VCINSTALLDIR environment variable must be defined. + GOTO errors +) + +REM +REM NOTE: If the list of platforms is not already set, use the default list. +REM +IF NOT DEFINED PLATFORMS ( + SET PLATFORMS=x86 x86_amd64 x86_arm +) + +%_VECHO% Platforms = '%PLATFORMS%' + +REM +REM NOTE: Setup environment variables to translate between the MSVC platform +REM names and the names to be used for the platform-specific binary +REM directories. +REM +SET x86_NAME=x86 +SET x86_amd64_NAME=x64 +SET x86_arm_NAME=ARM + +%_VECHO% x86_Name = '%x86_NAME%' +%_VECHO% x86_amd64_Name = '%x86_amd64_NAME%' +%_VECHO% x86_arm_Name = '%x86_arm_NAME%' + +REM +REM NOTE: Check for the external tools needed during the build process ^(i.e. +REM those that do not get compiled as part of the build process itself^) +REM along the PATH. +REM +FOR %%T IN (gawk.exe tclsh85.exe) DO ( + SET %%T_PATH=%%~dp$PATH:T +) + +REM +REM NOTE: Set the TOOLPATH variable to contain all the directories where the +REM external tools were found in the search above. +REM +SET TOOLPATH=%gawk.exe_PATH%;%tclsh85.exe_PATH% + +%_VECHO% ToolPath = '%TOOLPATH%' + +REM +REM NOTE: Check for MSVC 2012 because the Windows SDK directory handling is +REM slightly different for that version. +REM +IF "%VisualStudioVersion%" == "11.0" ( + SET SET_NSDKLIBPATH=1 +) ELSE ( + CALL :fn_UnsetVariable SET_NSDKLIBPATH +) + +REM +REM NOTE: This is the outer loop. There should be exactly one iteration per +REM platform. +REM +FOR %%P IN (%PLATFORMS%) DO ( + REM + REM NOTE: Using the MSVC platform name, lookup the simpler platform name to + REM be used for the name of the platform-specific binary directory via + REM the environment variables setup earlier. + REM + CALL :fn_SetVariable %%P_NAME PLATFORMNAME + + REM + REM NOTE: This is the inner loop. There should be exactly one iteration. + REM This loop is necessary because the PlatformName environment + REM variable was set above and that value is needed by some of the + REM commands contained in the inner loop. If these commands were + REM directly contained in the outer loop, the PlatformName environment + REM variable would be stuck with its initial empty value instead. + REM + FOR /F "tokens=2* delims==" %%D IN ('SET PLATFORMNAME') DO ( + REM + REM NOTE: Attempt to clean the environment of all variables used by MSVC + REM and/or Visual Studio. This block may need to be updated in the + REM future to account for additional environment variables. + REM + CALL :fn_UnsetVariable DevEnvDir + CALL :fn_UnsetVariable ExtensionSdkDir + CALL :fn_UnsetVariable Framework35Version + CALL :fn_UnsetVariable FrameworkDir + CALL :fn_UnsetVariable FrameworkDir32 + CALL :fn_UnsetVariable FrameworkVersion + CALL :fn_UnsetVariable FrameworkVersion32 + CALL :fn_UnsetVariable FSHARPINSTALLDIR + CALL :fn_UnsetVariable INCLUDE + CALL :fn_UnsetVariable LIB + CALL :fn_UnsetVariable LIBPATH + CALL :fn_UnsetVariable Platform + REM CALL :fn_UnsetVariable VCINSTALLDIR + CALL :fn_UnsetVariable VSINSTALLDIR + CALL :fn_UnsetVariable WindowsSdkDir + CALL :fn_UnsetVariable WindowsSdkDir_35 + CALL :fn_UnsetVariable WindowsSdkDir_old + + REM + REM NOTE: Reset the PATH here to the absolute bare minimum required. + REM + SET PATH=%TOOLPATH%;%SystemRoot%\System32;%SystemRoot% + + REM + REM NOTE: Launch a nested command shell to perform the following steps: + REM + REM 1. Setup the MSVC environment for this platform using the + REM official batch file. + REM + REM 2. Make sure that no stale build output files are present. + REM + REM 3. Build the "sqlite3.dll" and "sqlite3.lib" binaries for this + REM platform. + REM + REM 4. Copy the "sqlite3.dll" and "sqlite3.lib" binaries for this + REM platform to the platform-specific directory beneath the + REM binary directory. + REM + "%ComSpec%" /C ( + REM + REM NOTE: Attempt to setup the MSVC environment for this platform. + REM + %__ECHO% CALL "%VCINSTALLDIR%\vcvarsall.bat" %%P + + IF ERRORLEVEL 1 ( + ECHO Failed to call "%VCINSTALLDIR%\vcvarsall.bat" for platform %%P. + GOTO errors + ) + + REM + REM NOTE: If this batch file is not running in "what-if" mode, check to + REM be sure we were actually able to setup the MSVC environment as + REM current versions of their official batch file do not set the + REM exit code upon failure. + REM + IF NOT DEFINED __ECHO ( + IF NOT DEFINED WindowsSdkDir ( + ECHO Cannot build, Windows SDK not found for platform %%P. + GOTO errors + ) + ) + + REM + REM NOTE: When using MSVC 2012, the native SDK path cannot simply use + REM the "lib" sub-directory beneath the location specified in the + REM WindowsSdkDir environment variable because that location does + REM not actually contain the necessary library files for x86. + REM This must be done for each iteration because it relies upon + REM the WindowsSdkDir environment variable being set by the batch + REM file used to setup the MSVC environment. + REM + IF DEFINED SET_NSDKLIBPATH ( + CALL :fn_SetVariable WindowsSdkDir NSDKLIBPATH + CALL :fn_AppendVariable NSDKLIBPATH \lib\win8\um\x86 + ) + + REM + REM NOTE: Unless prevented from doing so, invoke NMAKE with the MSVC + REM makefile to clean any stale build output from previous + REM iterations of this loop and/or previous runs of this batch + REM file, etc. + REM + IF NOT DEFINED NOCLEAN ( + %__ECHO% nmake -f Makefile.msc clean + + IF ERRORLEVEL 1 ( + ECHO Failed to clean for platform %%P. + GOTO errors + ) + ) ELSE ( + REM + REM NOTE: Even when the cleaning step has been disabled, we still need + REM to remove the build output for the files we are specifically + REM wanting to build for each platform. + REM + %__ECHO% DEL /Q sqlite3.dll sqlite3.lib sqlite3.pdb + ) + + REM + REM NOTE: Invoke NMAKE with the MSVC makefile to build the "sqlite3.dll" + REM binary. The x86 compiler will be used to compile the native + REM command line tools needed during the build process itself. + REM Also, disable looking for and/or linking to the native Tcl + REM runtime library. + REM + %__ECHO% nmake -f Makefile.msc sqlite3.dll "NCC=""%VCINSTALLDIR%\bin\cl.exe""" USE_NATIVE_LIBPATHS=1 NO_TCL=1 %NMAKE_ARGS% + + IF ERRORLEVEL 1 ( + ECHO Failed to build "sqlite3.dll" for platform %%P. + GOTO errors + ) + + REM + REM NOTE: Copy the "sqlite3.dll" file to the platform-specific directory + REM beneath the binary directory. + REM + %__ECHO% XCOPY sqlite3.dll "%BINARYDIRECTORY%\%%D\" %FFLAGS% %DFLAGS% + + IF ERRORLEVEL 1 ( + ECHO Failed to copy "sqlite3.dll" to "%BINARYDIRECTORY%\%%D\". + GOTO errors + ) + + REM + REM NOTE: Copy the "sqlite3.lib" file to the platform-specific directory + REM beneath the binary directory. + REM + %__ECHO% XCOPY sqlite3.lib "%BINARYDIRECTORY%\%%D\" %FFLAGS% %DFLAGS% + + IF ERRORLEVEL 1 ( + ECHO Failed to copy "sqlite3.lib" to "%BINARYDIRECTORY%\%%D\". + GOTO errors + ) + + REM + REM NOTE: Copy the "sqlite3.pdb" file to the platform-specific directory + REM beneath the binary directory unless we are prevented from doing + REM so. + REM + IF NOT DEFINED NOSYMBOLS ( + %__ECHO% XCOPY sqlite3.pdb "%BINARYDIRECTORY%\%%D\" %FFLAGS% %DFLAGS% + + IF ERRORLEVEL 1 ( + ECHO Failed to copy "sqlite3.pdb" to "%BINARYDIRECTORY%\%%D\". + GOTO errors + ) + ) + ) + ) + + REM + REM NOTE: Handle any errors generated during the nested command shell. + REM + IF ERRORLEVEL 1 ( + GOTO errors + ) +) + +REM +REM NOTE: Restore the saved current directory from the directory stack. +REM +%__ECHO2% POPD + +IF ERRORLEVEL 1 ( + ECHO Could not restore directory. + GOTO errors +) + +REM +REM NOTE: If we get to this point, we have succeeded. +REM +GOTO no_errors + +:fn_ResetErrorLevel + VERIFY > NUL + GOTO :EOF + +:fn_SetErrorLevel + VERIFY MAYBE 2> NUL + GOTO :EOF + +:fn_SetVariable + SETLOCAL + IF NOT DEFINED %1 GOTO :EOF + IF "%2" == "" GOTO :EOF + SET __ECHO_CMD=ECHO %%%1%% + FOR /F "delims=" %%V IN ('%__ECHO_CMD%') DO ( + SET VALUE=%%V + ) + ENDLOCAL && SET %2=%VALUE% + GOTO :EOF + +:fn_UnsetVariable + IF NOT "%1" == "" ( + SET %1= + CALL :fn_ResetErrorLevel + ) + GOTO :EOF + +:fn_AppendVariable + SET __ECHO_CMD=ECHO %%%1%% + IF DEFINED %1 ( + FOR /F "delims=" %%V IN ('%__ECHO_CMD%') DO ( + SET %1=%%V%~2 + ) + ) ELSE ( + SET %1=%~2 + ) + SET __ECHO_CMD= + CALL :fn_ResetErrorLevel + GOTO :EOF + +:usage + ECHO. + ECHO Usage: %~nx0 ^ + ECHO. + GOTO errors + +:errors + CALL :fn_SetErrorLevel + ENDLOCAL + ECHO. + ECHO Failure, errors were encountered. + GOTO end_of_file + +:no_errors + CALL :fn_ResetErrorLevel + ENDLOCAL + ECHO. + ECHO Success, no errors were encountered. + GOTO end_of_file + +:end_of_file +%__ECHO% EXIT /B %ERRORLEVEL% ADDED tool/mkvsix.tcl Index: tool/mkvsix.tcl ================================================================== --- /dev/null +++ tool/mkvsix.tcl @@ -0,0 +1,419 @@ +#!/usr/bin/tclsh +# +# This script is used to generate a VSIX (Visual Studio Extension) file for +# SQLite usable by Visual Studio. + +proc fail { {error ""} {usage false} } { + if {[string length $error] > 0} then { + puts stdout $error + if {!$usage} then {exit 1} + } + + puts stdout "usage:\ +[file tail [info nameofexecutable]]\ +[file tail [info script]] \[sourceDirectory\]" + + exit 1 +} + +proc getEnvironmentVariable { name } { + # + # NOTE: Returns the value of the specified environment variable or an empty + # string for environment variables that do not exist in the current + # process environment. + # + return [expr {[info exists ::env($name)] ? $::env($name) : ""}] +} + +proc getTemporaryPath {} { + # + # NOTE: Returns the normalized path to the first temporary directory found + # in the typical set of environment variables used for that purpose + # or an empty string to signal a failure to locate such a directory. + # + set names [list] + + foreach name [list TEMP TMP] { + lappend names [string toupper $name] [string tolower $name] \ + [string totitle $name] + } + + foreach name $names { + set value [getEnvironmentVariable $name] + + if {[string length $value] > 0} then { + return [file normalize $value] + } + } + + return "" +} + +proc appendArgs { args } { + # + # NOTE: Returns all passed arguments joined together as a single string with + # no intervening spaces between arguments. + # + eval append result $args +} + +proc readFile { fileName } { + # + # NOTE: Reads and returns the entire contents of the specified file, which + # may contain binary data. + # + set file_id [open $fileName RDONLY] + fconfigure $file_id -encoding binary -translation binary + set result [read $file_id] + close $file_id + return $result +} + +proc writeFile { fileName data } { + # + # NOTE: Writes the entire contents of the specified file, which may contain + # binary data. + # + set file_id [open $fileName {WRONLY CREAT TRUNC}] + fconfigure $file_id -encoding binary -translation binary + puts -nonewline $file_id $data + close $file_id + return "" +} + +proc substFile { fileName } { + # + # NOTE: Performs all Tcl command, variable, and backslash substitutions in + # the specified file and then re-writes the contents of that same file + # with the substituted data. + # + return [writeFile $fileName [uplevel 1 [list subst [readFile $fileName]]]] +} + +proc replacePlatform { fileName platformName } { + # + # NOTE: Returns the specified file name containing the platform name instead + # of platform placeholder tokens. + # + return [string map [list $platformName] $fileName] +} + +set script [file normalize [info script]] + +if {[string length $script] == 0} then { + fail "script file currently being evaluated is unknown" true +} + +set path [file dirname $script] +set rootName [file rootname [file tail $script]] + +############################################################################### + +# +# NOTE: Process and verify all the command line arguments. +# +set argc [llength $argv] +if {$argc != 1 && $argc != 2} then {fail} + +set binaryDirectory [lindex $argv 0] + +if {[string length $binaryDirectory] == 0} then { + fail "invalid binary directory" +} + +if {![file exists $binaryDirectory] || \ + ![file isdirectory $binaryDirectory]} then { + fail "binary directory does not exist" +} + +if {$argc == 2} then { + set sourceDirectory [lindex $argv 1] +} else { + # + # NOTE: Assume that the source directory is the parent directory of the one + # that contains this script file. + # + set sourceDirectory [file dirname $path] +} + +if {[string length $sourceDirectory] == 0} then { + fail "invalid source directory" +} + +if {![file exists $sourceDirectory] || \ + ![file isdirectory $sourceDirectory]} then { + fail "source directory does not exist" +} + +############################################################################### + +# +# NOTE: Evaluate the user-specific customizations file, if it exists. +# +set userFile [file join $path [appendArgs \ + $rootName . $tcl_platform(user) .tcl]] + +if {[file exists $userFile] && \ + [file isfile $userFile]} then { + source $userFile +} + +############################################################################### + +set templateFile [file join $path win sqlite.vsix] + +if {![file exists $templateFile] || \ + ![file isfile $templateFile]} then { + fail [appendArgs "template file \"" $templateFile "\" does not exist"] +} + +set currentDirectory [pwd] +set outputFile [file join $currentDirectory sqlite-output.vsix] + +if {[file exists $outputFile]} then { + fail [appendArgs "output file \"" $outputFile "\" already exists"] +} + +############################################################################### + +# +# NOTE: Make sure that a valid temporary directory exists. +# +set temporaryDirectory [getTemporaryPath] + +if {[string length $temporaryDirectory] == 0 || \ + ![file exists $temporaryDirectory] || \ + ![file isdirectory $temporaryDirectory]} then { + fail "cannot locate a usable temporary directory" +} + +# +# NOTE: Setup the staging directory to have a unique name inside of the +# configured temporary directory. +# +set stagingDirectory [file normalize [file join $temporaryDirectory \ + [appendArgs $rootName . [pid]]]] + +############################################################################### + +# +# NOTE: Configure the external zipping tool. First, see if it has already +# been pre-configured. If not, try to query it from the environment. +# Finally, fallback on the default of simply "zip", which will then +# be assumed to exist somewhere along the PATH. +# +if {![info exists zip]} then { + if {[info exists env(ZipTool)]} then { + set zip $env(ZipTool) + } + if {![info exists zip] || ![file exists $zip]} then { + set zip zip + } +} + +# +# NOTE: Configure the external unzipping tool. First, see if it has already +# been pre-configured. If not, try to query it from the environment. +# Finally, fallback on the default of simply "unzip", which will then +# be assumed to exist somewhere along the PATH. +# +if {![info exists unzip]} then { + if {[info exists env(UnZipTool)]} then { + set unzip $env(UnZipTool) + } + if {![info exists unzip] || ![file exists $unzip]} then { + set unzip unzip + } +} + +############################################################################### + +# +# NOTE: Attempt to extract the SQLite version from the "sqlite3.h" header file +# in the source directory. This script assumes that the header file has +# already been generated by the build process. +# +set pattern {^#define\s+SQLITE_VERSION\s+"(.*)"$} +set data [readFile [file join $sourceDirectory sqlite3.h]] + +if {![regexp -line -- $pattern $data dummy version]} then { + fail [appendArgs "cannot locate SQLITE_VERSION value in \"" \ + [file join $sourceDirectory sqlite3.h] \"] +} + +############################################################################### + +# +# NOTE: Setup the master file list data, including the necessary flags. +# +if {![info exists fileNames(source)]} then { + set fileNames(source) [list "" "" "" \ + [file join $sourceDirectory sqlite3.h] \ + [file join $binaryDirectory sqlite3.lib] \ + [file join $binaryDirectory sqlite3.dll]] + + if {![info exists no(symbols)]} then { + lappend fileNames(source) \ + [file join $binaryDirectory sqlite3.pdb] + } +} + +if {![info exists fileNames(destination)]} then { + set fileNames(destination) [list \ + [file join $stagingDirectory extension.vsixmanifest] \ + [file join $stagingDirectory SDKManifest.xml] \ + [file join $stagingDirectory DesignTime CommonConfiguration \ + SQLite.WinRT.props] \ + [file join $stagingDirectory DesignTime CommonConfiguration \ + sqlite3.h] \ + [file join $stagingDirectory DesignTime CommonConfiguration \ + sqlite3.lib] \ + [file join $stagingDirectory Redist CommonConfiguration \ + sqlite3.dll]] + + if {![info exists no(symbols)]} then { + lappend fileNames(destination) \ + [file join $stagingDirectory Redist Debug \ + sqlite3.pdb] + } +} + +if {![info exists fileNames(neutral)]} then { + set fileNames(neutral) [list 1 1 1 1 0 0] + + if {![info exists no(symbols)]} then { + lappend fileNames(neutral) 0 + } +} + +if {![info exists fileNames(subst)]} then { + set fileNames(subst) [list 1 1 1 0 0 0] + + if {![info exists no(symbols)]} then { + lappend fileNames(subst) 0 + } +} + +############################################################################### + +# +# NOTE: Setup the list of platforms supported by this script. +# +if {![info exists platformNames]} then { + set platformNames [list x86 x64 ARM] +} + +############################################################################### + +# +# NOTE: Make sure the staging directory exists, creating it if necessary. +# +file mkdir $stagingDirectory + +# +# NOTE: Build the Tcl command used to extract the template package to the +# staging directory. +# +set extractCommand [list exec -- $unzip $templateFile -d $stagingDirectory] + +# +# NOTE: Extract the template package to the staging directory. +# +eval $extractCommand + +############################################################################### + +# +# NOTE: Process each file in the master file list. There are actually four +# parallel lists that contain the source file names, destination file +# names, the platform-neutral flags, and the use-subst flags. When the +# platform-neutral flag is non-zero, the file is not platform-specific. +# When the use-subst flag is non-zero, the file is considered to be a +# text file that may contain Tcl variable and/or command replacements, +# to be dynamically replaced during processing. If the source file name +# is an empty string, then the destination file name will be assumed to +# already exist in the staging directory and will not be copied; however, +# dynamic replacements may still be performed on the destination file +# prior to the package being re-zipped. +# +foreach sourceFileName $fileNames(source) \ + destinationFileName $fileNames(destination) \ + isNeutral $fileNames(neutral) useSubst $fileNames(subst) { + # + # NOTE: If the current file is platform-neutral, then only one platform will + # be processed for it, namely "neutral"; otherwise, each supported + # platform will be processed for it individually. + # + foreach platformName [expr {$isNeutral ? [list neutral] : $platformNames}] { + # + # NOTE: Use the actual platform name in the destination file name. + # + set newDestinationFileName [replacePlatform $destinationFileName \ + $platformName] + + # + # NOTE: Does the source file need to be copied to the destination file? + # + if {[string length $sourceFileName] > 0} then { + # + # NOTE: First, make sure the destination directory exists. + # + file mkdir [file dirname $newDestinationFileName] + + # + # NOTE: Then, copy the source file to the destination file verbatim. + # + file copy [replacePlatform $sourceFileName $platformName] \ + $newDestinationFileName + } + + # + # NOTE: Does the destination file contain dynamic replacements that must + # be processed now? + # + if {$useSubst} then { + # + # NOTE: Perform any dynamic replacements contained in the destination + # file and then re-write it in-place. + # + substFile $newDestinationFileName + } + } +} + +############################################################################### + +# +# NOTE: Change the current directory to the staging directory so that the +# external archive building tool can pickup the necessary files using +# relative paths. +# +cd $stagingDirectory + +# +# NOTE: Build the Tcl command used to archive the final package in the +# output directory. +# +set archiveCommand [list exec -- $zip -r $outputFile *] + +# +# NOTE: Build the final package archive in the output directory. +# +eval $archiveCommand + +# +# NOTE: Change back to the previously saved current directory. +# +cd $currentDirectory + +# +# NOTE: Cleanup the temporary staging directory. +# +file delete -force $stagingDirectory + +############################################################################### + +# +# NOTE: Success, emit the fully qualified path of the generated VSIX file. +# +puts stdout $outputFile ADDED tool/win/sqlite.vsix Index: tool/win/sqlite.vsix ================================================================== --- /dev/null +++ tool/win/sqlite.vsix cannot compute difference between binary files