tool/mkvsix.tcl

   1 #!/usr/bin/tclsh
   2 #
   3 # This script is used to generate a VSIX (Visual Studio Extension) file for
   4 # SQLite usable by Visual Studio.
   5 #
   6 # PREREQUISITES
   7 #
   8 # 1. Tcl 8.4 and later are supported, earlier versions have not been tested.
   9 #
  10 # 2. The "sqlite3.h" file is assumed to exist in the parent directory of the
  11 #    directory containing this script.  The [optional] second command line
  12 #    argument to this script may be used to specify an alternate location.
  13 #    This script also assumes that the "sqlite3.h" file corresponds with the
  14 #    version of the binaries to be packaged.  This assumption is not verified
  15 #    by this script.
  16 #
  17 # 3. The temporary directory specified in the TEMP or TMP environment variables
  18 #    must refer to an existing directory writable by the current user.
  19 #
  20 # 4. The "zip" and "unzip" command line tools must be located either in a
  21 #    directory contained in the PATH environment variable or specified as the
  22 #    exact file names to execute in the "ZipTool" and "UnZipTool" environment
  23 #    variables, respectively.
  24 #
  25 # 5. The template VSIX file (which is basically a zip file) must be located in
  26 #    a "win" directory inside the directory containing this script.  It should
  27 #    not contain any executable binaries.  It should only contain dynamic
  28 #    textual content files to be processed using [subst] and/or static content
  29 #    files to be copied verbatim.
  30 #
  31 # 6. The executable and other compiled binary files to be packaged into the
  32 #    final VSIX file (e.g. DLLs, LIBs, and PDBs) must be located in a single
  33 #    directory tree.  The top-level directory of the tree must be specified as
  34 #    the first command line argument to this script.  The second level
  35 #    sub-directory names must match those of the build configuration (e.g.
  36 #    "Debug" or "Retail").  The third level sub-directory names must match
  37 #    those of the platform (e.g. "x86", "x64", and "ARM").  For example, the
  38 #    binary files to be packaged would need to be organized as follows when
  39 #    packaging the "Debug" and "Retail" build configurations for the "x86" and
  40 #    "x64" platforms (in this example, "C:\temp" is the top-level directory as
  41 #    specified in the first command line argument):
  42 #
  43 #                         C:\Temp\Debug\x86\sqlite3.lib
  44 #                         C:\Temp\Debug\x86\sqlite3.dll
  45 #                         C:\Temp\Debug\x86\sqlite3.pdb
  46 #                         C:\Temp\Debug\x64\sqlite3.lib
  47 #                         C:\Temp\Debug\x64\sqlite3.dll
  48 #                         C:\Temp\Debug\x64\sqlite3.pdb
  49 #                         C:\Temp\Retail\x86\sqlite3.lib
  50 #                         C:\Temp\Retail\x86\sqlite3.dll
  51 #                         C:\Temp\Retail\x86\sqlite3.pdb
  52 #                         C:\Temp\Retail\x64\sqlite3.lib
  53 #                         C:\Temp\Retail\x64\sqlite3.dll
  54 #                         C:\Temp\Retail\x64\sqlite3.pdb
  55 #
  56 #    The above directory tree organization is performed automatically if the
  57 #    "tool\build-all-msvc.bat" batch script is used to build the binary files
  58 #    to be packaged.
  59 #
  60 # USAGE
  61 #
  62 # The first argument to this script is required and must be the name of the
  63 # top-level directory containing the directories and files organized into a
  64 # tree as described in item 6 of the PREREQUISITES section, above.  The second
  65 # argument is optional and if present must contain the name of the directory
  66 # containing the root of the source tree for SQLite.  The third argument is
  67 # optional and if present must contain the flavor the VSIX package to build.
  68 # Currently, the only supported package flavors are "WinRT", "WinRT81", "WP80",
  69 # "WP81", and "Win32".  The fourth argument is optional and if present must be
  70 # a string containing a list of platforms to include in the VSIX package.  The
  71 # platform list is "platform1,platform2,platform3".  The fifth argument is
  72 # optional and if present must contain the version of Visual Studio required by
  73 # the package.  Currently, the only supported versions are "2012" and "2013".
  74 # The package flavors "WinRT81" and "WP81" are only supported when the Visual
  75 # Studio version is "2013".  Typically, when on Windows, this script is
  76 # executed using commands similar to the following from a normal Windows
  77 # command prompt:
  78 #
  79 #                         CD /D C:\dev\sqlite\core
  80 #                         tclsh tool\mkvsix.tcl C:\Temp
  81 #
  82 # In the example above, "C:\dev\sqlite\core" represents the root of the source
  83 # tree for SQLite and "C:\Temp" represents the top-level directory containing
  84 # the executable and other compiled binary files, organized into a directory
  85 # tree as described in item 6 of the PREREQUISITES section, above.
  86 #
  87 # This script should work on non-Windows platforms as well, provided that all
  88 # the requirements listed in the PREREQUISITES section are met.
  89 #
  90 # NOTES
  91 #
  92 # The temporary directory is used as a staging area for the final VSIX file.
  93 # The template VSIX file is extracted, its contents processed, and then the
  94 # resulting files are packaged into the final VSIX file.
  95 #
  96 package require Tcl 8.4
  97 \f
  98 proc fail { {error ""} {usage false} } {
  99   if {[string length $error] > 0} then {
 100     puts stdout $error
 101     if {!$usage} then {exit 1}
 102   }
 103
 104   puts stdout "usage:\
 105 [file tail [info nameofexecutable]]\
 106 [file tail [info script]] <binaryDirectory> \[sourceDirectory\]\
 107 \[packageFlavor\] \[platformNames\] \[vsVersion\]"
 108
 109   exit 1
 110 }
 111 \f
 112 proc getEnvironmentVariable { name } {
 113   #
 114   # NOTE: Returns the value of the specified environment variable or an empty
 115   #       string for environment variables that do not exist in the current
 116   #       process environment.
 117   #
 118   return [expr {[info exists ::env($name)] ? $::env($name) : ""}]
 119 }
 120 \f
 121 proc getTemporaryPath {} {
 122   #
 123   # NOTE: Returns the normalized path to the first temporary directory found
 124   #       in the typical set of environment variables used for that purpose
 125   #       or an empty string to signal a failure to locate such a directory.
 126   #
 127   set names [list]
 128
 129   foreach name [list TEMP TMP] {
 130     lappend names [string toupper $name] [string tolower $name] \
 131         [string totitle $name]
 132   }
 133
 134   foreach name $names {
 135     set value [getEnvironmentVariable $name]
 136
 137     if {[string length $value] > 0} then {
 138       return [file normalize $value]
 139     }
 140   }
 141
 142   return ""
 143 }
 144 \f
 145 proc appendArgs { args } {
 146   #
 147   # NOTE: Returns all passed arguments joined together as a single string with
 148   #       no intervening spaces between arguments.
 149   #
 150   eval append result $args
 151 }
 152 \f
 153 proc readFile { fileName } {
 154   #
 155   # NOTE: Reads and returns the entire contents of the specified file, which
 156   #       may contain binary data.
 157   #
 158   set file_id [open $fileName RDONLY]
 159   fconfigure $file_id -encoding binary -translation binary
 160   set result [read $file_id]
 161   close $file_id
 162   return $result
 163 }
 164 \f
 165 proc writeFile { fileName data } {
 166   #
 167   # NOTE: Writes the entire contents of the specified file, which may contain
 168   #       binary data.
 169   #
 170   set file_id [open $fileName {WRONLY CREAT TRUNC}]
 171   fconfigure $file_id -encoding binary -translation binary
 172   puts -nonewline $file_id $data
 173   close $file_id
 174   return ""
 175 }
 176 \f
 177 #
 178 # TODO: Modify this procedure when a new version of Visual Studio is released.
 179 #
 180 proc getMinVsVersionXmlChunk { vsVersion } {
 181   switch -exact $vsVersion {
 182     2012 {
 183       return [appendArgs \
 184           "\r\n    " {MinVSVersion="11.0"}]
 185     }
 186     2013 {
 187       return [appendArgs \
 188           "\r\n    " {MinVSVersion="12.0"}]
 189     }
 190     2015 {
 191       return [appendArgs \
 192           "\r\n    " {MinVSVersion="14.0"}]
 193     }
 194     default {
 195       return ""
 196     }
 197   }
 198 }
 199 \f
 200 #
 201 # TODO: Modify this procedure when a new version of Visual Studio is released.
 202 #
 203 proc getMaxPlatformVersionXmlChunk { packageFlavor vsVersion } {
 204   #
 205   # NOTE: Only Visual Studio 2013 and later support this attribute within the
 206   #       SDK manifest.
 207   #
 208   if {![string equal $vsVersion 2013] && \
 209       ![string equal $vsVersion 2015]} then {
 210     return ""
 211   }
 212
 213   switch -exact $packageFlavor {
 214     WinRT {
 215       return [appendArgs \
 216           "\r\n    " {MaxPlatformVersion="8.0"}]
 217     }
 218     WinRT81 {
 219       return [appendArgs \
 220           "\r\n    " {MaxPlatformVersion="8.1"}]
 221     }
 222     WP80 {
 223       return [appendArgs \
 224           "\r\n    " {MaxPlatformVersion="8.0"}]
 225     }
 226     WP81 {
 227       return [appendArgs \
 228           "\r\n    " {MaxPlatformVersion="8.1"}]
 229     }
 230     default {
 231       return ""
 232     }
 233   }
 234 }
 235 \f
 236 #
 237 # TODO: Modify this procedure when a new version of Visual Studio is released.
 238 #
 239 proc getExtraFileListXmlChunk { packageFlavor vsVersion } {
 240   #
 241   # NOTE: Windows Phone 8.0 does not require any extra attributes in its VSIX
 242   #       package SDK manifests; however, it appears that Windows Phone 8.1
 243   #       does.
 244   #
 245   if {[string equal $packageFlavor WP80]} then {
 246     return ""
 247   }
 248
 249   set appliesTo [expr {[string equal $packageFlavor Win32] ? \
 250       "VisualC" : "WindowsAppContainer"}]
 251
 252   switch -exact $vsVersion {
 253     2012 {
 254       return [appendArgs \
 255           "\r\n    " AppliesTo=\" $appliesTo \" \
 256           "\r\n    " {DependsOn="Microsoft.VCLibs, version=11.0"}]
 257     }
 258     2013 {
 259       return [appendArgs \
 260           "\r\n    " AppliesTo=\" $appliesTo \" \
 261           "\r\n    " {DependsOn="Microsoft.VCLibs, version=12.0"}]
 262     }
 263     2015 {
 264       return [appendArgs \
 265           "\r\n    " AppliesTo=\" $appliesTo \" \
 266           "\r\n    " {DependsOn="Microsoft.VCLibs, version=14.0"}]
 267     }
 268     default {
 269       return ""
 270     }
 271   }
 272 }
 273 \f
 274 proc replaceFileNameTokens { fileName name buildName platformName } {
 275   #
 276   # NOTE: Returns the specified file name containing the platform name instead
 277   #       of platform placeholder tokens.
 278   #
 279   return [string map [list <build> $buildName <platform> $platformName \
 280       <name> $name] $fileName]
 281 }
 282 \f
 283 proc substFile { fileName } {
 284   #
 285   # NOTE: Performs all Tcl command, variable, and backslash substitutions in
 286   #       the specified file and then rewrites the contents of that same file
 287   #       with the substituted data.
 288   #
 289   return [writeFile $fileName [uplevel 1 [list subst [readFile $fileName]]]]
 290 }
 291 \f
 292 #
 293 # NOTE: This is the entry point for this script.
 294 #
 295 set script [file normalize [info script]]
 296
 297 if {[string length $script] == 0} then {
 298   fail "script file currently being evaluated is unknown" true
 299 }
 300
 301 set path [file dirname $script]
 302 set rootName [file rootname [file tail $script]]
 303
 304 ###############################################################################
 305
 306 #
 307 # NOTE: Process and verify all the command line arguments.
 308 #
 309 set argc [llength $argv]
 310 if {$argc < 1 || $argc > 5} then {fail}
 311
 312 set binaryDirectory [lindex $argv 0]
 313
 314 if {[string length $binaryDirectory] == 0} then {
 315   fail "invalid binary directory"
 316 }
 317
 318 if {![file exists $binaryDirectory] || \
 319     ![file isdirectory $binaryDirectory]} then {
 320   fail "binary directory does not exist"
 321 }
 322
 323 if {$argc >= 2} then {
 324   set sourceDirectory [lindex $argv 1]
 325 } else {
 326   #
 327   # NOTE: Assume that the source directory is the parent directory of the one
 328   #       that contains this script file.
 329   #
 330   set sourceDirectory [file dirname $path]
 331 }
 332
 333 if {[string length $sourceDirectory] == 0} then {
 334   fail "invalid source directory"
 335 }
 336
 337 if {![file exists $sourceDirectory] || \
 338     ![file isdirectory $sourceDirectory]} then {
 339   fail "source directory does not exist"
 340 }
 341
 342 if {$argc >= 3} then {
 343   set packageFlavor [lindex $argv 2]
 344 } else {
 345   #
 346   # NOTE: Assume the package flavor is WinRT.
 347   #
 348   set packageFlavor WinRT
 349 }
 350
 351 if {[string length $packageFlavor] == 0} then {
 352   fail "invalid package flavor"
 353 }
 354
 355 if {$argc >= 4} then {
 356   set platformNames [list]
 357
 358   foreach platformName [split [lindex $argv 3] ", "] {
 359     set platformName [string trim $platformName]
 360
 361     if {[string length $platformName] > 0} then {
 362       lappend platformNames $platformName
 363     }
 364   }
 365 }
 366
 367 if {$argc >= 5} then {
 368   set vsVersion [lindex $argv 4]
 369 } else {
 370   set vsVersion 2012
 371 }
 372
 373 if {[string length $vsVersion] == 0} then {
 374   fail "invalid Visual Studio version"
 375 }
 376
 377 if {![string equal $vsVersion 2012] && ![string equal $vsVersion 2013] && \
 378     ![string equal $vsVersion 2015]} then {
 379   fail [appendArgs \
 380       "unsupported Visual Studio version, must be one of: " \
 381       [list 2012 2013 2015]]
 382 }
 383
 384 set shortNames(WinRT,2012) SQLite.WinRT
 385 set shortNames(WinRT,2013) SQLite.WinRT.2013
 386 set shortNames(WinRT81,2013) SQLite.WinRT81
 387 set shortNames(WP80,2012) SQLite.WP80
 388 set shortNames(WP80,2013) SQLite.WP80.2013
 389 set shortNames(WP81,2013) SQLite.WP81
 390 set shortNames(Win32,2012) SQLite.Win32
 391 set shortNames(Win32,2013) SQLite.Win32.2013
 392 set shortNames(UWP,2015) SQLite.UWP.2015
 393
 394 set displayNames(WinRT,2012) "SQLite for Windows Runtime"
 395 set displayNames(WinRT,2013) "SQLite for Windows Runtime"
 396 set displayNames(WinRT81,2013) "SQLite for Windows Runtime (Windows 8.1)"
 397 set displayNames(WP80,2012) "SQLite for Windows Phone"
 398 set displayNames(WP80,2013) "SQLite for Windows Phone"
 399 set displayNames(WP81,2013) "SQLite for Windows Phone 8.1"
 400 set displayNames(Win32,2012) "SQLite for Windows"
 401 set displayNames(Win32,2013) "SQLite for Windows"
 402 set displayNames(UWP,2015) "SQLite for Universal Windows Platform"
 403
 404 if {[string equal $packageFlavor WinRT]} then {
 405   set shortName $shortNames($packageFlavor,$vsVersion)
 406   set displayName $displayNames($packageFlavor,$vsVersion)
 407   set targetPlatformIdentifier Windows
 408   set targetPlatformVersion v8.0
 409   set minVsVersion [getMinVsVersionXmlChunk $vsVersion]
 410   set maxPlatformVersion \
 411       [getMaxPlatformVersionXmlChunk $packageFlavor $vsVersion]
 412   set extraSdkPath ""
 413   set extraFileListAttributes \
 414       [getExtraFileListXmlChunk $packageFlavor $vsVersion]
 415 } elseif {[string equal $packageFlavor WinRT81]} then {
 416   if {$vsVersion ne "2013"} then {
 417     fail [appendArgs \
 418         "unsupported combination, package flavor " $packageFlavor \
 419         " is only supported with Visual Studio 2013"]
 420   }
 421   set shortName $shortNames($packageFlavor,$vsVersion)
 422   set displayName $displayNames($packageFlavor,$vsVersion)
 423   set targetPlatformIdentifier Windows
 424   set targetPlatformVersion v8.1
 425   set minVsVersion [getMinVsVersionXmlChunk $vsVersion]
 426   set maxPlatformVersion \
 427       [getMaxPlatformVersionXmlChunk $packageFlavor $vsVersion]
 428   set extraSdkPath ""
 429   set extraFileListAttributes \
 430       [getExtraFileListXmlChunk $packageFlavor $vsVersion]
 431 } elseif {[string equal $packageFlavor WP80]} then {
 432   set shortName $shortNames($packageFlavor,$vsVersion)
 433   set displayName $displayNames($packageFlavor,$vsVersion)
 434   set targetPlatformIdentifier "Windows Phone"
 435   set targetPlatformVersion v8.0
 436   set minVsVersion [getMinVsVersionXmlChunk $vsVersion]
 437   set maxPlatformVersion \
 438       [getMaxPlatformVersionXmlChunk $packageFlavor $vsVersion]
 439   set extraSdkPath "\\..\\$targetPlatformIdentifier"
 440   set extraFileListAttributes \
 441       [getExtraFileListXmlChunk $packageFlavor $vsVersion]
 442 } elseif {[string equal $packageFlavor WP81]} then {
 443   if {$vsVersion ne "2013"} then {
 444     fail [appendArgs \
 445         "unsupported combination, package flavor " $packageFlavor \
 446         " is only supported with Visual Studio 2013"]
 447   }
 448   set shortName $shortNames($packageFlavor,$vsVersion)
 449   set displayName $displayNames($packageFlavor,$vsVersion)
 450   set targetPlatformIdentifier WindowsPhoneApp
 451   set targetPlatformVersion v8.1
 452   set minVsVersion [getMinVsVersionXmlChunk $vsVersion]
 453   set maxPlatformVersion \
 454       [getMaxPlatformVersionXmlChunk $packageFlavor $vsVersion]
 455   set extraSdkPath "\\..\\$targetPlatformIdentifier"
 456   set extraFileListAttributes \
 457       [getExtraFileListXmlChunk $packageFlavor $vsVersion]
 458 } elseif {[string equal $packageFlavor UWP]} then {
 459   if {$vsVersion ne "2015"} then {
 460     fail [appendArgs \
 461         "unsupported combination, package flavor " $packageFlavor \
 462         " is only supported with Visual Studio 2015"]
 463   }
 464   set shortName $shortNames($packageFlavor,$vsVersion)
 465   set displayName $displayNames($packageFlavor,$vsVersion)
 466   set targetPlatformIdentifier UAP; # NOTE: Not "UWP".
 467   set targetPlatformVersion v0.8.0.0
 468   set minVsVersion [getMinVsVersionXmlChunk $vsVersion]
 469   set maxPlatformVersion \
 470       [getMaxPlatformVersionXmlChunk $packageFlavor $vsVersion]
 471   set extraSdkPath "\\..\\$targetPlatformIdentifier"
 472   set extraFileListAttributes \
 473       [getExtraFileListXmlChunk $packageFlavor $vsVersion]
 474 } elseif {[string equal $packageFlavor Win32]} then {
 475   set shortName $shortNames($packageFlavor,$vsVersion)
 476   set displayName $displayNames($packageFlavor,$vsVersion)
 477   set targetPlatformIdentifier Windows
 478   set targetPlatformVersion v8.0
 479   set minVsVersion [getMinVsVersionXmlChunk $vsVersion]
 480   set maxPlatformVersion \
 481       [getMaxPlatformVersionXmlChunk $packageFlavor $vsVersion]
 482   set extraSdkPath ""
 483   set extraFileListAttributes \
 484       [getExtraFileListXmlChunk $packageFlavor $vsVersion]
 485 } else {
 486   fail [appendArgs \
 487       "unsupported package flavor, must be one of: " \
 488       [list WinRT WinRT81 WP80 WP81 UWP Win32]]
 489 }
 490
 491 ###############################################################################
 492
 493 #
 494 # NOTE: Evaluate the user-specific customizations file, if it exists.
 495 #
 496 set userFile [file join $path [appendArgs \
 497     $rootName . $tcl_platform(user) .tcl]]
 498
 499 if {[file exists $userFile] && \
 500     [file isfile $userFile]} then {
 501   source $userFile
 502 }
 503
 504 ###############################################################################
 505
 506 set templateFile [file join $path win sqlite.vsix]
 507
 508 if {![file exists $templateFile] || \
 509     ![file isfile $templateFile]} then {
 510   fail [appendArgs "template file \"" $templateFile "\" does not exist"]
 511 }
 512
 513 set currentDirectory [pwd]
 514 set outputFile [file join $currentDirectory [appendArgs sqlite- \
 515     $packageFlavor -output.vsix]]
 516
 517 if {[file exists $outputFile]} then {
 518   fail [appendArgs "output file \"" $outputFile "\" already exists"]
 519 }
 520
 521 ###############################################################################
 522
 523 #
 524 # NOTE: Make sure that a valid temporary directory exists.
 525 #
 526 set temporaryDirectory [getTemporaryPath]
 527
 528 if {[string length $temporaryDirectory] == 0 || \
 529     ![file exists $temporaryDirectory] || \
 530     ![file isdirectory $temporaryDirectory]} then {
 531   fail "cannot locate a usable temporary directory"
 532 }
 533
 534 #
 535 # NOTE: Setup the staging directory to have a unique name inside of the
 536 #       configured temporary directory.
 537 #
 538 set stagingDirectory [file normalize [file join $temporaryDirectory \
 539     [appendArgs $rootName . [pid]]]]
 540
 541 ###############################################################################
 542
 543 #
 544 # NOTE: Configure the external zipping tool.  First, see if it has already
 545 #       been pre-configured.  If not, try to query it from the environment.
 546 #       Finally, fallback on the default of simply "zip", which will then
 547 #       be assumed to exist somewhere along the PATH.
 548 #
 549 if {![info exists zip]} then {
 550   if {[info exists env(ZipTool)]} then {
 551     set zip $env(ZipTool)
 552   }
 553   if {![info exists zip] || ![file exists $zip]} then {
 554     set zip zip
 555   }
 556 }
 557
 558 #
 559 # NOTE: Configure the external unzipping tool.  First, see if it has already
 560 #       been pre-configured.  If not, try to query it from the environment.
 561 #       Finally, fallback on the default of simply "unzip", which will then
 562 #       be assumed to exist somewhere along the PATH.
 563 #
 564 if {![info exists unzip]} then {
 565   if {[info exists env(UnZipTool)]} then {
 566     set unzip $env(UnZipTool)
 567   }
 568   if {![info exists unzip] || ![file exists $unzip]} then {
 569     set unzip unzip
 570   }
 571 }
 572
 573 ###############################################################################
 574
 575 #
 576 # NOTE: Attempt to extract the SQLite version from the "sqlite3.h" header file
 577 #       in the source directory.  This script assumes that the header file has
 578 #       already been generated by the build process.
 579 #
 580 set pattern {^#define\s+SQLITE_VERSION\s+"(.*)"$}
 581 set data [readFile [file join $sourceDirectory sqlite3.h]]
 582
 583 if {![regexp -line -- $pattern $data dummy version]} then {
 584   fail [appendArgs "cannot locate SQLITE_VERSION value in \"" \
 585       [file join $sourceDirectory sqlite3.h] \"]
 586 }
 587
 588 ###############################################################################
 589
 590 #
 591 # NOTE: Setup all the master file list data.  This includes the source file
 592 #       names, the destination file names, and the file processing flags.  The
 593 #       possible file processing flags are:
 594 #
 595 #       "buildNeutral" -- This flag indicates the file location and content do
 596 #                         not depend on the build configuration.
 597 #
 598 #       "platformNeutral" -- This flag indicates the file location and content
 599 #                            do not depend on the build platform.
 600 #
 601 #       "subst" -- This flag indicates that the file contains dynamic textual
 602 #                  content that needs to be processed using [subst] prior to
 603 #                  packaging the file into the final VSIX package.  The primary
 604 #                  use of this flag is to insert the name of the VSIX package,
 605 #                  some package flavor-specific value, or the SQLite version
 606 #                  into a file.
 607 #
 608 #       "noDebug" -- This flag indicates that the file should be skipped when
 609 #                    processing the debug build.
 610 #
 611 #       "noRetail" -- This flag indicates that the file should be skipped when
 612 #                     processing the retail build.
 613 #
 614 #       "move" -- This flag indicates that the file should be moved from the
 615 #                 source to the destination instead of being copied.
 616 #
 617 #       This file metadata may be overridden, either in whole or in part, via
 618 #       the user-specific customizations file.
 619 #
 620 if {![info exists fileNames(source)]} then {
 621   set fileNames(source) [list "" "" \
 622     [file join $stagingDirectory DesignTime <build> <platform> sqlite3.props] \
 623     [file join $sourceDirectory sqlite3.h] \
 624     [file join $binaryDirectory <build> <platform> sqlite3.lib] \
 625     [file join $binaryDirectory <build> <platform> sqlite3.dll]]
 626
 627   if {![info exists no(symbols)]} then {
 628     lappend fileNames(source) \
 629         [file join $binaryDirectory <build> <platform> sqlite3.pdb]
 630   }
 631 }
 632
 633 if {![info exists fileNames(destination)]} then {
 634   set fileNames(destination) [list \
 635     [file join $stagingDirectory extension.vsixmanifest] \
 636     [file join $stagingDirectory SDKManifest.xml] \
 637     [file join $stagingDirectory DesignTime <build> <platform> <name>.props] \
 638     [file join $stagingDirectory DesignTime <build> <platform> sqlite3.h] \
 639     [file join $stagingDirectory DesignTime <build> <platform> sqlite3.lib] \
 640     [file join $stagingDirectory Redist <build> <platform> sqlite3.dll]]
 641
 642   if {![info exists no(symbols)]} then {
 643     lappend fileNames(destination) \
 644         [file join $stagingDirectory Redist <build> <platform> sqlite3.pdb]
 645   }
 646 }
 647
 648 if {![info exists fileNames(flags)]} then {
 649   set fileNames(flags) [list \
 650       [list buildNeutral platformNeutral subst] \
 651       [list buildNeutral platformNeutral subst] \
 652       [list buildNeutral platformNeutral subst move] \
 653       [list buildNeutral platformNeutral] \
 654       [list] [list] [list noRetail]]
 655
 656   if {![info exists no(symbols)]} then {
 657     lappend fileNames(flags) [list noRetail]
 658   }
 659 }
 660
 661 ###############################################################################
 662
 663 #
 664 # NOTE: Setup the list of builds supported by this script.  These may be
 665 #       overridden via the user-specific customizations file.
 666 #
 667 if {![info exists buildNames]} then {
 668   set buildNames [list Debug Retail]
 669 }
 670
 671 ###############################################################################
 672
 673 #
 674 # NOTE: Setup the list of platforms supported by this script.  These may be
 675 #       overridden via the command line or the user-specific customizations
 676 #       file.
 677 #
 678 if {![info exists platformNames] || [llength $platformNames] == 0} then {
 679   set platformNames [list x86 x64 ARM]
 680 }
 681
 682 ###############################################################################
 683
 684 #
 685 # NOTE: Make sure the staging directory exists, creating it if necessary.
 686 #
 687 file mkdir $stagingDirectory
 688
 689 #
 690 # NOTE: Build the Tcl command used to extract the template VSIX package to
 691 #       the staging directory.
 692 #
 693 set extractCommand [list exec -- $unzip $templateFile -d $stagingDirectory]
 694
 695 #
 696 # NOTE: Extract the template VSIX package to the staging directory.
 697 #
 698 eval $extractCommand
 699
 700 ###############################################################################
 701
 702 #
 703 # NOTE: Process each file in the master file list.  There are actually three
 704 #       parallel lists that contain the source file names, the destination file
 705 #       names, and the file processing flags. If the "buildNeutral" flag is
 706 #       present, the file location and content do not depend on the build
 707 #       configuration and "CommonConfiguration" will be used in place of the
 708 #       build configuration name.  If the "platformNeutral" flag is present,
 709 #       the file location and content do not depend on the build platform and
 710 #       "neutral" will be used in place of the build platform name.  If the
 711 #       "subst" flag is present, the file is assumed to be a text file that may
 712 #       contain Tcl variable, command, and backslash replacements, to be
 713 #       dynamically replaced during processing using the Tcl [subst] command.
 714 #       If the "noDebug" flag is present, the file will be skipped when
 715 #       processing for the debug build.  If the "noRetail" flag is present, the
 716 #       file will be skipped when processing for the retail build.  If the
 717 #       "move" flag is present, the source file will be deleted after it is
 718 #       copied to the destination file.  If the source file name is an empty
 719 #       string, the destination file name will be assumed to already exist in
 720 #       the staging directory and will not be copied; however, Tcl variable,
 721 #       command, and backslash replacements may still be performed on the
 722 #       destination file prior to the final VSIX package being built if the
 723 #       "subst" flag is present.
 724 #
 725 foreach sourceFileName      $fileNames(source) \
 726         destinationFileName $fileNames(destination) \
 727         fileFlags           $fileNames(flags) {
 728   #
 729   # NOTE: Process the file flags into separate boolean variables that may be
 730   #       used within the loop.
 731   #
 732   set isBuildNeutral [expr {[lsearch $fileFlags buildNeutral] != -1}]
 733   set isPlatformNeutral [expr {[lsearch $fileFlags platformNeutral] != -1}]
 734   set isMove [expr {[lsearch $fileFlags move] != -1}]
 735   set useSubst [expr {[lsearch $fileFlags subst] != -1}]
 736
 737   #
 738   # NOTE: If the current file is build-neutral, then only one build will
 739   #       be processed for it, namely "CommonConfiguration"; otherwise, each
 740   #       supported build will be processed for it individually.
 741   #
 742   foreach buildName \
 743       [expr {$isBuildNeutral ? [list CommonConfiguration] : $buildNames}] {
 744     #
 745     # NOTE: Should the current file be skipped for this build?
 746     #
 747     if {[lsearch $fileFlags no${buildName}] != -1} then {
 748       continue
 749     }
 750
 751     #
 752     # NOTE: If the current file is platform-neutral, then only one platform
 753     #       will be processed for it, namely "neutral"; otherwise, each
 754     #       supported platform will be processed for it individually.
 755     #
 756     foreach platformName \
 757         [expr {$isPlatformNeutral ? [list neutral] : $platformNames}] {
 758       #
 759       # NOTE: Use the actual platform name in the destination file name.
 760       #
 761       set newDestinationFileName [replaceFileNameTokens $destinationFileName \
 762           $shortName $buildName $platformName]
 763
 764       #
 765       # NOTE: Does the source file need to be copied to the destination file?
 766       #
 767       if {[string length $sourceFileName] > 0} then {
 768         #
 769         # NOTE: First, make sure the destination directory exists.
 770         #
 771         file mkdir [file dirname $newDestinationFileName]
 772
 773         #
 774         # NOTE: Then, copy the source file to the destination file verbatim.
 775         #
 776         set newSourceFileName [replaceFileNameTokens $sourceFileName \
 777             $shortName $buildName $platformName]
 778
 779         file copy $newSourceFileName $newDestinationFileName
 780
 781         #
 782         # NOTE: If this is a move instead of a copy, delete the source file
 783         #       now.
 784         #
 785         if {$isMove} then {
 786           file delete $newSourceFileName
 787         }
 788       }
 789
 790       #
 791       # NOTE: Does the destination file contain dynamic replacements that must
 792       #       be processed now?
 793       #
 794       if {$useSubst} then {
 795         #
 796         # NOTE: Perform any dynamic replacements contained in the destination
 797         #       file and then re-write it in-place.
 798         #
 799         substFile $newDestinationFileName
 800       }
 801     }
 802   }
 803 }
 804
 805 ###############################################################################
 806
 807 #
 808 # NOTE: Change the current directory to the staging directory so that the
 809 #       external archive building tool can pickup the necessary files using
 810 #       relative paths.
 811 #
 812 cd $stagingDirectory
 813
 814 #
 815 # NOTE: Build the Tcl command used to archive the final VSIX package in the
 816 #       output directory.
 817 #
 818 set archiveCommand [list exec -- $zip -r $outputFile *]
 819
 820 #
 821 # NOTE: Build the final VSIX package archive in the output directory.
 822 #
 823 eval $archiveCommand
 824
 825 #
 826 # NOTE: Change back to the previously saved current directory.
 827 #
 828 cd $currentDirectory
 829
 830 #
 831 # NOTE: Cleanup the temporary staging directory.
 832 #
 833 file delete -force $stagingDirectory
 834
 835 ###############################################################################
 836
 837 #
 838 # NOTE: Success, emit the fully qualified path of the generated VSIX file.
 839 #
 840 puts stdout $outputFile