System.Data.SQLite


    proc runUpdateAndExit { {automatic false} } {
      set directory [file dirname [info nameofexecutable]]

      set command [list exec -shell -- \
          [file join $directory Hippogriff.exe] -delay 2000]

      #
      # HACK: The native StrongNameSignatureVerificationEx() function does
      #       not appear to work on WOA (Windows-on-ARM) on the Surface RT
      #       tablet; therefore, attempt to disable its use when calling
      #       into the updater on that platform.
      #
      if {[isWindows] && \
          [info exists ::tcl_platform(machine)] && \
          $::tcl_platform(machine) eq "arm"} then {
        #
        # NOTE: We appear to be running on WOA (Windows-on-ARM), add the
        #       command line option that skips strong name verification.
        #
        lappend command -noStrongNameSigned true
      }

      #
      # NOTE: If requested, enable fully automatic update mode.
      #
      if {$automatic} then {
        lappend command -silent true -confirm false
      }

      set baseUri [getUpdateBaseUri]

      if {[string length $baseUri] > 0} then {
        lappend command -baseUri $baseUri
      }

      set pathAndQuery [getUpdatePathAndQuery]

      if {[string length $pathAndQuery] > 0} then {
        lappend command -tagPathAndQuery $pathAndQuery
      }

      eval $command &; exit -force
    }

    proc getUpdateBaseUri {} {
      #
      # NOTE: Check the current base URI for updates against the one baked

        #
        # NOTE: Ok, they are both valid.  Are they different?
        #
        if {$baseUri(0) ne $baseUri(1)} then {
          return $baseUri(0)
        }
      }

      return ""
    }

    proc getUpdatePathAndQuery {} {
      #
      # NOTE: Check the current tag path and query for updates against the
      #       one baked into the assembly.  If they are different, then the
      #       tag path and query must have been overridden.  In that case,
      #       we must return the current tag path and query; otherwise, we
      #       must return an empty string.
      #
      set pathAndQuery(0) [info engine UpdatePathAndQuery \
          false]; # NOTE: Current.

      set pathAndQuery(1) [info engine UpdatePathAndQuery \
          true];  # NOTE: Default.

      if {[string length $pathAndQuery(0)] > 0 && \
          [string length $pathAndQuery(1)] > 0} then {
        #
        # NOTE: Ok, they are both valid.  Are they different?
        #
        if {$pathAndQuery(0) ne $pathAndQuery(1)} then {
          return $pathAndQuery(0)
        }
      }

      return ""
    }

    proc getUpdateData { uri } {
      #
      # NOTE: Start trusting ONLY our own self-signed SSL certificate.

        #
        set eagle_tests(Constraints) [getEnvironmentVariable testConstraints]

        if {[info exists test_flags(-constraints)]} then {
          eval lappend eagle_tests(Constraints) $test_flags(-constraints)
        }

        unset -nocomplain test_verbose
        set test_verbose [getEnvironmentVariable testVerbose]

        if {[string length $test_verbose] == 0} then {
          set test_verbose Default
        }

        if {[info exists test_flags(-verbose)] && \
            [string length $test_flags(-verbose)] > 0} then {
          #
          # NOTE: Map all test verbosity flags we support for script usage
          #       to their abbreviated names (which are all one letter) and
          #       then split them into a list.


  proc checkForFossil { channel } {
    tputs $channel "---- checking for Fossil... "

    if {[canExecFossil] && \
        [catch {exec -- fossil version} version] == 0} then {
      set version [string trim $version]

      set pattern {^This is fossil version (.*) \[([0-9a-f]+)\]\
          \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$}

      if {[regexp -- $pattern $version dummy version sourceId]} then {
        #
        # NOTE: Add a constraint to show that the Fossil executable
        #       itself is available.
        #
        addConstraint fossil_version

        #
        # NOTE: Append the version of Fossil currently in use.
        #
        append result version " " $version " \[" $sourceId \]

        if {[canExecFossil] && \
            [catch {exec -- fossil remote-url} remoteUrl] == 0} then {
          set remoteUrl [string trim $remoteUrl]; set validUrl false

          if {[isEagle]} then {
            #
            # NOTE: With Eagle, we can actually validate the URL.
            #
            if {[uri isvalid $remoteUrl]} then {
              set validUrl true
            }
          } else {
            #
            # HACK: Currently, there is no simple way to validate
            #       an arbitrary URL with Tcl (i.e. without using
            #       some hideously complex regular expression).
            #
            if {[string length $remoteUrl] > 0} then {
              set validUrl true
            }
          }

          if {$validUrl} then {
            #
            # NOTE: Add a constraint to show that a valid Fossil
            #       repository URL appears to be available.
            #
            addConstraint fossil_repository_url

            #
            # NOTE: If we are not prevented from doing so, save
            #       the test repository URL to the repository
            #       currently in use to a suitably named global
            #       variable.
            #
            if {![info exists ::no(setRepositoryUrl)]} then {
              set ::test_repository_url $remoteUrl
            }

            #
            # NOTE: Append the repository URL currently in use.
            #
            append result ", remote URL \"" $remoteUrl \"
          }
        }

        if {[canExecFossil] && \
            [catch {exec -- fossil info} info] == 0} then {
          set info [string trim $info]; set validFile false

          if {[string length $info] > 0} then {
            set pattern {^repository:\s+(.*?)\s+$}

            if {[regexp -line -- $pattern $info dummy repository] && \
                [file exists $repository]} then {
              set validFile true
            }
          }

          if {$validFile} then {
            #
            # NOTE: Add a constraint to show that a valid Fossil
            #       repository file appears to be available.
            #
            addConstraint fossil_repository_file

            #
            # NOTE: If we are not prevented from doing so, save
            #       the test repository file for the repository
            #       currently in use to a suitably named global
            #       variable.
            #
            if {![info exists ::no(setRepositoryFile)]} then {
              set ::test_repository_file $repository
            }

            #
            # NOTE: Append the repository file currently in use.
            #
            append result ", local file \"" $repository \"
          }
        }

        #
        # NOTE: Show the result of the checking.
        #
        tputs $channel [appendArgs "yes (" $result ")\n"]

        #
        # NOTE: We are done here, return now.
        #
        return


      }
    }

    tputs $channel no\n
  }

  proc checkForEagle { channel } {

    checkForWindowsCommandProcessor $test_channel cmd.exe
  }

  if {![info exists no(fossil)]} then {
    checkForFossil $test_channel
  }

  if {![info exists no(testRepositoryUrl)]} then {
    checkForVariable $test_channel test_repository_url
  }

  if {![info exists no(testRepositoryFile)]} then {
    checkForVariable $test_channel test_repository_file
  }

  if {![info exists no(version)]} then {
    checkForVersion $test_channel
  }

  if {![info exists no(eagle)]} then {