System.Data.SQLite

 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: $
 *
-->
<configuration>
  <appSettings>
    <!--
    <add key="ArgumentCount" value="3" />
    <add key="Argument0String" value="-anyInitialize" />
    <add key="Argument1String" value="puts stdout app_settings1" />
    <add key="Argument2List" value="-anyInitialize {puts stdout app_settings2}" />
    -->
  </appSettings>

  <startup useLegacyV2RuntimeActivationPolicy="true">
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />

    <!--
    <supportedRuntime version="v2.0.50727" />
    <supportedRuntime version="v4.0.30319" />
    -->

    #
    # NOTE: Load the extra script library files that contain commonly used
    #       procedures that are shared between native Tcl and Eagle.
    #
    loadScripts [file dirname [info script]] [list \
        auxiliary.eagle database.eagle exec.eagle file1.eagle \
        file2.eagle file3.eagle info.eagle list.eagle \
        pkgt.eagle platform.eagle testlog.eagle unzip.eagle]

    #
    # NOTE: Load the extra script library files that contain procedures that
    #       require a specific language (i.e. either native Tcl or Eagle).
    #
    if {[isEagle]} then {
      loadScripts [file dirname [info script]] [list \

          makeLogChannel readFile readSharedFile writeFile appendFile \
          appendLogFile appendSharedFile appendSharedLogFile \
          readAsciiFile writeAsciiFile readUnicodeFile \
          writeUnicodeFile getDirResultPath addToPath removeFromPath \
          execShell lshuffle ldifference filter map reduce \
          getLengthModifier debug findDirectories \
          findDirectoriesRecursive findFiles findFilesRecursive \
          exportAndImportPackageCommands setupUnzipVars \
          unzipMustBeInstalled extractZipArchive] false false
    }

    ###########################################################################
    ############################## END Tcl ONLY ###############################
    ###########################################################################
  }


package ifneeded Eagle.List 1.0 \
    [list sourceWithInfo [file join $dir list.eagle]]

package ifneeded Eagle.Object 1.0 \
    [list sourceWithInfo [file join $dir object.eagle]]

package ifneeded Eagle.Package.Toolset 1.0 \
    [list sourceWithInfo [file join $dir pkgt.eagle]]

package ifneeded Eagle.Platform 1.0 \
    [list sourceWithInfo [file join $dir platform.eagle]]

package ifneeded Eagle.Process 1.0 \
    [list sourceWithInfo [file join $dir process.eagle]]

package ifneeded Eagle.Runtime.Option 1.0 \

package ifneeded Eagle.Test.Log 1.0 \
    [list sourceWithInfo [file join $dir testlog.eagle]]

package ifneeded Eagle.Unknown.Object 1.0 \
    [list sourceWithInfo [file join $dir unkobj.eagle]]

package ifneeded Eagle.Unzip 1.0 \
    [list sourceWithInfo [file join $dir unzip.eagle]]

package ifneeded Eagle.Update 1.0 \
    [list sourceWithInfo [file join $dir update.eagle]]

package ifneeded Eagle.List 1.0 \
    [list source [file join $dir list.eagle]]

package ifneeded Eagle.Object 1.0 \
    [list source [file join $dir object.eagle]]

package ifneeded Eagle.Package.Toolset 1.0 \
    [list source [file join $dir pkgt.eagle]]

package ifneeded Eagle.Platform 1.0 \
    [list source [file join $dir platform.eagle]]

package ifneeded Eagle.Process 1.0 \
    [list source [file join $dir process.eagle]]

package ifneeded Eagle.Runtime.Option 1.0 \

package ifneeded Eagle.Test.Log 1.0 \
    [list source [file join $dir testlog.eagle]]

package ifneeded Eagle.Unknown.Object 1.0 \
    [list source [file join $dir unkobj.eagle]]

package ifneeded Eagle.Unzip 1.0 \
    [list source [file join $dir unzip.eagle]]

package ifneeded Eagle.Update 1.0 \
    [list source [file join $dir update.eagle]]

###############################################################################
#
# pkgt.eagle --
#
# Extensible Adaptable Generalized Logic Engine (Eagle)
# Eagle Package Toolset Package File
#
# Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# RCS: @(#) $Id: $
#
###############################################################################

#
# NOTE: Use our own namespace here because even though we do not directly
#       support namespaces ourselves, we do not want to pollute the global
#       namespace if this script actually ends up being evaluated in Tcl.
#
namespace eval ::Eagle {
  #
  # NOTE: This procedure sets up the default values for all configuration
  #       parameters used by this package.  If the force argument is non-zero,
  #       any existing values will be overwritten and set back to their
  #       default values.
  #
  proc setupPackageToolsetVars { force } {
    #
    # NOTE: Using the [getAuxiliaryBaseUri] procedure requires the update
    #       package.
    #
    # NOTE: The base URI used to build the URIs for the Package Client
    #       Toolset downloads.
    #
    variable baseUri; # DEFAULT: [getAuxiliaryBaseUri] -OR- https://urn.to/r

    if {$force || ![info exists baseUri]} then {
      if {[isEagle]} then {
        package require Eagle.Update
        set baseUri [getAuxiliaryBaseUri]
      } else {
        set baseUri https://urn.to/r
      }
    }

    #
    # NOTE: The URN, relative to the base URI, where the Package Client
    #       Toolset may be downloaded.
    #
    variable packageToolsetUrn; # DEFAULT: pkg_client_only

    if {$force || ![info exists packageToolsetUrn]} then {
      set packageToolsetUrn pkg_client_only
    }

    #
    # NOTE: The URI where the Package Client Toolset may be downloaded.
    #
    variable packageToolsetUri; # DEFAULT: ${baseUri}/${packageToolsetUrn}

    if {$force || ![info exists packageToolsetUri]} then {
      set packageToolsetUri {${baseUri}/${packageToolsetUrn}}
    }
  }

  #
  # NOTE: This procedure attempts to download and extract the Package Client
  #       Toolset.  The optional channel argument is the output channel where
  #       diagnostic information is sent.  The optional quiet argument should
  #       be non-zero to prevent diagnostic information from being emitted.
  #       This procedure may raise script errors.  The return value is the
  #       full path to the directory that should be added to the auto-path.
  #
  proc downloadAndExtractPackageClientToolset {
          {channel stdout} {quiet false} } {
    setupPackageToolsetVars false

    variable baseUri
    variable packageToolsetUri
    variable packageToolsetUrn

    package require Eagle.Test
    package require Eagle.Unzip

    set extractRootDirectory [getTemporaryPath]

    set directory [file join $extractRootDirectory [appendArgs \
        ea-pt-di- [pid] - [string trim [clock seconds] -]]]

    set uri [subst $packageToolsetUri]
    set fileName [getTemporaryFileName]

    if {[isEagle]} then {
      uri download $uri $fileName
    } else {
      package require Eagle.Tools.Common

      namespace import \
          ::Eagle::Tools::Common::getFileViaHttp \
          ::Eagle::Tools::Common::writeFile

      set data [getFileViaHttp $uri 20 $channel $quiet -binary true]

      writeFile $fileName $data
    }

    set extractDirectory [extractZipArchive $fileName $extractRootDirectory]
    return [file join $extractDirectory pkgr_an_d client 1.0 neutral]
  }

  #
  # NOTE: Provide the Eagle "package toolset" package to the interpreter.
  #
  package provide Eagle.Package.Toolset \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}


      # NOTE: Calculate how many whole seconds we need to spin for.
      #
      set seconds [expr {$milliseconds / 1000}]

      #
      # NOTE: Calculate the starting and ending values of [clock seconds].
      #
      set now [clock seconds]
      set start $now; set stop [expr {$now + $seconds}]

      #
      # NOTE: Do nothing for X seconds (i.e. except call [clock seconds]).
      #
      while {$start <= $now && $now < $stop} {set now [clock seconds]}

      #

      # NOTE: Tcl fallback, *assume* that we can use the
      #       directory where the executable is running for
      #       temporary storage.
      #
      return [file normalize [file dirname [info nameofexecutable]]]
    }
  }

  proc getTemporaryFileName { {seconds 5} } {
    if {[isEagle]} then {
      return [file tempname]
    } else {
      set path [getTemporaryPath]

      set now [clock seconds]
      set start $now; set stop [expr {$now + $seconds}]

      while {$start <= $now && $now < $stop} {
        binary scan [binary format d* [expr {rand()}]] h* random

        set fileNameOnly [appendArgs \
            tmp [string index $random 0] [string index $random 1] \
            [string index $random end-1] [string index $random end] \
            .tmp]

        set fileName [file join $path $fileNameOnly]

        if {![file exists $fileName]} then {
          return $fileName
        }

        set now [clock seconds]
      }

      error "cannot generate temporary file name"
    }
  }

  proc getFiles { directory pattern } {
    if {[isEagle]} then {
      set result [list]

      if {[file exists $directory] && [file isdirectory $directory]} then {
        foreach fileName [lsort -dictionary [file list $directory $pattern]] {

            trimleft [pid] -] [string trimleft [info tid] -] [string \
            trimleft [clock now] -] [string trimleft [clock clicks] -] \
            [string trimleft [expr $expr] -]]]
      }
    } else {
      #
      # NOTE: Generate a random number using [expr] and then convert it
      #       to a 64-bit integer.
      #
      binary scan [binary format d* [expr {rand()}]] w* random

      #
      # NOTE: Convert the host name to a hexadecimal string and include
      #       it in the result in an attempt to make it more unique in
      #       both time and space.

                }
              } else {
                if {$::tcltest::numTests(Failed) == 0} then {
                  incr ::tcltest::numTests(Total)
                  incr ::tcltest::numTests(Failed)
                }
              }
            } else {
              #
              # NOTE: At this point, we know the test file had an error that
              #       probably caused it to skip a bunch of tests -AND- the
              #       option to stop-testing-on-error is not enabled.  That
              #       being said, we must not simply ignore the error.  The
              #       overall results of the test suite run must now reflect
              #       the failure.  Set a special variable for the epilogue
              #       to pick up on (later).
              #
              lappend ::test_suite_errors $error
            }
          }

          #
          # NOTE: We evaluated another test file.
          #
          incr count

###############################################################################
#
# unzip.eagle --
#
# Extensible Adaptable Generalized Logic Engine (Eagle)
# Eagle Unzip Package File
#
# Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# RCS: @(#) $Id: $
#
###############################################################################

#
# NOTE: Use our own namespace here because even though we do not directly
#       support namespaces ourselves, we do not want to pollute the global
#       namespace if this script actually ends up being evaluated in Tcl.
#
namespace eval ::Eagle {
  #
  # NOTE: This procedure sets up the default values for all configuration
  #       parameters used by this package.  If the force argument is non-zero,
  #       any existing values will be overwritten and set back to their
  #       default values.
  #
  proc setupUnzipVars { force } {
    #
    # NOTE: Using the [getAuxiliaryBaseUri] procedure requires the update
    #       package.
    #
    # NOTE: The base URI used to build the URIs for the unzip command line
    #       tool downloads.
    #
    variable baseUri; # DEFAULT: [getAuxiliaryBaseUri] -OR- https://urn.to/r

    if {$force || ![info exists baseUri]} then {
      if {[isEagle]} then {
        package require Eagle.Update
        set baseUri [getAuxiliaryBaseUri]
      } else {
        set baseUri https://urn.to/r
      }
    }

    #
    # NOTE: The URN, relative to the base URI, where the unzip command
    #       line tool may be downloaded.
    #
    variable unzipUrn; # DEFAULT: unzip

    if {$force || ![info exists unzipUrn]} then {
      set unzipUrn unzip
    }

    #
    # NOTE: The URI where the unzip command line tool may be downloaded.
    #
    variable unzipUri; # DEFAULT: ${baseUri}/${unzipUrn}

    if {$force || ![info exists unzipUri]} then {
      set unzipUri {${baseUri}/${unzipUrn}}
    }

    #
    # NOTE: The command to use when attempting to verify that UnZip is
    #       installed locally.
    #
    variable unzipInstalledCommand; # DEFAULT: unzip

    if {$force || ![info exists unzipInstalledCommand]} then {
      set unzipInstalledCommand unzip
    }

    #
    # NOTE: The regular expression pattern used when attempting to verify
    #       that UnZip is installed locally.
    #
    variable unzipInstalledPattern; # DEFAULT: ^UnZip ..., by Info-ZIP\.

    if {$force || ![info exists unzipInstalledPattern]} then {
      set unzipInstalledPattern \
          {^UnZip \d+\.\d+ of \d{1,2} \w+ \d{4}, by Info-ZIP\.}
    }

    #
    # NOTE: The command to use when attempting to unzip an archive.
    #
    variable unzipExtractCommand; # DEFAULT: unzip ...

    if {$force || ![info exists unzipExtractCommand]} then {
      set unzipExtractCommand {unzip {${fileName}} -d {${directory}}}
    }
  }

  #
  # NOTE: This procedure attempts to verify that an implementation of the
  #       unzip command line tool is installed locally.  There are no
  #       arguments.  Script errors are raised if any problems are found.
  #       The return value is undefined.
  #
  proc unzipMustBeInstalled {} {
    variable unzipInstalledCommand
    variable unzipInstalledPattern

    set message {
      Cannot use UnZip: it does not appear to be installed.

      UnZip may be downloaded from "https://www.info-zip.org/"
      and then installed by copying the (single) UnZip binary to
      a directory that lies somewhere along the executable search
      path.

      Alternatively, it may be possible to install UnZip via the
      package management subsystem included with your operating
      system.
    }

    if {[isEagle]} then {
      if {[catch {
        eval exec -success Success $unzipInstalledCommand
      } result]} then {
        error $message
      }
    } else {
      if {[catch {
        eval exec $unzipInstalledCommand
      } result]} then {
        error $message
      }
    }

    if {![info exists result] || \
        ![regexp -- $unzipInstalledPattern $result]} then {
      error "cannot use UnZip: unknown or unsupported version"
    }

    return ""
  }

  #
  # NOTE: This procedure attempts to use the unzip command line tool in order
  #       to extract a ZIP archive file.  The archiveFileName argument is the
  #       ZIP archive file to extract.  The extractRootDirectory argument is
  #       the location of a directory that should contain a new temporary
  #       extraction directory.  The actual temporary extraction directory is
  #       returned.
  #
  proc extractZipArchive { archiveFileName extractRootDirectory } {
    setupUnzipVars false

    variable baseUri
    variable unzipExtractCommand
    variable unzipUri
    variable unzipUrn
    variable unzipVersionCommand

    set fileName [file nativename $archiveFileName]

    set extractDirectory [file join $extractRootDirectory \
        [appendArgs ea-uz-xa- [pid] - [string trim [clock seconds] -]]]

    set directory [file nativename $extractDirectory]

    if {[isEagle]} then {
      #
      # HACK: On Windows only, when the unzip command line tool does
      #       not appear to be installed, attempt to download it to a
      #       temporary directory and use it from there.  In theory,
      #       if this procedure is called multiple times, this should
      #       only be necessary the first time.
      #
      if {[isWindows] && [catch {unzipMustBeInstalled}]} then {
        set uri [subst $unzipUri]
        set exeFileName [file tempname]

        uri download $uri $exeFileName

        #
        # NOTE: *SECURITY* The downloaded unzip command line tool must
        #       be signed; otherwise, it will be deleted and a script
        #       error will be raised.
        #
        if {[catch {library certificate $exeFileName}]} then {
          catch {file delete $exeFileName}
          error "cannot use UnZip: downloaded file was not properly signed"
        }

        #
        # NOTE: Create a brand new temporary directory, underneath the
        #       extraction root directory, that will be added to the
        #       executable search path and move the downloaded file to
        #       it.
        #
        set exeDirectory [file join $extractRootDirectory \
            [appendArgs ea-uz-xt- [pid] - [string trim [clock seconds] -]]]

        file mkdir $exeDirectory
        file copy $exeFileName [file join $exeDirectory unzip.exe]
        catch {file delete $exeFileName}

        addToPath $exeDirectory
      }

      unzipMustBeInstalled

      set fileName [appendArgs \" $fileName \"]
      set directory [appendArgs \" $directory \"]

      if {[catch {
        eval exec -success Success [subst $unzipExtractCommand]
      } error]} then {
        error [appendArgs \
            "could not extract archive \"" $fileName "\": " $error]
      }
    } else {
      unzipMustBeInstalled

      if {[catch {
        eval exec [subst $unzipExtractCommand]
      } error]} then {
        error [appendArgs \
            "could not extract archive \"" $fileName "\": " $error]
      }
    }

    return $extractDirectory
  }

  #
  # NOTE: Provide the Eagle "unzip" package to the interpreter.
  #
  package provide Eagle.Unzip \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}


  proc getDownloadBaseUri {} {
    #
    # NOTE: Just return the current base URI for downloads.
    #
    return [info engine DownloadBaseUri]; # NOTE: Current.
  }

  #
  # NOTE: This procedure returns the base URI that should be used to download
  #       available scripts, if a specific base URI is not specified via the
  #       manifest of available scripts.
  #
  proc getScriptBaseUri {} {
    #
    # NOTE: Just return the current base URI for scripts.
    #
    return [info engine ScriptBaseUri]; # NOTE: Current.
  }

  #
  # NOTE: This procedure returns the base URI that should be used to download
  #       auxiliary data.
  #
  proc getAuxiliaryBaseUri {} {
    #
    # NOTE: Just return the current base URI for auxiliary data.
    #
    return [info engine AuxiliaryBaseUri]; # NOTE: Current.
  }

  #
  # NOTE: This procedure is used to check for new versions -OR- new update
  #       scripts for the runtime when a user executes the interactive
  #       "#check" command.  To disable this functionality, simply redefine
  #       this procedure to do nothing.
  #
  proc checkForUpdate {

                ($checkScript && $match)} then {
              #
              # NOTE: Grab the base URI field (i.e. it may be a mirror
              #       site).
              #
              set baseUri [lindex $fields 6]

              if {$checkBuild} then {
                if {[string length $baseUri] > 0} then {
                  set buildUri $baseUri
                } else {
                  set buildUri [getDownloadBaseUri]; # primary site.
                }
              }

              if {$checkScript} then {
                if {[string length $baseUri] > 0} then {
                  set scriptUri $baseUri
                } else {
                  set scriptUri [getScriptBaseUri]; # primary site.
                }
              }

              #
              # NOTE: Grab the notes field (which may be empty).
              #
              set notes [lindex $fields 10]

                      # NOTE: Ok, run the updater now and then exit.
                      #
                      runUpdateAndExit $automatic
                    }
                  }
                }

                return [list $text [list $buildUri $patchLevel] [list $notes]]
              }

              #
              # NOTE: The script patch level from the line matches the
              #       current engine patch level exactly, this script
              #       should be evaluated if it can be authenticated.
              #

                }

                #
                # NOTE: Next, verify the script has a valid base URI.
                #       For update scripts, this must be the location
                #       where the update script data can be downloaded.
                #
                if {[string length $scriptUri] == 0} then {
                  if {!$quiet} then {
                    tqputs $channel [appendArgs \
                        "---- invalid baseUri value for update script " \
                        "line: " $line \"\n]
                  }
                  incr scriptCount(invalid); continue
                }

                #
                # NOTE: Next, show the extra information associated with
                #       this update script, if any.
                #
                if {!$quiet} then {
                  tqputs $channel [appendArgs \
                      "---- fetching update script from \"" $scriptUri \
                      "\" (" $dateTime ") with notes:\n"]

                  set trimNotes [string trim $notes]

                  tqputs $channel [appendArgs \
                      [expr {[string length $trimNotes] > 0 ? $trimNotes : \
                      "<none>"}] "\n---- end of update script notes\n"]
                }

                #
                # NOTE: Next, attempt to fetch the update script data.
                #
                set code [catch {getUpdateScriptData $scriptUri} result]

                if {$code == 0} then {
                  #
                  # NOTE: Success, set the script data from the result.
                  #
                  set scriptData $result
                } else {

                #
                # NOTE: Finally, everything looks good.  Therefore, just
                #       evaluate the update script and print the result.
                #
                if {!$quiet} then {
                  tqputs $channel [appendArgs \
                      "---- evaluating update script from \"" $scriptUri \
                      \"...\n]
                }

                #
                # NOTE: Reset the variables that will be used to contain
                #       the result of the update script.
                #
                set code 0; set result ""

                #
                # NOTE: Manually override file name to be returned by
                #       [info script] to refer back to the originally
                #       read script base URI.
                #
                set pushed false

                if {[llength [info commands object]] > 0} then {
                  object invoke -flags +NonPublic Interpreter.GetActive \
                      PushScriptLocation $scriptUri true

                  set pushed true
                }

                try {
                  #
                  # NOTE: Evaluate the update script in the context of

#       support namespaces ourselves, we do not want to pollute the global
#       namespace if this script actually ends up being evaluated in Tcl.
#
namespace eval ::Eagle {
  proc getKnownBuildTypes {} {
    return [list \
        NetFx20 NetFx35 NetFx40 NetFx45 NetFx451 NetFx452 \
        NetFx46 NetFx461 NetFx462 NetFx47 Bare LeanAndMean \
        Database MonoOnUnix Development]
  }

  proc getKnownCompileOptions {} {
    return [list \
        APPDOMAINS APPROVED_VERBS ARGUMENT_CACHE ARM ARM64 ASSEMBLY_RELEASE \
        ASSEMBLY_STRONG_NAME_TAG ASSEMBLY_TAG ASSEMBLY_TEXT ASSEMBLY_URI \
        BREAK_ON_EXITING BREAKPOINTS CACHE_ARGUMENT_TOSTRING \
        CACHE_ARGUMENTLIST_TOSTRING CACHE_DICTIONARY CACHE_RESULT_TOSTRING \
        CACHE_STATISTICS CACHE_STRINGLIST_TOSTRING CALLBACK_QUEUE CAS_POLICY \
        CERTIFICATE_PLUGIN CERTIFICATE_POLICY CERTIFICATE_RENEWAL \
        CODE_ANALYSIS COM_TYPE_CACHE CONSOLE DAEMON DATA DEAD_CODE DEBUG \
        DEBUGGER DEBUGGER_ARGUMENTS DEBUGGER_ENGINE DEBUGGER_EXECUTE \
        DEBUGGER_EXPRESSION DEBUGGER_VARIABLE DEBUG_TRACE DEBUG_WRITE DRAWING \
        DYNAMIC EAGLE EMBEDDED_LIBRARY EMBED_CERTIFICATES ENTERPRISE_LOCKDOWN \
        EXECUTE_CACHE EXPRESSION_FLAGS FAST_ERRORCODE FAST_ERRORINFO \
        FOR_TEST_USE_ONLY HAVE_SIZEOF HISTORY IA64 INTERACTIVE_COMMANDS \
        INTERNALS_VISIBLE_TO ISOLATED_INTERPRETERS ISOLATED_PLUGINS LIBRARY \
        LICENSING LICENSE_MANAGER LIMITED_EDITION LIST_CACHE MONO MONO_BUILD \
        MONO_HACKS MONO_LEGACY NATIVE NATIVE_PACKAGE NATIVE_THREAD_ID \
        NATIVE_UTILITY NATIVE_UTILITY_BSTR NETWORK NET_20 NET_20_FAST_ENUM \
        NET_20_ONLY NET_20_SP1 NET_20_SP2 NET_30 NET_35 NET_40 NET_45 NET_451 \
        NET_452 NET_46 NET_461 NET_462 NET_47 NON_WORKING_CODE NOTIFY \
        NOTIFY_ACTIVE NOTIFY_ARGUMENTS NOTIFY_EXCEPTION NOTIFY_EXECUTE \
        NOTIFY_EXPRESSION NOTIFY_GLOBAL NOTIFY_OBJECT OBSOLETE OBFUSCATION \
        OFFICIAL PARSE_CACHE PATCHLEVEL PLUGIN_COMMANDS POLICY_TRACE \
        PREVIOUS_RESULT RANDOMIZE_ID REMOTING SAMPLE SECURITY SERIALIZATION \
        SHARED_ID_POOL SHELL SOURCE_ID SOURCE_TIMESTAMP STATIC TCL TCL_KITS \
        TCL_THREADED TCL_THREADS TCL_UNICODE TCL_WRAPPER TEST TEST_PLUGIN \
        THREADING THROW_ON_DISPOSED TRACE TYPE_CACHE UNIX \
        USE_APPDOMAIN_FOR_ID USE_NAMESPACES VERBOSE WEB WINDOWS WINFORMS \
        WIX_30 WIX_35 WIX_36 WIX_37 WIX_38 WIX_39 WIX_310 X64 X86 XML]

  }

  proc getKnownMonoVersions { {force false} } {
    #
    # NOTE: This job of this procedure is to return the list of "known"
    #       versions of Mono supported by the test suite infrastructure.
    #

    #       the Mono runtime is released.
    #
    if {$force || ![info exists ::no(monoVersions)]} then {
      return [list \
          [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
          [list 2 11] [list 3 0] [list 3 1] [list 3 2] [list 3 4] [list 3 6] \
          [list 3 8] [list 3 10] [list 3 12] [list 4 0] [list 4 2] [list 4 4] \
          [list 4 6] [list 4 8] [list 5 0] [list 5 2] [list 5 4]]
    } else {
      return [list]
    }
  }

  proc addKnownMonoConstraints { generic } {
    #

      set constraints [list monoToDo monoBug monoCrash]

      foreach constraint $constraints {
        addConstraint $constraint
      }
    }
  }

  proc getKnownTclVersions { {force false} } {
    #
    # NOTE: This job of this procedure is to return the list of "known"
    #       versions of Tcl/Tk supported by the test suite infrastructure.
    #
    if {$force || ![info exists ::no(tclVersions)]} then {
      return [list [list 8 4] [list 8 5] [list 8 6] [list 8 7]]
    } else {
      return [list]
    }
  }

  proc filterKnownVersions {
          versions {minimumVersion ""} {maximumVersion ""} } {
    if {[string length $minimumVersion] > 0} then {
      set dotMinimumVersion [getDottedVersion $minimumVersion]
    } else {
      set dotMinimumVersion ""
    }

    if {[string length $maximumVersion] > 0} then {
      set dotMaximumVersion [getDottedVersion $maximumVersion]
    } else {
      set dotMaximumVersion ""
    }

    set result [list]

    foreach version $versions {
      set dotVersion [getDottedVersion $version]

      if {[string length $dotMinimumVersion] > 0 && \
          $dotVersion < $dotMinimumVersion} then {
        continue
      }

      if {[string length $dotMaximumVersion] > 0 && \
          $dotVersion > $dotMaximumVersion} then {
        continue
      }

      lappend result $version
    }

    return $result
  }

  proc getDottedVersion { version } {
    return [join $version .]
  }

  proc getDotlessVersion { version } {
    if {[string first . $version] != -1} then {
      return [string map [list . ""] $version]
    } else {
      return [join $version ""]
    }
  }

  proc getMajorMinorVersion { version } {
    return [join [lrange [split $version .] 0 1] .]
  }

  #
  # NOTE: This procedure was adapted from the one listed on the Tcl Wiki page
  #       at "https://wiki.tcl.tk/43".  It is only intended to be used on very
  #       small lists because of its heavy use of recursion and complexity on
  #       the order of O(N!).
  #

    #       return true.
    #
    return [expr {
      [catch {interp readylimit {}} readylimit] || $readylimit == 0
    }]
  }

  #
  # NOTE: This procedure should return non-zero if the operating system
  #       shell may be executed by the test suite infrastructure outside
  #       the context of any specific tests.  The specific tests themselves
  #       must make use of their own constraints to prevent its execution.
  #
  proc canExecComSpec {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(comSpec)]} then {
      return false
    }

    if {[info exists ::no(canExecComSpec)]} then {
      return false
    }

    return true
  }

  #
  # NOTE: This procedure should return non-zero if the "whoami" command may
  #       be executed by the test suite infrastructure outside the context
  #       of any specific tests.  The specific tests themselves must make
  #       use of their own constraints to prevent its execution.
  #
  proc canExecWhoAmI {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(whoami)]} then {

    return true
  }

  #
  # NOTE: This procedure should return non-zero if the native Tcl shell may
  #       be executed by the test suite infrastructure outside the context
  #       of any specific tests.  The specific tests themselves must make
  #       use of their own constraints to prevent its execution.

  #
  proc canExecTclShell {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(tcl)]} then {

    return true
  }

  #
  # NOTE: This procedure should return non-zero if Fossil may be executed by
  #       the test suite infrastructure outside the context of any specific
  #       tests.  The specific tests themselves must make use of their own
  #       constraints to prevent its execution.
  #
  proc canExecFossil {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(fossil)]} then {
      return false
    }

    if {[info exists ::no(canExecFossil)]} then {
      return false
    }

    return true
  }

  #
  # NOTE: This procedure should return non-zero if the "vswhere" tool may be
  #       executed by the test suite infrastructure outside the context of
  #       any specific tests.  The specific tests themselves must make use
  #       of their own constraints to prevent its execution.
  #
  proc canExecVsWhere {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(vswhere)]} then {
      return false
    }

    if {[info exists ::no(canExecVsWhere)]} then {
      return false
    }

    return true
  }

  #
  # NOTE: This procedure should return non-zero if the test suite should be
  #       considered to be running on Mono.

      # TODO: If additional test suite files are added within the base
      #       package path, add them here as well.
      #
      foreach fileNameOnly [list \
          auxiliary.eagle compat.eagle csharp.eagle database.eagle \
          embed.eagle exec.eagle file1.eagle file2.eagle \
          file3.eagle info.eagle init.eagle list.eagle \
          object.eagle pkgIndex.eagle pkgIndex.tcl pkgt.eagle \
          platform.eagle process.eagle runopt.eagle safe.eagle \
          shell.eagle shim.eagle test.eagle testlog.eagle \
          unkobj.eagle unzip.eagle update.eagle vendor.eagle \
          word.tcl] {
        #
        # NOTE: First, check if the file resides in the Eagle-specific
        #       package sub-directory.  Failing that, fallback to using
        #       the base package path itself.
        #
        set fileName [file join \
            $::test_package_path Eagle1.0 $fileNameOnly]

        #
        if {[file exists $fileName]} then {
          lappend fileNames $fileName
        }
      }

      #
      # TODO: If additional test suite files are added within the test
      #       package path, add them here as well.
      #
      foreach fileNameOnly [list \
          all.eagle constraints.eagle epilogue.eagle pkgIndex.eagle \
          pkgIndex.tcl prologue.eagle] {
        #
        # NOTE: First, check if the file resides in the Eagle-specific

    #
    # NOTE: Check if the test package path is available.
    #
    if {[info exists ::test_path]} then {
      #
      # TODO: If additional test suite files are added within the test
      #       suite path, add them here as well.
      #
      foreach fileNameOnly [list all.eagle epilogue.eagle prologue.eagle] {
        #
        # NOTE: Check if the file resides in the test package directory.
        #
        set fileName [file join $::test_path $fileNameOnly]

        #
        return
      }
    }

    tputs $channel no\n
  }

  proc checkForVisualStudioViaVsWhere { channel } {
    tputs $channel "---- checking for Visual Studio using \"vswhere\"... "

    #
    # NOTE: Initially, no versions of Visual Studio have been found.
    #
    set visualStudioVersions [list]

    #
    # NOTE: Use of the "vswhere" tool must be enabled for us to detect
    #       any instances of Visual Studio.
    #
    if {[canExecVsWhere]} then {
      #
      # NOTE: The versions of Visual Studio that we support detection
      #       of using the "vswhere" tool.
      #
      set versions [list [list 15.0 2017]]

      #
      # NOTE: Check each version and keep track of the ones we find.
      #
      foreach version $versions {
        #
        # NOTE: Attempt to fetch Visual Studio install directories
        #       value using the "vswhere" tool.
        #
        if {[canExecVsWhere] && [catch {
          exec -nocarriagereturns -- vswhere -products * \
              -version [lindex $version 0] -property installationPath
        } installationPaths] == 0} then {
          #
          # NOTE: Check each Visual Studio install directory, in the
          #       order they were returned, after splitting them into
          #       a proper Tcl list.
          #
          set installationPaths [split \
              [string trim $installationPaths] \n]

          foreach installationPath $installationPaths {
            #
            # NOTE: Remove the trailing backslash, if any.  Does the
            #       directory name look valid and does it actually
            #       exist?
            #
            set fileName [file join \
                [string trimright $installationPath \\] Common7 IDE \
                msenv.dll]

            if {[file isfile $fileName]} then {
              #
              # NOTE: Yes, it appears that it is available.
              #
              addConstraint [appendArgs \
                  visualStudio [lindex $version 1]]

              #
              # NOTE: Keep track of all the versions that we find.
              #
              lappend visualStudioVersions [lindex $version 1]

              #
              # NOTE: Save the directory for later usage by the test
              #       suite itself.
              #
              if {![info exists ::no(setVisualStudio)]} then {
                set ::test_visual_studio [file dirname $fileName]
              }

              #
              # HACK: Stop after we find the first instance of Visual
              #       Studio with the requested version.
              #
              break
            }
          }
        }
      }
    }

    if {[llength $visualStudioVersions] > 0} then {
      #
      # NOTE: Show where we found the latest version.
      #
      tputs $channel [appendArgs \
          "yes (" $visualStudioVersions ", \"" \
          [expr {[info exists ::test_visual_studio] ? \
              $::test_visual_studio : "<none>"}] "\")\n"]
    } else {
      tputs $channel no\n
    }
  }

  proc checkForEagle { channel } {
    tputs $channel "---- checking for Eagle... "

    if {[isEagle]} then {
      #
      # NOTE: We are running inside Eagle.

      addConstraint tclBug
      addConstraint tclCrash

      #
      # NOTE: Add the necessary constraints for each
      #       version of Tcl we know about.
      #
      foreach tclVersion [getKnownTclVersions] {
        set version [getDotlessVersion $tclVersion]

        addConstraint [appendArgs tclBug $version]
        addConstraint [appendArgs tclCrash $version]
      }

      tputs $channel yes\n
    } else {
      #

        # NOTE: For each Tcl version we know about,
        #       check it against the currently running
        #       Tcl version.  If the two are not equal,
        #       add the test constraints that prevent
        #       skipping those tests that are buggy
        #       only for the particular version of Tcl.
        #
        foreach tclVersion [getKnownTclVersions] {
          set dotVersion [getDottedVersion $tclVersion]

          if {$::tcl_version ne $dotVersion} then {
            set version [getDotlessVersion $tclVersion]

            addConstraint [appendArgs tclBug $version]
            addConstraint [appendArgs tclCrash $version]
          }
        }
      }


  proc checkForTk { channel } {
    tputs $channel "---- checking for Tk... "

    #
    # HACK: For now, disable testing Tk 8.4/8.5 when running in Eagle.
    #
    if {![isEagle] || [haveConstraint tclLibrary86] || \
        [haveConstraint tclLibrary87]} then {
      addConstraint tk

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }

  proc checkForVersion { channel } {
    tputs $channel "---- checking for language version... "

    if {[info exists ::tcl_version]} then {
      #
      # NOTE: First, obtain the list of all "known" Tcl versions.

      #
      set tclVersions [getKnownTclVersions]



      #
      # NOTE: *EAGLE* We do want to include any tests that target
      #       "Tcl 8.X or higher" features because those tests
      #       would not be in the test suite if we did not support
      #       that particular feature, regardless of the language
      #       version.


      #
      if {[isEagle]} then {
        #
        # NOTE: Process each "known" Tcl version, adding each of
        #       the "feature" constraints (i.e. since this is an


        #       Eagle test suite infrastructure package).


        #
        foreach tclVersion(1) $tclVersions {
          set version(1) [getDotlessVersion $tclVersion(1)]
          addConstraint [appendArgs tcl $version(1) Feature]
        }
      }

      #
      # NOTE: Process each "known" Tcl version, checking for an
      #       exact match with the running Tcl version.  When an
      #       exact match is found, add appropriate constraints.
      #
      foreach tclVersion(1) $tclVersions {
        #
        # NOTE: Does the running Tcl version match this "known"
        #       Tcl version exactly?
        #
        if {$::tcl_version eq [getDottedVersion $tclVersion(1)]} then {
          #
          # NOTE: Yes, it does.  First, add the "exact" match
          #       constraint.  There can be only one of these.

          #
          addConstraint [appendArgs \
              tcl [getDotlessVersion $tclVersion(1)]]




          #
          # NOTE: Next, process each of the "known" Tcl versions
          #       less than or equal to the running Tcl version,
          #       while adding both the "feature" and "or higher"
          #       constraints.  There will always be at least one


          #       of these.
          #
          foreach tclVersion(2) [filterKnownVersions \
              $tclVersions "" $tclVersion(1)] {
            set version(2) [getDotlessVersion $tclVersion(2)]
            addConstraint [appendArgs tcl $version(2) Feature]
            addConstraint [appendArgs tcl $version(2) OrHigher]
          }

          #
          # NOTE: Finally, process each of the "known" Tcl versions
          #       greater than or equal to the running Tcl version,
          #       while adding the "or lower" constraints.  There
          #       will always be at least one of these.
          #
          foreach tclVersion(3) [filterKnownVersions \
              $tclVersions $tclVersion(1) ""] {
            set version(3) [getDotlessVersion $tclVersion(3)]
            addConstraint [appendArgs tcl $version(3) OrLower]
          }

          #
          # NOTE: There can be only one exact Tcl version match;


          #       therefore, we are done.
          #
          break







        }
      }

      tputs $channel [appendArgs $::tcl_version \n]
    } else {
      tputs $channel no\n
    }
  }

      addConstraint tip440

      tputs $channel [appendArgs "yes (" $engine ")\n"]
    } else {
      tputs $channel no\n
    }
  }

  proc checkForTip461 { channel } {
    tputs $channel "---- checking for TIP #461... "

    #
    # NOTE: Is the interpreter TIP #461 ready?
    #
    if {[catch {
      set expr(ge) {int("abc" ge "abc")}
      set expr(gt) {int("abc" gt "abc")}
      set expr(le) {int("abc" le "abc")}
      set expr(lt) {int("abc" lt "abc")}

      list [expr $expr(ge)] [expr $expr(gt)] \
          [expr $expr(le)] [expr $expr(lt)]
    }] == 0} then {
      addConstraint tip461

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }

  proc checkForTip463 { channel } {
    tputs $channel "---- checking for TIP #463... "

    #
    # NOTE: Is the interpreter TIP #463 ready?
    #
    if {[catch {
      regsub -command . . list
    }] == 0} then {
      addConstraint tip463

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }

  proc checkForTip471 { channel } {
    tputs $channel "---- checking for TIP #471... "

    #
    # NOTE: Is the interpreter TIP #471 ready?
    #
    catch {info linkedname} error

    if {[string match {wrong # args: should be "*} $error]} then {
      addConstraint tip471

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }

  proc checkForTiming {
          channel threshold {constraint ""} {tries 1} {delay 1000}
          {average false} {asynchronous false} } {
    tputs $channel [appendArgs \
        "---- checking for precision timing (threshold of " $threshold \
        " milliseconds" [expr {$average ? " average" : ""}] ", delay of " \

      tputs $channel "---- checking for image runtime version... "

      if {[info exists ::eagle_platform(imageRuntimeVersion)] && \
          [string length $::eagle_platform(imageRuntimeVersion)] > 0} then {
        #
        # NOTE: Get the major and minor portions of the version only.
        #
        set dotVersion [getMajorMinorVersion \
            $::eagle_platform(imageRuntimeVersion)]

        #
        # NOTE: Now create a version string for use in the constraint name
        #       (remove the periods).
        #
        set version [string map [list v "" . ""] $dotVersion]

      tputs $channel "---- checking for framework version... "

      if {[info exists ::eagle_platform(frameworkVersion)] && \
          [string length $::eagle_platform(frameworkVersion)] > 0} then {
        #
        # NOTE: Get the major and minor portions of the version only.
        #
        set dotVersion [getMajorMinorVersion \
            $::eagle_platform(frameworkVersion)]

        #
        # NOTE: Now create a version string for use in the constraint name
        #       (remove the periods).
        #
        set version [getDotlessVersion $dotVersion]

        #
        # NOTE: If the framework version was found, add a test constraint
        #       for it now.
        #
        if {[string length $version] > 0} then {
          addConstraint [appendArgs framework $version]
        }

        tputs $channel [appendArgs \
            $::eagle_platform(frameworkVersion) " (" $dotVersion ")\n"]
      } else {
        tputs $channel no\n
      }
    }

    proc checkForMatchingFrameworkVersion { channel } {
      tputs $channel "---- checking for matching framework version... "

      if {[info exists ::eagle_platform(frameworkVersion)] && \
          [string length $::eagle_platform(frameworkVersion)] > 0} then {
        if {[info exists ::eagle_platform(imageRuntimeVersion)] && \
            [string length $::eagle_platform(imageRuntimeVersion)] > 0} then {
          #
          # NOTE: Get the major and minor portions of the versions only.
          #
          set dotVersion(1) [getMajorMinorVersion \
              $::eagle_platform(frameworkVersion)]

          set dotVersion(2) [getMajorMinorVersion \
              $::eagle_platform(imageRuntimeVersion)]

          #
          # NOTE: Remove single leading "v" characters, if applicable.
          #
          if {[string index $dotVersion(1) 0] eq "v"} then {
            set dotVersion(1) [string range $dotVersion(1) 1 end]
          }

          if {[string index $dotVersion(2) 0] eq "v"} then {
            set dotVersion(2) [string range $dotVersion(2) 1 end]
          }

          #
          # NOTE: Now create a version string for use in the constraint
          #       name (remove the periods).
          #
          set version(1) [string map [list . ""] $dotVersion(1)]

          #
          # NOTE: Check for an exact match between the image runtime
          #       version and the framework version.
          #
          if {$dotVersion(1) eq $dotVersion(2)} then {
            #
            # NOTE: Yes, the image runtime version matches the framework.
            #
            addConstraint matchFramework
            addConstraint [appendArgs matchFramework $version(1)]

            addConstraint dotnetMatchFramework
            addConstraint [appendArgs dotnetMatchFramework $version(1)]

            addConstraint monoMatchFramework
            addConstraint [appendArgs monoMatchFramework $version(1)]

            tputs $channel yes\n
          } else {
            if {[isMono]} then {
              addConstraint dotnetMatchFramework
              addConstraint [appendArgs dotnetMatchFramework $version(1)]
            } else {
              addConstraint monoMatchFramework
              addConstraint [appendArgs monoMatchFramework $version(1)]
            }

            tputs $channel no\n
          }
        } else {
          tputs $channel "no, missing image runtime version\n"
        }
      } else {
        tputs $channel "no, missing framework version\n"
      }
    }

    proc checkForRuntimeVersion { channel } {
      tputs $channel "---- checking for runtime version... "

      if {[info exists ::eagle_platform(runtimeVersion)] && \
          [string length $::eagle_platform(runtimeVersion)] > 0} then {
        #
        # NOTE: Get the major and minor portions of the version only.
        #
        set dotVersion [getMajorMinorVersion \
            $::eagle_platform(runtimeVersion)]

        #
        # NOTE: Now create a version string for use in the constraint name
        #       (remove the periods).
        #
        set version [string map [list . ""] $dotVersion]

      #
      # NOTE: Check for dynamically loadable Tcl libraries (for this
      #       architecture only).
      #
      if {[catch {tcl select -architecture} tcl] == 0} then {
        #
        # NOTE: Found one?  Ok, attempt to grab the index of the version
        #       field from the list.
        #
        set index [lsearch -exact $tcl version]

        if {$index != -1} then {
          #
          # NOTE: The very next list index contains the value (i.e. like
          #       a Tcl 8.5+ dict).
          #
          set dotVersion [lindex $tcl [incr index]]

          #
          # NOTE: Do we know the version?
          #
          if {[string length $dotVersion] > 0 && \
              [regexp -- {^\d+\.\d+$} $dotVersion]} then {
            #
            # NOTE: Yes, some version of Tcl is available.
            #
            addConstraint tclLibrary

            #
            # NOTE: Is the version 8.x or higher?
            #
            foreach tclVersion [lreverse [getKnownTclVersions]] {
              if {$dotVersion >= [getDottedVersion $tclVersion]} then {
                addConstraint [appendArgs \

                    tclLibrary [getDotlessVersion $tclVersion]]

                #
                # NOTE: For now, there can be only one Tcl library match;
                #       therefore, we are done.
                #
                break
              }
            }

            tputs $channel [appendArgs $dotVersion \n]

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

        addConstraint tclReadyOrLibrary

        #
        # NOTE: Ok, attempt to determine the loaded Tcl version.
        #
        if {[catch {
          tcl eval [tcl master] {info tclversion}
        } dotVersion] == 0 && [regexp -- {^\d+\.\d+$} $dotVersion]} then {
          addConstraint [appendArgs \
              tclReady [getDotlessVersion $dotVersion]]

          #
          # NOTE: The Tcl library is ready; however, we need to add the
          #       appropriate test constraint to indicate that a specific
          #       version of Tcl is "either ready or available".
          #
          foreach tclVersion [lreverse [getKnownTclVersions]] {
            set version [getDotlessVersion $tclVersion]

            if {[haveConstraint [appendArgs tclLibrary $version]] && \
                $dotVersion >= [getDottedVersion $tclVersion]} then {
              addConstraint [appendArgs tclReadyOrLibrary $version]

              #
              # NOTE: For now, there can be only one Tcl library match;
              #       therefore, we are done.
              #
              break
            }
          }

          tputs $channel [appendArgs "yes (" $dotVersion ")\n"]
        } else {
          #
          # NOTE: The Tcl library is ready; however, we have no idea what
          #       version it actually is; therefore, skip adding the test
          #       constraint to indicate that a specific version of Tcl
          #       is "either ready or available".
          #
          tputs $channel yes\n
        }
      } else {
        #
        # NOTE: The Tcl library is not ready; however, we still need to add
        #       the appropriate test constraint to indicate that a specific
        #       version of Tcl is "either ready or available".
        #
        foreach tclVersion [lreverse [getKnownTclVersions]] {
          set version [getDotlessVersion $tclVersion]

          if {[haveConstraint [appendArgs tclLibrary $version]]} then {
            addConstraint [appendArgs tclReadyOrLibrary $version]

            #
            # NOTE: For now, there can be only one Tcl library match;
            #       therefore, we are done.
            #
            break
          }
        }

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

        set name [lindex $::eagle_platform(nativeUtility) 0]

        if {[string length $name] > 0} then {
          set version [lindex $::eagle_platform(nativeUtility) 1]

          if {[string length $version] > 0} then {
            set nativeUtility [appendArgs \
                $name . [getMajorMinorVersion $version]]
          } else {
            set nativeUtility $name
          }

          if {$nativeUtility ni "disabled unavailable"} then {
            addConstraint nativeUtility
          }

      }

      #
      # NOTE: We are not running on Windows 10, return the normal value.
      #
      return 394806
    }

    proc getFrameworkSetup47Value {} {
      #
      # NOTE: Check if we are running on Windows 10 or later.
      #
      if {[isWindows] && $::tcl_platform(osVersion) >= 10.0} then {
        #
        # NOTE: We are running on Windows 10, return the special value.
        #
        return 460798
      }

      #
      # NOTE: We are not running on Windows 10, return the normal value.
      #
      return 460805
    }

    proc checkForNetFx4x { channel } {
      tputs $channel "---- checking for .NET Framework 4.x... "

      #
      # NOTE: Platform must be Windows for this constraint to even be
      #       checked (i.e. we require the registry).

          #       is installed.  However, if the "release" value is also
          #       greater than or equal to 379893, then the .NET Framework
          #       4.5.2 is installed, which is an in-place upgrade to 4.5.1
          #       (and 4.5).  If the "release" value is also greater than or
          #       equal to 393297 (393295 on Windows 10), then the .NET
          #       Framework 4.6 is installed, which is an in-place upgrade
          #       to 4.5.x.  Similar handling is necessary for the .NET
          #       Framework 4.6.1, 4.6.2, and 4.7.  For more information,
          #       see:
          #
          #       https://msdn.microsoft.com/en-us/library/hh925568.aspx
          #
          if {$release >= [getFrameworkSetup47Value]} then {
            addConstraint dotNet451OrHigher
            addConstraint dotNet452OrHigher
            addConstraint dotNet46OrHigher
            addConstraint dotNet461OrHigher
            addConstraint dotNet462OrHigher
            addConstraint dotNet47
            addConstraint dotNet47OrHigher

            set version 4.7
          } elseif {$release >= [getFrameworkSetup462Value]} then {
            addConstraint dotNet451OrHigher
            addConstraint dotNet452OrHigher
            addConstraint dotNet46OrHigher
            addConstraint dotNet461OrHigher
            addConstraint dotNet462
            addConstraint dotNet462OrHigher

          return
        }
      }

      tputs $channel no\n
    }

    proc checkForVisualStudioViaRegistry { channel } {
      tputs $channel "---- checking for Visual Studio using registry... "

      #
      # NOTE: Initially, no versions of Visual Studio have been found.
      #
      set visualStudioVersions [list]

      #
      # NOTE: Platform must be Windows for this constraint to even be
      #       checked (i.e. we require the registry).
      #


      if {[isWindows]} then {
        #
        # NOTE: Registry hive where Visual Studio install information is
        #       stored.  Make sure to look in the WoW64 registry because
        #       Visual Studio is currently always a 32-bit application.
        #
        set key [appendArgs HKEY_LOCAL_MACHINE\\ \
            [getSoftwareRegistryKey true] {\Microsoft\VisualStudio}]

        #
        # NOTE: The versions of Visual Studio that we support detection
        #       of using the registry.
        #
        set versions [list [list 8.0 2005] [list 9.0 2008] \
            [list 10.0 2010] [list 11.0 2012] [list 12.0 2013] \
            [list 14.0 2015]]

        #
        # NOTE: Check each version and keep track of the ones we find.
        #
        foreach version $versions {
          #
          # NOTE: Attempt to fetch the Visual Studio install directory
          #       value from the registry, removing the trailing backslash,

          #       if any.
          #
          if {[catch {
            file normalize [file join [string trimright [object \
                invoke Microsoft.Win32.Registry GetValue [appendArgs \
                $key \\ [lindex $version 0]] InstallDir null] \\] \
                msenv.dll]
          } fileName] == 0} then {
            #
            # NOTE: Does the directory name look valid and does it
            #       actually exist?
            #
            if {[string length $fileName] > 0 && \
                [file isfile $fileName]} then {
              #
              # NOTE: Yes, it appears that it is available.
              #
              addConstraint [appendArgs \
                  visualStudio [lindex $version 1]]

              #
              # NOTE: Keep track of all the versions that we find.
              #
              lappend visualStudioVersions [lindex $version 1]

              #
              # NOTE: Save the directory for later usage by the test
              #       suite itself.
              #
              if {![info exists ::no(setVisualStudio)]} then {
                set ::test_visual_studio [file dirname $fileName]
              }
            }
          }
        }
      }

      if {[llength $visualStudioVersions] > 0} then {
        #
        # NOTE: Show where we found the latest version.
        #
        tputs $channel [appendArgs \
            "yes (" $visualStudioVersions ", \"" \
            [expr {[info exists ::test_visual_studio] ? \
                $::test_visual_studio : "<none>"}] "\")\n"]
      } else {
        tputs $channel no\n
      }
    }

    proc checkForNativeDebugger { channel } {
      tputs $channel "---- checking for native debugger... "

    #
    # NOTE: We need several of our test constraint related commands in the
    #       global namespace.
    #
    exportAndImportPackageCommands [namespace current] [list \
        getKnownBuildTypes getKnownCompileOptions getKnownMonoVersions \
        addKnownMonoConstraints lpermute alwaysFullInterpReady canExecComSpec \
        canExecWhoAmI canExecTclShell canExecFossil canExecVsWhere isTestMono \
        isTestAdministrator canPing cleanPackageName checkForTestSuiteFiles \
        checkForPlatform checkForWindowsVersion checkForScriptLibrary \
        checkForVariable checkForTclOptions checkForWindowsCommandProcessor \
        checkForPackage checkForFossil checkForVisualStudioViaVsWhere \
        checkForEagle checkForSymbols checkForLogFile checkForGaruda \
        checkForShell checkForOfficialStableReleaseInProgress checkForDebug \
        checkForTk checkForVersion checkForCommand checkForSubCommand \
        checkForNamespaces checkForTestExec checkForTestMachine \
        checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
        checkForFile checkForPathFile checkForNativeCode checkForTip127 \
        checkForTip194 checkForTip207 checkForTip241 checkForTip285 \
        checkForTip405 checkForTip426 checkForTip429 checkForTip440 \
        checkForTip461 checkForTip463 checkForTip471 checkForTiming \
        checkForPerformance checkForBigLists checkForProcessorIntensive \
        checkForTimeIntensive checkForFullTest checkForMemoryIntensive \
        checkForStackIntensive checkForStackSize checkForInteractive \
        checkForInteractiveCommand checkForUserInteraction checkForNetwork \
        checkForCompileOption checkForKnownCompileOptions] false false

    ###########################################################################

      #
      set percent 0
    }

    #
    # NOTE: Has the test pass threshold been set?  If so, is it set to
    #       the default value?
    #
    # HACK: If the test suite error message exists, the entire run will be
    #       considered a "failure", without regard for the pass percentage
    #       or the configured test pass threshold.
    #
    if {![info exists test_threshold] || $test_threshold == 100} then {
      #
      # NOTE: The test pass threshold is set to the default value (100%).
      #       Check to make sure that all tests pass and then set the
      #       exit code to success; otherwise, we set it to failure.
      #
      set passedOrSkipped [expr {$eagle_tests(Passed) + \
          $eagle_tests(Skipped)}]

      if {![info exists test_suite_errors] && \
          $passedOrSkipped == $eagle_tests(Total)} then {
        set exitCode Success

        if {$eagle_tests(Total) > 0} then {
          tresult Ok "OVERALL RESULT: SUCCESS\n"
        } else {
          tresult Ok "OVERALL RESULT: NONE\n"
        }
      } else {
        set exitCode Failure

        if {[info exists test_suite_errors]} then {
          tresult Error [appendArgs "OVERALL ERRORS: " \
              [expr {[llength $test_suite_errors] > 0 ? \
              $test_suite_errors : "<empty>"}] \n]
        }

        tresult Error "OVERALL RESULT: FAILURE\n"
      }

      unset passedOrSkipped
    } else {
      #
      # NOTE: They specified a non-default test pass threshold.  Check to
      #       make sure that we meet or exceed the requirement and then
      #       set the exit code to success; otherwise, set it to failure.
      #
      if {![info exists test_suite_errors] && \
          $percent >= $test_threshold} then {
        set exitCode Success

        if {$eagle_tests(Total) > 0} then {
          tresult Ok [appendArgs \
              "OVERALL RESULT: SUCCESS (" \
              $percent "% >= " $test_threshold %)\n]
        } else {
          tresult Ok [appendArgs \
              "OVERALL RESULT: NONE (" \
              $percent "% >= " $test_threshold %)\n]
        }
      } else {
        set exitCode Failure

        if {[info exists test_suite_errors]} then {
          tresult Error [appendArgs "OVERALL ERRORS: " \
              [expr {[llength $test_suite_errors] > 0 ? \
              $test_suite_errors : "<empty>"}] \n]
        }

        tresult Error [appendArgs \
            "OVERALL RESULT: FAILURE (" \
            $percent "% < " $test_threshold %)\n]
      }
    }

    unset percent

    tputs $test_channel \n; # NOTE: Blank line.
  } else {

  #
  # NOTE: Make sure all the variables used by this prologue are unset.
  #
  unset -nocomplain expr pkg_dir pattern dummy directory name value \
      exec encoding host memory stack drive server database timeout \
      user password percent checkout timeStamp loaded

  #
  # NOTE: Remove any stale test suite error messages from prior runs.
  #
  unset -nocomplain test_suite_errors

  #
  # NOTE: Indicate that the test suite is currently running.
  #
  if {![info exists test_suite_running] || !$test_suite_running} then {
    set test_suite_running true
  }

    # NOTE: Check the image runtime version (i.e. the runtime version that
    #       this assembly compiled against).
    #
    if {![info exists no(imageRuntimeVersion)]} then {
      checkForImageRuntimeVersion $test_channel
    }

    #
    # NOTE: Check if the image runtime version matches the framework.
    #
    if {![info exists no(matchingFrameworkVersion)]} then {
      checkForMatchingFrameworkVersion $test_channel
    }

    #
    # NOTE: Has process bits detection support been disabled?
    #
    if {![info exists no(processBits)]} then {
      checkForProcessBits $test_channel
    }

        }

        #
        # NOTE: Has Tcl threading support been enabled (at compile-time)?
        #
        if {![info exists no(compileTclThreaded)]} then {
          #
          # NOTE: For tests "tclLoad-3.*".
          #
          checkForCompileOption $test_channel TCL_THREADED
        }

        #
        # NOTE: Has Tcl isolated interpreter thread support been enabled (at
        #       compile-time)?
        #
        if {![info exists no(compileTclThreads)]} then {
          #
          # NOTE: For tests "tclLoad-3.*".
          #
          checkForCompileOption $test_channel TCL_THREADS
        }

        #
        # NOTE: Has GDI+ drawing support been enabled (at compile-time)?
        #

      checkForNativeUtility $test_channel
    }

    #
    # NOTE: Has Visual Studio testing support been disabled?
    #
    if {![info exists no(visualStudio)]} then {
      checkForVisualStudioViaRegistry $test_channel
    }

    #
    # NOTE: Has WiX testing support been disabled?
    #
    if {![info exists no(wix)]} then {
      #

  if {[info exists no(monoHacks)]} then {
    addKnownMonoConstraints true
    addKnownMonoConstraints false

    tputs $test_channel \
        "---- added all known Mono test constraints (forced)\n"
  }

  #
  # NOTE: Has Visual Studio testing support been disabled?
  #
  if {![info exists no(visualStudio)]} then {
    checkForVisualStudioViaVsWhere $test_channel
  }

  #
  # NOTE: Check for Eagle core library package names...
  #
  if {![info exists no(corePackageNames)]} then {
    checkForPackage $test_channel {^Eagle\._Plugins\.Core, .*$}
    checkForPackage $test_channel {^Eagle\._Plugins\.Object, .*$}

  # NOTE: Has namespace detection support been disabled?
  #
  if {![info exists no(namespaces)]} then {
    checkForNamespaces $test_channel [haveConstraint quiet]
  }

  #
  # NOTE: Check for various native Tcl features that were added
  #       (or simply proposed) through the TIP process.
  #
  if {![info exists no(tip127)]} then {
    checkForTip127 $test_channel
  }

  if {![info exists no(tip194)]} then {
    checkForTip194 $test_channel

  if {![info exists no(tip429)]} then {
    checkForTip429 $test_channel
  }

  if {![info exists no(tip440)]} then {
    checkForTip440 $test_channel
  }

  if {![info exists no(tip461)]} then {
    checkForTip461 $test_channel
  }

  if {![info exists no(tip463)]} then {
    checkForTip463 $test_channel
  }

  if {![info exists no(tip471)]} then {
    checkForTip471 $test_channel
  }

  #
  # NOTE: Has performance testing been disabled?
  #
  if {![info exists no(core)] && \
      ![info exists no(checkForPerformance)]} then {
    checkForPerformance $test_channel